diff --git a/demo/libs/framework/framework.d.ts b/demo/libs/framework/framework.d.ts
index 9ab1a179..6c72ef06 100644
--- a/demo/libs/framework/framework.d.ts
+++ b/demo/libs/framework/framework.d.ts
@@ -17,648 +17,842 @@ declare interface Array<T> {
     groupBy(keySelector: Function): Array<T>;
     sum(selector: any): any;
 }
-declare class PriorityQueueNode {
-    priority: number;
-    insertionIndex: number;
-    queueIndex: number;
+declare module es {
+    class PriorityQueueNode {
+        priority: number;
+        insertionIndex: number;
+        queueIndex: number;
+    }
 }
-declare class AStarPathfinder {
-    static search<T>(graph: IAstarGraph<T>, start: T, goal: T): T[];
-    private static hasKey;
-    private static getKey;
-    static recontructPath<T>(cameFrom: Map<T, T>, start: T, goal: T): T[];
+declare module es {
+    class AStarPathfinder {
+        static search<T>(graph: IAstarGraph<T>, start: T, goal: T): T[];
+        private static hasKey;
+        private static getKey;
+        static recontructPath<T>(cameFrom: Map<T, T>, start: T, goal: T): T[];
+    }
+    class AStarNode<T> extends PriorityQueueNode {
+        data: T;
+        constructor(data: T);
+    }
 }
-declare class AStarNode<T> extends PriorityQueueNode {
-    data: T;
-    constructor(data: T);
+declare module es {
+    class AstarGridGraph implements IAstarGraph<Vector2> {
+        dirs: Vector2[];
+        walls: Vector2[];
+        weightedNodes: Vector2[];
+        defaultWeight: number;
+        weightedNodeWeight: number;
+        private _width;
+        private _height;
+        private _neighbors;
+        constructor(width: number, height: number);
+        isNodeInBounds(node: Vector2): boolean;
+        isNodePassable(node: Vector2): boolean;
+        search(start: Vector2, goal: Vector2): Vector2[];
+        getNeighbors(node: Vector2): Vector2[];
+        cost(from: Vector2, to: Vector2): number;
+        heuristic(node: Vector2, goal: Vector2): number;
+    }
 }
-declare class AstarGridGraph implements IAstarGraph<Vector2> {
-    dirs: Vector2[];
-    walls: Vector2[];
-    weightedNodes: Vector2[];
-    defaultWeight: number;
-    weightedNodeWeight: number;
-    private _width;
-    private _height;
-    private _neighbors;
-    constructor(width: number, height: number);
-    isNodeInBounds(node: Vector2): boolean;
-    isNodePassable(node: Vector2): boolean;
-    search(start: Vector2, goal: Vector2): Vector2[];
-    getNeighbors(node: Vector2): Vector2[];
-    cost(from: Vector2, to: Vector2): number;
-    heuristic(node: Vector2, goal: Vector2): number;
+declare module es {
+    interface IAstarGraph<T> {
+        getNeighbors(node: T): Array<T>;
+        cost(from: T, to: T): number;
+        heuristic(node: T, goal: T): any;
+    }
 }
-interface IAstarGraph<T> {
-    getNeighbors(node: T): Array<T>;
-    cost(from: T, to: T): number;
-    heuristic(node: T, goal: T): any;
+declare module es {
+    class PriorityQueue<T extends PriorityQueueNode> {
+        private _numNodes;
+        private _nodes;
+        private _numNodesEverEnqueued;
+        constructor(maxNodes: number);
+        clear(): void;
+        readonly count: number;
+        readonly maxSize: number;
+        contains(node: T): boolean;
+        enqueue(node: T, priority: number): void;
+        dequeue(): T;
+        remove(node: T): void;
+        isValidQueue(): boolean;
+        private onNodeUpdated;
+        private cascadeDown;
+        private cascadeUp;
+        private swap;
+        private hasHigherPriority;
+    }
 }
-declare class PriorityQueue<T extends PriorityQueueNode> {
-    private _numNodes;
-    private _nodes;
-    private _numNodesEverEnqueued;
-    constructor(maxNodes: number);
-    clear(): void;
-    readonly count: number;
-    readonly maxSize: number;
-    contains(node: T): boolean;
-    enqueue(node: T, priority: number): void;
-    dequeue(): T;
-    remove(node: T): void;
-    isValidQueue(): boolean;
-    private onNodeUpdated;
-    private cascadeDown;
-    private cascadeUp;
-    private swap;
-    private hasHigherPriority;
+declare module es {
+    class BreadthFirstPathfinder {
+        static search<T>(graph: IUnweightedGraph<T>, start: T, goal: T): T[];
+        private static hasKey;
+    }
 }
-declare class BreadthFirstPathfinder {
-    static search<T>(graph: IUnweightedGraph<T>, start: T, goal: T): T[];
-    private static hasKey;
+declare module es {
+    interface IUnweightedGraph<T> {
+        getNeighbors(node: T): T[];
+    }
 }
-interface IUnweightedGraph<T> {
-    getNeighbors(node: T): T[];
+declare module es {
+    class UnweightedGraph<T> implements IUnweightedGraph<T> {
+        edges: Map<T, T[]>;
+        addEdgesForNode(node: T, edges: T[]): this;
+        getNeighbors(node: T): T[];
+    }
 }
-declare class UnweightedGraph<T> implements IUnweightedGraph<T> {
-    edges: Map<T, T[]>;
-    addEdgesForNode(node: T, edges: T[]): this;
-    getNeighbors(node: T): T[];
+declare module es {
+    class Vector2 {
+        x: number;
+        y: number;
+        private static readonly unitYVector;
+        private static readonly unitXVector;
+        private static readonly unitVector2;
+        private static readonly zeroVector2;
+        static readonly zero: Vector2;
+        static readonly one: Vector2;
+        static readonly unitX: Vector2;
+        static readonly unitY: Vector2;
+        constructor(x?: number, y?: number);
+        static add(value1: Vector2, value2: Vector2): Vector2;
+        static divide(value1: Vector2, value2: Vector2): Vector2;
+        static multiply(value1: Vector2, value2: Vector2): Vector2;
+        static subtract(value1: Vector2, value2: Vector2): Vector2;
+        normalize(): void;
+        length(): number;
+        round(): Vector2;
+        static normalize(value: Vector2): Vector2;
+        static dot(value1: Vector2, value2: Vector2): number;
+        static distanceSquared(value1: Vector2, value2: Vector2): number;
+        static clamp(value1: Vector2, min: Vector2, max: Vector2): Vector2;
+        static lerp(value1: Vector2, value2: Vector2, amount: number): Vector2;
+        static transform(position: Vector2, matrix: Matrix2D): Vector2;
+        static distance(value1: Vector2, value2: Vector2): number;
+        static negate(value: Vector2): Vector2;
+    }
 }
-declare class Vector2 {
-    x: number;
-    y: number;
-    private static readonly unitYVector;
-    private static readonly unitXVector;
-    private static readonly unitVector2;
-    private static readonly zeroVector2;
-    static readonly zero: Vector2;
-    static readonly one: Vector2;
-    static readonly unitX: Vector2;
-    static readonly unitY: Vector2;
-    constructor(x?: number, y?: number);
-    static add(value1: Vector2, value2: Vector2): Vector2;
-    static divide(value1: Vector2, value2: Vector2): Vector2;
-    static multiply(value1: Vector2, value2: Vector2): Vector2;
-    static subtract(value1: Vector2, value2: Vector2): Vector2;
-    normalize(): void;
-    length(): number;
-    round(): Vector2;
-    static normalize(value: Vector2): Vector2;
-    static dot(value1: Vector2, value2: Vector2): number;
-    static distanceSquared(value1: Vector2, value2: Vector2): number;
-    static clamp(value1: Vector2, min: Vector2, max: Vector2): Vector2;
-    static lerp(value1: Vector2, value2: Vector2, amount: number): Vector2;
-    static transform(position: Vector2, matrix: Matrix2D): Vector2;
-    static distance(value1: Vector2, value2: Vector2): number;
-    static negate(value: Vector2): Vector2;
+declare module es {
+    class UnweightedGridGraph implements IUnweightedGraph<Vector2> {
+        private static readonly CARDINAL_DIRS;
+        private static readonly COMPASS_DIRS;
+        walls: Vector2[];
+        private _width;
+        private _hegiht;
+        private _dirs;
+        private _neighbors;
+        constructor(width: number, height: number, allowDiagonalSearch?: boolean);
+        isNodeInBounds(node: Vector2): boolean;
+        isNodePassable(node: Vector2): boolean;
+        getNeighbors(node: Vector2): Vector2[];
+        search(start: Vector2, goal: Vector2): Vector2[];
+    }
 }
-declare class UnweightedGridGraph implements IUnweightedGraph<Vector2> {
-    private static readonly CARDINAL_DIRS;
-    private static readonly COMPASS_DIRS;
-    walls: Vector2[];
-    private _width;
-    private _hegiht;
-    private _dirs;
-    private _neighbors;
-    constructor(width: number, height: number, allowDiagonalSearch?: boolean);
-    isNodeInBounds(node: Vector2): boolean;
-    isNodePassable(node: Vector2): boolean;
-    getNeighbors(node: Vector2): Vector2[];
-    search(start: Vector2, goal: Vector2): Vector2[];
+declare module es {
+    interface IWeightedGraph<T> {
+        getNeighbors(node: T): T[];
+        cost(from: T, to: T): number;
+    }
 }
-interface IWeightedGraph<T> {
-    getNeighbors(node: T): T[];
-    cost(from: T, to: T): number;
+declare module es {
+    class WeightedGridGraph implements IWeightedGraph<Vector2> {
+        static readonly CARDINAL_DIRS: Vector2[];
+        private static readonly COMPASS_DIRS;
+        walls: Vector2[];
+        weightedNodes: Vector2[];
+        defaultWeight: number;
+        weightedNodeWeight: number;
+        private _width;
+        private _height;
+        private _dirs;
+        private _neighbors;
+        constructor(width: number, height: number, allowDiagonalSearch?: boolean);
+        isNodeInBounds(node: Vector2): boolean;
+        isNodePassable(node: Vector2): boolean;
+        search(start: Vector2, goal: Vector2): Vector2[];
+        getNeighbors(node: Vector2): Vector2[];
+        cost(from: Vector2, to: Vector2): number;
+    }
 }
-declare class WeightedGridGraph implements IWeightedGraph<Vector2> {
-    static readonly CARDINAL_DIRS: Vector2[];
-    private static readonly COMPASS_DIRS;
-    walls: Vector2[];
-    weightedNodes: Vector2[];
-    defaultWeight: number;
-    weightedNodeWeight: number;
-    private _width;
-    private _height;
-    private _dirs;
-    private _neighbors;
-    constructor(width: number, height: number, allowDiagonalSearch?: boolean);
-    isNodeInBounds(node: Vector2): boolean;
-    isNodePassable(node: Vector2): boolean;
-    search(start: Vector2, goal: Vector2): Vector2[];
-    getNeighbors(node: Vector2): Vector2[];
-    cost(from: Vector2, to: Vector2): number;
+declare module es {
+    class WeightedNode<T> extends PriorityQueueNode {
+        data: T;
+        constructor(data: T);
+    }
+    class WeightedPathfinder {
+        static search<T>(graph: IWeightedGraph<T>, start: T, goal: T): T[];
+        private static hasKey;
+        private static getKey;
+        static recontructPath<T>(cameFrom: Map<T, T>, start: T, goal: T): T[];
+    }
 }
-declare class WeightedNode<T> extends PriorityQueueNode {
-    data: T;
-    constructor(data: T);
+declare module es {
+    class Debug {
+        private static _debugDrawItems;
+        static drawHollowRect(rectanle: Rectangle, color: number, duration?: number): void;
+        static render(): void;
+    }
 }
-declare class WeightedPathfinder {
-    static search<T>(graph: IWeightedGraph<T>, start: T, goal: T): T[];
-    private static hasKey;
-    private static getKey;
-    static recontructPath<T>(cameFrom: Map<T, T>, start: T, goal: T): T[];
+declare module es {
+    class DebugDefaults {
+        static verletParticle: number;
+        static verletConstraintEdge: number;
+    }
 }
-declare class Debug {
-    private static _debugDrawItems;
-    static drawHollowRect(rectanle: Rectangle, color: number, duration?: number): void;
-    static render(): void;
+declare module es {
+    enum DebugDrawType {
+        line = 0,
+        hollowRectangle = 1,
+        pixel = 2,
+        text = 3
+    }
+    class DebugDrawItem {
+        rectangle: Rectangle;
+        color: number;
+        duration: number;
+        drawType: DebugDrawType;
+        text: string;
+        start: Vector2;
+        end: Vector2;
+        x: number;
+        y: number;
+        size: number;
+        constructor(rectangle: Rectangle, color: number, duration: number);
+        draw(shape: egret.Shape): boolean;
+    }
 }
-declare class DebugDefaults {
-    static verletParticle: number;
-    static verletConstraintEdge: number;
+declare module es {
+    abstract class Component {
+        entity: Entity;
+        readonly transform: Transform;
+        enabled: boolean;
+        updateOrder: number;
+        updateInterval: number;
+        private _enabled;
+        private _updateOrder;
+        initialize(): void;
+        onAddedToEntity(): void;
+        onRemovedFromEntity(): void;
+        onEntityTransformChanged(comp: transform.Component): void;
+        debugRender(): void;
+        onEnabled(): void;
+        onDisabled(): void;
+        update(): void;
+        setEnabled(isEnabled: boolean): this;
+        setUpdateOrder(updateOrder: number): this;
+        clone(): Component;
+    }
 }
-declare enum DebugDrawType {
-    line = 0,
-    hollowRectangle = 1,
-    pixel = 2,
-    text = 3
+declare module es {
+    enum CoreEvents {
+        SceneChanged = 0
+    }
 }
-declare class DebugDrawItem {
-    rectangle: Rectangle;
-    color: number;
-    duration: number;
-    drawType: DebugDrawType;
-    text: string;
-    start: Vector2;
-    end: Vector2;
-    x: number;
-    y: number;
-    size: number;
-    constructor(rectangle: Rectangle, color: number, duration: number);
-    draw(shape: egret.Shape): boolean;
+declare module es {
+    class Entity {
+        static _idGenerator: number;
+        scene: Scene;
+        name: string;
+        readonly id: number;
+        readonly transform: Transform;
+        readonly components: ComponentList;
+        tag: number;
+        updateInterval: number;
+        enabled: boolean;
+        updateOrder: number;
+        _isDestroyed: boolean;
+        readonly isDestroyed: boolean;
+        componentBits: BitSet;
+        private _tag;
+        private _enabled;
+        private _updateOrder;
+        parent: Transform;
+        readonly childCount: number;
+        position: Vector2;
+        rotation: number;
+        scale: Vector2;
+        constructor(name: string);
+        onTransformChanged(comp: transform.Component): void;
+        setTag(tag: number): Entity;
+        setEnabled(isEnabled: boolean): this;
+        setUpdateOrder(updateOrder: number): this;
+        destroy(): void;
+        detachFromScene(): void;
+        attachToScene(newScene: Scene): void;
+        clone(position?: Vector2): Entity;
+        protected copyFrom(entity: Entity): void;
+        onAddedToScene(): void;
+        onRemovedFromScene(): void;
+        update(): void;
+        addComponent<T extends Component>(component: T): T;
+        getComponent<T extends Component>(type: any): T;
+        hasComponent<T extends Component>(type: any): boolean;
+        getOrCreateComponent<T extends Component>(type: T): T;
+        getComponents(typeName: string | any, componentList?: any): any;
+        removeComponent(component: Component): void;
+        removeComponentForType<T extends Component>(type: any): boolean;
+        removeAllComponents(): void;
+        toString(): string;
+    }
 }
-declare abstract class Component extends egret.DisplayObjectContainer {
-    entity: Entity;
-    private _enabled;
-    updateInterval: number;
-    userData: any;
-    private _updateOrder;
-    enabled: boolean;
-    readonly localPosition: Vector2;
-    setEnabled(isEnabled: boolean): this;
-    updateOrder: number;
-    setUpdateOrder(updateOrder: number): this;
-    initialize(): void;
-    onAddedToEntity(): void;
-    onRemovedFromEntity(): void;
-    onEnabled(): void;
-    onDisabled(): void;
-    debugRender(): void;
-    update(): void;
-    onEntityTransformChanged(comp: TransformComponent): void;
-    registerComponent(): void;
-    deregisterComponent(): void;
+declare module es {
+    class Scene extends egret.DisplayObjectContainer {
+        camera: Camera;
+        readonly content: ContentManager;
+        enablePostProcessing: boolean;
+        readonly entities: EntityList;
+        readonly renderableComponents: RenderableComponentList;
+        readonly entityProcessors: EntityProcessorList;
+        _renderers: Renderer[];
+        readonly _postProcessors: PostProcessor[];
+        _didSceneBegin: any;
+        static createWithDefaultRenderer(): Scene;
+        constructor();
+        initialize(): void;
+        onStart(): Promise<void>;
+        unload(): void;
+        onActive(): void;
+        onDeactive(): void;
+        begin(): Promise<void>;
+        end(): void;
+        update(): void;
+        render(): void;
+        postRender(): void;
+        addRenderer<T extends Renderer>(renderer: T): T;
+        getRenderer<T extends Renderer>(type: any): T;
+        removeRenderer(renderer: Renderer): void;
+        addPostProcessor<T extends PostProcessor>(postProcessor: T): T;
+        getPostProcessor<T extends PostProcessor>(type: any): T;
+        removePostProcessor(postProcessor: PostProcessor): void;
+        createEntity(name: string): Entity;
+        addEntity(entity: Entity): Entity;
+        destroyAllEntities(): void;
+        findEntity(name: string): Entity;
+        findEntitiesWithTag(tag: number): Entity[];
+        entitiesOfType<T extends Entity>(type: any): T[];
+        findComponentOfType<T extends Component>(type: any): T;
+        findComponentsOfType<T extends Component>(type: any): T[];
+        addEntityProcessor(processor: EntitySystem): EntitySystem;
+        removeEntityProcessor(processor: EntitySystem): void;
+        getEntityProcessor<T extends EntitySystem>(): T;
+    }
 }
-declare enum CoreEvents {
-    SceneChanged = 0
+declare module es {
+    class SceneManager {
+        private static _scene;
+        private static _nextScene;
+        static sceneTransition: SceneTransition;
+        static stage: egret.Stage;
+        static activeSceneChanged: Function;
+        static emitter: Emitter<CoreEvents>;
+        static content: ContentManager;
+        private static _instnace;
+        private static timerRuler;
+        static readonly Instance: SceneManager;
+        constructor(stage: egret.Stage);
+        static scene: Scene;
+        static initialize(stage: egret.Stage): void;
+        static update(): void;
+        static render(): void;
+        static startSceneTransition<T extends SceneTransition>(sceneTransition: T): T;
+        static registerActiveSceneChanged(current: Scene, next: Scene): void;
+        onSceneChanged(): void;
+        private static startDebugUpdate;
+        private static endDebugUpdate;
+    }
 }
-declare class Entity extends egret.DisplayObjectContainer {
-    private static _idGenerator;
-    name: string;
-    readonly id: number;
-    scene: Scene;
-    readonly components: ComponentList;
-    private _updateOrder;
-    private _enabled;
-    _isDestoryed: boolean;
-    private _tag;
-    componentBits: BitSet;
-    readonly isDestoryed: boolean;
-    position: Vector2;
-    scale: Vector2;
-    rotation: number;
-    enabled: boolean;
-    setEnabled(isEnabled: boolean): this;
-    tag: number;
-    readonly stage: egret.Stage;
-    constructor(name: string);
-    private onAddToStage;
-    updateOrder: number;
-    roundPosition(): void;
-    setUpdateOrder(updateOrder: number): this;
-    setTag(tag: number): Entity;
-    attachToScene(newScene: Scene): void;
-    detachFromScene(): void;
-    addComponent<T extends Component>(component: T): T;
-    hasComponent<T extends Component>(type: any): boolean;
-    getOrCreateComponent<T extends Component>(type: T): T;
-    getComponent<T extends Component>(type: any): T;
-    getComponents(typeName: string | any, componentList?: any): any;
-    onEntityTransformChanged(comp: TransformComponent): void;
-    removeComponentForType<T extends Component>(type: any): boolean;
-    removeComponent(component: Component): void;
-    removeAllComponents(): void;
-    update(): void;
-    onAddedToScene(): void;
-    onRemovedFromScene(): void;
-    destroy(): void;
+declare module transform {
+    enum Component {
+        position = 0,
+        scale = 1,
+        rotation = 2
+    }
 }
-declare enum TransformComponent {
-    rotation = 0,
-    scale = 1,
-    position = 2
+declare module es {
+    enum DirtyType {
+        clean = 0,
+        positionDirty = 1,
+        scaleDirty = 2,
+        rotationDirty = 3
+    }
+    class Transform {
+        readonly entity: Entity;
+        parent: Transform;
+        readonly childCount: number;
+        position: Vector2;
+        rotation: number;
+        scale: Vector2;
+        _parent: Transform;
+        hierarchyDirty: DirtyType;
+        _children: Transform[];
+        constructor(entity: Entity);
+        getChild(index: number): Transform;
+        setParent(parent: Transform): Transform;
+        setPosition(x: number, y: number): Transform;
+        setRotation(degrees: number): Transform;
+        setScale(scale: Vector2): Transform;
+        lookAt(pos: Vector2): void;
+        roundPosition(): void;
+        setDirty(dirtyFlagType: DirtyType): void;
+        copyFrom(transform: Transform): void;
+    }
 }
-declare class Scene extends egret.DisplayObjectContainer {
-    camera: Camera;
-    readonly entities: EntityList;
-    readonly renderableComponents: RenderableComponentList;
-    readonly content: ContentManager;
-    enablePostProcessing: boolean;
-    private _renderers;
-    private _postProcessors;
-    private _didSceneBegin;
-    readonly entityProcessors: EntityProcessorList;
-    constructor();
-    createEntity(name: string): Entity;
-    addEntity(entity: Entity): Entity;
-    destroyAllEntities(): void;
-    findEntity(name: string): Entity;
-    addEntityProcessor(processor: EntitySystem): EntitySystem;
-    removeEntityProcessor(processor: EntitySystem): void;
-    getEntityProcessor<T extends EntitySystem>(): T;
-    addRenderer<T extends Renderer>(renderer: T): T;
-    getRenderer<T extends Renderer>(type: any): T;
-    removeRenderer(renderer: Renderer): void;
-    begin(): void;
-    end(): void;
-    protected onStart(): Promise<void>;
-    protected onActive(): void;
-    protected onDeactive(): void;
-    protected unload(): void;
-    update(): void;
-    postRender(): void;
-    render(): void;
-    addPostProcessor<T extends PostProcessor>(postProcessor: T): T;
+declare module es {
+    enum CameraStyle {
+        lockOn = 0,
+        cameraWindow = 1
+    }
+    class Camera extends Component {
+        position: Vector2;
+        rotation: number;
+        zoom: number;
+        minimumZoom: number;
+        maximumZoom: number;
+        readonly bounds: Rectangle;
+        origin: Vector2;
+        private _zoom;
+        private _minimumZoom;
+        private _maximumZoom;
+        private _origin;
+        followLerp: number;
+        deadzone: Rectangle;
+        focusOffset: Vector2;
+        mapLockEnabled: boolean;
+        mapSize: Vector2;
+        _targetEntity: Entity;
+        _targetCollider: Collider;
+        _desiredPositionDelta: Vector2;
+        _cameraStyle: CameraStyle;
+        _worldSpaceDeadZone: Rectangle;
+        constructor(targetEntity?: Entity, cameraStyle?: CameraStyle);
+        onSceneSizeChanged(newWidth: number, newHeight: number): void;
+        setPosition(position: Vector2): this;
+        setRotation(rotation: number): Camera;
+        setZoom(zoom: number): Camera;
+        setMinimumZoom(minZoom: number): Camera;
+        setMaximumZoom(maxZoom: number): Camera;
+        zoomIn(deltaZoom: number): void;
+        zoomOut(deltaZoom: number): void;
+        onAddedToEntity(): void;
+        update(): void;
+        clampToMapSize(position: Vector2): Vector2;
+        updateFollow(): void;
+        follow(targetEntity: Entity, cameraStyle?: CameraStyle): void;
+        setCenteredDeadzone(width: number, height: number): void;
+    }
 }
-declare class SceneManager {
-    private static _scene;
-    private static _nextScene;
-    static sceneTransition: SceneTransition;
-    static stage: egret.Stage;
-    static activeSceneChanged: Function;
-    static emitter: Emitter<CoreEvents>;
-    static content: ContentManager;
-    private static _instnace;
-    private static timerRuler;
-    static readonly Instance: SceneManager;
-    constructor(stage: egret.Stage);
-    static scene: Scene;
-    static initialize(stage: egret.Stage): void;
-    static update(): void;
-    static render(): void;
-    static startSceneTransition<T extends SceneTransition>(sceneTransition: T): T;
-    static registerActiveSceneChanged(current: Scene, next: Scene): void;
-    onSceneChanged(): void;
-    private static startDebugUpdate;
-    private static endDebugUpdate;
+declare module es {
+    class ComponentPool<T extends PooledComponent> {
+        private _cache;
+        private _type;
+        constructor(typeClass: any);
+        obtain(): T;
+        free(component: T): void;
+    }
 }
-declare class Camera extends Component {
-    private _zoom;
-    private _origin;
-    private _minimumZoom;
-    private _maximumZoom;
-    private _position;
-    followLerp: number;
-    deadzone: Rectangle;
-    focusOffset: Vector2;
-    mapLockEnabled: boolean;
-    mapSize: Vector2;
-    targetEntity: Entity;
-    private _worldSpaceDeadZone;
-    private _desiredPositionDelta;
-    private _targetCollider;
-    cameraStyle: CameraStyle;
-    zoom: number;
-    minimumZoom: number;
-    maximumZoom: number;
-    origin: Vector2;
-    position: Vector2;
-    x: number;
-    y: number;
-    constructor();
-    onSceneSizeChanged(newWidth: number, newHeight: number): void;
-    setMinimumZoom(minZoom: number): Camera;
-    setMaximumZoom(maxZoom: number): Camera;
-    setZoom(zoom: number): Camera;
-    setRotation(rotation: number): Camera;
-    setPosition(position: Vector2): this;
-    follow(targetEntity: Entity, cameraStyle?: CameraStyle): void;
-    update(): void;
-    private clampToMapSize;
-    private updateFollow;
+declare module es {
+    class IUpdatableComparer {
+        compare(a: Component, b: Component): number;
+    }
 }
-declare enum CameraStyle {
-    lockOn = 0,
-    cameraWindow = 1
+declare module es {
+    abstract class PooledComponent extends Component {
+        abstract reset(): any;
+    }
 }
-declare class ComponentPool<T extends PooledComponent> {
-    private _cache;
-    private _type;
-    constructor(typeClass: any);
-    obtain(): T;
-    free(component: T): void;
+declare module es {
+    abstract class RenderableComponent extends Component implements IRenderable {
+        readonly width: number;
+        readonly height: number;
+        readonly bounds: Rectangle;
+        renderLayer: number;
+        color: number;
+        localOffset: Vector2;
+        isVisible: boolean;
+        protected _localOffset: Vector2;
+        protected _renderLayer: number;
+        protected _bounds: Rectangle;
+        private _isVisible;
+        protected _areBoundsDirty: boolean;
+        onEntityTransformChanged(comp: transform.Component): void;
+        abstract render(camera: Camera): any;
+        protected onBecameVisible(): void;
+        protected onBecameInvisible(): void;
+        isVisibleFromCamera(camera: Camera): boolean;
+        setRenderLayer(renderLayer: number): RenderableComponent;
+        setColor(color: number): RenderableComponent;
+        setLocalOffset(offset: Vector2): RenderableComponent;
+        toString(): string;
+    }
 }
-declare abstract class PooledComponent extends Component {
-    abstract reset(): any;
+declare module es {
+    class Mesh extends RenderableComponent {
+        private _mesh;
+        constructor();
+        setTexture(texture: egret.Texture): Mesh;
+        reset(): void;
+        render(camera: es.Camera): void;
+    }
 }
-declare abstract class RenderableComponent extends PooledComponent implements IRenderable {
-    private _isVisible;
-    protected _areBoundsDirty: boolean;
-    protected _bounds: Rectangle;
-    protected _localOffset: Vector2;
-    color: number;
-    readonly width: number;
-    readonly height: number;
-    isVisible: boolean;
-    readonly bounds: Rectangle;
-    protected getWidth(): number;
-    protected getHeight(): number;
-    protected onBecameVisible(): void;
-    protected onBecameInvisible(): void;
-    abstract render(camera: Camera): any;
-    isVisibleFromCamera(camera: Camera): boolean;
+declare module es {
+    class SpriteRenderer extends RenderableComponent {
+        readonly bounds: Rectangle;
+        origin: Vector2;
+        originNormalized: Vector2;
+        sprite: Sprite;
+        protected _origin: Vector2;
+        protected _sprite: Sprite;
+        constructor(sprite?: Sprite | egret.Texture);
+        setSprite(sprite: Sprite): SpriteRenderer;
+        setOrigin(origin: Vector2): SpriteRenderer;
+        setOriginNormalized(value: Vector2): SpriteRenderer;
+        render(camera: Camera): void;
+    }
 }
-declare class Mesh extends RenderableComponent {
-    private _mesh;
-    constructor();
-    setTexture(texture: egret.Texture): Mesh;
-    onAddedToEntity(): void;
-    onRemovedFromEntity(): void;
-    render(camera: Camera): void;
-    reset(): void;
+declare module es {
+    class TiledSpriteRenderer extends SpriteRenderer {
+        protected sourceRect: Rectangle;
+        protected leftTexture: egret.Bitmap;
+        protected rightTexture: egret.Bitmap;
+        scrollX: number;
+        scrollY: number;
+        constructor(sprite: Sprite);
+        render(camera: es.Camera): void;
+    }
 }
-declare class SpriteRenderer extends RenderableComponent {
-    private _sprite;
-    protected bitmap: egret.Bitmap;
-    sprite: Sprite;
-    setSprite(sprite: Sprite): SpriteRenderer;
-    setColor(color: number): SpriteRenderer;
-    isVisibleFromCamera(camera: Camera): boolean;
-    render(camera: Camera): void;
-    onRemovedFromEntity(): void;
-    reset(): void;
+declare module es {
+    class ScrollingSpriteRenderer extends TiledSpriteRenderer {
+        scrollSpeedX: number;
+        scroolSpeedY: number;
+        private _scrollX;
+        private _scrollY;
+        update(): void;
+        render(camera: Camera): void;
+    }
 }
-declare class TiledSpriteRenderer extends SpriteRenderer {
-    protected sourceRect: Rectangle;
-    protected leftTexture: egret.Bitmap;
-    protected rightTexture: egret.Bitmap;
-    scrollX: number;
-    scrollY: number;
-    constructor(sprite: Sprite);
-    render(camera: Camera): void;
+declare module es {
+    class Sprite {
+        texture2D: egret.Texture;
+        readonly sourceRect: Rectangle;
+        readonly center: Vector2;
+        origin: Vector2;
+        readonly uvs: Rectangle;
+        constructor(texture: egret.Texture, sourceRect?: Rectangle, origin?: Vector2);
+    }
 }
-declare class ScrollingSpriteRenderer extends TiledSpriteRenderer {
-    scrollSpeedX: number;
-    scroolSpeedY: number;
-    private _scrollX;
-    private _scrollY;
-    update(): void;
-    render(camera: Camera): void;
+declare module es {
+    class SpriteAnimation {
+        readonly sprites: Sprite[];
+        readonly frameRate: number;
+        constructor(sprites: Sprite[], frameRate: number);
+    }
 }
-declare class Sprite {
-    texture2D: egret.Texture;
-    readonly sourceRect: Rectangle;
-    readonly center: Vector2;
-    origin: Vector2;
-    readonly uvs: Rectangle;
-    constructor(texture: egret.Texture, sourceRect?: Rectangle, origin?: Vector2);
+declare module es {
+    enum LoopMode {
+        loop = 0,
+        once = 1,
+        clampForever = 2,
+        pingPong = 3,
+        pingPongOnce = 4
+    }
+    enum State {
+        none = 0,
+        running = 1,
+        paused = 2,
+        completed = 3
+    }
+    class SpriteAnimator extends SpriteRenderer {
+        onAnimationCompletedEvent: (string: any) => {};
+        speed: number;
+        animationState: State;
+        currentAnimation: SpriteAnimation;
+        currentAnimationName: string;
+        currentFrame: number;
+        readonly isRunning: boolean;
+        readonly animations: Map<string, SpriteAnimation>;
+        private _animations;
+        _elapsedTime: number;
+        _loopMode: LoopMode;
+        constructor(sprite?: Sprite);
+        update(): void;
+        addAnimation(name: string, animation: SpriteAnimation): SpriteAnimator;
+        play(name: string, loopMode?: LoopMode): void;
+        isAnimationActive(name: string): boolean;
+        pause(): void;
+        unPause(): void;
+        stop(): void;
+    }
 }
-declare class SpriteAnimation {
-    readonly sprites: Sprite[];
-    readonly frameRate: number;
-    constructor(sprites: Sprite[], frameRate: number);
+declare module es {
+    interface ITriggerListener {
+        onTriggerEnter(other: Collider, local: Collider): any;
+        onTriggerExit(other: Collider, local: Collider): any;
+    }
 }
-declare class SpriteAnimator extends SpriteRenderer {
-    onAnimationCompletedEvent: Function;
-    speed: number;
-    animationState: State;
-    currentAnimation: SpriteAnimation;
-    currentAnimationName: string;
-    currentFrame: number;
-    readonly isRunning: boolean;
-    readonly animations: Map<string, SpriteAnimation>;
-    private _animations;
-    private _elapsedTime;
-    private _loopMode;
-    constructor(sprite?: Sprite);
-    addAnimation(name: string, animation: SpriteAnimation): SpriteAnimator;
-    play(name: string, loopMode?: LoopMode): void;
-    isAnimationActive(name: string): boolean;
-    pause(): void;
-    unPause(): void;
-    stop(): void;
-    update(): void;
+declare module es {
+    class Mover extends Component {
+        private _triggerHelper;
+        onAddedToEntity(): void;
+        calculateMovement(motion: Vector2): {
+            collisionResult: CollisionResult;
+            motion: Vector2;
+        };
+        applyMovement(motion: Vector2): void;
+        move(motion: Vector2): CollisionResult;
+    }
 }
-declare enum LoopMode {
-    loop = 0,
-    once = 1,
-    clampForever = 2,
-    pingPong = 3,
-    pingPongOnce = 4
+declare module es {
+    class ProjectileMover extends Component {
+        private _tempTriggerList;
+        private _collider;
+        onAddedToEntity(): void;
+        move(motion: Vector2): boolean;
+        private notifyTriggerListeners;
+    }
 }
-declare enum State {
-    none = 0,
-    running = 1,
-    paused = 2,
-    completed = 3
+declare module es {
+    abstract class Collider extends Component {
+        shape: Shape;
+        localOffset: Vector2;
+        readonly absolutePosition: Vector2;
+        readonly rotation: number;
+        isTrigger: boolean;
+        physicsLayer: number;
+        collidesWithLayers: number;
+        shouldColliderScaleAndRotateWithTransform: boolean;
+        readonly bounds: Rectangle;
+        registeredPhysicsBounds: Rectangle;
+        protected _colliderRequiresAutoSizing: any;
+        protected _localOffset: Vector2;
+        _localOffsetLength: number;
+        protected _isParentEntityAddedToScene: any;
+        protected _isColliderRegistered: any;
+        setLocalOffset(offset: Vector2): Collider;
+        setShouldColliderScaleAndRotateWithTransform(shouldColliderScaleAndRotationWithTransform: boolean): Collider;
+        onAddedToEntity(): void;
+        onRemovedFromEntity(): void;
+        onEntityTransformChanged(comp: transform.Component): void;
+        onEnabled(): void;
+        onDisabled(): void;
+        registerColliderWithPhysicsSystem(): void;
+        unregisterColliderWithPhysicsSystem(): void;
+        overlaps(other: Collider): any;
+        collidesWith(collider: Collider, motion: Vector2): CollisionResult;
+    }
 }
-interface ITriggerListener {
-    onTriggerEnter(other: Collider, local: Collider): any;
-    onTriggerExit(other: Collider, local: Collider): any;
+declare module es {
+    class BoxCollider extends Collider {
+        width: number;
+        height: number;
+        constructor();
+        setSize(width: number, height: number): this;
+        setWidth(width: number): BoxCollider;
+        setHeight(height: number): void;
+        toString(): string;
+    }
 }
-declare class Mover extends Component {
-    private _triggerHelper;
-    onAddedToEntity(): void;
-    calculateMovement(motion: Vector2): {
-        collisionResult: CollisionResult;
-        motion: Vector2;
-    };
-    applyMovement(motion: Vector2): void;
-    move(motion: Vector2): CollisionResult;
+declare module es {
+    class CircleCollider extends Collider {
+        radius: number;
+        constructor(radius?: number);
+        setRadius(radius: number): CircleCollider;
+        toString(): string;
+    }
 }
-declare class ProjectileMover extends Component {
-    private _tempTriggerList;
-    private _collider;
-    onAddedToEntity(): void;
-    move(motion: Vector2): boolean;
-    private notifyTriggerListeners;
+declare module es {
+    class PolygonCollider extends Collider {
+        constructor(points: Vector2[]);
+    }
 }
-declare abstract class Collider extends Component {
-    shape: Shape;
-    physicsLayer: number;
-    isTrigger: boolean;
-    registeredPhysicsBounds: Rectangle;
-    shouldColliderScaleAndRotateWithTransform: boolean;
-    collidesWithLayers: number;
-    protected _isParentEntityAddedToScene: any;
-    protected _colliderRequiresAutoSizing: any;
-    protected _isColliderRegistered: any;
-    readonly bounds: Rectangle;
-    registerColliderWithPhysicsSystem(): void;
-    unregisterColliderWithPhysicsSystem(): void;
-    overlaps(other: Collider): any;
-    collidesWith(collider: Collider, motion: Vector2): CollisionResult;
-    onAddedToEntity(): void;
-    onRemovedFromEntity(): void;
-    onEnabled(): void;
-    onDisabled(): void;
-    onEntityTransformChanged(comp: TransformComponent): void;
-    update(): void;
+declare module es {
+    class EntitySystem {
+        private _scene;
+        private _entities;
+        private _matcher;
+        readonly matcher: Matcher;
+        scene: Scene;
+        constructor(matcher?: Matcher);
+        initialize(): void;
+        onChanged(entity: Entity): void;
+        add(entity: Entity): void;
+        onAdded(entity: Entity): void;
+        remove(entity: Entity): void;
+        onRemoved(entity: Entity): void;
+        update(): void;
+        lateUpdate(): void;
+        protected begin(): void;
+        protected process(entities: Entity[]): void;
+        protected lateProcess(entities: Entity[]): void;
+        protected end(): void;
+    }
 }
-declare class BoxCollider extends Collider {
-    width: number;
-    setWidth(width: number): BoxCollider;
-    height: number;
-    setHeight(height: number): void;
-    constructor();
-    setSize(width: number, height: number): this;
+declare module es {
+    abstract class EntityProcessingSystem extends EntitySystem {
+        constructor(matcher: Matcher);
+        abstract processEntity(entity: Entity): any;
+        lateProcessEntity(entity: Entity): void;
+        protected process(entities: Entity[]): void;
+        protected lateProcess(entities: Entity[]): void;
+    }
 }
-declare class CircleCollider extends Collider {
-    radius: number;
-    constructor(radius?: number);
-    setRadius(radius: number): CircleCollider;
+declare module es {
+    abstract class PassiveSystem extends EntitySystem {
+        onChanged(entity: Entity): void;
+        protected process(entities: Entity[]): void;
+    }
 }
-declare class PolygonCollider extends Collider {
-    constructor(points: Vector2[]);
+declare module es {
+    abstract class ProcessingSystem extends EntitySystem {
+        onChanged(entity: Entity): void;
+        protected process(entities: Entity[]): void;
+        abstract processSystem(): any;
+    }
 }
-declare class EntitySystem {
-    private _scene;
-    private _entities;
-    private _matcher;
-    readonly matcher: Matcher;
-    scene: Scene;
-    constructor(matcher?: Matcher);
-    initialize(): void;
-    onChanged(entity: Entity): void;
-    add(entity: Entity): void;
-    onAdded(entity: Entity): void;
-    remove(entity: Entity): void;
-    onRemoved(entity: Entity): void;
-    update(): void;
-    lateUpdate(): void;
-    protected begin(): void;
-    protected process(entities: Entity[]): void;
-    protected lateProcess(entities: Entity[]): void;
-    protected end(): void;
+declare module es {
+    class BitSet {
+        private static LONG_MASK;
+        private _bits;
+        constructor(nbits?: number);
+        and(bs: BitSet): void;
+        andNot(bs: BitSet): void;
+        cardinality(): number;
+        clear(pos?: number): void;
+        private ensure;
+        get(pos: number): boolean;
+        intersects(set: BitSet): boolean;
+        isEmpty(): boolean;
+        nextSetBit(from: number): number;
+        set(pos: number, value?: boolean): void;
+    }
 }
-declare abstract class EntityProcessingSystem extends EntitySystem {
-    constructor(matcher: Matcher);
-    abstract processEntity(entity: Entity): any;
-    lateProcessEntity(entity: Entity): void;
-    protected process(entities: Entity[]): void;
-    protected lateProcess(entities: Entity[]): void;
+declare module es {
+    class ComponentList {
+        static compareUpdatableOrder: IUpdatableComparer;
+        _entity: Entity;
+        _components: Component[];
+        _componentsToAdd: Component[];
+        _componentsToRemove: Component[];
+        _tempBufferList: Component[];
+        _isComponentListUnsorted: boolean;
+        constructor(entity: Entity);
+        readonly count: number;
+        readonly buffer: Component[];
+        markEntityListUnsorted(): void;
+        add(component: Component): void;
+        remove(component: Component): void;
+        removeAllComponents(): void;
+        deregisterAllComponents(): void;
+        registerAllComponents(): void;
+        updateLists(): void;
+        handleRemove(component: Component): void;
+        getComponent<T extends Component>(type: any, onlyReturnInitializedComponents: boolean): T;
+        getComponents(typeName: string | any, components?: any): any;
+        update(): void;
+        onEntityTransformChanged(comp: transform.Component): void;
+        onEntityEnabled(): void;
+        onEntityDisabled(): void;
+    }
 }
-declare abstract class PassiveSystem extends EntitySystem {
-    onChanged(entity: Entity): void;
-    protected process(entities: Entity[]): void;
+declare module es {
+    class ComponentTypeManager {
+        private static _componentTypesMask;
+        static add(type: any): void;
+        static getIndexFor(type: any): number;
+    }
 }
-declare abstract class ProcessingSystem extends EntitySystem {
-    onChanged(entity: Entity): void;
-    protected process(entities: Entity[]): void;
-    abstract processSystem(): any;
+declare module es {
+    class EntityList {
+        scene: Scene;
+        private _entitiesToRemove;
+        private _entitiesToAdded;
+        private _tempEntityList;
+        private _entities;
+        private _entityDict;
+        private _unsortedTags;
+        constructor(scene: Scene);
+        readonly count: number;
+        readonly buffer: Entity[];
+        add(entity: Entity): void;
+        remove(entity: Entity): void;
+        findEntity(name: string): Entity;
+        entitiesWithTag(tag: number): Entity[];
+        entitiesOfType<T extends Entity>(type: any): T[];
+        findComponentOfType<T extends Component>(type: any): T;
+        findComponentsOfType<T extends Component>(type: any): T[];
+        getTagList(tag: number): Entity[];
+        addToTagList(entity: Entity): void;
+        removeFromTagList(entity: Entity): void;
+        update(): void;
+        removeAllEntities(): void;
+        updateLists(): void;
+    }
 }
-declare class BitSet {
-    private static LONG_MASK;
-    private _bits;
-    constructor(nbits?: number);
-    and(bs: BitSet): void;
-    andNot(bs: BitSet): void;
-    cardinality(): number;
-    clear(pos?: number): void;
-    private ensure;
-    get(pos: number): boolean;
-    intersects(set: BitSet): boolean;
-    isEmpty(): boolean;
-    nextSetBit(from: number): number;
-    set(pos: number, value?: boolean): void;
+declare module es {
+    class EntityProcessorList {
+        private _processors;
+        add(processor: EntitySystem): void;
+        remove(processor: EntitySystem): void;
+        onComponentAdded(entity: Entity): void;
+        onComponentRemoved(entity: Entity): void;
+        onEntityAdded(entity: Entity): void;
+        onEntityRemoved(entity: Entity): void;
+        protected notifyEntityChanged(entity: Entity): void;
+        protected removeFromProcessors(entity: Entity): void;
+        begin(): void;
+        update(): void;
+        lateUpdate(): void;
+        end(): void;
+        getProcessor<T extends EntitySystem>(): T;
+    }
 }
-declare class ComponentList {
-    private _entity;
-    private _components;
-    private _componentsToAdd;
-    private _componentsToRemove;
-    private _tempBufferList;
-    constructor(entity: Entity);
-    readonly count: number;
-    readonly buffer: Component[];
-    add(component: Component): void;
-    remove(component: Component): void;
-    removeAllComponents(): void;
-    deregisterAllComponents(): void;
-    registerAllComponents(): void;
-    updateLists(): void;
-    onEntityTransformChanged(comp: TransformComponent): void;
-    private handleRemove;
-    getComponent<T extends Component>(type: any, onlyReturnInitializedComponents: boolean): T;
-    getComponents(typeName: string | any, components?: any): any;
-    update(): void;
-}
-declare class ComponentTypeManager {
-    private static _componentTypesMask;
-    static add(type: any): void;
-    static getIndexFor(type: any): number;
-}
-declare class EntityList {
-    scene: Scene;
-    private _entitiesToRemove;
-    private _entitiesToAdded;
-    private _tempEntityList;
-    private _entities;
-    private _entityDict;
-    private _unsortedTags;
-    constructor(scene: Scene);
-    readonly count: number;
-    readonly buffer: Entity[];
-    add(entity: Entity): void;
-    remove(entity: Entity): void;
-    findEntity(name: string): Entity;
-    getTagList(tag: number): Entity[];
-    addToTagList(entity: Entity): void;
-    removeFromTagList(entity: Entity): void;
-    update(): void;
-    removeAllEntities(): void;
-    updateLists(): void;
-}
-declare class EntityProcessorList {
-    private _processors;
-    add(processor: EntitySystem): void;
-    remove(processor: EntitySystem): void;
-    onComponentAdded(entity: Entity): void;
-    onComponentRemoved(entity: Entity): void;
-    onEntityAdded(entity: Entity): void;
-    onEntityRemoved(entity: Entity): void;
-    protected notifyEntityChanged(entity: Entity): void;
-    protected removeFromProcessors(entity: Entity): void;
-    begin(): void;
-    update(): void;
-    lateUpdate(): void;
-    end(): void;
-    getProcessor<T extends EntitySystem>(): T;
-}
-declare class Matcher {
-    protected allSet: BitSet;
-    protected exclusionSet: BitSet;
-    protected oneSet: BitSet;
-    static empty(): Matcher;
-    getAllSet(): BitSet;
-    getExclusionSet(): BitSet;
-    getOneSet(): BitSet;
-    IsIntersted(e: Entity): boolean;
-    all(...types: any[]): Matcher;
-    exclude(...types: any[]): this;
-    one(...types: any[]): this;
+declare module es {
+    class Matcher {
+        protected allSet: BitSet;
+        protected exclusionSet: BitSet;
+        protected oneSet: BitSet;
+        static empty(): Matcher;
+        getAllSet(): BitSet;
+        getExclusionSet(): BitSet;
+        getOneSet(): BitSet;
+        IsIntersted(e: Entity): boolean;
+        all(...types: any[]): Matcher;
+        exclude(...types: any[]): this;
+        one(...types: any[]): this;
+    }
 }
 declare class ObjectUtils {
     static clone<T>(p: any, c?: T): T;
 }
-declare class RenderableComponentList {
-    private _components;
-    readonly count: number;
-    readonly buffer: IRenderable[];
-    add(component: IRenderable): void;
-    remove(component: IRenderable): void;
-    updateList(): void;
+declare module es {
+    interface IRenderable {
+        bounds: Rectangle;
+        enabled: boolean;
+        renderLayer: number;
+        isVisible: boolean;
+        isVisibleFromCamera(camera: Camera): any;
+        render(camera: Camera): any;
+    }
+    class RenderableComparer {
+        compare(self: IRenderable, other: IRenderable): number;
+    }
+}
+declare module es {
+    class RenderableComponentList {
+        static compareUpdatableOrder: RenderableComparer;
+        _components: IRenderable[];
+        _componentsByRenderLayer: Map<number, IRenderable[]>;
+        _unsortedRenderLayers: number[];
+        _componentsNeedSort: boolean;
+        readonly count: number;
+        readonly buffer: IRenderable[];
+        add(component: IRenderable): void;
+        remove(component: IRenderable): void;
+        updateRenderableRenderLayer(component: IRenderable, oldRenderLayer: number, newRenderLayer: number): void;
+        setRenderLayerNeedsComponentSort(renderLayer: number): void;
+        setNeedsComponentSort(): void;
+        addToRenderLayerList(component: IRenderable, renderLayer: number): void;
+        componentsWithRenderLayer(renderLayer: number): IRenderable[];
+        updateList(): void;
+    }
 }
 declare class StringUtils {
     static matchChineseWord(str: string): string[];
@@ -674,25 +868,29 @@ declare class StringUtils {
     static cutOff(str: string, start: number, len: number, order?: boolean): string;
     static strReplace(str: string, rStr: string[]): string;
 }
-declare class TextureUtils {
-    static sharedCanvas: HTMLCanvasElement;
-    static sharedContext: CanvasRenderingContext2D;
-    static convertImageToCanvas(texture: egret.Texture, rect?: egret.Rectangle): HTMLCanvasElement;
-    static toDataURL(type: string, texture: egret.Texture, rect?: egret.Rectangle, encoderOptions?: any): string;
-    static eliFoTevas(type: string, texture: egret.Texture, filePath: string, rect?: egret.Rectangle, encoderOptions?: any): void;
-    static getPixel32(texture: egret.Texture, x: number, y: number): number[];
-    static getPixels(texture: egret.Texture, x: number, y: number, width?: number, height?: number): number[];
+declare module es {
+    class TextureUtils {
+        static sharedCanvas: HTMLCanvasElement;
+        static sharedContext: CanvasRenderingContext2D;
+        static convertImageToCanvas(texture: egret.Texture, rect?: egret.Rectangle): HTMLCanvasElement;
+        static toDataURL(type: string, texture: egret.Texture, rect?: egret.Rectangle, encoderOptions?: any): string;
+        static eliFoTevas(type: string, texture: egret.Texture, filePath: string, rect?: egret.Rectangle, encoderOptions?: any): void;
+        static getPixel32(texture: egret.Texture, x: number, y: number): number[];
+        static getPixels(texture: egret.Texture, x: number, y: number, width?: number, height?: number): number[];
+    }
 }
-declare class Time {
-    static unscaledDeltaTime: any;
-    static deltaTime: number;
-    static timeScale: number;
-    static frameCount: number;
-    private static _lastTime;
-    static _timeSinceSceneLoad: any;
-    static update(currentTime: number): void;
-    static sceneChanged(): void;
-    static checkEvery(interval: number): boolean;
+declare module es {
+    class Time {
+        static unscaledDeltaTime: any;
+        static deltaTime: number;
+        static timeScale: number;
+        static frameCount: number;
+        private static _lastTime;
+        static _timeSinceSceneLoad: any;
+        static update(currentTime: number): void;
+        static sceneChanged(): void;
+        static checkEvery(interval: number): boolean;
+    }
 }
 declare class TimeUtils {
     static monthId(d?: Date): number;
@@ -708,362 +906,417 @@ declare class TimeUtils {
     static secondToTime(time?: number, partition?: string, showHour?: boolean): string;
     static timeToMillisecond(time: string, partition?: string): string;
 }
-declare class GraphicsCapabilities extends egret.Capabilities {
-    initialize(device: GraphicsDevice): void;
-    private platformInitialize;
+declare module es {
+    class GraphicsCapabilities extends egret.Capabilities {
+        initialize(device: GraphicsDevice): void;
+        private platformInitialize;
+    }
 }
-declare class GraphicsDevice {
-    private viewport;
-    graphicsCapabilities: GraphicsCapabilities;
-    constructor();
+declare module es {
+    class GraphicsDevice {
+        private viewport;
+        graphicsCapabilities: GraphicsCapabilities;
+        constructor();
+    }
 }
-declare class Viewport {
-    private _x;
-    private _y;
-    private _width;
-    private _height;
-    private _minDepth;
-    private _maxDepth;
-    readonly aspectRatio: number;
-    bounds: Rectangle;
-    constructor(x: number, y: number, width: number, height: number);
-}
-declare class GaussianBlurEffect extends egret.CustomFilter {
-    private static blur_frag;
-    constructor();
-}
-declare class PolygonLightEffect extends egret.CustomFilter {
-    private static vertSrc;
-    private static fragmentSrc;
-    constructor();
-}
-declare class PostProcessor {
-    enable: boolean;
-    effect: egret.Filter;
-    scene: Scene;
-    shape: egret.Shape;
-    static default_vert: string;
-    constructor(effect?: egret.Filter);
-    onAddedToScene(scene: Scene): void;
-    process(): void;
-    onSceneBackBufferSizeChanged(newWidth: number, newHeight: number): void;
-    protected drawFullscreenQuad(): void;
-    unload(): void;
-}
-declare class GaussianBlurPostProcessor extends PostProcessor {
-    onAddedToScene(scene: Scene): void;
-}
-declare abstract class Renderer {
-    camera: Camera;
-    onAddedToScene(scene: Scene): void;
-    protected beginRender(cam: Camera): void;
-    abstract render(scene: Scene): any;
-    unload(): void;
-    protected renderAfterStateCheck(renderable: IRenderable, cam: Camera): void;
-}
-declare class DefaultRenderer extends Renderer {
-    render(scene: Scene): void;
-}
-interface IRenderable {
-    bounds: Rectangle;
-    enabled: boolean;
-    isVisible: boolean;
-    isVisibleFromCamera(camera: Camera): any;
-    render(camera: Camera): any;
-}
-declare class ScreenSpaceRenderer extends Renderer {
-    render(scene: Scene): void;
-}
-declare class PolyLight extends RenderableComponent {
-    power: number;
-    protected _radius: number;
-    private _lightEffect;
-    private _indices;
-    radius: number;
-    constructor(radius: number, color: number, power: number);
-    private computeTriangleIndices;
-    setRadius(radius: number): void;
-    render(camera: Camera): void;
-    reset(): void;
-}
-declare abstract class SceneTransition {
-    private _hasPreviousSceneRender;
-    loadsNewScene: boolean;
-    isNewSceneLoaded: boolean;
-    protected sceneLoadAction: Function;
-    onScreenObscured: Function;
-    onTransitionCompleted: Function;
-    readonly hasPreviousSceneRender: boolean;
-    constructor(sceneLoadAction: Function);
-    preRender(): void;
-    render(): void;
-    onBeginTransition(): Promise<void>;
-    protected transitionComplete(): void;
-    protected loadNextScene(): Promise<void>;
-    tickEffectProgressProperty(filter: egret.CustomFilter, duration: number, easeType: Function, reverseDirection?: boolean): Promise<boolean>;
-}
-declare class FadeTransition extends SceneTransition {
-    fadeToColor: number;
-    fadeOutDuration: number;
-    fadeEaseType: Function;
-    delayBeforeFadeInDuration: number;
-    private _mask;
-    private _alpha;
-    constructor(sceneLoadAction: Function);
-    onBeginTransition(): Promise<void>;
-    render(): void;
-}
-declare class WindTransition extends SceneTransition {
-    private _mask;
-    private _windEffect;
-    duration: number;
-    windSegments: number;
-    size: number;
-    easeType: (t: number) => number;
-    constructor(sceneLoadAction: Function);
-    onBeginTransition(): Promise<void>;
-}
-declare class Bezier {
-    static getPoint(p0: Vector2, p1: Vector2, p2: Vector2, t: number): Vector2;
-    static getFirstDerivative(p0: Vector2, p1: Vector2, p2: Vector2, t: number): Vector2;
-    static getFirstDerivativeThree(start: Vector2, firstControlPoint: Vector2, secondControlPoint: Vector2, end: Vector2, t: number): Vector2;
-    static getPointThree(start: Vector2, firstControlPoint: Vector2, secondControlPoint: Vector2, end: Vector2, t: number): Vector2;
-    static getOptimizedDrawingPoints(start: Vector2, firstCtrlPoint: Vector2, secondCtrlPoint: Vector2, end: Vector2, distanceTolerance?: number): Vector2[];
-    private static recursiveGetOptimizedDrawingPoints;
-}
-declare class Flags {
-    static isFlagSet(self: number, flag: number): boolean;
-    static isUnshiftedFlagSet(self: number, flag: number): boolean;
-    static setFlagExclusive(self: number, flag: number): number;
-    static setFlag(self: number, flag: number): number;
-    static unsetFlag(self: number, flag: number): number;
-    static invertFlags(self: number): number;
-}
-declare class MathHelper {
-    static readonly Epsilon: number;
-    static readonly Rad2Deg: number;
-    static readonly Deg2Rad: number;
-    static toDegrees(radians: number): number;
-    static toRadians(degrees: number): number;
-    static map(value: number, leftMin: number, leftMax: number, rightMin: number, rightMax: number): number;
-    static lerp(value1: number, value2: number, amount: number): number;
-    static clamp(value: number, min: number, max: number): number;
-    static pointOnCirlce(circleCenter: Vector2, radius: number, angleInDegrees: number): Vector2;
-    static isEven(value: number): boolean;
-    static clamp01(value: number): number;
-    static angleBetweenVectors(from: Vector2, to: Vector2): number;
-}
-declare class Matrix2D {
-    m11: number;
-    m12: number;
-    m21: number;
-    m22: number;
-    m31: number;
-    m32: number;
-    private static _identity;
-    static readonly identity: Matrix2D;
-    constructor(m11?: number, m12?: number, m21?: number, m22?: number, m31?: number, m32?: number);
-    translation: Vector2;
-    rotation: number;
-    rotationDegrees: number;
-    scale: Vector2;
-    static add(matrix1: Matrix2D, matrix2: Matrix2D): Matrix2D;
-    static divide(matrix1: Matrix2D, matrix2: Matrix2D): Matrix2D;
-    static multiply(matrix1: Matrix2D, matrix2: Matrix2D): Matrix2D;
-    static multiplyTranslation(matrix: Matrix2D, x: number, y: number): Matrix2D;
-    determinant(): number;
-    static invert(matrix: Matrix2D, result?: Matrix2D): Matrix2D;
-    static createTranslation(xPosition: number, yPosition: number): Matrix2D;
-    static createTranslationVector(position: Vector2): Matrix2D;
-    static createRotation(radians: number, result?: Matrix2D): Matrix2D;
-    static createScale(xScale: number, yScale: number, result?: Matrix2D): Matrix2D;
-    toEgretMatrix(): egret.Matrix;
-}
-declare class Rectangle extends egret.Rectangle {
-    readonly max: Vector2;
-    readonly center: Vector2;
-    location: Vector2;
-    size: Vector2;
-    intersects(value: egret.Rectangle): boolean;
-    containsRect(value: Rectangle): boolean;
-    getHalfSize(): Vector2;
-    static fromMinMax(minX: number, minY: number, maxX: number, maxY: number): Rectangle;
-    getClosestPointOnRectangleBorderToPoint(point: Vector2): {
-        res: Vector2;
-        edgeNormal: Vector2;
-    };
-    getClosestPointOnBoundsToOrigin(): Vector2;
-    setEgretRect(rect: egret.Rectangle): Rectangle;
-    static rectEncompassingPoints(points: Vector2[]): Rectangle;
-}
-declare class Vector3 {
-    x: number;
-    y: number;
-    z: number;
-    constructor(x: number, y: number, z: number);
-}
-declare class ColliderTriggerHelper {
-    private _entity;
-    private _activeTriggerIntersections;
-    private _previousTriggerIntersections;
-    private _tempTriggerList;
-    constructor(entity: Entity);
-    update(): void;
-    private checkForExitedColliders;
-    private notifyTriggerListeners;
-}
-declare enum PointSectors {
-    center = 0,
-    top = 1,
-    bottom = 2,
-    topLeft = 9,
-    topRight = 5,
-    left = 8,
-    right = 4,
-    bottomLeft = 10,
-    bottomRight = 6
-}
-declare class Collisions {
-    static isLineToLine(a1: Vector2, a2: Vector2, b1: Vector2, b2: Vector2): boolean;
-    static lineToLineIntersection(a1: Vector2, a2: Vector2, b1: Vector2, b2: Vector2): Vector2;
-    static closestPointOnLine(lineA: Vector2, lineB: Vector2, closestTo: Vector2): Vector2;
-    static isCircleToCircle(circleCenter1: Vector2, circleRadius1: number, circleCenter2: Vector2, circleRadius2: number): boolean;
-    static isCircleToLine(circleCenter: Vector2, radius: number, lineFrom: Vector2, lineTo: Vector2): boolean;
-    static isCircleToPoint(circleCenter: Vector2, radius: number, point: Vector2): boolean;
-    static isRectToCircle(rect: egret.Rectangle, cPosition: Vector2, cRadius: number): boolean;
-    static isRectToLine(rect: Rectangle, lineFrom: Vector2, lineTo: Vector2): boolean;
-    static isRectToPoint(rX: number, rY: number, rW: number, rH: number, point: Vector2): boolean;
-    static getSector(rX: number, rY: number, rW: number, rH: number, point: Vector2): PointSectors;
-}
-declare class Physics {
-    private static _spatialHash;
-    static spatialHashCellSize: number;
-    static readonly allLayers: number;
-    static reset(): void;
-    static clear(): void;
-    static overlapCircleAll(center: Vector2, randius: number, results: any[], layerMask?: number): number;
-    static boxcastBroadphase(rect: Rectangle, layerMask?: number): {
-        colliders: Collider[];
-        rect: Rectangle;
-    };
-    static boxcastBroadphaseExcludingSelf(collider: Collider, rect: Rectangle, layerMask?: number): {
-        tempHashSet: Collider[];
+declare module es {
+    class Viewport {
+        private _x;
+        private _y;
+        private _width;
+        private _height;
+        private _minDepth;
+        private _maxDepth;
+        readonly aspectRatio: number;
         bounds: Rectangle;
-    };
-    static addCollider(collider: Collider): void;
-    static removeCollider(collider: Collider): void;
-    static updateCollider(collider: Collider): void;
-    static debugDraw(secondsToDisplay: any): void;
+        constructor(x: number, y: number, width: number, height: number);
+    }
 }
-declare abstract class Shape extends egret.DisplayObject {
-    abstract bounds: Rectangle;
-    abstract center: Vector2;
-    abstract position: Vector2;
-    abstract pointCollidesWithShape(point: Vector2): CollisionResult;
-    abstract overlaps(other: Shape): any;
-    abstract collidesWithShape(other: Shape): CollisionResult;
+declare module es {
+    class GaussianBlurEffect extends egret.CustomFilter {
+        private static blur_frag;
+        constructor();
+    }
 }
-declare class Polygon extends Shape {
-    points: Vector2[];
-    private _polygonCenter;
-    private _areEdgeNormalsDirty;
-    protected _originalPoints: Vector2[];
-    center: Vector2;
-    readonly position: Vector2;
-    readonly bounds: Rectangle;
-    _edgeNormals: Vector2[];
-    readonly edgeNormals: Vector2[];
-    isBox: boolean;
-    constructor(points: Vector2[], isBox?: boolean);
-    private buildEdgeNormals;
-    setPoints(points: Vector2[]): void;
-    collidesWithShape(other: Shape): any;
-    recalculateCenterAndEdgeNormals(): void;
-    overlaps(other: Shape): any;
-    static findPolygonCenter(points: Vector2[]): Vector2;
-    static recenterPolygonVerts(points: Vector2[]): void;
-    static getClosestPointOnPolygonToPoint(points: Vector2[], point: Vector2): {
-        closestPoint: any;
-        distanceSquared: any;
-        edgeNormal: any;
-    };
-    pointCollidesWithShape(point: Vector2): CollisionResult;
-    containsPoint(point: Vector2): boolean;
-    static buildSymmertricalPolygon(vertCount: number, radius: number): any[];
+declare module es {
+    class PolygonLightEffect extends egret.CustomFilter {
+        private static vertSrc;
+        private static fragmentSrc;
+        constructor();
+    }
 }
-declare class Box extends Polygon {
-    constructor(width: number, height: number);
-    private static buildBox;
-    overlaps(other: Shape): any;
-    collidesWithShape(other: Shape): any;
-    updateBox(width: number, height: number): void;
-    containsPoint(point: Vector2): boolean;
+declare module es {
+    class PostProcessor {
+        enabled: boolean;
+        effect: egret.Filter;
+        scene: Scene;
+        shape: egret.Shape;
+        static default_vert: string;
+        constructor(effect?: egret.Filter);
+        onAddedToScene(scene: Scene): void;
+        process(): void;
+        onSceneBackBufferSizeChanged(newWidth: number, newHeight: number): void;
+        protected drawFullscreenQuad(): void;
+        unload(): void;
+    }
 }
-declare class Circle extends Shape {
-    radius: number;
-    _originalRadius: number;
-    center: Vector2;
-    readonly position: Vector2;
-    readonly bounds: Rectangle;
-    constructor(radius: number);
-    pointCollidesWithShape(point: Vector2): CollisionResult;
-    collidesWithShape(other: Shape): CollisionResult;
-    overlaps(other: Shape): any;
+declare module es {
+    class GaussianBlurPostProcessor extends PostProcessor {
+        onAddedToScene(scene: Scene): void;
+    }
 }
-declare class CollisionResult {
-    collider: Collider;
-    minimumTranslationVector: Vector2;
-    normal: Vector2;
-    point: Vector2;
-    invertResult(): void;
+declare module es {
+    abstract class Renderer {
+        camera: Camera;
+        onAddedToScene(scene: Scene): void;
+        protected beginRender(cam: Camera): void;
+        abstract render(scene: Scene): any;
+        unload(): void;
+        protected renderAfterStateCheck(renderable: IRenderable, cam: Camera): void;
+    }
 }
-declare class ShapeCollisions {
-    static polygonToPolygon(first: Polygon, second: Polygon): CollisionResult;
-    static intervalDistance(minA: number, maxA: number, minB: number, maxB: any): number;
-    static getInterval(axis: Vector2, polygon: Polygon, min: number, max: number): {
-        min: number;
-        max: number;
-    };
-    static circleToPolygon(circle: Circle, polygon: Polygon): CollisionResult;
-    static circleToBox(circle: Circle, box: Box): CollisionResult;
-    static pointToCircle(point: Vector2, circle: Circle): CollisionResult;
-    static closestPointOnLine(lineA: Vector2, lineB: Vector2, closestTo: Vector2): Vector2;
-    static pointToPoly(point: Vector2, poly: Polygon): CollisionResult;
-    static circleToCircle(first: Circle, second: Circle): CollisionResult;
-    static boxToBox(first: Box, second: Box): CollisionResult;
-    private static minkowskiDifference;
+declare module es {
+    class DefaultRenderer extends Renderer {
+        render(scene: Scene): void;
+    }
 }
-declare class SpatialHash {
-    gridBounds: Rectangle;
-    private _raycastParser;
-    private _cellSize;
-    private _inverseCellSize;
-    private _overlapTestCircle;
-    private _tempHashSet;
-    private _cellDict;
-    constructor(cellSize?: number);
-    remove(collider: Collider): void;
-    register(collider: Collider): void;
-    clear(): void;
-    overlapCircle(circleCenter: Vector2, radius: number, results: Collider[], layerMask: any): number;
-    aabbBroadphase(bounds: Rectangle, excludeCollider: Collider, layerMask: number): {
-        tempHashSet: Collider[];
+declare module es {
+    class ScreenSpaceRenderer extends Renderer {
+        render(scene: Scene): void;
+    }
+}
+declare module es {
+    class PolyLight extends RenderableComponent {
+        power: number;
+        protected _radius: number;
+        private _lightEffect;
+        private _indices;
+        radius: number;
+        constructor(radius: number, color: number, power: number);
+        private computeTriangleIndices;
+        setRadius(radius: number): void;
+        render(camera: Camera): void;
+        reset(): void;
+    }
+}
+declare module es {
+    abstract class SceneTransition {
+        private _hasPreviousSceneRender;
+        loadsNewScene: boolean;
+        isNewSceneLoaded: boolean;
+        protected sceneLoadAction: Function;
+        onScreenObscured: Function;
+        onTransitionCompleted: Function;
+        readonly hasPreviousSceneRender: boolean;
+        constructor(sceneLoadAction: Function);
+        preRender(): void;
+        render(): void;
+        onBeginTransition(): Promise<void>;
+        protected transitionComplete(): void;
+        protected loadNextScene(): Promise<void>;
+        tickEffectProgressProperty(filter: egret.CustomFilter, duration: number, easeType: Function, reverseDirection?: boolean): Promise<boolean>;
+    }
+}
+declare module es {
+    class FadeTransition extends SceneTransition {
+        fadeToColor: number;
+        fadeOutDuration: number;
+        fadeEaseType: Function;
+        delayBeforeFadeInDuration: number;
+        private _mask;
+        private _alpha;
+        constructor(sceneLoadAction: Function);
+        onBeginTransition(): Promise<void>;
+        render(): void;
+    }
+}
+declare module es {
+    class WindTransition extends SceneTransition {
+        private _mask;
+        private _windEffect;
+        duration: number;
+        windSegments: number;
+        size: number;
+        easeType: (t: number) => number;
+        constructor(sceneLoadAction: Function);
+        onBeginTransition(): Promise<void>;
+    }
+}
+declare module es {
+    class Bezier {
+        static getPoint(p0: Vector2, p1: Vector2, p2: Vector2, t: number): Vector2;
+        static getFirstDerivative(p0: Vector2, p1: Vector2, p2: Vector2, t: number): Vector2;
+        static getFirstDerivativeThree(start: Vector2, firstControlPoint: Vector2, secondControlPoint: Vector2, end: Vector2, t: number): Vector2;
+        static getPointThree(start: Vector2, firstControlPoint: Vector2, secondControlPoint: Vector2, end: Vector2, t: number): Vector2;
+        static getOptimizedDrawingPoints(start: Vector2, firstCtrlPoint: Vector2, secondCtrlPoint: Vector2, end: Vector2, distanceTolerance?: number): Vector2[];
+        private static recursiveGetOptimizedDrawingPoints;
+    }
+}
+declare module es {
+    class Flags {
+        static isFlagSet(self: number, flag: number): boolean;
+        static isUnshiftedFlagSet(self: number, flag: number): boolean;
+        static setFlagExclusive(self: number, flag: number): number;
+        static setFlag(self: number, flag: number): number;
+        static unsetFlag(self: number, flag: number): number;
+        static invertFlags(self: number): number;
+    }
+}
+declare module es {
+    class MathHelper {
+        static readonly Epsilon: number;
+        static readonly Rad2Deg: number;
+        static readonly Deg2Rad: number;
+        static toDegrees(radians: number): number;
+        static toRadians(degrees: number): number;
+        static map(value: number, leftMin: number, leftMax: number, rightMin: number, rightMax: number): number;
+        static lerp(value1: number, value2: number, amount: number): number;
+        static clamp(value: number, min: number, max: number): number;
+        static pointOnCirlce(circleCenter: Vector2, radius: number, angleInDegrees: number): Vector2;
+        static isEven(value: number): boolean;
+        static clamp01(value: number): number;
+        static angleBetweenVectors(from: Vector2, to: Vector2): number;
+    }
+}
+declare module es {
+    class Matrix2D {
+        m11: number;
+        m12: number;
+        m21: number;
+        m22: number;
+        m31: number;
+        m32: number;
+        private static _identity;
+        static readonly identity: Matrix2D;
+        constructor(m11?: number, m12?: number, m21?: number, m22?: number, m31?: number, m32?: number);
+        translation: Vector2;
+        rotation: number;
+        rotationDegrees: number;
+        scale: Vector2;
+        static add(matrix1: Matrix2D, matrix2: Matrix2D): Matrix2D;
+        static divide(matrix1: Matrix2D, matrix2: Matrix2D): Matrix2D;
+        static multiply(matrix1: Matrix2D, matrix2: Matrix2D): Matrix2D;
+        static multiplyTranslation(matrix: Matrix2D, x: number, y: number): Matrix2D;
+        determinant(): number;
+        static invert(matrix: Matrix2D, result?: Matrix2D): Matrix2D;
+        static createTranslation(xPosition: number, yPosition: number): Matrix2D;
+        static createTranslationVector(position: Vector2): Matrix2D;
+        static createRotation(radians: number, result?: Matrix2D): Matrix2D;
+        static createScale(xScale: number, yScale: number, result?: Matrix2D): Matrix2D;
+        toEgretMatrix(): egret.Matrix;
+    }
+}
+declare module es {
+    class Rectangle extends egret.Rectangle {
+        readonly max: Vector2;
+        readonly center: Vector2;
+        location: Vector2;
+        size: Vector2;
+        intersects(value: egret.Rectangle): boolean;
+        containsRect(value: Rectangle): boolean;
+        getHalfSize(): Vector2;
+        static fromMinMax(minX: number, minY: number, maxX: number, maxY: number): Rectangle;
+        getClosestPointOnRectangleBorderToPoint(point: Vector2): {
+            res: Vector2;
+            edgeNormal: Vector2;
+        };
+        getClosestPointOnBoundsToOrigin(): Vector2;
+        calculateBounds(parentPosition: Vector2, position: Vector2, origin: Vector2, scale: Vector2, rotation: number, width: number, height: number): void;
+        setEgretRect(rect: egret.Rectangle): Rectangle;
+        static rectEncompassingPoints(points: Vector2[]): Rectangle;
+    }
+}
+declare module es {
+    class Vector3 {
+        x: number;
+        y: number;
+        z: number;
+        constructor(x: number, y: number, z: number);
+    }
+}
+declare module es {
+    class ColliderTriggerHelper {
+        private _entity;
+        private _activeTriggerIntersections;
+        private _previousTriggerIntersections;
+        private _tempTriggerList;
+        constructor(entity: Entity);
+        update(): void;
+        private checkForExitedColliders;
+        private notifyTriggerListeners;
+    }
+}
+declare module es {
+    enum PointSectors {
+        center = 0,
+        top = 1,
+        bottom = 2,
+        topLeft = 9,
+        topRight = 5,
+        left = 8,
+        right = 4,
+        bottomLeft = 10,
+        bottomRight = 6
+    }
+    class Collisions {
+        static isLineToLine(a1: Vector2, a2: Vector2, b1: Vector2, b2: Vector2): boolean;
+        static lineToLineIntersection(a1: Vector2, a2: Vector2, b1: Vector2, b2: Vector2): Vector2;
+        static closestPointOnLine(lineA: Vector2, lineB: Vector2, closestTo: Vector2): Vector2;
+        static isCircleToCircle(circleCenter1: Vector2, circleRadius1: number, circleCenter2: Vector2, circleRadius2: number): boolean;
+        static isCircleToLine(circleCenter: Vector2, radius: number, lineFrom: Vector2, lineTo: Vector2): boolean;
+        static isCircleToPoint(circleCenter: Vector2, radius: number, point: Vector2): boolean;
+        static isRectToCircle(rect: egret.Rectangle, cPosition: Vector2, cRadius: number): boolean;
+        static isRectToLine(rect: Rectangle, lineFrom: Vector2, lineTo: Vector2): boolean;
+        static isRectToPoint(rX: number, rY: number, rW: number, rH: number, point: Vector2): boolean;
+        static getSector(rX: number, rY: number, rW: number, rH: number, point: Vector2): PointSectors;
+    }
+}
+declare module es {
+    class Physics {
+        private static _spatialHash;
+        static spatialHashCellSize: number;
+        static readonly allLayers: number;
+        static reset(): void;
+        static clear(): void;
+        static overlapCircleAll(center: Vector2, randius: number, results: any[], layerMask?: number): number;
+        static boxcastBroadphase(rect: Rectangle, layerMask?: number): {
+            colliders: Collider[];
+            rect: Rectangle;
+        };
+        static boxcastBroadphaseExcludingSelf(collider: Collider, rect: Rectangle, layerMask?: number): {
+            tempHashSet: Collider[];
+            bounds: Rectangle;
+        };
+        static addCollider(collider: Collider): void;
+        static removeCollider(collider: Collider): void;
+        static updateCollider(collider: Collider): void;
+        static debugDraw(secondsToDisplay: any): void;
+    }
+}
+declare module es {
+    abstract class Shape {
+        position: Vector2;
+        center: Vector2;
         bounds: Rectangle;
-    };
-    private cellAtPosition;
-    private cellCoords;
-    debugDraw(secondsToDisplay: number, textScale?: number): void;
-    private debugDrawCellDetails;
+        abstract recalculateBounds(collider: Collider): any;
+        abstract pointCollidesWithShape(point: Vector2): CollisionResult;
+        abstract overlaps(other: Shape): any;
+        abstract collidesWithShape(other: Shape): CollisionResult;
+    }
 }
-declare class RaycastResultParser {
+declare module es {
+    class Polygon extends Shape {
+        points: Vector2[];
+        readonly edgeNormals: Vector2[];
+        _areEdgeNormalsDirty: boolean;
+        _edgeNormals: Vector2[];
+        _originalPoints: Vector2[];
+        _polygonCenter: Vector2;
+        isBox: boolean;
+        isUnrotated: boolean;
+        constructor(points: Vector2[], isBox?: boolean);
+        setPoints(points: Vector2[]): void;
+        recalculateCenterAndEdgeNormals(): void;
+        buildEdgeNormals(): void;
+        static buildSymmetricalPolygon(vertCount: number, radius: number): any[];
+        static recenterPolygonVerts(points: Vector2[]): void;
+        static findPolygonCenter(points: Vector2[]): Vector2;
+        static getClosestPointOnPolygonToPoint(points: Vector2[], point: Vector2): {
+            closestPoint: any;
+            distanceSquared: any;
+            edgeNormal: any;
+        };
+        recalculateBounds(collider: Collider): void;
+        overlaps(other: Shape): any;
+        collidesWithShape(other: Shape): any;
+        containsPoint(point: Vector2): boolean;
+        pointCollidesWithShape(point: Vector2): CollisionResult;
+    }
 }
-declare class NumberDictionary {
-    private _store;
-    private getKey;
-    add(x: number, y: number, list: Collider[]): void;
-    remove(obj: Collider): void;
-    tryGetValue(x: number, y: number): Collider[];
-    clear(): void;
+declare module es {
+    class Box extends Polygon {
+        width: number;
+        height: number;
+        constructor(width: number, height: number);
+        private static buildBox;
+        updateBox(width: number, height: number): void;
+        overlaps(other: Shape): any;
+        collidesWithShape(other: Shape): any;
+        containsPoint(point: Vector2): boolean;
+    }
+}
+declare module es {
+    class Circle extends Shape {
+        radius: number;
+        _originalRadius: number;
+        constructor(radius: number);
+        recalculateBounds(collider: es.Collider): void;
+        overlaps(other: Shape): any;
+        collidesWithShape(other: Shape): CollisionResult;
+        pointCollidesWithShape(point: Vector2): CollisionResult;
+    }
+}
+declare module es {
+    class CollisionResult {
+        collider: Collider;
+        minimumTranslationVector: Vector2;
+        normal: Vector2;
+        point: Vector2;
+        invertResult(): void;
+    }
+}
+declare module es {
+    class ShapeCollisions {
+        static polygonToPolygon(first: Polygon, second: Polygon): CollisionResult;
+        static intervalDistance(minA: number, maxA: number, minB: number, maxB: any): number;
+        static getInterval(axis: Vector2, polygon: Polygon, min: number, max: number): {
+            min: number;
+            max: number;
+        };
+        static circleToPolygon(circle: Circle, polygon: Polygon): CollisionResult;
+        static circleToBox(circle: Circle, box: Box): CollisionResult;
+        static pointToCircle(point: Vector2, circle: Circle): CollisionResult;
+        static closestPointOnLine(lineA: Vector2, lineB: Vector2, closestTo: Vector2): Vector2;
+        static pointToPoly(point: Vector2, poly: Polygon): CollisionResult;
+        static circleToCircle(first: Circle, second: Circle): CollisionResult;
+        static boxToBox(first: Box, second: Box): CollisionResult;
+        private static minkowskiDifference;
+    }
+}
+declare module es {
+    class SpatialHash {
+        gridBounds: Rectangle;
+        _raycastParser: RaycastResultParser;
+        _cellSize: number;
+        _inverseCellSize: number;
+        _overlapTestCircle: Circle;
+        _cellDict: NumberDictionary;
+        _tempHashSet: Collider[];
+        constructor(cellSize?: number);
+        private cellCoords;
+        private cellAtPosition;
+        register(collider: Collider): void;
+        remove(collider: Collider): void;
+        removeWithBruteForce(obj: Collider): void;
+        clear(): void;
+        debugDraw(secondsToDisplay: number, textScale?: number): void;
+        private debugDrawCellDetails;
+        aabbBroadphase(bounds: Rectangle, excludeCollider: Collider, layerMask: number): {
+            tempHashSet: Collider[];
+            bounds: Rectangle;
+        };
+        overlapCircle(circleCenter: Vector2, radius: number, results: Collider[], layerMask: any): number;
+    }
+    class NumberDictionary {
+        _store: Map<string, Collider[]>;
+        private getKey;
+        add(x: number, y: number, list: Collider[]): void;
+        remove(obj: Collider): void;
+        tryGetValue(x: number, y: number): Collider[];
+        clear(): void;
+    }
+    class RaycastResultParser {
+    }
 }
 declare class ArrayUtils {
     static bubbleSort(ary: number[]): void;
@@ -1090,72 +1343,83 @@ declare class Base64Utils {
     private static _utf8_decode;
     private static getConfKey;
 }
-declare class ContentManager {
-    protected loadedAssets: Map<string, any>;
-    loadRes(name: string, local?: boolean): Promise<any>;
-    dispose(): void;
+declare module es {
+    class ContentManager {
+        protected loadedAssets: Map<string, any>;
+        loadRes(name: string, local?: boolean): Promise<any>;
+        dispose(): void;
+    }
 }
-declare class DrawUtils {
-    static drawLine(shape: egret.Shape, start: Vector2, end: Vector2, color: number, thickness?: number): void;
-    static drawLineAngle(shape: egret.Shape, start: Vector2, radians: number, length: number, color: number, thickness?: number): void;
-    static drawHollowRect(shape: egret.Shape, rect: Rectangle, color: number, thickness?: number): void;
-    static drawHollowRectR(shape: egret.Shape, x: number, y: number, width: number, height: number, color: number, thickness?: number): void;
-    static drawPixel(shape: egret.Shape, position: Vector2, color: number, size?: number): void;
+declare module es {
+    class DrawUtils {
+        static drawLine(shape: egret.Shape, start: Vector2, end: Vector2, color: number, thickness?: number): void;
+        static drawLineAngle(shape: egret.Shape, start: Vector2, radians: number, length: number, color: number, thickness?: number): void;
+        static drawHollowRect(shape: egret.Shape, rect: Rectangle, color: number, thickness?: number): void;
+        static drawHollowRectR(shape: egret.Shape, x: number, y: number, width: number, height: number, color: number, thickness?: number): void;
+        static drawPixel(shape: egret.Shape, position: Vector2, color: number, size?: number): void;
+        static getColorMatrix(color: number): egret.ColorMatrixFilter;
+    }
 }
-declare class Emitter<T> {
-    private _messageTable;
-    constructor();
-    addObserver(eventType: T, handler: Function, context: any): void;
-    removeObserver(eventType: T, handler: Function): void;
-    emit(eventType: T, data?: any): void;
+declare module es {
+    class FuncPack {
+        func: Function;
+        context: any;
+        constructor(func: Function, context: any);
+    }
+    class Emitter<T> {
+        private _messageTable;
+        constructor();
+        addObserver(eventType: T, handler: Function, context: any): void;
+        removeObserver(eventType: T, handler: Function): void;
+        emit(eventType: T, data?: any): void;
+    }
 }
-declare class FuncPack {
-    func: Function;
-    context: any;
-    constructor(func: Function, context: any);
+declare module es {
+    class GlobalManager {
+        static globalManagers: GlobalManager[];
+        private _enabled;
+        enabled: boolean;
+        setEnabled(isEnabled: boolean): void;
+        onEnabled(): void;
+        onDisabled(): void;
+        update(): void;
+        static registerGlobalManager(manager: GlobalManager): void;
+        static unregisterGlobalManager(manager: GlobalManager): void;
+        static getGlobalManager<T extends GlobalManager>(type: any): T;
+    }
 }
-declare class GlobalManager {
-    static globalManagers: GlobalManager[];
-    private _enabled;
-    enabled: boolean;
-    setEnabled(isEnabled: boolean): void;
-    onEnabled(): void;
-    onDisabled(): void;
-    update(): void;
-    static registerGlobalManager(manager: GlobalManager): void;
-    static unregisterGlobalManager(manager: GlobalManager): void;
-    static getGlobalManager<T extends GlobalManager>(type: any): T;
-}
-declare class TouchState {
-    x: number;
-    y: number;
-    touchPoint: number;
-    touchDown: boolean;
-    readonly position: Vector2;
-    reset(): void;
-}
-declare class Input {
-    private static _init;
-    private static _stage;
-    private static _previousTouchState;
-    private static _gameTouchs;
-    private static _resolutionOffset;
-    private static _resolutionScale;
-    private static _touchIndex;
-    private static _totalTouchCount;
-    static readonly touchPosition: Vector2;
-    static maxSupportedTouch: number;
-    static readonly resolutionScale: Vector2;
-    static readonly totalTouchCount: number;
-    static readonly gameTouchs: TouchState[];
-    static readonly touchPositionDelta: Vector2;
-    static initialize(stage: egret.Stage): void;
-    private static initTouchCache;
-    private static touchBegin;
-    private static touchMove;
-    private static touchEnd;
-    private static setpreviousTouchState;
-    static scaledPosition(position: Vector2): Vector2;
+declare module es {
+    class TouchState {
+        x: number;
+        y: number;
+        touchPoint: number;
+        touchDown: boolean;
+        readonly position: Vector2;
+        reset(): void;
+    }
+    class Input {
+        private static _init;
+        private static _stage;
+        private static _previousTouchState;
+        private static _gameTouchs;
+        private static _resolutionOffset;
+        private static _resolutionScale;
+        private static _touchIndex;
+        private static _totalTouchCount;
+        static readonly touchPosition: Vector2;
+        static maxSupportedTouch: number;
+        static readonly resolutionScale: Vector2;
+        static readonly totalTouchCount: number;
+        static readonly gameTouchs: TouchState[];
+        static readonly touchPositionDelta: Vector2;
+        static initialize(stage: egret.Stage): void;
+        private static initTouchCache;
+        private static touchBegin;
+        private static touchMove;
+        private static touchEnd;
+        private static setpreviousTouchState;
+        static scaledPosition(position: Vector2): Vector2;
+    }
 }
 declare class KeyboardUtils {
     static TYPE_KEY_DOWN: number;
@@ -1241,13 +1505,15 @@ declare class KeyboardUtils {
     private static keyCodeToString;
     static destroy(): void;
 }
-declare class ListPool {
-    private static readonly _objectQueue;
-    static warmCache(cacheCount: number): void;
-    static trimCache(cacheCount: any): void;
-    static clearCache(): void;
-    static obtain<T>(): Array<T>;
-    static free<T>(obj: Array<T>): void;
+declare module es {
+    class ListPool {
+        private static readonly _objectQueue;
+        static warmCache(cacheCount: number): void;
+        static trimCache(cacheCount: any): void;
+        static clearCache(): void;
+        static obtain<T>(): T[];
+        static free<T>(obj: Array<T>): void;
+    }
 }
 declare const THREAD_ID: string;
 declare const setItem: any;
@@ -1260,12 +1526,14 @@ declare class LockUtils {
     constructor(key: any);
     lock(): Promise<{}>;
 }
-declare class Pair<T> {
-    first: T;
-    second: T;
-    constructor(first: T, second: T);
-    clear(): void;
-    equals(other: Pair<T>): boolean;
+declare module es {
+    class Pair<T> {
+        first: T;
+        second: T;
+        constructor(first: T, second: T);
+        clear(): void;
+        equals(other: Pair<T>): boolean;
+    }
 }
 declare class RandomUtils {
     static randrange(start: number, stop: number, step?: number): number;
@@ -1278,53 +1546,61 @@ declare class RandomUtils {
     static random(): number;
     static boolean(chance?: number): boolean;
 }
-declare class RectangleExt {
-    static union(first: Rectangle, point: Vector2): Rectangle;
+declare module es {
+    class RectangleExt {
+        static union(first: Rectangle, point: Vector2): Rectangle;
+    }
 }
-declare class Triangulator {
-    triangleIndices: number[];
-    private _triPrev;
-    private _triNext;
-    triangulate(points: Vector2[], arePointsCCW?: boolean): void;
-    private initialize;
-    static testPointTriangle(point: Vector2, a: Vector2, b: Vector2, c: Vector2): boolean;
+declare module es {
+    class Triangulator {
+        triangleIndices: number[];
+        private _triPrev;
+        private _triNext;
+        triangulate(points: Vector2[], arePointsCCW?: boolean): void;
+        private initialize;
+        static testPointTriangle(point: Vector2, a: Vector2, b: Vector2, c: Vector2): boolean;
+    }
 }
-declare class Vector2Ext {
-    static isTriangleCCW(a: Vector2, center: Vector2, c: Vector2): boolean;
-    static cross(u: Vector2, v: Vector2): number;
-    static perpendicular(first: Vector2, second: Vector2): Vector2;
-    static normalize(vec: Vector2): Vector2;
-    static transformA(sourceArray: Vector2[], sourceIndex: number, matrix: Matrix2D, destinationArray: Vector2[], destinationIndex: number, length: number): void;
-    static transformR(position: Vector2, matrix: Matrix2D): Vector2;
-    static transform(sourceArray: Vector2[], matrix: Matrix2D, destinationArray: Vector2[]): void;
-    static round(vec: Vector2): Vector2;
+declare module es {
+    class Vector2Ext {
+        static isTriangleCCW(a: Vector2, center: Vector2, c: Vector2): boolean;
+        static cross(u: Vector2, v: Vector2): number;
+        static perpendicular(first: Vector2, second: Vector2): Vector2;
+        static normalize(vec: Vector2): Vector2;
+        static transformA(sourceArray: Vector2[], sourceIndex: number, matrix: Matrix2D, destinationArray: Vector2[], destinationIndex: number, length: number): void;
+        static transformR(position: Vector2, matrix: Matrix2D): Vector2;
+        static transform(sourceArray: Vector2[], matrix: Matrix2D, destinationArray: Vector2[]): void;
+        static round(vec: Vector2): Vector2;
+    }
 }
 declare class WebGLUtils {
     static getContext(): CanvasRenderingContext2D;
 }
-declare class Layout {
-    clientArea: Rectangle;
-    safeArea: Rectangle;
-    constructor();
-    place(size: Vector2, horizontalMargin: number, verticalMargine: number, alignment: Alignment): Rectangle;
-}
-declare enum Alignment {
-    none = 0,
-    left = 1,
-    right = 2,
-    horizontalCenter = 4,
-    top = 8,
-    bottom = 16,
-    verticalCenter = 32,
-    topLeft = 9,
-    topRight = 10,
-    topCenter = 12,
-    bottomLeft = 17,
-    bottomRight = 18,
-    bottomCenter = 20,
-    centerLeft = 33,
-    centerRight = 34,
-    center = 36
+declare module es {
+    class Layout {
+        clientArea: Rectangle;
+        safeArea: Rectangle;
+        constructor();
+        place(size: Vector2, horizontalMargin: number, verticalMargine: number, alignment: Alignment): Rectangle;
+    }
+    enum Alignment {
+        none = 0,
+        left = 1,
+        right = 2,
+        horizontalCenter = 4,
+        top = 8,
+        bottom = 16,
+        verticalCenter = 32,
+        topLeft = 9,
+        topRight = 10,
+        topCenter = 12,
+        bottomLeft = 17,
+        bottomRight = 18,
+        bottomCenter = 20,
+        centerLeft = 33,
+        centerRight = 34,
+        center = 36
+    }
 }
 declare namespace stopwatch {
     class Stopwatch {
@@ -1365,72 +1641,74 @@ declare namespace stopwatch {
         readonly duration: number;
     }
 }
-declare class TimeRuler {
-    static readonly maxBars: number;
-    static readonly maxSamples: number;
-    static readonly maxNestCall: number;
-    static readonly barHeight: number;
-    static readonly maxSampleFrames: number;
-    static readonly logSnapDuration: number;
-    static readonly barPadding: number;
-    static readonly autoAdjustDelay: number;
-    static Instance: TimeRuler;
-    private _frameKey;
-    private _logKey;
-    private _logs;
-    private sampleFrames;
-    targetSampleFrames: number;
-    width: number;
-    enabled: true;
-    private _position;
-    private _prevLog;
-    private _curLog;
-    private frameCount;
-    private markers;
-    private stopwacth;
-    private _markerNameToIdMap;
-    private _updateCount;
-    showLog: boolean;
-    private _frameAdjust;
-    constructor();
-    private onGraphicsDeviceReset;
-    startFrame(): void;
-    beginMark(markerName: string, color: number, barIndex?: number): void;
-    endMark(markerName: string, barIndex?: number): void;
-    getAverageTime(barIndex: number, markerName: string): number;
-    resetLog(): void;
-    render(position?: Vector2, width?: number): void;
-}
-declare class FrameLog {
-    bars: MarkerCollection[];
-    constructor();
-}
-declare class MarkerCollection {
-    markers: Marker[];
-    markCount: number;
-    markerNests: number[];
-    nestCount: number;
-    constructor();
-}
-declare class Marker {
-    markerId: number;
-    beginTime: number;
-    endTime: number;
-    color: number;
-}
-declare class MarkerInfo {
-    name: string;
-    logs: MarkerLog[];
-    constructor(name: any);
-}
-declare class MarkerLog {
-    snapMin: number;
-    snapMax: number;
-    snapAvg: number;
-    min: number;
-    max: number;
-    avg: number;
-    samples: number;
-    color: number;
-    initialized: boolean;
+declare module es {
+    class TimeRuler {
+        static readonly maxBars: number;
+        static readonly maxSamples: number;
+        static readonly maxNestCall: number;
+        static readonly barHeight: number;
+        static readonly maxSampleFrames: number;
+        static readonly logSnapDuration: number;
+        static readonly barPadding: number;
+        static readonly autoAdjustDelay: number;
+        static Instance: TimeRuler;
+        private _frameKey;
+        private _logKey;
+        private _logs;
+        private sampleFrames;
+        targetSampleFrames: number;
+        width: number;
+        enabled: true;
+        private _position;
+        private _prevLog;
+        private _curLog;
+        private frameCount;
+        private markers;
+        private stopwacth;
+        private _markerNameToIdMap;
+        private _updateCount;
+        showLog: boolean;
+        private _frameAdjust;
+        constructor();
+        private onGraphicsDeviceReset;
+        startFrame(): void;
+        beginMark(markerName: string, color: number, barIndex?: number): void;
+        endMark(markerName: string, barIndex?: number): void;
+        getAverageTime(barIndex: number, markerName: string): number;
+        resetLog(): void;
+        render(position?: Vector2, width?: number): void;
+    }
+    class FrameLog {
+        bars: MarkerCollection[];
+        constructor();
+    }
+    class MarkerCollection {
+        markers: Marker[];
+        markCount: number;
+        markerNests: number[];
+        nestCount: number;
+        constructor();
+    }
+    class Marker {
+        markerId: number;
+        beginTime: number;
+        endTime: number;
+        color: number;
+    }
+    class MarkerInfo {
+        name: string;
+        logs: MarkerLog[];
+        constructor(name: any);
+    }
+    class MarkerLog {
+        snapMin: number;
+        snapMax: number;
+        snapAvg: number;
+        min: number;
+        max: number;
+        avg: number;
+        samples: number;
+        color: number;
+        initialized: boolean;
+    }
 }
diff --git a/demo/libs/framework/framework.js b/demo/libs/framework/framework.js
index c729622d..c83321cc 100644
--- a/demo/libs/framework/framework.js
+++ b/demo/libs/framework/framework.js
@@ -273,2772 +273,3282 @@ Array.prototype.sum = function (selector) {
     }
     return sum(this, selector);
 };
-var PriorityQueueNode = (function () {
-    function PriorityQueueNode() {
-        this.priority = 0;
-        this.insertionIndex = 0;
-        this.queueIndex = 0;
-    }
-    return PriorityQueueNode;
-}());
-var AStarPathfinder = (function () {
-    function AStarPathfinder() {
-    }
-    AStarPathfinder.search = function (graph, start, goal) {
-        var _this = this;
-        var foundPath = false;
-        var cameFrom = new Map();
-        cameFrom.set(start, start);
-        var costSoFar = new Map();
-        var frontier = new PriorityQueue(1000);
-        frontier.enqueue(new AStarNode(start), 0);
-        costSoFar.set(start, 0);
-        var _loop_2 = function () {
-            var current = frontier.dequeue();
-            if (JSON.stringify(current.data) == JSON.stringify(goal)) {
-                foundPath = true;
-                return "break";
-            }
-            graph.getNeighbors(current.data).forEach(function (next) {
-                var newCost = costSoFar.get(current.data) + graph.cost(current.data, next);
-                if (!_this.hasKey(costSoFar, next) || newCost < costSoFar.get(next)) {
-                    costSoFar.set(next, newCost);
-                    var priority = newCost + graph.heuristic(next, goal);
-                    frontier.enqueue(new AStarNode(next), priority);
-                    cameFrom.set(next, current.data);
+var es;
+(function (es) {
+    var PriorityQueueNode = (function () {
+        function PriorityQueueNode() {
+            this.priority = 0;
+            this.insertionIndex = 0;
+            this.queueIndex = 0;
+        }
+        return PriorityQueueNode;
+    }());
+    es.PriorityQueueNode = PriorityQueueNode;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var AStarPathfinder = (function () {
+        function AStarPathfinder() {
+        }
+        AStarPathfinder.search = function (graph, start, goal) {
+            var _this = this;
+            var foundPath = false;
+            var cameFrom = new Map();
+            cameFrom.set(start, start);
+            var costSoFar = new Map();
+            var frontier = new es.PriorityQueue(1000);
+            frontier.enqueue(new AStarNode(start), 0);
+            costSoFar.set(start, 0);
+            var _loop_2 = function () {
+                var current = frontier.dequeue();
+                if (JSON.stringify(current.data) == JSON.stringify(goal)) {
+                    foundPath = true;
+                    return "break";
                 }
-            });
+                graph.getNeighbors(current.data).forEach(function (next) {
+                    var newCost = costSoFar.get(current.data) + graph.cost(current.data, next);
+                    if (!_this.hasKey(costSoFar, next) || newCost < costSoFar.get(next)) {
+                        costSoFar.set(next, newCost);
+                        var priority = newCost + graph.heuristic(next, goal);
+                        frontier.enqueue(new AStarNode(next), priority);
+                        cameFrom.set(next, current.data);
+                    }
+                });
+            };
+            while (frontier.count > 0) {
+                var state_1 = _loop_2();
+                if (state_1 === "break")
+                    break;
+            }
+            return foundPath ? this.recontructPath(cameFrom, start, goal) : null;
         };
-        while (frontier.count > 0) {
-            var state_1 = _loop_2();
-            if (state_1 === "break")
-                break;
+        AStarPathfinder.hasKey = function (map, compareKey) {
+            var iterator = map.keys();
+            var r;
+            while (r = iterator.next(), !r.done) {
+                if (JSON.stringify(r.value) == JSON.stringify(compareKey))
+                    return true;
+            }
+            return false;
+        };
+        AStarPathfinder.getKey = function (map, compareKey) {
+            var iterator = map.keys();
+            var valueIterator = map.values();
+            var r;
+            var v;
+            while (r = iterator.next(), v = valueIterator.next(), !r.done) {
+                if (JSON.stringify(r.value) == JSON.stringify(compareKey))
+                    return v.value;
+            }
+            return null;
+        };
+        AStarPathfinder.recontructPath = function (cameFrom, start, goal) {
+            var path = [];
+            var current = goal;
+            path.push(goal);
+            while (current != start) {
+                current = this.getKey(cameFrom, current);
+                path.push(current);
+            }
+            path.reverse();
+            return path;
+        };
+        return AStarPathfinder;
+    }());
+    es.AStarPathfinder = AStarPathfinder;
+    var AStarNode = (function (_super) {
+        __extends(AStarNode, _super);
+        function AStarNode(data) {
+            var _this = _super.call(this) || this;
+            _this.data = data;
+            return _this;
         }
-        return foundPath ? this.recontructPath(cameFrom, start, goal) : null;
-    };
-    AStarPathfinder.hasKey = function (map, compareKey) {
-        var iterator = map.keys();
-        var r;
-        while (r = iterator.next(), !r.done) {
-            if (JSON.stringify(r.value) == JSON.stringify(compareKey))
-                return true;
+        return AStarNode;
+    }(es.PriorityQueueNode));
+    es.AStarNode = AStarNode;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var AstarGridGraph = (function () {
+        function AstarGridGraph(width, height) {
+            this.dirs = [
+                new es.Vector2(1, 0),
+                new es.Vector2(0, -1),
+                new es.Vector2(-1, 0),
+                new es.Vector2(0, 1)
+            ];
+            this.walls = [];
+            this.weightedNodes = [];
+            this.defaultWeight = 1;
+            this.weightedNodeWeight = 5;
+            this._neighbors = new Array(4);
+            this._width = width;
+            this._height = height;
         }
-        return false;
-    };
-    AStarPathfinder.getKey = function (map, compareKey) {
-        var iterator = map.keys();
-        var valueIterator = map.values();
-        var r;
-        var v;
-        while (r = iterator.next(), v = valueIterator.next(), !r.done) {
-            if (JSON.stringify(r.value) == JSON.stringify(compareKey))
-                return v.value;
+        AstarGridGraph.prototype.isNodeInBounds = function (node) {
+            return 0 <= node.x && node.x < this._width && 0 <= node.y && node.y < this._height;
+        };
+        AstarGridGraph.prototype.isNodePassable = function (node) {
+            return !this.walls.firstOrDefault(function (wall) { return JSON.stringify(wall) == JSON.stringify(node); });
+        };
+        AstarGridGraph.prototype.search = function (start, goal) {
+            return es.AStarPathfinder.search(this, start, goal);
+        };
+        AstarGridGraph.prototype.getNeighbors = function (node) {
+            var _this = this;
+            this._neighbors.length = 0;
+            this.dirs.forEach(function (dir) {
+                var next = new es.Vector2(node.x + dir.x, node.y + dir.y);
+                if (_this.isNodeInBounds(next) && _this.isNodePassable(next))
+                    _this._neighbors.push(next);
+            });
+            return this._neighbors;
+        };
+        AstarGridGraph.prototype.cost = function (from, to) {
+            return this.weightedNodes.find(function (p) { return JSON.stringify(p) == JSON.stringify(to); }) ? this.weightedNodeWeight : this.defaultWeight;
+        };
+        AstarGridGraph.prototype.heuristic = function (node, goal) {
+            return Math.abs(node.x - goal.x) + Math.abs(node.y - goal.y);
+        };
+        return AstarGridGraph;
+    }());
+    es.AstarGridGraph = AstarGridGraph;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var PriorityQueue = (function () {
+        function PriorityQueue(maxNodes) {
+            this._numNodes = 0;
+            this._nodes = new Array(maxNodes + 1);
+            this._numNodesEverEnqueued = 0;
         }
-        return null;
-    };
-    AStarPathfinder.recontructPath = function (cameFrom, start, goal) {
-        var path = [];
-        var current = goal;
-        path.push(goal);
-        while (current != start) {
-            current = this.getKey(cameFrom, current);
-            path.push(current);
-        }
-        path.reverse();
-        return path;
-    };
-    return AStarPathfinder;
-}());
-var AStarNode = (function (_super) {
-    __extends(AStarNode, _super);
-    function AStarNode(data) {
-        var _this = _super.call(this) || this;
-        _this.data = data;
-        return _this;
-    }
-    return AStarNode;
-}(PriorityQueueNode));
-var AstarGridGraph = (function () {
-    function AstarGridGraph(width, height) {
-        this.dirs = [
-            new Vector2(1, 0),
-            new Vector2(0, -1),
-            new Vector2(-1, 0),
-            new Vector2(0, 1)
-        ];
-        this.walls = [];
-        this.weightedNodes = [];
-        this.defaultWeight = 1;
-        this.weightedNodeWeight = 5;
-        this._neighbors = new Array(4);
-        this._width = width;
-        this._height = height;
-    }
-    AstarGridGraph.prototype.isNodeInBounds = function (node) {
-        return 0 <= node.x && node.x < this._width && 0 <= node.y && node.y < this._height;
-    };
-    AstarGridGraph.prototype.isNodePassable = function (node) {
-        return !this.walls.firstOrDefault(function (wall) { return JSON.stringify(wall) == JSON.stringify(node); });
-    };
-    AstarGridGraph.prototype.search = function (start, goal) {
-        return AStarPathfinder.search(this, start, goal);
-    };
-    AstarGridGraph.prototype.getNeighbors = function (node) {
-        var _this = this;
-        this._neighbors.length = 0;
-        this.dirs.forEach(function (dir) {
-            var next = new Vector2(node.x + dir.x, node.y + dir.y);
-            if (_this.isNodeInBounds(next) && _this.isNodePassable(next))
-                _this._neighbors.push(next);
+        PriorityQueue.prototype.clear = function () {
+            this._nodes.splice(1, this._numNodes);
+            this._numNodes = 0;
+        };
+        Object.defineProperty(PriorityQueue.prototype, "count", {
+            get: function () {
+                return this._numNodes;
+            },
+            enumerable: true,
+            configurable: true
         });
-        return this._neighbors;
-    };
-    AstarGridGraph.prototype.cost = function (from, to) {
-        return this.weightedNodes.find(function (p) { return JSON.stringify(p) == JSON.stringify(to); }) ? this.weightedNodeWeight : this.defaultWeight;
-    };
-    AstarGridGraph.prototype.heuristic = function (node, goal) {
-        return Math.abs(node.x - goal.x) + Math.abs(node.y - goal.y);
-    };
-    return AstarGridGraph;
-}());
-var PriorityQueue = (function () {
-    function PriorityQueue(maxNodes) {
-        this._numNodes = 0;
-        this._nodes = new Array(maxNodes + 1);
-        this._numNodesEverEnqueued = 0;
-    }
-    PriorityQueue.prototype.clear = function () {
-        this._nodes.splice(1, this._numNodes);
-        this._numNodes = 0;
-    };
-    Object.defineProperty(PriorityQueue.prototype, "count", {
-        get: function () {
-            return this._numNodes;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(PriorityQueue.prototype, "maxSize", {
-        get: function () {
-            return this._nodes.length - 1;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    PriorityQueue.prototype.contains = function (node) {
-        if (!node) {
-            console.error("node cannot be null");
-            return false;
-        }
-        if (node.queueIndex < 0 || node.queueIndex >= this._nodes.length) {
-            console.error("node.QueueIndex has been corrupted. Did you change it manually? Or add this node to another queue?");
-            return false;
-        }
-        return (this._nodes[node.queueIndex] == node);
-    };
-    PriorityQueue.prototype.enqueue = function (node, priority) {
-        node.priority = priority;
-        this._numNodes++;
-        this._nodes[this._numNodes] = node;
-        node.queueIndex = this._numNodes;
-        node.insertionIndex = this._numNodesEverEnqueued++;
-        this.cascadeUp(this._nodes[this._numNodes]);
-    };
-    PriorityQueue.prototype.dequeue = function () {
-        var returnMe = this._nodes[1];
-        this.remove(returnMe);
-        return returnMe;
-    };
-    PriorityQueue.prototype.remove = function (node) {
-        if (node.queueIndex == this._numNodes) {
-            this._nodes[this._numNodes] = null;
+        Object.defineProperty(PriorityQueue.prototype, "maxSize", {
+            get: function () {
+                return this._nodes.length - 1;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        PriorityQueue.prototype.contains = function (node) {
+            if (!node) {
+                console.error("node cannot be null");
+                return false;
+            }
+            if (node.queueIndex < 0 || node.queueIndex >= this._nodes.length) {
+                console.error("node.QueueIndex has been corrupted. Did you change it manually? Or add this node to another queue?");
+                return false;
+            }
+            return (this._nodes[node.queueIndex] == node);
+        };
+        PriorityQueue.prototype.enqueue = function (node, priority) {
+            node.priority = priority;
+            this._numNodes++;
+            this._nodes[this._numNodes] = node;
+            node.queueIndex = this._numNodes;
+            node.insertionIndex = this._numNodesEverEnqueued++;
+            this.cascadeUp(this._nodes[this._numNodes]);
+        };
+        PriorityQueue.prototype.dequeue = function () {
+            var returnMe = this._nodes[1];
+            this.remove(returnMe);
+            return returnMe;
+        };
+        PriorityQueue.prototype.remove = function (node) {
+            if (node.queueIndex == this._numNodes) {
+                this._nodes[this._numNodes] = null;
+                this._numNodes--;
+                return;
+            }
+            var formerLastNode = this._nodes[this._numNodes];
+            this.swap(node, formerLastNode);
+            delete this._nodes[this._numNodes];
             this._numNodes--;
-            return;
-        }
-        var formerLastNode = this._nodes[this._numNodes];
-        this.swap(node, formerLastNode);
-        delete this._nodes[this._numNodes];
-        this._numNodes--;
-        this.onNodeUpdated(formerLastNode);
-    };
-    PriorityQueue.prototype.isValidQueue = function () {
-        for (var i = 1; i < this._nodes.length; i++) {
-            if (this._nodes[i]) {
-                var childLeftIndex = 2 * i;
-                if (childLeftIndex < this._nodes.length && this._nodes[childLeftIndex] &&
-                    this.hasHigherPriority(this._nodes[childLeftIndex], this._nodes[i]))
-                    return false;
+            this.onNodeUpdated(formerLastNode);
+        };
+        PriorityQueue.prototype.isValidQueue = function () {
+            for (var i = 1; i < this._nodes.length; i++) {
+                if (this._nodes[i]) {
+                    var childLeftIndex = 2 * i;
+                    if (childLeftIndex < this._nodes.length && this._nodes[childLeftIndex] &&
+                        this.hasHigherPriority(this._nodes[childLeftIndex], this._nodes[i]))
+                        return false;
+                    var childRightIndex = childLeftIndex + 1;
+                    if (childRightIndex < this._nodes.length && this._nodes[childRightIndex] &&
+                        this.hasHigherPriority(this._nodes[childRightIndex], this._nodes[i]))
+                        return false;
+                }
+            }
+            return true;
+        };
+        PriorityQueue.prototype.onNodeUpdated = function (node) {
+            var parentIndex = Math.floor(node.queueIndex / 2);
+            var parentNode = this._nodes[parentIndex];
+            if (parentIndex > 0 && this.hasHigherPriority(node, parentNode)) {
+                this.cascadeUp(node);
+            }
+            else {
+                this.cascadeDown(node);
+            }
+        };
+        PriorityQueue.prototype.cascadeDown = function (node) {
+            var newParent;
+            var finalQueueIndex = node.queueIndex;
+            while (true) {
+                newParent = node;
+                var childLeftIndex = 2 * finalQueueIndex;
+                if (childLeftIndex > this._numNodes) {
+                    node.queueIndex = finalQueueIndex;
+                    this._nodes[finalQueueIndex] = node;
+                    break;
+                }
+                var childLeft = this._nodes[childLeftIndex];
+                if (this.hasHigherPriority(childLeft, newParent)) {
+                    newParent = childLeft;
+                }
                 var childRightIndex = childLeftIndex + 1;
-                if (childRightIndex < this._nodes.length && this._nodes[childRightIndex] &&
-                    this.hasHigherPriority(this._nodes[childRightIndex], this._nodes[i]))
-                    return false;
-            }
-        }
-        return true;
-    };
-    PriorityQueue.prototype.onNodeUpdated = function (node) {
-        var parentIndex = Math.floor(node.queueIndex / 2);
-        var parentNode = this._nodes[parentIndex];
-        if (parentIndex > 0 && this.hasHigherPriority(node, parentNode)) {
-            this.cascadeUp(node);
-        }
-        else {
-            this.cascadeDown(node);
-        }
-    };
-    PriorityQueue.prototype.cascadeDown = function (node) {
-        var newParent;
-        var finalQueueIndex = node.queueIndex;
-        while (true) {
-            newParent = node;
-            var childLeftIndex = 2 * finalQueueIndex;
-            if (childLeftIndex > this._numNodes) {
-                node.queueIndex = finalQueueIndex;
-                this._nodes[finalQueueIndex] = node;
-                break;
-            }
-            var childLeft = this._nodes[childLeftIndex];
-            if (this.hasHigherPriority(childLeft, newParent)) {
-                newParent = childLeft;
-            }
-            var childRightIndex = childLeftIndex + 1;
-            if (childRightIndex <= this._numNodes) {
-                var childRight = this._nodes[childRightIndex];
-                if (this.hasHigherPriority(childRight, newParent)) {
-                    newParent = childRight;
+                if (childRightIndex <= this._numNodes) {
+                    var childRight = this._nodes[childRightIndex];
+                    if (this.hasHigherPriority(childRight, newParent)) {
+                        newParent = childRight;
+                    }
+                }
+                if (newParent != node) {
+                    this._nodes[finalQueueIndex] = newParent;
+                    var temp = newParent.queueIndex;
+                    newParent.queueIndex = finalQueueIndex;
+                    finalQueueIndex = temp;
+                }
+                else {
+                    node.queueIndex = finalQueueIndex;
+                    this._nodes[finalQueueIndex] = node;
+                    break;
                 }
             }
-            if (newParent != node) {
-                this._nodes[finalQueueIndex] = newParent;
-                var temp = newParent.queueIndex;
-                newParent.queueIndex = finalQueueIndex;
-                finalQueueIndex = temp;
-            }
-            else {
-                node.queueIndex = finalQueueIndex;
-                this._nodes[finalQueueIndex] = node;
-                break;
-            }
-        }
-    };
-    PriorityQueue.prototype.cascadeUp = function (node) {
-        var parent = Math.floor(node.queueIndex / 2);
-        while (parent >= 1) {
-            var parentNode = this._nodes[parent];
-            if (this.hasHigherPriority(parentNode, node))
-                break;
-            this.swap(node, parentNode);
-            parent = Math.floor(node.queueIndex / 2);
-        }
-    };
-    PriorityQueue.prototype.swap = function (node1, node2) {
-        this._nodes[node1.queueIndex] = node2;
-        this._nodes[node2.queueIndex] = node1;
-        var temp = node1.queueIndex;
-        node1.queueIndex = node2.queueIndex;
-        node2.queueIndex = temp;
-    };
-    PriorityQueue.prototype.hasHigherPriority = function (higher, lower) {
-        return (higher.priority < lower.priority ||
-            (higher.priority == lower.priority && higher.insertionIndex < lower.insertionIndex));
-    };
-    return PriorityQueue;
-}());
-var BreadthFirstPathfinder = (function () {
-    function BreadthFirstPathfinder() {
-    }
-    BreadthFirstPathfinder.search = function (graph, start, goal) {
-        var _this = this;
-        var foundPath = false;
-        var frontier = [];
-        frontier.unshift(start);
-        var cameFrom = new Map();
-        cameFrom.set(start, start);
-        var _loop_3 = function () {
-            var current = frontier.shift();
-            if (JSON.stringify(current) == JSON.stringify(goal)) {
-                foundPath = true;
-                return "break";
-            }
-            graph.getNeighbors(current).forEach(function (next) {
-                if (!_this.hasKey(cameFrom, next)) {
-                    frontier.unshift(next);
-                    cameFrom.set(next, current);
-                }
-            });
         };
-        while (frontier.length > 0) {
-            var state_2 = _loop_3();
-            if (state_2 === "break")
-                break;
-        }
-        return foundPath ? AStarPathfinder.recontructPath(cameFrom, start, goal) : null;
-    };
-    BreadthFirstPathfinder.hasKey = function (map, compareKey) {
-        var iterator = map.keys();
-        var r;
-        while (r = iterator.next(), !r.done) {
-            if (JSON.stringify(r.value) == JSON.stringify(compareKey))
-                return true;
-        }
-        return false;
-    };
-    return BreadthFirstPathfinder;
-}());
-var UnweightedGraph = (function () {
-    function UnweightedGraph() {
-        this.edges = new Map();
-    }
-    UnweightedGraph.prototype.addEdgesForNode = function (node, edges) {
-        this.edges.set(node, edges);
-        return this;
-    };
-    UnweightedGraph.prototype.getNeighbors = function (node) {
-        return this.edges.get(node);
-    };
-    return UnweightedGraph;
-}());
-var Vector2 = (function () {
-    function Vector2(x, y) {
-        this.x = 0;
-        this.y = 0;
-        this.x = x ? x : 0;
-        this.y = y ? y : this.x;
-    }
-    Object.defineProperty(Vector2, "zero", {
-        get: function () {
-            return Vector2.zeroVector2;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Vector2, "one", {
-        get: function () {
-            return Vector2.unitVector2;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Vector2, "unitX", {
-        get: function () {
-            return Vector2.unitXVector;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Vector2, "unitY", {
-        get: function () {
-            return Vector2.unitYVector;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Vector2.add = function (value1, value2) {
-        var result = new Vector2(0, 0);
-        result.x = value1.x + value2.x;
-        result.y = value1.y + value2.y;
-        return result;
-    };
-    Vector2.divide = function (value1, value2) {
-        var result = new Vector2(0, 0);
-        result.x = value1.x / value2.x;
-        result.y = value1.y / value2.y;
-        return result;
-    };
-    Vector2.multiply = function (value1, value2) {
-        var result = new Vector2(0, 0);
-        result.x = value1.x * value2.x;
-        result.y = value1.y * value2.y;
-        return result;
-    };
-    Vector2.subtract = function (value1, value2) {
-        var result = new Vector2(0, 0);
-        result.x = value1.x - value2.x;
-        result.y = value1.y - value2.y;
-        return result;
-    };
-    Vector2.prototype.normalize = function () {
-        var val = 1 / Math.sqrt((this.x * this.x) + (this.y * this.y));
-        this.x *= val;
-        this.y *= val;
-    };
-    Vector2.prototype.length = function () {
-        return Math.sqrt((this.x * this.x) + (this.y * this.y));
-    };
-    Vector2.prototype.round = function () {
-        return new Vector2(Math.round(this.x), Math.round(this.y));
-    };
-    Vector2.normalize = function (value) {
-        var val = 1 / Math.sqrt((value.x * value.x) + (value.y * value.y));
-        value.x *= val;
-        value.y *= val;
-        return value;
-    };
-    Vector2.dot = function (value1, value2) {
-        return (value1.x * value2.x) + (value1.y * value2.y);
-    };
-    Vector2.distanceSquared = function (value1, value2) {
-        var v1 = value1.x - value2.x, v2 = value1.y - value2.y;
-        return (v1 * v1) + (v2 * v2);
-    };
-    Vector2.clamp = function (value1, min, max) {
-        return new Vector2(MathHelper.clamp(value1.x, min.x, max.x), MathHelper.clamp(value1.y, min.y, max.y));
-    };
-    Vector2.lerp = function (value1, value2, amount) {
-        return new Vector2(MathHelper.lerp(value1.x, value2.x, amount), MathHelper.lerp(value1.y, value2.y, amount));
-    };
-    Vector2.transform = function (position, matrix) {
-        return new Vector2((position.x * matrix.m11) + (position.y * matrix.m21), (position.x * matrix.m12) + (position.y * matrix.m22));
-    };
-    Vector2.distance = function (value1, value2) {
-        var v1 = value1.x - value2.x, v2 = value1.y - value2.y;
-        return Math.sqrt((v1 * v1) + (v2 * v2));
-    };
-    Vector2.negate = function (value) {
-        var result = new Vector2();
-        result.x = -value.x;
-        result.y = -value.y;
-        return result;
-    };
-    Vector2.unitYVector = new Vector2(0, 1);
-    Vector2.unitXVector = new Vector2(1, 0);
-    Vector2.unitVector2 = new Vector2(1, 1);
-    Vector2.zeroVector2 = new Vector2(0, 0);
-    return Vector2;
-}());
-var UnweightedGridGraph = (function () {
-    function UnweightedGridGraph(width, height, allowDiagonalSearch) {
-        if (allowDiagonalSearch === void 0) { allowDiagonalSearch = false; }
-        this.walls = [];
-        this._neighbors = new Array(4);
-        this._width = width;
-        this._hegiht = height;
-        this._dirs = allowDiagonalSearch ? UnweightedGridGraph.COMPASS_DIRS : UnweightedGridGraph.CARDINAL_DIRS;
-    }
-    UnweightedGridGraph.prototype.isNodeInBounds = function (node) {
-        return 0 <= node.x && node.x < this._width && 0 <= node.y && node.y < this._hegiht;
-    };
-    UnweightedGridGraph.prototype.isNodePassable = function (node) {
-        return !this.walls.firstOrDefault(function (wall) { return JSON.stringify(wall) == JSON.stringify(node); });
-    };
-    UnweightedGridGraph.prototype.getNeighbors = function (node) {
-        var _this = this;
-        this._neighbors.length = 0;
-        this._dirs.forEach(function (dir) {
-            var next = new Vector2(node.x + dir.x, node.y + dir.y);
-            if (_this.isNodeInBounds(next) && _this.isNodePassable(next))
-                _this._neighbors.push(next);
-        });
-        return this._neighbors;
-    };
-    UnweightedGridGraph.prototype.search = function (start, goal) {
-        return BreadthFirstPathfinder.search(this, start, goal);
-    };
-    UnweightedGridGraph.CARDINAL_DIRS = [
-        new Vector2(1, 0),
-        new Vector2(0, -1),
-        new Vector2(-1, 0),
-        new Vector2(0, -1)
-    ];
-    UnweightedGridGraph.COMPASS_DIRS = [
-        new Vector2(1, 0),
-        new Vector2(1, -1),
-        new Vector2(0, -1),
-        new Vector2(-1, -1),
-        new Vector2(-1, 0),
-        new Vector2(-1, 1),
-        new Vector2(0, 1),
-        new Vector2(1, 1),
-    ];
-    return UnweightedGridGraph;
-}());
-var WeightedGridGraph = (function () {
-    function WeightedGridGraph(width, height, allowDiagonalSearch) {
-        if (allowDiagonalSearch === void 0) { allowDiagonalSearch = false; }
-        this.walls = [];
-        this.weightedNodes = [];
-        this.defaultWeight = 1;
-        this.weightedNodeWeight = 5;
-        this._neighbors = new Array(4);
-        this._width = width;
-        this._height = height;
-        this._dirs = allowDiagonalSearch ? WeightedGridGraph.COMPASS_DIRS : WeightedGridGraph.CARDINAL_DIRS;
-    }
-    WeightedGridGraph.prototype.isNodeInBounds = function (node) {
-        return 0 <= node.x && node.x < this._width && 0 <= node.y && node.y < this._height;
-    };
-    WeightedGridGraph.prototype.isNodePassable = function (node) {
-        return !this.walls.firstOrDefault(function (wall) { return JSON.stringify(wall) == JSON.stringify(node); });
-    };
-    WeightedGridGraph.prototype.search = function (start, goal) {
-        return WeightedPathfinder.search(this, start, goal);
-    };
-    WeightedGridGraph.prototype.getNeighbors = function (node) {
-        var _this = this;
-        this._neighbors.length = 0;
-        this._dirs.forEach(function (dir) {
-            var next = new Vector2(node.x + dir.x, node.y + dir.y);
-            if (_this.isNodeInBounds(next) && _this.isNodePassable(next))
-                _this._neighbors.push(next);
-        });
-        return this._neighbors;
-    };
-    WeightedGridGraph.prototype.cost = function (from, to) {
-        return this.weightedNodes.find(function (t) { return JSON.stringify(t) == JSON.stringify(to); }) ? this.weightedNodeWeight : this.defaultWeight;
-    };
-    WeightedGridGraph.CARDINAL_DIRS = [
-        new Vector2(1, 0),
-        new Vector2(0, -1),
-        new Vector2(-1, 0),
-        new Vector2(0, 1)
-    ];
-    WeightedGridGraph.COMPASS_DIRS = [
-        new Vector2(1, 0),
-        new Vector2(1, -1),
-        new Vector2(0, -1),
-        new Vector2(-1, -1),
-        new Vector2(-1, 0),
-        new Vector2(-1, 1),
-        new Vector2(0, 1),
-        new Vector2(1, 1),
-    ];
-    return WeightedGridGraph;
-}());
-var WeightedNode = (function (_super) {
-    __extends(WeightedNode, _super);
-    function WeightedNode(data) {
-        var _this = _super.call(this) || this;
-        _this.data = data;
-        return _this;
-    }
-    return WeightedNode;
-}(PriorityQueueNode));
-var WeightedPathfinder = (function () {
-    function WeightedPathfinder() {
-    }
-    WeightedPathfinder.search = function (graph, start, goal) {
-        var _this = this;
-        var foundPath = false;
-        var cameFrom = new Map();
-        cameFrom.set(start, start);
-        var costSoFar = new Map();
-        var frontier = new PriorityQueue(1000);
-        frontier.enqueue(new WeightedNode(start), 0);
-        costSoFar.set(start, 0);
-        var _loop_4 = function () {
-            var current = frontier.dequeue();
-            if (JSON.stringify(current.data) == JSON.stringify(goal)) {
-                foundPath = true;
-                return "break";
+        PriorityQueue.prototype.cascadeUp = function (node) {
+            var parent = Math.floor(node.queueIndex / 2);
+            while (parent >= 1) {
+                var parentNode = this._nodes[parent];
+                if (this.hasHigherPriority(parentNode, node))
+                    break;
+                this.swap(node, parentNode);
+                parent = Math.floor(node.queueIndex / 2);
             }
-            graph.getNeighbors(current.data).forEach(function (next) {
-                var newCost = costSoFar.get(current.data) + graph.cost(current.data, next);
-                if (!_this.hasKey(costSoFar, next) || newCost < costSoFar.get(next)) {
-                    costSoFar.set(next, newCost);
-                    var priprity = newCost;
-                    frontier.enqueue(new WeightedNode(next), priprity);
-                    cameFrom.set(next, current.data);
-                }
-            });
         };
-        while (frontier.count > 0) {
-            var state_3 = _loop_4();
-            if (state_3 === "break")
-                break;
+        PriorityQueue.prototype.swap = function (node1, node2) {
+            this._nodes[node1.queueIndex] = node2;
+            this._nodes[node2.queueIndex] = node1;
+            var temp = node1.queueIndex;
+            node1.queueIndex = node2.queueIndex;
+            node2.queueIndex = temp;
+        };
+        PriorityQueue.prototype.hasHigherPriority = function (higher, lower) {
+            return (higher.priority < lower.priority ||
+                (higher.priority == lower.priority && higher.insertionIndex < lower.insertionIndex));
+        };
+        return PriorityQueue;
+    }());
+    es.PriorityQueue = PriorityQueue;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var BreadthFirstPathfinder = (function () {
+        function BreadthFirstPathfinder() {
         }
-        return foundPath ? this.recontructPath(cameFrom, start, goal) : null;
-    };
-    WeightedPathfinder.hasKey = function (map, compareKey) {
-        var iterator = map.keys();
-        var r;
-        while (r = iterator.next(), !r.done) {
-            if (JSON.stringify(r.value) == JSON.stringify(compareKey))
-                return true;
-        }
-        return false;
-    };
-    WeightedPathfinder.getKey = function (map, compareKey) {
-        var iterator = map.keys();
-        var valueIterator = map.values();
-        var r;
-        var v;
-        while (r = iterator.next(), v = valueIterator.next(), !r.done) {
-            if (JSON.stringify(r.value) == JSON.stringify(compareKey))
-                return v.value;
-        }
-        return null;
-    };
-    WeightedPathfinder.recontructPath = function (cameFrom, start, goal) {
-        var path = [];
-        var current = goal;
-        path.push(goal);
-        while (current != start) {
-            current = this.getKey(cameFrom, current);
-            path.push(current);
-        }
-        path.reverse();
-        return path;
-    };
-    return WeightedPathfinder;
-}());
-var Debug = (function () {
-    function Debug() {
-    }
-    Debug.drawHollowRect = function (rectanle, color, duration) {
-        if (duration === void 0) { duration = 0; }
-        this._debugDrawItems.push(new DebugDrawItem(rectanle, color, duration));
-    };
-    Debug.render = function () {
-        if (this._debugDrawItems.length > 0) {
-            var debugShape = new egret.Shape();
-            if (SceneManager.scene) {
-                SceneManager.scene.addChild(debugShape);
+        BreadthFirstPathfinder.search = function (graph, start, goal) {
+            var _this = this;
+            var foundPath = false;
+            var frontier = [];
+            frontier.unshift(start);
+            var cameFrom = new Map();
+            cameFrom.set(start, start);
+            var _loop_3 = function () {
+                var current = frontier.shift();
+                if (JSON.stringify(current) == JSON.stringify(goal)) {
+                    foundPath = true;
+                    return "break";
+                }
+                graph.getNeighbors(current).forEach(function (next) {
+                    if (!_this.hasKey(cameFrom, next)) {
+                        frontier.unshift(next);
+                        cameFrom.set(next, current);
+                    }
+                });
+            };
+            while (frontier.length > 0) {
+                var state_2 = _loop_3();
+                if (state_2 === "break")
+                    break;
             }
-            for (var i = this._debugDrawItems.length - 1; i >= 0; i--) {
-                var item = this._debugDrawItems[i];
-                if (item.draw(debugShape))
-                    this._debugDrawItems.removeAt(i);
+            return foundPath ? es.AStarPathfinder.recontructPath(cameFrom, start, goal) : null;
+        };
+        BreadthFirstPathfinder.hasKey = function (map, compareKey) {
+            var iterator = map.keys();
+            var r;
+            while (r = iterator.next(), !r.done) {
+                if (JSON.stringify(r.value) == JSON.stringify(compareKey))
+                    return true;
             }
+            return false;
+        };
+        return BreadthFirstPathfinder;
+    }());
+    es.BreadthFirstPathfinder = BreadthFirstPathfinder;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var UnweightedGraph = (function () {
+        function UnweightedGraph() {
+            this.edges = new Map();
         }
-    };
-    Debug._debugDrawItems = [];
-    return Debug;
-}());
-var DebugDefaults = (function () {
-    function DebugDefaults() {
-    }
-    DebugDefaults.verletParticle = 0xDC345E;
-    DebugDefaults.verletConstraintEdge = 0x433E36;
-    return DebugDefaults;
-}());
-var DebugDrawType;
-(function (DebugDrawType) {
-    DebugDrawType[DebugDrawType["line"] = 0] = "line";
-    DebugDrawType[DebugDrawType["hollowRectangle"] = 1] = "hollowRectangle";
-    DebugDrawType[DebugDrawType["pixel"] = 2] = "pixel";
-    DebugDrawType[DebugDrawType["text"] = 3] = "text";
-})(DebugDrawType || (DebugDrawType = {}));
-var DebugDrawItem = (function () {
-    function DebugDrawItem(rectangle, color, duration) {
-        this.rectangle = rectangle;
-        this.color = color;
-        this.duration = duration;
-        this.drawType = DebugDrawType.hollowRectangle;
-    }
-    DebugDrawItem.prototype.draw = function (shape) {
-        switch (this.drawType) {
-            case DebugDrawType.line:
-                DrawUtils.drawLine(shape, this.start, this.end, this.color);
-                break;
-            case DebugDrawType.hollowRectangle:
-                DrawUtils.drawHollowRect(shape, this.rectangle, this.color);
-                break;
-            case DebugDrawType.pixel:
-                DrawUtils.drawPixel(shape, new Vector2(this.x, this.y), this.color, this.size);
-                break;
-            case DebugDrawType.text:
-                break;
+        UnweightedGraph.prototype.addEdgesForNode = function (node, edges) {
+            this.edges.set(node, edges);
+            return this;
+        };
+        UnweightedGraph.prototype.getNeighbors = function (node) {
+            return this.edges.get(node);
+        };
+        return UnweightedGraph;
+    }());
+    es.UnweightedGraph = UnweightedGraph;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Vector2 = (function () {
+        function Vector2(x, y) {
+            this.x = 0;
+            this.y = 0;
+            this.x = x ? x : 0;
+            this.y = y ? y : this.x;
         }
-        this.duration -= Time.deltaTime;
-        return this.duration < 0;
-    };
-    return DebugDrawItem;
-}());
-var Component = (function (_super) {
-    __extends(Component, _super);
-    function Component() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this._enabled = true;
-        _this.updateInterval = 1;
-        _this._updateOrder = 0;
-        return _this;
-    }
-    Object.defineProperty(Component.prototype, "enabled", {
-        get: function () {
-            return this.entity ? this.entity.enabled && this._enabled : this._enabled;
-        },
-        set: function (value) {
-            this.setEnabled(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Component.prototype, "localPosition", {
-        get: function () {
-            return new Vector2(this.entity.x + this.x, this.entity.y + this.y);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Component.prototype.setEnabled = function (isEnabled) {
-        if (this._enabled != isEnabled) {
-            this._enabled = isEnabled;
-            if (this._enabled) {
-                this.onEnabled();
+        Object.defineProperty(Vector2, "zero", {
+            get: function () {
+                return Vector2.zeroVector2;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Vector2, "one", {
+            get: function () {
+                return Vector2.unitVector2;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Vector2, "unitX", {
+            get: function () {
+                return Vector2.unitXVector;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Vector2, "unitY", {
+            get: function () {
+                return Vector2.unitYVector;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Vector2.add = function (value1, value2) {
+            var result = new Vector2(0, 0);
+            result.x = value1.x + value2.x;
+            result.y = value1.y + value2.y;
+            return result;
+        };
+        Vector2.divide = function (value1, value2) {
+            var result = new Vector2(0, 0);
+            result.x = value1.x / value2.x;
+            result.y = value1.y / value2.y;
+            return result;
+        };
+        Vector2.multiply = function (value1, value2) {
+            var result = new Vector2(0, 0);
+            result.x = value1.x * value2.x;
+            result.y = value1.y * value2.y;
+            return result;
+        };
+        Vector2.subtract = function (value1, value2) {
+            var result = new Vector2(0, 0);
+            result.x = value1.x - value2.x;
+            result.y = value1.y - value2.y;
+            return result;
+        };
+        Vector2.prototype.normalize = function () {
+            var val = 1 / Math.sqrt((this.x * this.x) + (this.y * this.y));
+            this.x *= val;
+            this.y *= val;
+        };
+        Vector2.prototype.length = function () {
+            return Math.sqrt((this.x * this.x) + (this.y * this.y));
+        };
+        Vector2.prototype.round = function () {
+            return new Vector2(Math.round(this.x), Math.round(this.y));
+        };
+        Vector2.normalize = function (value) {
+            var val = 1 / Math.sqrt((value.x * value.x) + (value.y * value.y));
+            value.x *= val;
+            value.y *= val;
+            return value;
+        };
+        Vector2.dot = function (value1, value2) {
+            return (value1.x * value2.x) + (value1.y * value2.y);
+        };
+        Vector2.distanceSquared = function (value1, value2) {
+            var v1 = value1.x - value2.x, v2 = value1.y - value2.y;
+            return (v1 * v1) + (v2 * v2);
+        };
+        Vector2.clamp = function (value1, min, max) {
+            return new Vector2(es.MathHelper.clamp(value1.x, min.x, max.x), es.MathHelper.clamp(value1.y, min.y, max.y));
+        };
+        Vector2.lerp = function (value1, value2, amount) {
+            return new Vector2(es.MathHelper.lerp(value1.x, value2.x, amount), es.MathHelper.lerp(value1.y, value2.y, amount));
+        };
+        Vector2.transform = function (position, matrix) {
+            return new Vector2((position.x * matrix.m11) + (position.y * matrix.m21), (position.x * matrix.m12) + (position.y * matrix.m22));
+        };
+        Vector2.distance = function (value1, value2) {
+            var v1 = value1.x - value2.x, v2 = value1.y - value2.y;
+            return Math.sqrt((v1 * v1) + (v2 * v2));
+        };
+        Vector2.negate = function (value) {
+            var result = new Vector2();
+            result.x = -value.x;
+            result.y = -value.y;
+            return result;
+        };
+        Vector2.unitYVector = new Vector2(0, 1);
+        Vector2.unitXVector = new Vector2(1, 0);
+        Vector2.unitVector2 = new Vector2(1, 1);
+        Vector2.zeroVector2 = new Vector2(0, 0);
+        return Vector2;
+    }());
+    es.Vector2 = Vector2;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var UnweightedGridGraph = (function () {
+        function UnweightedGridGraph(width, height, allowDiagonalSearch) {
+            if (allowDiagonalSearch === void 0) { allowDiagonalSearch = false; }
+            this.walls = [];
+            this._neighbors = new Array(4);
+            this._width = width;
+            this._hegiht = height;
+            this._dirs = allowDiagonalSearch ? UnweightedGridGraph.COMPASS_DIRS : UnweightedGridGraph.CARDINAL_DIRS;
+        }
+        UnweightedGridGraph.prototype.isNodeInBounds = function (node) {
+            return 0 <= node.x && node.x < this._width && 0 <= node.y && node.y < this._hegiht;
+        };
+        UnweightedGridGraph.prototype.isNodePassable = function (node) {
+            return !this.walls.firstOrDefault(function (wall) { return JSON.stringify(wall) == JSON.stringify(node); });
+        };
+        UnweightedGridGraph.prototype.getNeighbors = function (node) {
+            var _this = this;
+            this._neighbors.length = 0;
+            this._dirs.forEach(function (dir) {
+                var next = new es.Vector2(node.x + dir.x, node.y + dir.y);
+                if (_this.isNodeInBounds(next) && _this.isNodePassable(next))
+                    _this._neighbors.push(next);
+            });
+            return this._neighbors;
+        };
+        UnweightedGridGraph.prototype.search = function (start, goal) {
+            return es.BreadthFirstPathfinder.search(this, start, goal);
+        };
+        UnweightedGridGraph.CARDINAL_DIRS = [
+            new es.Vector2(1, 0),
+            new es.Vector2(0, -1),
+            new es.Vector2(-1, 0),
+            new es.Vector2(0, -1)
+        ];
+        UnweightedGridGraph.COMPASS_DIRS = [
+            new es.Vector2(1, 0),
+            new es.Vector2(1, -1),
+            new es.Vector2(0, -1),
+            new es.Vector2(-1, -1),
+            new es.Vector2(-1, 0),
+            new es.Vector2(-1, 1),
+            new es.Vector2(0, 1),
+            new es.Vector2(1, 1),
+        ];
+        return UnweightedGridGraph;
+    }());
+    es.UnweightedGridGraph = UnweightedGridGraph;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var WeightedGridGraph = (function () {
+        function WeightedGridGraph(width, height, allowDiagonalSearch) {
+            if (allowDiagonalSearch === void 0) { allowDiagonalSearch = false; }
+            this.walls = [];
+            this.weightedNodes = [];
+            this.defaultWeight = 1;
+            this.weightedNodeWeight = 5;
+            this._neighbors = new Array(4);
+            this._width = width;
+            this._height = height;
+            this._dirs = allowDiagonalSearch ? WeightedGridGraph.COMPASS_DIRS : WeightedGridGraph.CARDINAL_DIRS;
+        }
+        WeightedGridGraph.prototype.isNodeInBounds = function (node) {
+            return 0 <= node.x && node.x < this._width && 0 <= node.y && node.y < this._height;
+        };
+        WeightedGridGraph.prototype.isNodePassable = function (node) {
+            return !this.walls.firstOrDefault(function (wall) { return JSON.stringify(wall) == JSON.stringify(node); });
+        };
+        WeightedGridGraph.prototype.search = function (start, goal) {
+            return es.WeightedPathfinder.search(this, start, goal);
+        };
+        WeightedGridGraph.prototype.getNeighbors = function (node) {
+            var _this = this;
+            this._neighbors.length = 0;
+            this._dirs.forEach(function (dir) {
+                var next = new es.Vector2(node.x + dir.x, node.y + dir.y);
+                if (_this.isNodeInBounds(next) && _this.isNodePassable(next))
+                    _this._neighbors.push(next);
+            });
+            return this._neighbors;
+        };
+        WeightedGridGraph.prototype.cost = function (from, to) {
+            return this.weightedNodes.find(function (t) { return JSON.stringify(t) == JSON.stringify(to); }) ? this.weightedNodeWeight : this.defaultWeight;
+        };
+        WeightedGridGraph.CARDINAL_DIRS = [
+            new es.Vector2(1, 0),
+            new es.Vector2(0, -1),
+            new es.Vector2(-1, 0),
+            new es.Vector2(0, 1)
+        ];
+        WeightedGridGraph.COMPASS_DIRS = [
+            new es.Vector2(1, 0),
+            new es.Vector2(1, -1),
+            new es.Vector2(0, -1),
+            new es.Vector2(-1, -1),
+            new es.Vector2(-1, 0),
+            new es.Vector2(-1, 1),
+            new es.Vector2(0, 1),
+            new es.Vector2(1, 1),
+        ];
+        return WeightedGridGraph;
+    }());
+    es.WeightedGridGraph = WeightedGridGraph;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var WeightedNode = (function (_super) {
+        __extends(WeightedNode, _super);
+        function WeightedNode(data) {
+            var _this = _super.call(this) || this;
+            _this.data = data;
+            return _this;
+        }
+        return WeightedNode;
+    }(es.PriorityQueueNode));
+    es.WeightedNode = WeightedNode;
+    var WeightedPathfinder = (function () {
+        function WeightedPathfinder() {
+        }
+        WeightedPathfinder.search = function (graph, start, goal) {
+            var _this = this;
+            var foundPath = false;
+            var cameFrom = new Map();
+            cameFrom.set(start, start);
+            var costSoFar = new Map();
+            var frontier = new es.PriorityQueue(1000);
+            frontier.enqueue(new WeightedNode(start), 0);
+            costSoFar.set(start, 0);
+            var _loop_4 = function () {
+                var current = frontier.dequeue();
+                if (JSON.stringify(current.data) == JSON.stringify(goal)) {
+                    foundPath = true;
+                    return "break";
+                }
+                graph.getNeighbors(current.data).forEach(function (next) {
+                    var newCost = costSoFar.get(current.data) + graph.cost(current.data, next);
+                    if (!_this.hasKey(costSoFar, next) || newCost < costSoFar.get(next)) {
+                        costSoFar.set(next, newCost);
+                        var priprity = newCost;
+                        frontier.enqueue(new WeightedNode(next), priprity);
+                        cameFrom.set(next, current.data);
+                    }
+                });
+            };
+            while (frontier.count > 0) {
+                var state_3 = _loop_4();
+                if (state_3 === "break")
+                    break;
             }
-            else {
-                this.onDisabled();
+            return foundPath ? this.recontructPath(cameFrom, start, goal) : null;
+        };
+        WeightedPathfinder.hasKey = function (map, compareKey) {
+            var iterator = map.keys();
+            var r;
+            while (r = iterator.next(), !r.done) {
+                if (JSON.stringify(r.value) == JSON.stringify(compareKey))
+                    return true;
             }
+            return false;
+        };
+        WeightedPathfinder.getKey = function (map, compareKey) {
+            var iterator = map.keys();
+            var valueIterator = map.values();
+            var r;
+            var v;
+            while (r = iterator.next(), v = valueIterator.next(), !r.done) {
+                if (JSON.stringify(r.value) == JSON.stringify(compareKey))
+                    return v.value;
+            }
+            return null;
+        };
+        WeightedPathfinder.recontructPath = function (cameFrom, start, goal) {
+            var path = [];
+            var current = goal;
+            path.push(goal);
+            while (current != start) {
+                current = this.getKey(cameFrom, current);
+                path.push(current);
+            }
+            path.reverse();
+            return path;
+        };
+        return WeightedPathfinder;
+    }());
+    es.WeightedPathfinder = WeightedPathfinder;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Debug = (function () {
+        function Debug() {
         }
-        return this;
-    };
-    Object.defineProperty(Component.prototype, "updateOrder", {
-        get: function () {
-            return this._updateOrder;
-        },
-        set: function (value) {
-            this.setUpdateOrder(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Component.prototype.setUpdateOrder = function (updateOrder) {
-        if (this._updateOrder != updateOrder) {
-            this._updateOrder = updateOrder;
+        Debug.drawHollowRect = function (rectanle, color, duration) {
+            if (duration === void 0) { duration = 0; }
+            this._debugDrawItems.push(new es.DebugDrawItem(rectanle, color, duration));
+        };
+        Debug.render = function () {
+            if (this._debugDrawItems.length > 0) {
+                var debugShape = new egret.Shape();
+                if (es.SceneManager.scene) {
+                    es.SceneManager.scene.addChild(debugShape);
+                }
+                for (var i = this._debugDrawItems.length - 1; i >= 0; i--) {
+                    var item = this._debugDrawItems[i];
+                    if (item.draw(debugShape))
+                        this._debugDrawItems.removeAt(i);
+                }
+            }
+        };
+        Debug._debugDrawItems = [];
+        return Debug;
+    }());
+    es.Debug = Debug;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var DebugDefaults = (function () {
+        function DebugDefaults() {
         }
-        return this;
-    };
-    Component.prototype.initialize = function () {
-    };
-    Component.prototype.onAddedToEntity = function () {
-    };
-    Component.prototype.onRemovedFromEntity = function () {
-    };
-    Component.prototype.onEnabled = function () {
-    };
-    Component.prototype.onDisabled = function () {
-    };
-    Component.prototype.debugRender = function () {
-    };
-    Component.prototype.update = function () {
-    };
-    Component.prototype.onEntityTransformChanged = function (comp) {
-    };
-    Component.prototype.registerComponent = function () {
-        this.entity.componentBits.set(ComponentTypeManager.getIndexFor(this), false);
-        this.entity.scene.entityProcessors.onComponentAdded(this.entity);
-    };
-    Component.prototype.deregisterComponent = function () {
-        this.entity.componentBits.set(ComponentTypeManager.getIndexFor(this));
-        this.entity.scene.entityProcessors.onComponentRemoved(this.entity);
-    };
-    return Component;
-}(egret.DisplayObjectContainer));
-var CoreEvents;
-(function (CoreEvents) {
-    CoreEvents[CoreEvents["SceneChanged"] = 0] = "SceneChanged";
-})(CoreEvents || (CoreEvents = {}));
-var Entity = (function (_super) {
-    __extends(Entity, _super);
-    function Entity(name) {
-        var _this = _super.call(this) || this;
-        _this._updateOrder = 0;
-        _this._enabled = true;
-        _this._tag = 0;
-        _this.name = name;
-        _this.components = new ComponentList(_this);
-        _this.id = Entity._idGenerator++;
-        _this.componentBits = new BitSet();
-        _this.addEventListener(egret.Event.ADDED_TO_STAGE, _this.onAddToStage, _this);
-        return _this;
-    }
-    Object.defineProperty(Entity.prototype, "isDestoryed", {
-        get: function () {
-            return this._isDestoryed;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Entity.prototype, "position", {
-        get: function () {
-            return new Vector2(this.x, this.y);
-        },
-        set: function (value) {
-            this.$setX(value.x);
-            this.$setY(value.y);
-            this.onEntityTransformChanged(TransformComponent.position);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Entity.prototype, "scale", {
-        get: function () {
-            return new Vector2(this.scaleX, this.scaleY);
-        },
-        set: function (value) {
-            this.$setScaleX(value.x);
-            this.$setScaleY(value.y);
-            this.onEntityTransformChanged(TransformComponent.scale);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Entity.prototype, "rotation", {
-        get: function () {
-            return this.$getRotation();
-        },
-        set: function (value) {
-            this.$setRotation(value);
-            this.onEntityTransformChanged(TransformComponent.rotation);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Entity.prototype, "enabled", {
-        get: function () {
-            return this._enabled;
-        },
-        set: function (value) {
-            this.setEnabled(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Entity.prototype.setEnabled = function (isEnabled) {
-        if (this._enabled != isEnabled) {
-            this._enabled = isEnabled;
+        DebugDefaults.verletParticle = 0xDC345E;
+        DebugDefaults.verletConstraintEdge = 0x433E36;
+        return DebugDefaults;
+    }());
+    es.DebugDefaults = DebugDefaults;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var DebugDrawType;
+    (function (DebugDrawType) {
+        DebugDrawType[DebugDrawType["line"] = 0] = "line";
+        DebugDrawType[DebugDrawType["hollowRectangle"] = 1] = "hollowRectangle";
+        DebugDrawType[DebugDrawType["pixel"] = 2] = "pixel";
+        DebugDrawType[DebugDrawType["text"] = 3] = "text";
+    })(DebugDrawType = es.DebugDrawType || (es.DebugDrawType = {}));
+    var DebugDrawItem = (function () {
+        function DebugDrawItem(rectangle, color, duration) {
+            this.rectangle = rectangle;
+            this.color = color;
+            this.duration = duration;
+            this.drawType = DebugDrawType.hollowRectangle;
         }
-        return this;
-    };
-    Object.defineProperty(Entity.prototype, "tag", {
-        get: function () {
-            return this._tag;
-        },
-        set: function (value) {
-            this.setTag(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Entity.prototype, "stage", {
-        get: function () {
-            if (!this.scene)
-                return null;
-            return this.scene.stage;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Entity.prototype.onAddToStage = function () {
-        this.onEntityTransformChanged(TransformComponent.position);
-    };
-    Object.defineProperty(Entity.prototype, "updateOrder", {
-        get: function () {
-            return this._updateOrder;
-        },
-        set: function (value) {
-            this.setUpdateOrder(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Entity.prototype.roundPosition = function () {
-        this.position = Vector2Ext.round(this.position);
-    };
-    Entity.prototype.setUpdateOrder = function (updateOrder) {
-        if (this._updateOrder != updateOrder) {
-            this._updateOrder = updateOrder;
-            if (this.scene) {
+        DebugDrawItem.prototype.draw = function (shape) {
+            switch (this.drawType) {
+                case DebugDrawType.line:
+                    es.DrawUtils.drawLine(shape, this.start, this.end, this.color);
+                    break;
+                case DebugDrawType.hollowRectangle:
+                    es.DrawUtils.drawHollowRect(shape, this.rectangle, this.color);
+                    break;
+                case DebugDrawType.pixel:
+                    es.DrawUtils.drawPixel(shape, new es.Vector2(this.x, this.y), this.color, this.size);
+                    break;
+                case DebugDrawType.text:
+                    break;
+            }
+            this.duration -= es.Time.deltaTime;
+            return this.duration < 0;
+        };
+        return DebugDrawItem;
+    }());
+    es.DebugDrawItem = DebugDrawItem;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Component = (function () {
+        function Component() {
+            this.updateInterval = 1;
+            this._enabled = true;
+            this._updateOrder = 0;
+        }
+        Object.defineProperty(Component.prototype, "transform", {
+            get: function () {
+                return this.entity.transform;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Component.prototype, "enabled", {
+            get: function () {
+                return this.entity ? this.entity.enabled && this._enabled : this._enabled;
+            },
+            set: function (value) {
+                this.setEnabled(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Component.prototype, "updateOrder", {
+            get: function () {
+                return this._updateOrder;
+            },
+            set: function (value) {
+                this.setUpdateOrder(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Component.prototype.initialize = function () {
+        };
+        Component.prototype.onAddedToEntity = function () {
+        };
+        Component.prototype.onRemovedFromEntity = function () {
+        };
+        Component.prototype.onEntityTransformChanged = function (comp) {
+        };
+        Component.prototype.debugRender = function () {
+        };
+        Component.prototype.onEnabled = function () {
+        };
+        Component.prototype.onDisabled = function () {
+        };
+        Component.prototype.update = function () {
+        };
+        Component.prototype.setEnabled = function (isEnabled) {
+            if (this._enabled != isEnabled) {
+                this._enabled = isEnabled;
+                if (this._enabled) {
+                    this.onEnabled();
+                }
+                else {
+                    this.onDisabled();
+                }
             }
             return this;
-        }
-    };
-    Entity.prototype.setTag = function (tag) {
-        if (this._tag != tag) {
-            if (this.scene) {
-                this.scene.entities.removeFromTagList(this);
-            }
-            this._tag = tag;
-            if (this.scene) {
-                this.scene.entities.addToTagList(this);
+        };
+        Component.prototype.setUpdateOrder = function (updateOrder) {
+            if (this._updateOrder != updateOrder) {
+                this._updateOrder = updateOrder;
             }
+            return this;
+        };
+        Component.prototype.clone = function () {
+            var component = ObjectUtils.clone(this);
+            component.entity = null;
+            return component;
+        };
+        return Component;
+    }());
+    es.Component = Component;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var CoreEvents;
+    (function (CoreEvents) {
+        CoreEvents[CoreEvents["SceneChanged"] = 0] = "SceneChanged";
+    })(CoreEvents = es.CoreEvents || (es.CoreEvents = {}));
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Entity = (function () {
+        function Entity(name) {
+            this.updateInterval = 1;
+            this._tag = 0;
+            this._enabled = true;
+            this._updateOrder = 0;
+            this.components = new es.ComponentList(this);
+            this.transform = new es.Transform(this);
+            this.name = name;
+            this.id = Entity._idGenerator++;
+            this.componentBits = new es.BitSet();
         }
-        return this;
-    };
-    Entity.prototype.attachToScene = function (newScene) {
-        this.scene = newScene;
-        newScene.entities.add(this);
-        this.components.registerAllComponents();
-        for (var i = 0; i < this.numChildren; i++) {
-            this.getChildAt(i).entity.attachToScene(newScene);
-        }
-    };
-    Entity.prototype.detachFromScene = function () {
-        this.scene.entities.remove(this);
-        this.components.deregisterAllComponents();
-        for (var i = 0; i < this.numChildren; i++)
-            this.getChildAt(i).entity.detachFromScene();
-    };
-    Entity.prototype.addComponent = function (component) {
-        component.entity = this;
-        this.components.add(component);
-        this.addChild(component);
-        component.initialize();
-        return component;
-    };
-    Entity.prototype.hasComponent = function (type) {
-        return this.components.getComponent(type, false) != null;
-    };
-    Entity.prototype.getOrCreateComponent = function (type) {
-        var comp = this.components.getComponent(type, true);
-        if (!comp) {
-            comp = this.addComponent(type);
-        }
-        return comp;
-    };
-    Entity.prototype.getComponent = function (type) {
-        return this.components.getComponent(type, false);
-    };
-    Entity.prototype.getComponents = function (typeName, componentList) {
-        return this.components.getComponents(typeName, componentList);
-    };
-    Entity.prototype.onEntityTransformChanged = function (comp) {
-        this.components.onEntityTransformChanged(comp);
-    };
-    Entity.prototype.removeComponentForType = function (type) {
-        var comp = this.getComponent(type);
-        if (comp) {
-            this.removeComponent(comp);
-            return true;
-        }
-        return false;
-    };
-    Entity.prototype.removeComponent = function (component) {
-        this.components.remove(component);
-    };
-    Entity.prototype.removeAllComponents = function () {
-        for (var i = 0; i < this.components.count; i++) {
-            this.removeComponent(this.components.buffer[i]);
-        }
-    };
-    Entity.prototype.update = function () {
-        this.components.update();
-    };
-    Entity.prototype.onAddedToScene = function () {
-    };
-    Entity.prototype.onRemovedFromScene = function () {
-        if (this._isDestoryed)
-            this.components.removeAllComponents();
-    };
-    Entity.prototype.destroy = function () {
-        this._isDestoryed = true;
-        this.removeEventListener(egret.Event.ADDED_TO_STAGE, this.onAddToStage, this);
-        this.scene.entities.remove(this);
-        this.removeChildren();
-        if (this.parent)
-            this.parent.removeChild(this);
-        for (var i = this.numChildren - 1; i >= 0; i--) {
-            var child = this.getChildAt(i);
-            child.entity.destroy();
-        }
-    };
-    return Entity;
-}(egret.DisplayObjectContainer));
-var TransformComponent;
-(function (TransformComponent) {
-    TransformComponent[TransformComponent["rotation"] = 0] = "rotation";
-    TransformComponent[TransformComponent["scale"] = 1] = "scale";
-    TransformComponent[TransformComponent["position"] = 2] = "position";
-})(TransformComponent || (TransformComponent = {}));
-var Scene = (function (_super) {
-    __extends(Scene, _super);
-    function Scene() {
-        var _this = _super.call(this) || this;
-        _this.enablePostProcessing = true;
-        _this._renderers = [];
-        _this._postProcessors = [];
-        _this.entityProcessors = new EntityProcessorList();
-        _this.renderableComponents = new RenderableComponentList();
-        _this.entities = new EntityList(_this);
-        _this.content = new ContentManager();
-        _this.width = SceneManager.stage.stageWidth;
-        _this.height = SceneManager.stage.stageHeight;
-        _this.addEventListener(egret.Event.ACTIVATE, _this.onActive, _this);
-        _this.addEventListener(egret.Event.DEACTIVATE, _this.onDeactive, _this);
-        return _this;
-    }
-    Scene.prototype.createEntity = function (name) {
-        var entity = new Entity(name);
-        entity.position = new Vector2(0, 0);
-        return this.addEntity(entity);
-    };
-    Scene.prototype.addEntity = function (entity) {
-        this.entities.add(entity);
-        entity.scene = this;
-        this.addChild(entity);
-        for (var i = 0; i < entity.numChildren; i++)
-            this.addEntity(entity.getChildAt(i).entity);
-        return entity;
-    };
-    Scene.prototype.destroyAllEntities = function () {
-        for (var i = 0; i < this.entities.count; i++) {
-            this.entities.buffer[i].destroy();
-        }
-    };
-    Scene.prototype.findEntity = function (name) {
-        return this.entities.findEntity(name);
-    };
-    Scene.prototype.addEntityProcessor = function (processor) {
-        processor.scene = this;
-        this.entityProcessors.add(processor);
-        return processor;
-    };
-    Scene.prototype.removeEntityProcessor = function (processor) {
-        this.entityProcessors.remove(processor);
-    };
-    Scene.prototype.getEntityProcessor = function () {
-        return this.entityProcessors.getProcessor();
-    };
-    Scene.prototype.addRenderer = function (renderer) {
-        this._renderers.push(renderer);
-        this._renderers.sort();
-        renderer.onAddedToScene(this);
-        return renderer;
-    };
-    Scene.prototype.getRenderer = function (type) {
-        for (var i = 0; i < this._renderers.length; i++) {
-            if (this._renderers[i] instanceof type)
-                return this._renderers[i];
-        }
-        return null;
-    };
-    Scene.prototype.removeRenderer = function (renderer) {
-        this._renderers.remove(renderer);
-        renderer.unload();
-    };
-    Scene.prototype.begin = function () {
-        if (SceneManager.sceneTransition) {
-            SceneManager.stage.addChildAt(this, SceneManager.stage.numChildren - 1);
-        }
-        else {
-            SceneManager.stage.addChild(this);
-        }
-        if (this._renderers.length == 0) {
-            this.addRenderer(new DefaultRenderer());
-            console.warn("场景开始时没有渲染器 自动添加DefaultRenderer以保证能够正常渲染");
-        }
-        this.camera = this.createEntity("camera").getOrCreateComponent(new Camera());
-        Physics.reset();
-        if (this.entityProcessors)
-            this.entityProcessors.begin();
-        this.camera.onSceneSizeChanged(this.stage.stageWidth, this.stage.stageHeight);
-        this._didSceneBegin = true;
-        this.onStart();
-    };
-    Scene.prototype.end = function () {
-        this._didSceneBegin = false;
-        this.removeEventListener(egret.Event.DEACTIVATE, this.onDeactive, this);
-        this.removeEventListener(egret.Event.ACTIVATE, this.onActive, this);
-        for (var i = 0; i < this._renderers.length; i++) {
-            this._renderers[i].unload();
-        }
-        for (var i = 0; i < this._postProcessors.length; i++) {
-            this._postProcessors[i].unload();
-        }
-        this.entities.removeAllEntities();
-        this.removeChildren();
-        Physics.clear();
-        this.camera = null;
-        this.content.dispose();
-        if (this.entityProcessors)
-            this.entityProcessors.end();
-        this.unload();
-        if (this.parent)
-            this.parent.removeChild(this);
-    };
-    Scene.prototype.onStart = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2];
-            });
+        Object.defineProperty(Entity.prototype, "tag", {
+            get: function () {
+                return this._tag;
+            },
+            set: function (value) {
+                this.setTag(value);
+            },
+            enumerable: true,
+            configurable: true
         });
-    };
-    Scene.prototype.onActive = function () {
-    };
-    Scene.prototype.onDeactive = function () {
-    };
-    Scene.prototype.unload = function () { };
-    Scene.prototype.update = function () {
-        this.entities.updateLists();
-        if (this.entityProcessors)
-            this.entityProcessors.update();
-        this.entities.update();
-        if (this.entityProcessors)
-            this.entityProcessors.lateUpdate();
-        this.renderableComponents.updateList();
-    };
-    Scene.prototype.postRender = function () {
-        var enabledCounter = 0;
-        if (this.enablePostProcessing) {
+        Object.defineProperty(Entity.prototype, "enabled", {
+            get: function () {
+                return this._enabled;
+            },
+            set: function (value) {
+                this.setEnabled(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Entity.prototype, "updateOrder", {
+            get: function () {
+                return this._updateOrder;
+            },
+            set: function (value) {
+                this.setUpdateOrder(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Entity.prototype, "isDestroyed", {
+            get: function () {
+                return this._isDestroyed;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Entity.prototype, "parent", {
+            get: function () {
+                return this.transform.parent;
+            },
+            set: function (value) {
+                this.transform.setParent(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Entity.prototype, "childCount", {
+            get: function () {
+                return this.transform.childCount;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Entity.prototype, "position", {
+            get: function () {
+                return this.transform.position;
+            },
+            set: function (value) {
+                this.transform.setPosition(value.x, value.y);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Entity.prototype, "rotation", {
+            get: function () {
+                return this.transform.rotation;
+            },
+            set: function (value) {
+                this.transform.setRotation(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Entity.prototype, "scale", {
+            get: function () {
+                return this.transform.scale;
+            },
+            set: function (value) {
+                this.transform.setScale(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Entity.prototype.onTransformChanged = function (comp) {
+            this.components.onEntityTransformChanged(comp);
+        };
+        Entity.prototype.setTag = function (tag) {
+            if (this._tag != tag) {
+                if (this.scene)
+                    this.scene.entities.removeFromTagList(this);
+                this._tag = tag;
+                if (this.scene)
+                    this.scene.entities.addToTagList(this);
+            }
+            return this;
+        };
+        Entity.prototype.setEnabled = function (isEnabled) {
+            if (this._enabled != isEnabled) {
+                this._enabled = isEnabled;
+                if (this._enabled)
+                    this.components.onEntityEnabled();
+                else
+                    this.components.onEntityDisabled();
+            }
+            return this;
+        };
+        Entity.prototype.setUpdateOrder = function (updateOrder) {
+            if (this._updateOrder != updateOrder) {
+                this._updateOrder = updateOrder;
+                if (this.scene) {
+                }
+                return this;
+            }
+        };
+        Entity.prototype.destroy = function () {
+            this._isDestroyed = true;
+            this.scene.entities.remove(this);
+            this.transform.parent = null;
+            for (var i = this.transform.childCount - 1; i >= 0; i--) {
+                var child = this.transform.getChild(i);
+                child.entity.destroy();
+            }
+        };
+        Entity.prototype.detachFromScene = function () {
+            this.scene.entities.remove(this);
+            this.components.deregisterAllComponents();
+            for (var i = 0; i < this.transform.childCount; i++)
+                this.transform.getChild(i).entity.detachFromScene();
+        };
+        Entity.prototype.attachToScene = function (newScene) {
+            this.scene = newScene;
+            newScene.entities.add(this);
+            this.components.registerAllComponents();
+            for (var i = 0; i < this.transform.childCount; i++) {
+                this.transform.getChild(i).entity.attachToScene(newScene);
+            }
+        };
+        Entity.prototype.clone = function (position) {
+            if (position === void 0) { position = new es.Vector2(); }
+            var entity = new Entity(this.name + "(clone)");
+            entity.copyFrom(this);
+            entity.transform.position = position;
+            return entity;
+        };
+        Entity.prototype.copyFrom = function (entity) {
+            this.tag = entity.tag;
+            this.updateInterval = entity.updateInterval;
+            this.updateOrder = entity.updateOrder;
+            this.enabled = entity.enabled;
+            this.transform.scale = entity.transform.scale;
+            this.transform.rotation = entity.transform.rotation;
+            for (var i = 0; i < entity.components.count; i++)
+                this.addComponent(entity.components.buffer[i].clone());
+            for (var i = 0; i < entity.components._componentsToAdd.length; i++)
+                this.addComponent(entity.components._componentsToAdd[i].clone());
+            for (var i = 0; i < entity.transform.childCount; i++) {
+                var child = entity.transform.getChild(i).entity;
+                var childClone = child.clone();
+                childClone.transform.copyFrom(child.transform);
+                childClone.transform.parent = this.transform;
+            }
+        };
+        Entity.prototype.onAddedToScene = function () {
+        };
+        Entity.prototype.onRemovedFromScene = function () {
+            if (this._isDestroyed)
+                this.components.removeAllComponents();
+        };
+        Entity.prototype.update = function () {
+            this.components.update();
+        };
+        Entity.prototype.addComponent = function (component) {
+            component.entity = this;
+            this.components.add(component);
+            component.initialize();
+            return component;
+        };
+        Entity.prototype.getComponent = function (type) {
+            return this.components.getComponent(type, false);
+        };
+        Entity.prototype.hasComponent = function (type) {
+            return this.components.getComponent(type, false) != null;
+        };
+        Entity.prototype.getOrCreateComponent = function (type) {
+            var comp = this.components.getComponent(type, true);
+            if (!comp) {
+                comp = this.addComponent(type);
+            }
+            return comp;
+        };
+        Entity.prototype.getComponents = function (typeName, componentList) {
+            return this.components.getComponents(typeName, componentList);
+        };
+        Entity.prototype.removeComponent = function (component) {
+            this.components.remove(component);
+        };
+        Entity.prototype.removeComponentForType = function (type) {
+            var comp = this.getComponent(type);
+            if (comp) {
+                this.removeComponent(comp);
+                return true;
+            }
+            return false;
+        };
+        Entity.prototype.removeAllComponents = function () {
+            for (var i = 0; i < this.components.count; i++) {
+                this.removeComponent(this.components.buffer[i]);
+            }
+        };
+        Entity.prototype.toString = function () {
+            return "[Entity: name: " + this.name + ", tag: " + this.tag + ", enabled: " + this.enabled + ", depth: " + this.updateOrder + "]";
+        };
+        return Entity;
+    }());
+    es.Entity = Entity;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Scene = (function (_super) {
+        __extends(Scene, _super);
+        function Scene() {
+            var _this = _super.call(this) || this;
+            _this.enablePostProcessing = true;
+            _this._renderers = [];
+            _this._postProcessors = [];
+            _this.entities = new es.EntityList(_this);
+            _this.renderableComponents = new es.RenderableComponentList();
+            _this.content = new es.ContentManager();
+            _this.entityProcessors = new es.EntityProcessorList();
+            _this.width = es.SceneManager.stage.stageWidth;
+            _this.height = es.SceneManager.stage.stageHeight;
+            _this.initialize();
+            return _this;
+        }
+        Scene.createWithDefaultRenderer = function () {
+            var scene = new Scene();
+            scene.addRenderer(new es.DefaultRenderer());
+            return scene;
+        };
+        Scene.prototype.initialize = function () { };
+        Scene.prototype.onStart = function () {
+            return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
+                return [2];
+            }); });
+        };
+        Scene.prototype.unload = function () { };
+        Scene.prototype.onActive = function () { };
+        Scene.prototype.onDeactive = function () { };
+        Scene.prototype.begin = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    if (es.SceneManager.sceneTransition) {
+                        es.SceneManager.stage.addChildAt(this, es.SceneManager.stage.numChildren - 1);
+                    }
+                    else {
+                        es.SceneManager.stage.addChild(this);
+                    }
+                    if (this._renderers.length == 0) {
+                        this.addRenderer(new es.DefaultRenderer());
+                        console.warn("场景开始时没有渲染器 自动添加DefaultRenderer以保证能够正常渲染");
+                    }
+                    this.camera = this.createEntity("camera").getOrCreateComponent(new es.Camera());
+                    es.Physics.reset();
+                    if (this.entityProcessors)
+                        this.entityProcessors.begin();
+                    this.addEventListener(egret.Event.ACTIVATE, this.onActive, this);
+                    this.addEventListener(egret.Event.DEACTIVATE, this.onDeactive, this);
+                    this.camera.onSceneSizeChanged(this.stage.stageWidth, this.stage.stageHeight);
+                    this._didSceneBegin = true;
+                    this.onStart();
+                    return [2];
+                });
+            });
+        };
+        Scene.prototype.end = function () {
+            this._didSceneBegin = false;
+            this.removeEventListener(egret.Event.DEACTIVATE, this.onDeactive, this);
+            this.removeEventListener(egret.Event.ACTIVATE, this.onActive, this);
+            for (var i = 0; i < this._renderers.length; i++) {
+                this._renderers[i].unload();
+            }
             for (var i = 0; i < this._postProcessors.length; i++) {
-                if (this._postProcessors[i].enable) {
-                    var isEven = MathHelper.isEven(enabledCounter);
-                    enabledCounter++;
-                    this._postProcessors[i].process();
-                }
+                this._postProcessors[i].unload();
             }
-        }
-    };
-    Scene.prototype.render = function () {
-        for (var i = 0; i < this._renderers.length; i++) {
-            this._renderers[i].render(this);
-        }
-    };
-    Scene.prototype.addPostProcessor = function (postProcessor) {
-        this._postProcessors.push(postProcessor);
-        this._postProcessors.sort();
-        postProcessor.onAddedToScene(this);
-        if (this._didSceneBegin) {
-            postProcessor.onSceneBackBufferSizeChanged(this.stage.stageWidth, this.stage.stageHeight);
-        }
-        return postProcessor;
-    };
-    return Scene;
-}(egret.DisplayObjectContainer));
-var SceneManager = (function () {
-    function SceneManager(stage) {
-        stage.addEventListener(egret.Event.ENTER_FRAME, SceneManager.update, this);
-        SceneManager._instnace = this;
-        SceneManager.emitter = new Emitter();
-        SceneManager.content = new ContentManager();
-        SceneManager.stage = stage;
-        SceneManager.initialize(stage);
-        SceneManager.timerRuler = new TimeRuler();
-    }
-    Object.defineProperty(SceneManager, "Instance", {
-        get: function () {
-            return this._instnace;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(SceneManager, "scene", {
-        get: function () {
-            return this._scene;
-        },
-        set: function (value) {
-            if (!value)
-                throw new Error("场景不能为空");
-            if (this._scene == null) {
-                this._scene = value;
-                this._scene.begin();
-                SceneManager.Instance.onSceneChanged();
+            this.entities.removeAllEntities();
+            this.removeChildren();
+            this.camera = null;
+            this.content.dispose();
+            if (this.entityProcessors)
+                this.entityProcessors.end();
+            if (this.parent)
+                this.parent.removeChild(this);
+            this.unload();
+        };
+        Scene.prototype.update = function () {
+            this.entities.updateLists();
+            if (this.entityProcessors)
+                this.entityProcessors.update();
+            this.entities.update();
+            if (this.entityProcessors)
+                this.entityProcessors.lateUpdate();
+            this.renderableComponents.updateList();
+        };
+        Scene.prototype.render = function () {
+            if (this._renderers.length == 0) {
+                console.error("there are no renderers in the scene!");
+                return;
             }
-            else {
-                this._nextScene = value;
+            for (var i = 0; i < this._renderers.length; i++) {
+                this._renderers[i].render(this);
             }
-            this.registerActiveSceneChanged(this._scene, this._nextScene);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    SceneManager.initialize = function (stage) {
-        Input.initialize(stage);
-    };
-    SceneManager.update = function () {
-        SceneManager.startDebugUpdate();
-        Time.update(egret.getTimer());
-        if (SceneManager._scene) {
-            for (var i = GlobalManager.globalManagers.length - 1; i >= 0; i--) {
-                if (GlobalManager.globalManagers[i].enabled)
-                    GlobalManager.globalManagers[i].update();
-            }
-            if (!SceneManager.sceneTransition ||
-                (SceneManager.sceneTransition && (!SceneManager.sceneTransition.loadsNewScene || SceneManager.sceneTransition.isNewSceneLoaded))) {
-                SceneManager._scene.update();
-            }
-            if (SceneManager._nextScene) {
-                SceneManager._scene.end();
-                SceneManager._scene = SceneManager._nextScene;
-                SceneManager._nextScene = null;
-                SceneManager._instnace.onSceneChanged();
-                SceneManager._scene.begin();
-            }
-        }
-        SceneManager.endDebugUpdate();
-        SceneManager.render();
-    };
-    SceneManager.render = function () {
-        if (this.sceneTransition) {
-            this.sceneTransition.preRender();
-            if (this._scene && !this.sceneTransition.hasPreviousSceneRender) {
-                this._scene.render();
-                this._scene.postRender();
-                this.sceneTransition.onBeginTransition();
-            }
-            else if (this.sceneTransition) {
-                if (this._scene && this.sceneTransition.isNewSceneLoaded) {
-                    this._scene.render();
-                    this._scene.postRender();
-                }
-                this.sceneTransition.render();
-            }
-        }
-        else if (this._scene) {
-            this._scene.render();
-            Debug.render();
-            this._scene.postRender();
-        }
-    };
-    SceneManager.startSceneTransition = function (sceneTransition) {
-        if (this.sceneTransition) {
-            console.warn("在前一个场景完成之前，不能开始一个新的场景转换。");
-            return;
-        }
-        this.sceneTransition = sceneTransition;
-        return sceneTransition;
-    };
-    SceneManager.registerActiveSceneChanged = function (current, next) {
-        if (this.activeSceneChanged)
-            this.activeSceneChanged(current, next);
-    };
-    SceneManager.prototype.onSceneChanged = function () {
-        SceneManager.emitter.emit(CoreEvents.SceneChanged);
-        Time.sceneChanged();
-    };
-    SceneManager.startDebugUpdate = function () {
-        TimeRuler.Instance.startFrame();
-        TimeRuler.Instance.beginMark("update", 0x00FF00);
-    };
-    SceneManager.endDebugUpdate = function () {
-        TimeRuler.Instance.endMark("update");
-    };
-    return SceneManager;
-}());
-var Camera = (function (_super) {
-    __extends(Camera, _super);
-    function Camera() {
-        var _this = _super.call(this) || this;
-        _this._origin = Vector2.zero;
-        _this._minimumZoom = 0.3;
-        _this._maximumZoom = 3;
-        _this._position = Vector2.zero;
-        _this.followLerp = 0.1;
-        _this.deadzone = new Rectangle();
-        _this.focusOffset = new Vector2();
-        _this.mapLockEnabled = false;
-        _this.mapSize = new Vector2();
-        _this._worldSpaceDeadZone = new Rectangle();
-        _this._desiredPositionDelta = new Vector2();
-        _this.cameraStyle = CameraStyle.lockOn;
-        _this.width = SceneManager.stage.stageWidth;
-        _this.height = SceneManager.stage.stageHeight;
-        _this.setZoom(0);
-        return _this;
-    }
-    Object.defineProperty(Camera.prototype, "zoom", {
-        get: function () {
-            if (this._zoom == 0)
-                return 1;
-            if (this._zoom < 1)
-                return MathHelper.map(this._zoom, this._minimumZoom, 1, -1, 0);
-            return MathHelper.map(this._zoom, 1, this._maximumZoom, 0, 1);
-        },
-        set: function (value) {
-            this.setZoom(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Camera.prototype, "minimumZoom", {
-        get: function () {
-            return this._minimumZoom;
-        },
-        set: function (value) {
-            this.setMinimumZoom(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Camera.prototype, "maximumZoom", {
-        get: function () {
-            return this._maximumZoom;
-        },
-        set: function (value) {
-            this.setMaximumZoom(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Camera.prototype, "origin", {
-        get: function () {
-            return this._origin;
-        },
-        set: function (value) {
-            if (this._origin != value) {
-                this._origin = value;
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Camera.prototype, "position", {
-        get: function () {
-            return this._position;
-        },
-        set: function (value) {
-            this._position = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Camera.prototype, "x", {
-        get: function () {
-            return this._position.x;
-        },
-        set: function (value) {
-            this._position.x = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Camera.prototype, "y", {
-        get: function () {
-            return this._position.y;
-        },
-        set: function (value) {
-            this._position.y = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Camera.prototype.onSceneSizeChanged = function (newWidth, newHeight) {
-        var oldOrigin = this._origin;
-        this.origin = new Vector2(newWidth / 2, newHeight / 2);
-        this.entity.position = Vector2.add(this.entity.position, Vector2.subtract(this._origin, oldOrigin));
-    };
-    Camera.prototype.setMinimumZoom = function (minZoom) {
-        if (this._zoom < minZoom)
-            this._zoom = this.minimumZoom;
-        this._minimumZoom = minZoom;
-        return this;
-    };
-    Camera.prototype.setMaximumZoom = function (maxZoom) {
-        if (this._zoom > maxZoom)
-            this._zoom = maxZoom;
-        this._maximumZoom = maxZoom;
-        return this;
-    };
-    Camera.prototype.setZoom = function (zoom) {
-        var newZoom = MathHelper.clamp(zoom, -1, 1);
-        if (newZoom == 0) {
-            this._zoom = 1;
-        }
-        else if (newZoom < 0) {
-            this._zoom = MathHelper.map(newZoom, -1, 0, this._minimumZoom, 1);
-        }
-        else {
-            this._zoom = MathHelper.map(newZoom, 0, 1, 1, this._maximumZoom);
-        }
-        SceneManager.scene.scaleX = this._zoom;
-        SceneManager.scene.scaleY = this._zoom;
-        return this;
-    };
-    Camera.prototype.setRotation = function (rotation) {
-        SceneManager.scene.rotation = rotation;
-        return this;
-    };
-    Camera.prototype.setPosition = function (position) {
-        this.entity.position = position;
-        return this;
-    };
-    Camera.prototype.follow = function (targetEntity, cameraStyle) {
-        if (cameraStyle === void 0) { cameraStyle = CameraStyle.cameraWindow; }
-        this.targetEntity = targetEntity;
-        this.cameraStyle = cameraStyle;
-        var cameraBounds = new Rectangle(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-        switch (this.cameraStyle) {
-            case CameraStyle.cameraWindow:
-                var w = cameraBounds.width / 6;
-                var h = cameraBounds.height / 3;
-                this.deadzone = new Rectangle((cameraBounds.width - w) / 2, (cameraBounds.height - h) / 2, w, h);
-                break;
-            case CameraStyle.lockOn:
-                this.deadzone = new Rectangle(cameraBounds.width / 2, cameraBounds.height / 2, 10, 10);
-                break;
-        }
-    };
-    Camera.prototype.update = function () {
-        var cameraBounds = new Rectangle(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-        var halfScreen = Vector2.multiply(new Vector2(cameraBounds.width, cameraBounds.height), new Vector2(0.5));
-        this._worldSpaceDeadZone.x = this.position.x - halfScreen.x * SceneManager.scene.scaleX + this.deadzone.x + this.focusOffset.x;
-        this._worldSpaceDeadZone.y = this.position.y - halfScreen.y * SceneManager.scene.scaleY + this.deadzone.y + this.focusOffset.y;
-        this._worldSpaceDeadZone.width = this.deadzone.width;
-        this._worldSpaceDeadZone.height = this.deadzone.height;
-        if (this.targetEntity)
-            this.updateFollow();
-        this.position = Vector2.lerp(this.position, Vector2.add(this.position, this._desiredPositionDelta), this.followLerp);
-        this.entity.roundPosition();
-        if (this.mapLockEnabled) {
-            this.position = this.clampToMapSize(this.position);
-            this.entity.roundPosition();
-        }
-    };
-    Camera.prototype.clampToMapSize = function (position) {
-        var cameraBounds = new Rectangle(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-        var halfScreen = Vector2.multiply(new Vector2(cameraBounds.width, cameraBounds.height), new Vector2(0.5));
-        var cameraMax = new Vector2(this.mapSize.x - halfScreen.x, this.mapSize.y - halfScreen.y);
-        return Vector2.clamp(position, halfScreen, cameraMax);
-    };
-    Camera.prototype.updateFollow = function () {
-        this._desiredPositionDelta.x = this._desiredPositionDelta.y = 0;
-        if (this.cameraStyle == CameraStyle.lockOn) {
-            var targetX = this.targetEntity.position.x;
-            var targetY = this.targetEntity.position.y;
-            if (this._worldSpaceDeadZone.x > targetX)
-                this._desiredPositionDelta.x = targetX - this._worldSpaceDeadZone.x;
-            else if (this._worldSpaceDeadZone.x < targetX)
-                this._desiredPositionDelta.x = targetX - this._worldSpaceDeadZone.x;
-            if (this._worldSpaceDeadZone.y < targetY)
-                this._desiredPositionDelta.y = targetY - this._worldSpaceDeadZone.y;
-            else if (this._worldSpaceDeadZone.y > targetY)
-                this._desiredPositionDelta.y = targetY - this._worldSpaceDeadZone.y;
-        }
-        else {
-            if (!this._targetCollider) {
-                this._targetCollider = this.targetEntity.getComponent(Collider);
-                if (!this._targetCollider)
-                    return;
-            }
-            var targetBounds = this.targetEntity.getComponent(Collider).bounds;
-            if (!this._worldSpaceDeadZone.containsRect(targetBounds)) {
-                if (this._worldSpaceDeadZone.left > targetBounds.left)
-                    this._desiredPositionDelta.x = targetBounds.left - this._worldSpaceDeadZone.left;
-                else if (this._worldSpaceDeadZone.right < targetBounds.right)
-                    this._desiredPositionDelta.x = targetBounds.right - this._worldSpaceDeadZone.right;
-                if (this._worldSpaceDeadZone.bottom < targetBounds.bottom)
-                    this._desiredPositionDelta.y = targetBounds.bottom - this._worldSpaceDeadZone.bottom;
-                else if (this._worldSpaceDeadZone.top > targetBounds.top)
-                    this._desiredPositionDelta.y = targetBounds.top - this._worldSpaceDeadZone.top;
-            }
-        }
-    };
-    return Camera;
-}(Component));
-var CameraStyle;
-(function (CameraStyle) {
-    CameraStyle[CameraStyle["lockOn"] = 0] = "lockOn";
-    CameraStyle[CameraStyle["cameraWindow"] = 1] = "cameraWindow";
-})(CameraStyle || (CameraStyle = {}));
-var ComponentPool = (function () {
-    function ComponentPool(typeClass) {
-        this._type = typeClass;
-        this._cache = [];
-    }
-    ComponentPool.prototype.obtain = function () {
-        try {
-            return this._cache.length > 0 ? this._cache.shift() : new this._type();
-        }
-        catch (err) {
-            throw new Error(this._type + err);
-        }
-    };
-    ComponentPool.prototype.free = function (component) {
-        component.reset();
-        this._cache.push(component);
-    };
-    return ComponentPool;
-}());
-var PooledComponent = (function (_super) {
-    __extends(PooledComponent, _super);
-    function PooledComponent() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return PooledComponent;
-}(Component));
-var RenderableComponent = (function (_super) {
-    __extends(RenderableComponent, _super);
-    function RenderableComponent() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this._areBoundsDirty = true;
-        _this._bounds = new Rectangle();
-        _this._localOffset = Vector2.zero;
-        _this.color = 0x000000;
-        return _this;
-    }
-    Object.defineProperty(RenderableComponent.prototype, "width", {
-        get: function () {
-            return this.getWidth();
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(RenderableComponent.prototype, "height", {
-        get: function () {
-            return this.getHeight();
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(RenderableComponent.prototype, "isVisible", {
-        get: function () {
-            return this._isVisible;
-        },
-        set: function (value) {
-            this._isVisible = value;
-            if (this._isVisible)
-                this.onBecameVisible();
-            else
-                this.onBecameInvisible();
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(RenderableComponent.prototype, "bounds", {
-        get: function () {
-            return new Rectangle(this.getBounds().x, this.getBounds().y, this.getBounds().width, this.getBounds().height);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    RenderableComponent.prototype.getWidth = function () {
-        return this.bounds.width;
-    };
-    RenderableComponent.prototype.getHeight = function () {
-        return this.bounds.height;
-    };
-    RenderableComponent.prototype.onBecameVisible = function () { };
-    RenderableComponent.prototype.onBecameInvisible = function () { };
-    RenderableComponent.prototype.isVisibleFromCamera = function (camera) {
-        this.isVisible = camera.getBounds().intersects(this.getBounds());
-        return this.isVisible;
-    };
-    return RenderableComponent;
-}(PooledComponent));
-var Mesh = (function (_super) {
-    __extends(Mesh, _super);
-    function Mesh() {
-        var _this = _super.call(this) || this;
-        _this._mesh = new egret.Mesh();
-        return _this;
-    }
-    Mesh.prototype.setTexture = function (texture) {
-        this._mesh.texture = texture;
-        return this;
-    };
-    Mesh.prototype.onAddedToEntity = function () {
-        this.addChild(this._mesh);
-    };
-    Mesh.prototype.onRemovedFromEntity = function () {
-        this.removeChild(this._mesh);
-    };
-    Mesh.prototype.render = function (camera) {
-        this.x = this.entity.position.x - camera.position.x + camera.origin.x;
-        this.y = this.entity.position.y - camera.position.y + camera.origin.y;
-    };
-    Mesh.prototype.reset = function () {
-    };
-    return Mesh;
-}(RenderableComponent));
-var SpriteRenderer = (function (_super) {
-    __extends(SpriteRenderer, _super);
-    function SpriteRenderer() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Object.defineProperty(SpriteRenderer.prototype, "sprite", {
-        get: function () {
-            return this._sprite;
-        },
-        set: function (value) {
-            this.setSprite(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    SpriteRenderer.prototype.setSprite = function (sprite) {
-        this.removeChildren();
-        this._sprite = sprite;
-        if (this._sprite) {
-            this.anchorOffsetX = this._sprite.origin.x / this._sprite.sourceRect.width;
-            this.anchorOffsetY = this._sprite.origin.y / this._sprite.sourceRect.height;
-        }
-        this.bitmap = new egret.Bitmap(sprite.texture2D);
-        this.addChild(this.bitmap);
-        return this;
-    };
-    SpriteRenderer.prototype.setColor = function (color) {
-        var colorMatrix = [
-            1, 0, 0, 0, 0,
-            0, 1, 0, 0, 0,
-            0, 0, 1, 0, 0,
-            0, 0, 0, 1, 0
-        ];
-        colorMatrix[0] = Math.floor(color / 256 / 256) / 255;
-        colorMatrix[6] = Math.floor(color / 256 % 256) / 255;
-        colorMatrix[12] = color % 256 / 255;
-        var colorFilter = new egret.ColorMatrixFilter(colorMatrix);
-        this.filters = [colorFilter];
-        return this;
-    };
-    SpriteRenderer.prototype.isVisibleFromCamera = function (camera) {
-        this.isVisible = new Rectangle(0, 0, this.stage.stageWidth, this.stage.stageHeight).intersects(this.bounds);
-        this.visible = this.isVisible;
-        return this.isVisible;
-    };
-    SpriteRenderer.prototype.render = function (camera) {
-        if (this.x != -camera.position.x + camera.origin.x ||
-            this.y != -camera.position.y + camera.origin.y) {
-            this.x = -camera.position.x + camera.origin.x;
-            this.y = -camera.position.y + camera.origin.y;
-            this.entity.onEntityTransformChanged(TransformComponent.position);
-        }
-    };
-    SpriteRenderer.prototype.onRemovedFromEntity = function () {
-        if (this.parent)
-            this.parent.removeChild(this);
-    };
-    SpriteRenderer.prototype.reset = function () {
-    };
-    return SpriteRenderer;
-}(RenderableComponent));
-var TiledSpriteRenderer = (function (_super) {
-    __extends(TiledSpriteRenderer, _super);
-    function TiledSpriteRenderer(sprite) {
-        var _this = _super.call(this) || this;
-        _this.leftTexture = new egret.Bitmap();
-        _this.rightTexture = new egret.Bitmap();
-        _this.leftTexture.texture = sprite.texture2D;
-        _this.rightTexture.texture = sprite.texture2D;
-        _this.setSprite(sprite);
-        _this.sourceRect = sprite.sourceRect;
-        return _this;
-    }
-    Object.defineProperty(TiledSpriteRenderer.prototype, "scrollX", {
-        get: function () {
-            return this.sourceRect.x;
-        },
-        set: function (value) {
-            this.sourceRect.x = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(TiledSpriteRenderer.prototype, "scrollY", {
-        get: function () {
-            return this.sourceRect.y;
-        },
-        set: function (value) {
-            this.sourceRect.y = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    TiledSpriteRenderer.prototype.render = function (camera) {
-        if (!this.sprite)
-            return;
-        _super.prototype.render.call(this, camera);
-        var renderTexture = new egret.RenderTexture();
-        var cacheBitmap = new egret.DisplayObjectContainer();
-        cacheBitmap.removeChildren();
-        cacheBitmap.addChild(this.leftTexture);
-        cacheBitmap.addChild(this.rightTexture);
-        this.leftTexture.x = this.sourceRect.x;
-        this.rightTexture.x = this.sourceRect.x - this.sourceRect.width;
-        this.leftTexture.y = this.sourceRect.y;
-        this.rightTexture.y = this.sourceRect.y;
-        cacheBitmap.cacheAsBitmap = true;
-        renderTexture.drawToTexture(cacheBitmap, new egret.Rectangle(0, 0, this.sourceRect.width, this.sourceRect.height));
-        this.bitmap.texture = renderTexture;
-    };
-    return TiledSpriteRenderer;
-}(SpriteRenderer));
-var ScrollingSpriteRenderer = (function (_super) {
-    __extends(ScrollingSpriteRenderer, _super);
-    function ScrollingSpriteRenderer() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.scrollSpeedX = 15;
-        _this.scroolSpeedY = 0;
-        _this._scrollX = 0;
-        _this._scrollY = 0;
-        return _this;
-    }
-    ScrollingSpriteRenderer.prototype.update = function () {
-        this._scrollX += this.scrollSpeedX * Time.deltaTime;
-        this._scrollY += this.scroolSpeedY * Time.deltaTime;
-        this.sourceRect.x = this._scrollX;
-        this.sourceRect.y = this._scrollY;
-    };
-    ScrollingSpriteRenderer.prototype.render = function (camera) {
-        if (!this.sprite)
-            return;
-        _super.prototype.render.call(this, camera);
-        var renderTexture = new egret.RenderTexture();
-        var cacheBitmap = new egret.DisplayObjectContainer();
-        cacheBitmap.removeChildren();
-        cacheBitmap.addChild(this.leftTexture);
-        cacheBitmap.addChild(this.rightTexture);
-        this.leftTexture.x = this.sourceRect.x;
-        this.rightTexture.x = this.sourceRect.x - this.sourceRect.width;
-        this.leftTexture.y = this.sourceRect.y;
-        this.rightTexture.y = this.sourceRect.y;
-        cacheBitmap.cacheAsBitmap = true;
-        renderTexture.drawToTexture(cacheBitmap, new egret.Rectangle(0, 0, this.sourceRect.width, this.sourceRect.height));
-        this.bitmap.texture = renderTexture;
-    };
-    return ScrollingSpriteRenderer;
-}(TiledSpriteRenderer));
-var Sprite = (function () {
-    function Sprite(texture, sourceRect, origin) {
-        if (sourceRect === void 0) { sourceRect = new Rectangle(0, 0, texture.textureWidth, texture.textureHeight); }
-        if (origin === void 0) { origin = sourceRect.getHalfSize(); }
-        this.uvs = new Rectangle();
-        this.texture2D = texture;
-        this.sourceRect = sourceRect;
-        this.center = new Vector2(sourceRect.width * 0.5, sourceRect.height * 0.5);
-        this.origin = origin;
-        var inverseTexW = 1 / texture.textureWidth;
-        var inverseTexH = 1 / texture.textureHeight;
-        this.uvs.x = sourceRect.x * inverseTexW;
-        this.uvs.y = sourceRect.y * inverseTexH;
-        this.uvs.width = sourceRect.width * inverseTexW;
-        this.uvs.height = sourceRect.height * inverseTexH;
-    }
-    return Sprite;
-}());
-var SpriteAnimation = (function () {
-    function SpriteAnimation(sprites, frameRate) {
-        this.sprites = sprites;
-        this.frameRate = frameRate;
-    }
-    return SpriteAnimation;
-}());
-var SpriteAnimator = (function (_super) {
-    __extends(SpriteAnimator, _super);
-    function SpriteAnimator(sprite) {
-        var _this = _super.call(this) || this;
-        _this.speed = 1;
-        _this.animationState = State.none;
-        _this._animations = new Map();
-        _this._elapsedTime = 0;
-        if (sprite)
-            _this.setSprite(sprite);
-        return _this;
-    }
-    Object.defineProperty(SpriteAnimator.prototype, "isRunning", {
-        get: function () {
-            return this.animationState == State.running;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(SpriteAnimator.prototype, "animations", {
-        get: function () {
-            return this._animations;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    SpriteAnimator.prototype.addAnimation = function (name, animation) {
-        if (!this.sprite && animation.sprites.length > 0)
-            this.setSprite(animation.sprites[0]);
-        this._animations[name] = animation;
-        return this;
-    };
-    SpriteAnimator.prototype.play = function (name, loopMode) {
-        if (loopMode === void 0) { loopMode = null; }
-        this.currentAnimation = this._animations[name];
-        this.currentAnimationName = name;
-        this.currentFrame = 0;
-        this.animationState = State.running;
-        this.sprite = this.currentAnimation.sprites[0];
-        this._elapsedTime = 0;
-        this._loopMode = loopMode ? loopMode : LoopMode.loop;
-    };
-    SpriteAnimator.prototype.isAnimationActive = function (name) {
-        return this.currentAnimation && this.currentAnimationName == name;
-    };
-    SpriteAnimator.prototype.pause = function () {
-        this.animationState = State.paused;
-    };
-    SpriteAnimator.prototype.unPause = function () {
-        this.animationState = State.running;
-    };
-    SpriteAnimator.prototype.stop = function () {
-        this.currentAnimation = null;
-        this.currentAnimationName = null;
-        this.currentFrame = 0;
-        this.animationState = State.none;
-    };
-    SpriteAnimator.prototype.update = function () {
-        if (this.animationState != State.running || !this.currentAnimation)
-            return;
-        var animation = this.currentAnimation;
-        var secondsPerFrame = 1 / (animation.frameRate * this.speed);
-        var iterationDuration = secondsPerFrame * animation.sprites.length;
-        this._elapsedTime += Time.deltaTime;
-        var time = Math.abs(this._elapsedTime);
-        if (this._loopMode == LoopMode.once && time > iterationDuration ||
-            this._loopMode == LoopMode.pingPongOnce && time > iterationDuration * 2) {
-            this.animationState = State.completed;
-            this._elapsedTime = 0;
-            this.currentFrame = 0;
-            this.sprite = animation.sprites[this.currentFrame];
-            return;
-        }
-        var i = Math.floor(time / secondsPerFrame);
-        var n = animation.sprites.length;
-        if (n > 2 && (this._loopMode == LoopMode.pingPong || this._loopMode == LoopMode.pingPongOnce)) {
-            var maxIndex = n - 1;
-            this.currentFrame = maxIndex - Math.abs(maxIndex - i % (maxIndex * 2));
-        }
-        else {
-            this.currentFrame = i % n;
-        }
-        this.sprite = animation.sprites[this.currentFrame];
-    };
-    return SpriteAnimator;
-}(SpriteRenderer));
-var LoopMode;
-(function (LoopMode) {
-    LoopMode[LoopMode["loop"] = 0] = "loop";
-    LoopMode[LoopMode["once"] = 1] = "once";
-    LoopMode[LoopMode["clampForever"] = 2] = "clampForever";
-    LoopMode[LoopMode["pingPong"] = 3] = "pingPong";
-    LoopMode[LoopMode["pingPongOnce"] = 4] = "pingPongOnce";
-})(LoopMode || (LoopMode = {}));
-var State;
-(function (State) {
-    State[State["none"] = 0] = "none";
-    State[State["running"] = 1] = "running";
-    State[State["paused"] = 2] = "paused";
-    State[State["completed"] = 3] = "completed";
-})(State || (State = {}));
-var Mover = (function (_super) {
-    __extends(Mover, _super);
-    function Mover() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Mover.prototype.onAddedToEntity = function () {
-        this._triggerHelper = new ColliderTriggerHelper(this.entity);
-    };
-    Mover.prototype.calculateMovement = function (motion) {
-        var collisionResult = new CollisionResult();
-        if (!this.entity.getComponent(Collider) || !this._triggerHelper) {
-            return null;
-        }
-        var colliders = this.entity.getComponents(Collider);
-        for (var i = 0; i < colliders.length; i++) {
-            var collider = colliders[i];
-            if (collider.isTrigger)
-                continue;
-            var bounds = collider.bounds;
-            bounds.x += motion.x;
-            bounds.y += motion.y;
-            var boxcastResult = Physics.boxcastBroadphaseExcludingSelf(collider, bounds, collider.collidesWithLayers);
-            bounds = boxcastResult.bounds;
-            var neighbors = boxcastResult.tempHashSet;
-            for (var j = 0; j < neighbors.length; j++) {
-                var neighbor = neighbors[j];
-                if (neighbor.isTrigger)
-                    continue;
-                var _internalcollisionResult = collider.collidesWith(neighbor, motion);
-                if (_internalcollisionResult) {
-                    motion = Vector2.subtract(motion, _internalcollisionResult.minimumTranslationVector);
-                    if (_internalcollisionResult.collider) {
-                        collisionResult = _internalcollisionResult;
+        };
+        Scene.prototype.postRender = function () {
+            if (this.enablePostProcessing) {
+                for (var i = 0; i < this._postProcessors.length; i++) {
+                    if (this._postProcessors[i].enabled) {
+                        this._postProcessors[i].process();
                     }
                 }
             }
-        }
-        ListPool.free(colliders);
-        return { collisionResult: collisionResult, motion: motion };
-    };
-    Mover.prototype.applyMovement = function (motion) {
-        this.entity.position = Vector2.add(this.entity.position, motion);
-        if (this._triggerHelper)
-            this._triggerHelper.update();
-    };
-    Mover.prototype.move = function (motion) {
-        var movementResult = this.calculateMovement(motion);
-        var collisionResult = movementResult.collisionResult;
-        motion = movementResult.motion;
-        this.applyMovement(motion);
-        return collisionResult;
-    };
-    return Mover;
-}(Component));
-var ProjectileMover = (function (_super) {
-    __extends(ProjectileMover, _super);
-    function ProjectileMover() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this._tempTriggerList = [];
-        return _this;
-    }
-    ProjectileMover.prototype.onAddedToEntity = function () {
-        this._collider = this.entity.getComponent(Collider);
-        if (!this._collider)
-            console.warn("ProjectileMover has no Collider. ProjectilMover requires a Collider!");
-    };
-    ProjectileMover.prototype.move = function (motion) {
-        if (!this._collider)
-            return false;
-        var didCollide = false;
-        this.entity.position = Vector2.add(this.entity.position, motion);
-        var neighbors = Physics.boxcastBroadphase(this._collider.bounds, this._collider.collidesWithLayers);
-        for (var i = 0; i < neighbors.colliders.length; i++) {
-            var neighbor = neighbors.colliders[i];
-            if (this._collider.overlaps(neighbor) && neighbor.enabled) {
-                didCollide = true;
-                this.notifyTriggerListeners(this._collider, neighbor);
+        };
+        Scene.prototype.addRenderer = function (renderer) {
+            this._renderers.push(renderer);
+            this._renderers.sort();
+            renderer.onAddedToScene(this);
+            return renderer;
+        };
+        Scene.prototype.getRenderer = function (type) {
+            for (var i = 0; i < this._renderers.length; i++) {
+                if (this._renderers[i] instanceof type)
+                    return this._renderers[i];
             }
-        }
-        return didCollide;
-    };
-    ProjectileMover.prototype.notifyTriggerListeners = function (self, other) {
-        other.entity.getComponents("ITriggerListener", this._tempTriggerList);
-        for (var i = 0; i < this._tempTriggerList.length; i++) {
-            this._tempTriggerList[i].onTriggerEnter(self, other);
-        }
-        this._tempTriggerList.length = 0;
-        this.entity.getComponents("ITriggerListener", this._tempTriggerList);
-        for (var i = 0; i < this._tempTriggerList.length; i++) {
-            this._tempTriggerList[i].onTriggerEnter(other, self);
-        }
-        this._tempTriggerList.length = 0;
-    };
-    return ProjectileMover;
-}(Component));
-var Collider = (function (_super) {
-    __extends(Collider, _super);
-    function Collider() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.physicsLayer = 1 << 0;
-        _this.registeredPhysicsBounds = new Rectangle();
-        _this.shouldColliderScaleAndRotateWithTransform = true;
-        _this.collidesWithLayers = Physics.allLayers;
-        return _this;
-    }
-    Object.defineProperty(Collider.prototype, "bounds", {
-        get: function () {
-            var shapeBounds = this.shape.bounds;
-            var colliderBuonds = new Rectangle(this.entity.x, this.entity.y, shapeBounds.width, shapeBounds.height);
-            return colliderBuonds;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Collider.prototype.registerColliderWithPhysicsSystem = function () {
-        if (this._isParentEntityAddedToScene && !this._isColliderRegistered) {
-            Physics.addCollider(this);
-            this._isColliderRegistered = true;
-        }
-    };
-    Collider.prototype.unregisterColliderWithPhysicsSystem = function () {
-        if (this._isParentEntityAddedToScene && this._isColliderRegistered) {
-            Physics.removeCollider(this);
-        }
-        this._isColliderRegistered = false;
-    };
-    Collider.prototype.overlaps = function (other) {
-        return this.shape.overlaps(other.shape);
-    };
-    Collider.prototype.collidesWith = function (collider, motion) {
-        var oldPosition = this.entity.position;
-        this.entity.position = Vector2.add(this.entity.position, motion);
-        var result = this.shape.collidesWithShape(collider.shape);
-        if (result)
-            result.collider = collider;
-        this.entity.position = oldPosition;
-        return result;
-    };
-    Collider.prototype.onAddedToEntity = function () {
-        if (this._colliderRequiresAutoSizing) {
-            if (!(this instanceof BoxCollider || this instanceof CircleCollider)) {
-                console.error("Only box and circle colliders can be created automatically");
+            return null;
+        };
+        Scene.prototype.removeRenderer = function (renderer) {
+            if (!this._renderers.contains(renderer))
+                return;
+            this._renderers.remove(renderer);
+            renderer.unload();
+        };
+        Scene.prototype.addPostProcessor = function (postProcessor) {
+            this._postProcessors.push(postProcessor);
+            this._postProcessors.sort();
+            postProcessor.onAddedToScene(this);
+            if (this._didSceneBegin) {
+                postProcessor.onSceneBackBufferSizeChanged(this.stage.stageWidth, this.stage.stageHeight);
             }
-            var renderable = this.entity.getComponent(RenderableComponent);
-            if (renderable) {
-                var bounds = renderable.bounds;
-                var width = bounds.width / this.entity.scale.x;
-                var height = bounds.height / this.entity.scale.y;
-                if (this instanceof CircleCollider) {
-                    var circleCollider = this;
-                    circleCollider.radius = Math.max(width, height) * 0.5;
+            return postProcessor;
+        };
+        Scene.prototype.getPostProcessor = function (type) {
+            for (var i = 0; i < this._postProcessors.length; i++) {
+                if (this._postProcessors[i] instanceof type)
+                    return this._postProcessors[i];
+            }
+            return null;
+        };
+        Scene.prototype.removePostProcessor = function (postProcessor) {
+            if (!this._postProcessors.contains(postProcessor))
+                return;
+            this._postProcessors.remove(postProcessor);
+            postProcessor.unload();
+        };
+        Scene.prototype.createEntity = function (name) {
+            var entity = new es.Entity(name);
+            return this.addEntity(entity);
+        };
+        Scene.prototype.addEntity = function (entity) {
+            if (this.entities.buffer.contains(entity))
+                console.warn("You are attempting to add the same entity to a scene twice: " + entity);
+            this.entities.add(entity);
+            entity.scene = this;
+            for (var i = 0; i < entity.transform.childCount; i++)
+                this.addEntity(entity.transform.getChild(i).entity);
+            return entity;
+        };
+        Scene.prototype.destroyAllEntities = function () {
+            for (var i = 0; i < this.entities.count; i++) {
+                this.entities.buffer[i].destroy();
+            }
+        };
+        Scene.prototype.findEntity = function (name) {
+            return this.entities.findEntity(name);
+        };
+        Scene.prototype.findEntitiesWithTag = function (tag) {
+            return this.entities.entitiesWithTag(tag);
+        };
+        Scene.prototype.entitiesOfType = function (type) {
+            return this.entities.entitiesOfType(type);
+        };
+        Scene.prototype.findComponentOfType = function (type) {
+            return this.entities.findComponentOfType(type);
+        };
+        Scene.prototype.findComponentsOfType = function (type) {
+            return this.entities.findComponentsOfType(type);
+        };
+        Scene.prototype.addEntityProcessor = function (processor) {
+            processor.scene = this;
+            this.entityProcessors.add(processor);
+            return processor;
+        };
+        Scene.prototype.removeEntityProcessor = function (processor) {
+            this.entityProcessors.remove(processor);
+        };
+        Scene.prototype.getEntityProcessor = function () {
+            return this.entityProcessors.getProcessor();
+        };
+        return Scene;
+    }(egret.DisplayObjectContainer));
+    es.Scene = Scene;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var SceneManager = (function () {
+        function SceneManager(stage) {
+            stage.addEventListener(egret.Event.ENTER_FRAME, SceneManager.update, this);
+            SceneManager._instnace = this;
+            SceneManager.emitter = new es.Emitter();
+            SceneManager.content = new es.ContentManager();
+            SceneManager.stage = stage;
+            SceneManager.initialize(stage);
+            SceneManager.timerRuler = new es.TimeRuler();
+        }
+        Object.defineProperty(SceneManager, "Instance", {
+            get: function () {
+                return this._instnace;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(SceneManager, "scene", {
+            get: function () {
+                return this._scene;
+            },
+            set: function (value) {
+                if (!value)
+                    throw new Error("场景不能为空");
+                if (this._scene == null) {
+                    this._scene = value;
+                    this._scene.begin();
+                    SceneManager.Instance.onSceneChanged();
                 }
                 else {
-                    this.width = width;
-                    this.height = height;
+                    this._nextScene = value;
                 }
-                this.addChild(this.shape);
+                this.registerActiveSceneChanged(this._scene, this._nextScene);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        SceneManager.initialize = function (stage) {
+            es.Input.initialize(stage);
+        };
+        SceneManager.update = function () {
+            SceneManager.startDebugUpdate();
+            es.Time.update(egret.getTimer());
+            if (SceneManager._scene) {
+                for (var i = es.GlobalManager.globalManagers.length - 1; i >= 0; i--) {
+                    if (es.GlobalManager.globalManagers[i].enabled)
+                        es.GlobalManager.globalManagers[i].update();
+                }
+                if (!SceneManager.sceneTransition ||
+                    (SceneManager.sceneTransition && (!SceneManager.sceneTransition.loadsNewScene || SceneManager.sceneTransition.isNewSceneLoaded))) {
+                    SceneManager._scene.update();
+                }
+                if (SceneManager._nextScene) {
+                    SceneManager._scene.end();
+                    SceneManager._scene = SceneManager._nextScene;
+                    SceneManager._nextScene = null;
+                    SceneManager._instnace.onSceneChanged();
+                    SceneManager._scene.begin();
+                }
+            }
+            SceneManager.endDebugUpdate();
+            SceneManager.render();
+        };
+        SceneManager.render = function () {
+            if (this.sceneTransition) {
+                this.sceneTransition.preRender();
+                if (this._scene && !this.sceneTransition.hasPreviousSceneRender) {
+                    this._scene.render();
+                    this._scene.postRender();
+                    this.sceneTransition.onBeginTransition();
+                }
+                else if (this.sceneTransition) {
+                    if (this._scene && this.sceneTransition.isNewSceneLoaded) {
+                        this._scene.render();
+                        this._scene.postRender();
+                    }
+                    this.sceneTransition.render();
+                }
+            }
+            else if (this._scene) {
+                this._scene.render();
+                es.Debug.render();
+                this._scene.postRender();
+            }
+        };
+        SceneManager.startSceneTransition = function (sceneTransition) {
+            if (this.sceneTransition) {
+                console.warn("在前一个场景完成之前，不能开始一个新的场景转换。");
+                return;
+            }
+            this.sceneTransition = sceneTransition;
+            return sceneTransition;
+        };
+        SceneManager.registerActiveSceneChanged = function (current, next) {
+            if (this.activeSceneChanged)
+                this.activeSceneChanged(current, next);
+        };
+        SceneManager.prototype.onSceneChanged = function () {
+            SceneManager.emitter.emit(es.CoreEvents.SceneChanged);
+            es.Time.sceneChanged();
+        };
+        SceneManager.startDebugUpdate = function () {
+            es.TimeRuler.Instance.startFrame();
+            es.TimeRuler.Instance.beginMark("update", 0x00FF00);
+        };
+        SceneManager.endDebugUpdate = function () {
+            es.TimeRuler.Instance.endMark("update");
+        };
+        return SceneManager;
+    }());
+    es.SceneManager = SceneManager;
+})(es || (es = {}));
+var transform;
+(function (transform) {
+    var Component;
+    (function (Component) {
+        Component[Component["position"] = 0] = "position";
+        Component[Component["scale"] = 1] = "scale";
+        Component[Component["rotation"] = 2] = "rotation";
+    })(Component = transform.Component || (transform.Component = {}));
+})(transform || (transform = {}));
+var es;
+(function (es) {
+    var DirtyType;
+    (function (DirtyType) {
+        DirtyType[DirtyType["clean"] = 0] = "clean";
+        DirtyType[DirtyType["positionDirty"] = 1] = "positionDirty";
+        DirtyType[DirtyType["scaleDirty"] = 2] = "scaleDirty";
+        DirtyType[DirtyType["rotationDirty"] = 3] = "rotationDirty";
+    })(DirtyType = es.DirtyType || (es.DirtyType = {}));
+    var Transform = (function () {
+        function Transform(entity) {
+            this.entity = entity;
+            this.scale = es.Vector2.one;
+            this._children = [];
+        }
+        Object.defineProperty(Transform.prototype, "parent", {
+            get: function () {
+                return this._parent;
+            },
+            set: function (value) {
+                this.setParent(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Transform.prototype, "childCount", {
+            get: function () {
+                return this._children.length;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Transform.prototype.getChild = function (index) {
+            return this._children[index];
+        };
+        Transform.prototype.setParent = function (parent) {
+            if (this._parent == parent)
+                return this;
+            if (!this._parent) {
+                this._parent._children.remove(this);
+                this._parent._children.push(this);
+            }
+            this._parent = parent;
+            this.setDirty(DirtyType.positionDirty);
+            return this;
+        };
+        Transform.prototype.setPosition = function (x, y) {
+            this.position = new es.Vector2(x, y);
+            this.setDirty(DirtyType.positionDirty);
+            return this;
+        };
+        Transform.prototype.setRotation = function (degrees) {
+            this.rotation = degrees;
+            this.setDirty(DirtyType.rotationDirty);
+            return this;
+        };
+        Transform.prototype.setScale = function (scale) {
+            this.scale = scale;
+            this.setDirty(DirtyType.scaleDirty);
+            return this;
+        };
+        Transform.prototype.lookAt = function (pos) {
+            var sign = this.position.x > pos.x ? -1 : 1;
+            var vectorToAlignTo = es.Vector2.normalize(es.Vector2.subtract(this.position, pos));
+            this.rotation = sign * Math.acos(es.Vector2.dot(vectorToAlignTo, es.Vector2.unitY));
+        };
+        Transform.prototype.roundPosition = function () {
+            this.position = this.position.round();
+        };
+        Transform.prototype.setDirty = function (dirtyFlagType) {
+            if ((this.hierarchyDirty & dirtyFlagType) == 0) {
+                this.hierarchyDirty |= dirtyFlagType;
+                switch (dirtyFlagType) {
+                    case es.DirtyType.positionDirty:
+                        this.entity.onTransformChanged(transform.Component.position);
+                        break;
+                    case es.DirtyType.rotationDirty:
+                        this.entity.onTransformChanged(transform.Component.rotation);
+                        break;
+                    case es.DirtyType.scaleDirty:
+                        this.entity.onTransformChanged(transform.Component.scale);
+                        break;
+                }
+                if (!this._children)
+                    this._children = [];
+                for (var i = 0; i < this._children.length; i++)
+                    this._children[i].setDirty(dirtyFlagType);
+            }
+        };
+        Transform.prototype.copyFrom = function (transform) {
+            this.position = transform.position;
+            this.rotation = transform.rotation;
+            this.scale = transform.scale;
+            this.setDirty(DirtyType.positionDirty);
+            this.setDirty(DirtyType.rotationDirty);
+            this.setDirty(DirtyType.scaleDirty);
+        };
+        return Transform;
+    }());
+    es.Transform = Transform;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var CameraStyle;
+    (function (CameraStyle) {
+        CameraStyle[CameraStyle["lockOn"] = 0] = "lockOn";
+        CameraStyle[CameraStyle["cameraWindow"] = 1] = "cameraWindow";
+    })(CameraStyle = es.CameraStyle || (es.CameraStyle = {}));
+    var Camera = (function (_super) {
+        __extends(Camera, _super);
+        function Camera(targetEntity, cameraStyle) {
+            if (targetEntity === void 0) { targetEntity = null; }
+            if (cameraStyle === void 0) { cameraStyle = CameraStyle.lockOn; }
+            var _this = _super.call(this) || this;
+            _this._minimumZoom = 0.3;
+            _this._maximumZoom = 3;
+            _this._origin = es.Vector2.zero;
+            _this.followLerp = 0.1;
+            _this.deadzone = new es.Rectangle();
+            _this.focusOffset = new es.Vector2();
+            _this.mapLockEnabled = false;
+            _this.mapSize = new es.Vector2();
+            _this._desiredPositionDelta = new es.Vector2();
+            _this._worldSpaceDeadZone = new es.Rectangle();
+            _this._targetEntity = targetEntity;
+            _this._cameraStyle = cameraStyle;
+            _this.setZoom(0);
+            return _this;
+        }
+        Object.defineProperty(Camera.prototype, "position", {
+            get: function () {
+                return this.entity.transform.position;
+            },
+            set: function (value) {
+                this.entity.transform.position = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Camera.prototype, "rotation", {
+            get: function () {
+                return this.entity.transform.rotation;
+            },
+            set: function (value) {
+                this.entity.transform.rotation = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Camera.prototype, "zoom", {
+            get: function () {
+                if (this._zoom == 0)
+                    return 1;
+                if (this._zoom < 1)
+                    return es.MathHelper.map(this._zoom, this._minimumZoom, 1, -1, 0);
+                return es.MathHelper.map(this._zoom, 1, this._maximumZoom, 0, 1);
+            },
+            set: function (value) {
+                this.setZoom(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Camera.prototype, "minimumZoom", {
+            get: function () {
+                return this._minimumZoom;
+            },
+            set: function (value) {
+                this.setMinimumZoom(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Camera.prototype, "maximumZoom", {
+            get: function () {
+                return this._maximumZoom;
+            },
+            set: function (value) {
+                this.setMaximumZoom(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Camera.prototype, "bounds", {
+            get: function () {
+                return new es.Rectangle(0, 0, es.SceneManager.stage.stageWidth, es.SceneManager.stage.stageHeight);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Camera.prototype, "origin", {
+            get: function () {
+                return this._origin;
+            },
+            set: function (value) {
+                if (this._origin != value) {
+                    this._origin = value;
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Camera.prototype.onSceneSizeChanged = function (newWidth, newHeight) {
+            var oldOrigin = this._origin;
+            this.origin = new es.Vector2(newWidth / 2, newHeight / 2);
+            this.entity.transform.position = es.Vector2.add(this.entity.transform.position, es.Vector2.subtract(this._origin, oldOrigin));
+        };
+        Camera.prototype.setPosition = function (position) {
+            this.entity.transform.setPosition(position.x, position.y);
+            return this;
+        };
+        Camera.prototype.setRotation = function (rotation) {
+            this.entity.transform.setRotation(rotation);
+            return this;
+        };
+        Camera.prototype.setZoom = function (zoom) {
+            var newZoom = es.MathHelper.clamp(zoom, -1, 1);
+            if (newZoom == 0) {
+                this._zoom = 1;
+            }
+            else if (newZoom < 0) {
+                this._zoom = es.MathHelper.map(newZoom, -1, 0, this._minimumZoom, 1);
             }
             else {
-                console.warn("Collider has no shape and no RenderableComponent. Can't figure out how to size it.");
+                this._zoom = es.MathHelper.map(newZoom, 0, 1, 1, this._maximumZoom);
             }
-        }
-        this._isParentEntityAddedToScene = true;
-        this.registerColliderWithPhysicsSystem();
-    };
-    Collider.prototype.onRemovedFromEntity = function () {
-        this.unregisterColliderWithPhysicsSystem();
-        this._isParentEntityAddedToScene = false;
-        this.removeChild(this.shape);
-    };
-    Collider.prototype.onEnabled = function () {
-        this.registerColliderWithPhysicsSystem();
-    };
-    Collider.prototype.onDisabled = function () {
-        this.unregisterColliderWithPhysicsSystem();
-    };
-    Collider.prototype.onEntityTransformChanged = function (comp) {
-        if (this._isColliderRegistered)
-            Physics.updateCollider(this);
-    };
-    Collider.prototype.update = function () {
-        var renderable = this.entity.getComponent(RenderableComponent);
-        if (renderable) {
-            this.$setX(renderable.x);
-            this.$setY(renderable.y);
-        }
-    };
-    return Collider;
-}(Component));
-var BoxCollider = (function (_super) {
-    __extends(BoxCollider, _super);
-    function BoxCollider() {
-        var _this = _super.call(this) || this;
-        _this.shape = new Box(1, 1);
-        _this._colliderRequiresAutoSizing = true;
-        return _this;
-    }
-    Object.defineProperty(BoxCollider.prototype, "width", {
-        get: function () {
-            return this.shape.width;
-        },
-        set: function (value) {
-            this.setWidth(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    BoxCollider.prototype.setWidth = function (width) {
-        this._colliderRequiresAutoSizing = false;
-        var box = this.shape;
-        if (width != box.width) {
-            box.updateBox(width, box.height);
-            if (this.entity && this._isParentEntityAddedToScene)
-                Physics.updateCollider(this);
-        }
-        return this;
-    };
-    Object.defineProperty(BoxCollider.prototype, "height", {
-        get: function () {
-            return this.shape.height;
-        },
-        set: function (value) {
-            this.setHeight(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    BoxCollider.prototype.setHeight = function (height) {
-        this._colliderRequiresAutoSizing = false;
-        var box = this.shape;
-        if (height != box.height) {
-            box.updateBox(box.width, height);
-            if (this.entity && this._isParentEntityAddedToScene)
-                Physics.updateCollider(this);
-        }
-    };
-    BoxCollider.prototype.setSize = function (width, height) {
-        this._colliderRequiresAutoSizing = false;
-        var box = this.shape;
-        if (width != box.width || height != box.height) {
-            box.updateBox(width, height);
-            if (this.entity && this._isParentEntityAddedToScene)
-                Physics.updateCollider(this);
-        }
-        return this;
-    };
-    return BoxCollider;
-}(Collider));
-var CircleCollider = (function (_super) {
-    __extends(CircleCollider, _super);
-    function CircleCollider(radius) {
-        var _this = _super.call(this) || this;
-        if (radius)
-            _this._colliderRequiresAutoSizing = true;
-        _this.shape = new Circle(radius ? radius : 1);
-        return _this;
-    }
-    Object.defineProperty(CircleCollider.prototype, "radius", {
-        get: function () {
-            return this.shape.radius;
-        },
-        set: function (value) {
-            this.setRadius(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    CircleCollider.prototype.setRadius = function (radius) {
-        this._colliderRequiresAutoSizing = false;
-        var circle = this.shape;
-        if (radius != circle.radius) {
-            circle.radius = radius;
-            circle._originalRadius = radius;
-            if (this.entity && this._isParentEntityAddedToScene)
-                Physics.updateCollider(this);
-        }
-        return this;
-    };
-    return CircleCollider;
-}(Collider));
-var PolygonCollider = (function (_super) {
-    __extends(PolygonCollider, _super);
-    function PolygonCollider(points) {
-        var _this = _super.call(this) || this;
-        var isPolygonClosed = points[0] == points[points.length - 1];
-        if (isPolygonClosed)
-            points.splice(points.length - 1, 1);
-        Polygon.recenterPolygonVerts(points);
-        _this.shape = new Polygon(points);
-        return _this;
-    }
-    return PolygonCollider;
-}(Collider));
-var EntitySystem = (function () {
-    function EntitySystem(matcher) {
-        this._entities = [];
-        this._matcher = matcher ? matcher : Matcher.empty();
-    }
-    Object.defineProperty(EntitySystem.prototype, "matcher", {
-        get: function () {
-            return this._matcher;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(EntitySystem.prototype, "scene", {
-        get: function () {
-            return this._scene;
-        },
-        set: function (value) {
-            this._scene = value;
-            this._entities = [];
-        },
-        enumerable: true,
-        configurable: true
-    });
-    EntitySystem.prototype.initialize = function () {
-    };
-    EntitySystem.prototype.onChanged = function (entity) {
-        var contains = this._entities.contains(entity);
-        var interest = this._matcher.IsIntersted(entity);
-        if (interest && !contains)
-            this.add(entity);
-        else if (!interest && contains)
-            this.remove(entity);
-    };
-    EntitySystem.prototype.add = function (entity) {
-        this._entities.push(entity);
-        this.onAdded(entity);
-    };
-    EntitySystem.prototype.onAdded = function (entity) {
-    };
-    EntitySystem.prototype.remove = function (entity) {
-        this._entities.remove(entity);
-        this.onRemoved(entity);
-    };
-    EntitySystem.prototype.onRemoved = function (entity) {
-    };
-    EntitySystem.prototype.update = function () {
-        this.begin();
-        this.process(this._entities);
-    };
-    EntitySystem.prototype.lateUpdate = function () {
-        this.lateProcess(this._entities);
-        this.end();
-    };
-    EntitySystem.prototype.begin = function () {
-    };
-    EntitySystem.prototype.process = function (entities) {
-    };
-    EntitySystem.prototype.lateProcess = function (entities) {
-    };
-    EntitySystem.prototype.end = function () {
-    };
-    return EntitySystem;
-}());
-var EntityProcessingSystem = (function (_super) {
-    __extends(EntityProcessingSystem, _super);
-    function EntityProcessingSystem(matcher) {
-        return _super.call(this, matcher) || this;
-    }
-    EntityProcessingSystem.prototype.lateProcessEntity = function (entity) {
-    };
-    EntityProcessingSystem.prototype.process = function (entities) {
-        var _this = this;
-        entities.forEach(function (entity) { return _this.processEntity(entity); });
-    };
-    EntityProcessingSystem.prototype.lateProcess = function (entities) {
-        var _this = this;
-        entities.forEach(function (entity) { return _this.lateProcessEntity(entity); });
-    };
-    return EntityProcessingSystem;
-}(EntitySystem));
-var PassiveSystem = (function (_super) {
-    __extends(PassiveSystem, _super);
-    function PassiveSystem() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    PassiveSystem.prototype.onChanged = function (entity) {
-    };
-    PassiveSystem.prototype.process = function (entities) {
-        this.begin();
-        this.end();
-    };
-    return PassiveSystem;
-}(EntitySystem));
-var ProcessingSystem = (function (_super) {
-    __extends(ProcessingSystem, _super);
-    function ProcessingSystem() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ProcessingSystem.prototype.onChanged = function (entity) {
-    };
-    ProcessingSystem.prototype.process = function (entities) {
-        this.begin();
-        this.processSystem();
-        this.end();
-    };
-    return ProcessingSystem;
-}(EntitySystem));
-var BitSet = (function () {
-    function BitSet(nbits) {
-        if (nbits === void 0) { nbits = 64; }
-        var length = nbits >> 6;
-        if ((nbits & BitSet.LONG_MASK) != 0)
-            length++;
-        this._bits = new Array(length);
-    }
-    BitSet.prototype.and = function (bs) {
-        var max = Math.min(this._bits.length, bs._bits.length);
-        var i;
-        for (var i_1 = 0; i_1 < max; ++i_1)
-            this._bits[i_1] &= bs._bits[i_1];
-        while (i < this._bits.length)
-            this._bits[i++] = 0;
-    };
-    BitSet.prototype.andNot = function (bs) {
-        var i = Math.min(this._bits.length, bs._bits.length);
-        while (--i >= 0)
-            this._bits[i] &= ~bs._bits[i];
-    };
-    BitSet.prototype.cardinality = function () {
-        var card = 0;
-        for (var i = this._bits.length - 1; i >= 0; i--) {
-            var a = this._bits[i];
-            if (a == 0)
-                continue;
-            if (a == -1) {
-                card += 64;
-                continue;
+            es.SceneManager.scene.scaleX = this._zoom;
+            es.SceneManager.scene.scaleY = this._zoom;
+            return this;
+        };
+        Camera.prototype.setMinimumZoom = function (minZoom) {
+            if (this._zoom < minZoom)
+                this._zoom = this.minimumZoom;
+            this._minimumZoom = minZoom;
+            return this;
+        };
+        Camera.prototype.setMaximumZoom = function (maxZoom) {
+            if (maxZoom <= 0) {
+                console.error("maximumZoom must be greater than zero");
+                return;
             }
-            a = ((a >> 1) & 0x5555555555555555) + (a & 0x5555555555555555);
-            a = ((a >> 2) & 0x3333333333333333) + (a & 0x3333333333333333);
-            var b = ((a >> 32) + a);
-            b = ((b >> 4) & 0x0f0f0f0f) + (b & 0x0f0f0f0f);
-            b = ((b >> 8) & 0x00ff00ff) + (b & 0x00ff00ff);
-            card += ((b >> 16) & 0x0000ffff) + (b & 0x0000ffff);
-        }
-        return card;
-    };
-    BitSet.prototype.clear = function (pos) {
-        if (pos != undefined) {
-            var offset = pos >> 6;
-            this.ensure(offset);
-            this._bits[offset] &= ~(1 << pos);
-        }
-        else {
-            for (var i = 0; i < this._bits.length; i++)
-                this._bits[i] = 0;
-        }
-    };
-    BitSet.prototype.ensure = function (lastElt) {
-        if (lastElt >= this._bits.length) {
-            var nd = new Number[lastElt + 1];
-            nd = this._bits.copyWithin(0, 0, this._bits.length);
-            this._bits = nd;
-        }
-    };
-    BitSet.prototype.get = function (pos) {
-        var offset = pos >> 6;
-        if (offset >= this._bits.length)
-            return false;
-        return (this._bits[offset] & (1 << pos)) != 0;
-    };
-    BitSet.prototype.intersects = function (set) {
-        var i = Math.min(this._bits.length, set._bits.length);
-        while (--i >= 0) {
-            if ((this._bits[i] & set._bits[i]) != 0)
-                return true;
-        }
-        return false;
-    };
-    BitSet.prototype.isEmpty = function () {
-        for (var i = this._bits.length - 1; i >= 0; i--) {
-            if (this._bits[i])
-                return false;
-        }
-        return true;
-    };
-    BitSet.prototype.nextSetBit = function (from) {
-        var offset = from >> 6;
-        var mask = 1 << from;
-        while (offset < this._bits.length) {
-            var h = this._bits[offset];
-            do {
-                if ((h & mask) != 0)
-                    return from;
-                mask <<= 1;
-                from++;
-            } while (mask != 0);
-            mask = 1;
-            offset++;
-        }
-        return -1;
-    };
-    BitSet.prototype.set = function (pos, value) {
-        if (value === void 0) { value = true; }
-        if (value) {
-            var offset = pos >> 6;
-            this.ensure(offset);
-            this._bits[offset] |= 1 << pos;
-        }
-        else {
-            this.clear(pos);
-        }
-    };
-    BitSet.LONG_MASK = 0x3f;
-    return BitSet;
-}());
-var ComponentList = (function () {
-    function ComponentList(entity) {
-        this._components = [];
-        this._componentsToAdd = [];
-        this._componentsToRemove = [];
-        this._tempBufferList = [];
-        this._entity = entity;
-    }
-    Object.defineProperty(ComponentList.prototype, "count", {
-        get: function () {
-            return this._components.length;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(ComponentList.prototype, "buffer", {
-        get: function () {
-            return this._components;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    ComponentList.prototype.add = function (component) {
-        this._componentsToAdd.push(component);
-    };
-    ComponentList.prototype.remove = function (component) {
-        if (this._componentsToRemove.contains(component))
-            console.warn("You are trying to remove a Component (" + component + ") that you already removed");
-        if (this._componentsToAdd.contains(component)) {
-            this._componentsToAdd.remove(component);
-            return;
-        }
-        this._componentsToRemove.push(component);
-    };
-    ComponentList.prototype.removeAllComponents = function () {
-        for (var i = 0; i < this._components.length; i++) {
-            this.handleRemove(this._components[i]);
-        }
-        this._components.length = 0;
-        this._componentsToAdd.length = 0;
-        this._componentsToRemove.length = 0;
-    };
-    ComponentList.prototype.deregisterAllComponents = function () {
-        for (var i = 0; i < this._components.length; i++) {
-            var component = this._components[i];
-            if (component instanceof RenderableComponent)
-                this._entity.scene.renderableComponents.remove(component);
-            this._entity.componentBits.set(ComponentTypeManager.getIndexFor(component), false);
-            this._entity.scene.entityProcessors.onComponentRemoved(this._entity);
-        }
-    };
-    ComponentList.prototype.registerAllComponents = function () {
-        for (var i = 0; i < this._components.length; i++) {
-            var component = this._components[i];
-            if (component instanceof RenderableComponent)
-                this._entity.scene.renderableComponents.add(component);
-            this._entity.componentBits.set(ComponentTypeManager.getIndexFor(component));
-            this._entity.scene.entityProcessors.onComponentAdded(this._entity);
-        }
-    };
-    ComponentList.prototype.updateLists = function () {
-        if (this._componentsToRemove.length > 0) {
-            for (var i = 0; i < this._componentsToRemove.length; i++) {
-                this.handleRemove(this._componentsToRemove[i]);
-                this._components.remove(this._componentsToRemove[i]);
+            if (this._zoom > maxZoom)
+                this._zoom = maxZoom;
+            this._maximumZoom = maxZoom;
+            return this;
+        };
+        Camera.prototype.zoomIn = function (deltaZoom) {
+            this.zoom += deltaZoom;
+        };
+        Camera.prototype.zoomOut = function (deltaZoom) {
+            this.zoom -= deltaZoom;
+        };
+        Camera.prototype.onAddedToEntity = function () {
+            this.follow(this._targetEntity, this._cameraStyle);
+        };
+        Camera.prototype.update = function () {
+            var halfScreen = es.Vector2.multiply(new es.Vector2(this.bounds.width, this.bounds.height), new es.Vector2(0.5));
+            this._worldSpaceDeadZone.x = this.position.x - halfScreen.x * es.SceneManager.scene.scaleX + this.deadzone.x + this.focusOffset.x;
+            this._worldSpaceDeadZone.y = this.position.y - halfScreen.y * es.SceneManager.scene.scaleY + this.deadzone.y + this.focusOffset.y;
+            this._worldSpaceDeadZone.width = this.deadzone.width;
+            this._worldSpaceDeadZone.height = this.deadzone.height;
+            if (this._targetEntity)
+                this.updateFollow();
+            this.position = es.Vector2.lerp(this.position, es.Vector2.add(this.position, this._desiredPositionDelta), this.followLerp);
+            this.entity.transform.roundPosition();
+            if (this.mapLockEnabled) {
+                this.position = this.clampToMapSize(this.position);
+                this.entity.transform.roundPosition();
             }
-            this._componentsToRemove.length = 0;
-        }
-        if (this._componentsToAdd.length > 0) {
-            for (var i = 0, count = this._componentsToAdd.length; i < count; i++) {
-                var component = this._componentsToAdd[i];
-                if (component instanceof RenderableComponent)
-                    this._entity.scene.renderableComponents.add(component);
-                this._entity.componentBits.set(ComponentTypeManager.getIndexFor(component));
-                this._entity.scene.entityProcessors.onComponentAdded(this._entity);
-                this._components.push(component);
-                this._tempBufferList.push(component);
+        };
+        Camera.prototype.clampToMapSize = function (position) {
+            var halfScreen = es.Vector2.multiply(new es.Vector2(this.bounds.width, this.bounds.height), new es.Vector2(0.5));
+            var cameraMax = new es.Vector2(this.mapSize.x - halfScreen.x, this.mapSize.y - halfScreen.y);
+            return es.Vector2.clamp(position, halfScreen, cameraMax);
+        };
+        Camera.prototype.updateFollow = function () {
+            this._desiredPositionDelta.x = this._desiredPositionDelta.y = 0;
+            if (this._cameraStyle == CameraStyle.lockOn) {
+                var targetX = this._targetEntity.transform.position.x;
+                var targetY = this._targetEntity.transform.position.y;
+                if (this._worldSpaceDeadZone.x > targetX)
+                    this._desiredPositionDelta.x = targetX - this._worldSpaceDeadZone.x;
+                else if (this._worldSpaceDeadZone.x < targetX)
+                    this._desiredPositionDelta.x = targetX - this._worldSpaceDeadZone.x;
+                if (this._worldSpaceDeadZone.y < targetY)
+                    this._desiredPositionDelta.y = targetY - this._worldSpaceDeadZone.y;
+                else if (this._worldSpaceDeadZone.y > targetY)
+                    this._desiredPositionDelta.y = targetY - this._worldSpaceDeadZone.y;
             }
-            this._componentsToAdd.length = 0;
-            for (var i = 0; i < this._tempBufferList.length; i++) {
-                var component = this._tempBufferList[i];
-                component.onAddedToEntity();
-                if (component.enabled) {
-                    component.onEnabled();
+            else {
+                if (!this._targetCollider) {
+                    this._targetCollider = this._targetEntity.getComponent(es.Collider);
+                    if (!this._targetCollider)
+                        return;
+                }
+                var targetBounds = this._targetEntity.getComponent(es.Collider).bounds;
+                if (!this._worldSpaceDeadZone.containsRect(targetBounds)) {
+                    if (this._worldSpaceDeadZone.left > targetBounds.left)
+                        this._desiredPositionDelta.x = targetBounds.left - this._worldSpaceDeadZone.left;
+                    else if (this._worldSpaceDeadZone.right < targetBounds.right)
+                        this._desiredPositionDelta.x = targetBounds.right - this._worldSpaceDeadZone.right;
+                    if (this._worldSpaceDeadZone.bottom < targetBounds.bottom)
+                        this._desiredPositionDelta.y = targetBounds.bottom - this._worldSpaceDeadZone.bottom;
+                    else if (this._worldSpaceDeadZone.top > targetBounds.top)
+                        this._desiredPositionDelta.y = targetBounds.top - this._worldSpaceDeadZone.top;
                 }
             }
-            this._tempBufferList.length = 0;
+        };
+        Camera.prototype.follow = function (targetEntity, cameraStyle) {
+            if (cameraStyle === void 0) { cameraStyle = CameraStyle.cameraWindow; }
+            this._targetEntity = targetEntity;
+            this._cameraStyle = cameraStyle;
+            switch (this._cameraStyle) {
+                case CameraStyle.cameraWindow:
+                    var w = this.bounds.width / 6;
+                    var h = this.bounds.height / 3;
+                    this.deadzone = new es.Rectangle((this.bounds.width - w) / 2, (this.bounds.height - h) / 2, w, h);
+                    break;
+                case CameraStyle.lockOn:
+                    this.deadzone = new es.Rectangle(this.bounds.width / 2, this.bounds.height / 2, 10, 10);
+                    break;
+            }
+        };
+        Camera.prototype.setCenteredDeadzone = function (width, height) {
+            this.deadzone = new es.Rectangle((this.bounds.width - width) / 2, (this.bounds.height - height) / 2, width, height);
+        };
+        return Camera;
+    }(es.Component));
+    es.Camera = Camera;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var ComponentPool = (function () {
+        function ComponentPool(typeClass) {
+            this._type = typeClass;
+            this._cache = [];
         }
-    };
-    ComponentList.prototype.onEntityTransformChanged = function (comp) {
-        for (var i = 0; i < this._components.length; i++) {
-            if (this._components[i].enabled)
-                this._components[i].onEntityTransformChanged(comp);
+        ComponentPool.prototype.obtain = function () {
+            try {
+                return this._cache.length > 0 ? this._cache.shift() : new this._type();
+            }
+            catch (err) {
+                throw new Error(this._type + err);
+            }
+        };
+        ComponentPool.prototype.free = function (component) {
+            component.reset();
+            this._cache.push(component);
+        };
+        return ComponentPool;
+    }());
+    es.ComponentPool = ComponentPool;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var IUpdatableComparer = (function () {
+        function IUpdatableComparer() {
         }
-        for (var i = 0; i < this._componentsToAdd.length; i++) {
-            if (this._componentsToAdd[i].enabled)
-                this._componentsToAdd[i].onEntityTransformChanged(comp);
+        IUpdatableComparer.prototype.compare = function (a, b) {
+            return a.updateOrder - b.updateOrder;
+        };
+        return IUpdatableComparer;
+    }());
+    es.IUpdatableComparer = IUpdatableComparer;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var PooledComponent = (function (_super) {
+        __extends(PooledComponent, _super);
+        function PooledComponent() {
+            return _super !== null && _super.apply(this, arguments) || this;
         }
-    };
-    ComponentList.prototype.handleRemove = function (component) {
-        if (component instanceof RenderableComponent)
-            this._entity.scene.renderableComponents.remove(component);
-        this._entity.componentBits.set(ComponentTypeManager.getIndexFor(component), false);
-        this._entity.scene.entityProcessors.onComponentRemoved(this._entity);
-        component.onRemovedFromEntity();
-        component.entity = null;
-    };
-    ComponentList.prototype.getComponent = function (type, onlyReturnInitializedComponents) {
-        for (var i = 0; i < this._components.length; i++) {
-            var component = this._components[i];
-            if (component instanceof type)
-                return component;
+        return PooledComponent;
+    }(es.Component));
+    es.PooledComponent = PooledComponent;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var RenderableComponent = (function (_super) {
+        __extends(RenderableComponent, _super);
+        function RenderableComponent() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.color = 0x000000;
+            _this._localOffset = es.Vector2.zero;
+            _this._renderLayer = 0;
+            _this._bounds = new es.Rectangle();
+            _this._areBoundsDirty = true;
+            return _this;
         }
-        if (!onlyReturnInitializedComponents) {
-            for (var i = 0; i < this._componentsToAdd.length; i++) {
-                var component = this._componentsToAdd[i];
+        Object.defineProperty(RenderableComponent.prototype, "width", {
+            get: function () {
+                return this.bounds.width;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(RenderableComponent.prototype, "height", {
+            get: function () {
+                return this.bounds.height;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(RenderableComponent.prototype, "bounds", {
+            get: function () {
+                if (this._areBoundsDirty) {
+                    this._bounds.calculateBounds(this.entity.transform.position, this._localOffset, es.Vector2.zero, this.entity.transform.scale, this.entity.transform.rotation, this.width, this.height);
+                    this._areBoundsDirty = false;
+                }
+                return this._bounds;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(RenderableComponent.prototype, "renderLayer", {
+            get: function () {
+                return this._renderLayer;
+            },
+            set: function (value) {
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(RenderableComponent.prototype, "localOffset", {
+            get: function () {
+                return this._localOffset;
+            },
+            set: function (value) {
+                this.setLocalOffset(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(RenderableComponent.prototype, "isVisible", {
+            get: function () {
+                return this._isVisible;
+            },
+            set: function (value) {
+                if (this._isVisible != value) {
+                    this._isVisible = value;
+                    if (this._isVisible)
+                        this.onBecameVisible();
+                    else
+                        this.onBecameInvisible();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        RenderableComponent.prototype.onEntityTransformChanged = function (comp) {
+            this._areBoundsDirty = true;
+        };
+        RenderableComponent.prototype.onBecameVisible = function () {
+        };
+        RenderableComponent.prototype.onBecameInvisible = function () {
+        };
+        RenderableComponent.prototype.isVisibleFromCamera = function (camera) {
+            this.isVisible = camera.bounds.intersects(this.bounds);
+            return this.isVisible;
+        };
+        RenderableComponent.prototype.setRenderLayer = function (renderLayer) {
+            if (renderLayer != this._renderLayer) {
+                var oldRenderLayer = this._renderLayer;
+                this._renderLayer = renderLayer;
+                if (this.entity && this.entity.scene)
+                    this.entity.scene.renderableComponents.updateRenderableRenderLayer(this, oldRenderLayer, this._renderLayer);
+            }
+            return this;
+        };
+        RenderableComponent.prototype.setColor = function (color) {
+            this.color = color;
+            return this;
+        };
+        RenderableComponent.prototype.setLocalOffset = function (offset) {
+            if (this._localOffset != offset) {
+                this._localOffset = offset;
+            }
+            return this;
+        };
+        RenderableComponent.prototype.toString = function () {
+            return "[RenderableComponent] " + this + ", renderLayer: " + this.renderLayer;
+        };
+        return RenderableComponent;
+    }(es.Component));
+    es.RenderableComponent = RenderableComponent;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Mesh = (function (_super) {
+        __extends(Mesh, _super);
+        function Mesh() {
+            var _this = _super.call(this) || this;
+            _this._mesh = new egret.Mesh();
+            return _this;
+        }
+        Mesh.prototype.setTexture = function (texture) {
+            this._mesh.texture = texture;
+            return this;
+        };
+        Mesh.prototype.reset = function () {
+        };
+        Mesh.prototype.render = function (camera) {
+        };
+        return Mesh;
+    }(es.RenderableComponent));
+    es.Mesh = Mesh;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var SpriteRenderer = (function (_super) {
+        __extends(SpriteRenderer, _super);
+        function SpriteRenderer(sprite) {
+            if (sprite === void 0) { sprite = null; }
+            var _this = _super.call(this) || this;
+            if (sprite instanceof es.Sprite)
+                _this.setSprite(sprite);
+            else if (sprite instanceof egret.Texture)
+                _this.setSprite(new es.Sprite(sprite));
+            return _this;
+        }
+        Object.defineProperty(SpriteRenderer.prototype, "bounds", {
+            get: function () {
+                if (this._areBoundsDirty) {
+                    if (this._sprite) {
+                        this._bounds.calculateBounds(this.entity.transform.position, this._localOffset, this._origin, this.entity.transform.scale, this.entity.transform.rotation, this._sprite.sourceRect.width, this._sprite.sourceRect.height);
+                        this._areBoundsDirty = false;
+                    }
+                    return this._bounds;
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(SpriteRenderer.prototype, "origin", {
+            get: function () {
+                return this._origin;
+            },
+            set: function (value) {
+                this.setOrigin(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(SpriteRenderer.prototype, "originNormalized", {
+            get: function () {
+                return new es.Vector2(this._origin.x / this.width * this.entity.transform.scale.x, this._origin.y / this.height * this.entity.transform.scale.y);
+            },
+            set: function (value) {
+                this.setOrigin(new es.Vector2(value.x * this.width / this.entity.transform.scale.x, value.y * this.height / this.entity.transform.scale.y));
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(SpriteRenderer.prototype, "sprite", {
+            get: function () {
+                return this._sprite;
+            },
+            set: function (value) {
+                this.setSprite(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        SpriteRenderer.prototype.setSprite = function (sprite) {
+            this._sprite = sprite;
+            if (this._sprite) {
+                this._origin = this._sprite.origin;
+            }
+            return this;
+        };
+        SpriteRenderer.prototype.setOrigin = function (origin) {
+            if (this._origin != origin) {
+                this._origin = origin;
+                this._areBoundsDirty = true;
+            }
+            return this;
+        };
+        SpriteRenderer.prototype.setOriginNormalized = function (value) {
+            this.setOrigin(new es.Vector2(value.x * this.width / this.entity.transform.scale.x, value.y * this.height / this.entity.transform.scale.y));
+            return this;
+        };
+        SpriteRenderer.prototype.render = function (camera) {
+        };
+        return SpriteRenderer;
+    }(es.RenderableComponent));
+    es.SpriteRenderer = SpriteRenderer;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var TiledSpriteRenderer = (function (_super) {
+        __extends(TiledSpriteRenderer, _super);
+        function TiledSpriteRenderer(sprite) {
+            var _this = _super.call(this, sprite) || this;
+            _this.leftTexture = new egret.Bitmap();
+            _this.rightTexture = new egret.Bitmap();
+            _this.leftTexture.texture = sprite.texture2D;
+            _this.rightTexture.texture = sprite.texture2D;
+            _this.setSprite(sprite);
+            _this.sourceRect = sprite.sourceRect;
+            return _this;
+        }
+        Object.defineProperty(TiledSpriteRenderer.prototype, "scrollX", {
+            get: function () {
+                return this.sourceRect.x;
+            },
+            set: function (value) {
+                this.sourceRect.x = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(TiledSpriteRenderer.prototype, "scrollY", {
+            get: function () {
+                return this.sourceRect.y;
+            },
+            set: function (value) {
+                this.sourceRect.y = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        TiledSpriteRenderer.prototype.render = function (camera) {
+            if (!this.sprite)
+                return;
+            _super.prototype.render.call(this, camera);
+            var renderTexture = new egret.RenderTexture();
+            var cacheBitmap = new egret.DisplayObjectContainer();
+            cacheBitmap.removeChildren();
+            cacheBitmap.addChild(this.leftTexture);
+            cacheBitmap.addChild(this.rightTexture);
+            this.leftTexture.x = this.sourceRect.x;
+            this.rightTexture.x = this.sourceRect.x - this.sourceRect.width;
+            this.leftTexture.y = this.sourceRect.y;
+            this.rightTexture.y = this.sourceRect.y;
+            cacheBitmap.cacheAsBitmap = true;
+            renderTexture.drawToTexture(cacheBitmap, new egret.Rectangle(0, 0, this.sourceRect.width, this.sourceRect.height));
+        };
+        return TiledSpriteRenderer;
+    }(es.SpriteRenderer));
+    es.TiledSpriteRenderer = TiledSpriteRenderer;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var ScrollingSpriteRenderer = (function (_super) {
+        __extends(ScrollingSpriteRenderer, _super);
+        function ScrollingSpriteRenderer() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.scrollSpeedX = 15;
+            _this.scroolSpeedY = 0;
+            _this._scrollX = 0;
+            _this._scrollY = 0;
+            return _this;
+        }
+        ScrollingSpriteRenderer.prototype.update = function () {
+            this._scrollX += this.scrollSpeedX * es.Time.deltaTime;
+            this._scrollY += this.scroolSpeedY * es.Time.deltaTime;
+            this.sourceRect.x = this._scrollX;
+            this.sourceRect.y = this._scrollY;
+        };
+        ScrollingSpriteRenderer.prototype.render = function (camera) {
+            if (!this.sprite)
+                return;
+            _super.prototype.render.call(this, camera);
+            var renderTexture = new egret.RenderTexture();
+            var cacheBitmap = new egret.DisplayObjectContainer();
+            cacheBitmap.removeChildren();
+            cacheBitmap.addChild(this.leftTexture);
+            cacheBitmap.addChild(this.rightTexture);
+            this.leftTexture.x = this.sourceRect.x;
+            this.rightTexture.x = this.sourceRect.x - this.sourceRect.width;
+            this.leftTexture.y = this.sourceRect.y;
+            this.rightTexture.y = this.sourceRect.y;
+            cacheBitmap.cacheAsBitmap = true;
+            renderTexture.drawToTexture(cacheBitmap, new egret.Rectangle(0, 0, this.sourceRect.width, this.sourceRect.height));
+        };
+        return ScrollingSpriteRenderer;
+    }(es.TiledSpriteRenderer));
+    es.ScrollingSpriteRenderer = ScrollingSpriteRenderer;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Sprite = (function () {
+        function Sprite(texture, sourceRect, origin) {
+            if (sourceRect === void 0) { sourceRect = new es.Rectangle(0, 0, texture.textureWidth, texture.textureHeight); }
+            if (origin === void 0) { origin = sourceRect.getHalfSize(); }
+            this.uvs = new es.Rectangle();
+            this.texture2D = texture;
+            this.sourceRect = sourceRect;
+            this.center = new es.Vector2(sourceRect.width * 0.5, sourceRect.height * 0.5);
+            this.origin = origin;
+            var inverseTexW = 1 / texture.textureWidth;
+            var inverseTexH = 1 / texture.textureHeight;
+            this.uvs.x = sourceRect.x * inverseTexW;
+            this.uvs.y = sourceRect.y * inverseTexH;
+            this.uvs.width = sourceRect.width * inverseTexW;
+            this.uvs.height = sourceRect.height * inverseTexH;
+        }
+        return Sprite;
+    }());
+    es.Sprite = Sprite;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var SpriteAnimation = (function () {
+        function SpriteAnimation(sprites, frameRate) {
+            this.sprites = sprites;
+            this.frameRate = frameRate;
+        }
+        return SpriteAnimation;
+    }());
+    es.SpriteAnimation = SpriteAnimation;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var LoopMode;
+    (function (LoopMode) {
+        LoopMode[LoopMode["loop"] = 0] = "loop";
+        LoopMode[LoopMode["once"] = 1] = "once";
+        LoopMode[LoopMode["clampForever"] = 2] = "clampForever";
+        LoopMode[LoopMode["pingPong"] = 3] = "pingPong";
+        LoopMode[LoopMode["pingPongOnce"] = 4] = "pingPongOnce";
+    })(LoopMode = es.LoopMode || (es.LoopMode = {}));
+    var State;
+    (function (State) {
+        State[State["none"] = 0] = "none";
+        State[State["running"] = 1] = "running";
+        State[State["paused"] = 2] = "paused";
+        State[State["completed"] = 3] = "completed";
+    })(State = es.State || (es.State = {}));
+    var SpriteAnimator = (function (_super) {
+        __extends(SpriteAnimator, _super);
+        function SpriteAnimator(sprite) {
+            var _this = _super.call(this, sprite) || this;
+            _this.speed = 1;
+            _this.animationState = State.none;
+            _this._animations = new Map();
+            _this._elapsedTime = 0;
+            return _this;
+        }
+        Object.defineProperty(SpriteAnimator.prototype, "isRunning", {
+            get: function () {
+                return this.animationState == State.running;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(SpriteAnimator.prototype, "animations", {
+            get: function () {
+                return this._animations;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        SpriteAnimator.prototype.update = function () {
+            if (this.animationState != State.running || !this.currentAnimation)
+                return;
+            var animation = this.currentAnimation;
+            var secondsPerFrame = 1 / (animation.frameRate * this.speed);
+            var iterationDuration = secondsPerFrame * animation.sprites.length;
+            this._elapsedTime += es.Time.deltaTime;
+            var time = Math.abs(this._elapsedTime);
+            if (this._loopMode == LoopMode.once && time > iterationDuration ||
+                this._loopMode == LoopMode.pingPongOnce && time > iterationDuration * 2) {
+                this.animationState = State.completed;
+                this._elapsedTime = 0;
+                this.currentFrame = 0;
+                this.sprite = animation.sprites[this.currentFrame];
+                return;
+            }
+            var i = Math.floor(time / secondsPerFrame);
+            var n = animation.sprites.length;
+            if (n > 2 && (this._loopMode == LoopMode.pingPong || this._loopMode == LoopMode.pingPongOnce)) {
+                var maxIndex = n - 1;
+                this.currentFrame = maxIndex - Math.abs(maxIndex - i % (maxIndex * 2));
+            }
+            else {
+                this.currentFrame = i % n;
+            }
+            this.sprite = animation.sprites[this.currentFrame];
+        };
+        SpriteAnimator.prototype.addAnimation = function (name, animation) {
+            if (!this.sprite && animation.sprites.length > 0)
+                this.setSprite(animation.sprites[0]);
+            this._animations[name] = animation;
+            return this;
+        };
+        SpriteAnimator.prototype.play = function (name, loopMode) {
+            if (loopMode === void 0) { loopMode = null; }
+            this.currentAnimation = this._animations[name];
+            this.currentAnimationName = name;
+            this.currentFrame = 0;
+            this.animationState = State.running;
+            this.sprite = this.currentAnimation.sprites[0];
+            this._elapsedTime = 0;
+            this._loopMode = loopMode ? loopMode : LoopMode.loop;
+        };
+        SpriteAnimator.prototype.isAnimationActive = function (name) {
+            return this.currentAnimation && this.currentAnimationName == name;
+        };
+        SpriteAnimator.prototype.pause = function () {
+            this.animationState = State.paused;
+        };
+        SpriteAnimator.prototype.unPause = function () {
+            this.animationState = State.running;
+        };
+        SpriteAnimator.prototype.stop = function () {
+            this.currentAnimation = null;
+            this.currentAnimationName = null;
+            this.currentFrame = 0;
+            this.animationState = State.none;
+        };
+        return SpriteAnimator;
+    }(es.SpriteRenderer));
+    es.SpriteAnimator = SpriteAnimator;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Mover = (function (_super) {
+        __extends(Mover, _super);
+        function Mover() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        Mover.prototype.onAddedToEntity = function () {
+            this._triggerHelper = new es.ColliderTriggerHelper(this.entity);
+        };
+        Mover.prototype.calculateMovement = function (motion) {
+            var collisionResult = new es.CollisionResult();
+            if (!this.entity.getComponent(es.Collider) || !this._triggerHelper) {
+                return null;
+            }
+            var colliders = this.entity.getComponents(es.Collider);
+            for (var i = 0; i < colliders.length; i++) {
+                var collider = colliders[i];
+                if (collider.isTrigger)
+                    continue;
+                var bounds = collider.bounds;
+                bounds.x += motion.x;
+                bounds.y += motion.y;
+                var boxcastResult = es.Physics.boxcastBroadphaseExcludingSelf(collider, bounds, collider.collidesWithLayers);
+                bounds = boxcastResult.bounds;
+                var neighbors = boxcastResult.tempHashSet;
+                for (var j = 0; j < neighbors.length; j++) {
+                    var neighbor = neighbors[j];
+                    if (neighbor.isTrigger)
+                        continue;
+                    var _internalcollisionResult = collider.collidesWith(neighbor, motion);
+                    if (_internalcollisionResult) {
+                        motion = es.Vector2.subtract(motion, _internalcollisionResult.minimumTranslationVector);
+                        if (_internalcollisionResult.collider) {
+                            collisionResult = _internalcollisionResult;
+                        }
+                    }
+                }
+            }
+            es.ListPool.free(colliders);
+            return { collisionResult: collisionResult, motion: motion };
+        };
+        Mover.prototype.applyMovement = function (motion) {
+            this.entity.position = es.Vector2.add(this.entity.position, motion);
+            if (this._triggerHelper)
+                this._triggerHelper.update();
+        };
+        Mover.prototype.move = function (motion) {
+            var movementResult = this.calculateMovement(motion);
+            var collisionResult = movementResult.collisionResult;
+            motion = movementResult.motion;
+            this.applyMovement(motion);
+            return collisionResult;
+        };
+        return Mover;
+    }(es.Component));
+    es.Mover = Mover;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var ProjectileMover = (function (_super) {
+        __extends(ProjectileMover, _super);
+        function ProjectileMover() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this._tempTriggerList = [];
+            return _this;
+        }
+        ProjectileMover.prototype.onAddedToEntity = function () {
+            this._collider = this.entity.getComponent(es.Collider);
+            if (!this._collider)
+                console.warn("ProjectileMover has no Collider. ProjectilMover requires a Collider!");
+        };
+        ProjectileMover.prototype.move = function (motion) {
+            if (!this._collider)
+                return false;
+            var didCollide = false;
+            this.entity.position = es.Vector2.add(this.entity.position, motion);
+            var neighbors = es.Physics.boxcastBroadphase(this._collider.bounds, this._collider.collidesWithLayers);
+            for (var i = 0; i < neighbors.colliders.length; i++) {
+                var neighbor = neighbors.colliders[i];
+                if (this._collider.overlaps(neighbor) && neighbor.enabled) {
+                    didCollide = true;
+                    this.notifyTriggerListeners(this._collider, neighbor);
+                }
+            }
+            return didCollide;
+        };
+        ProjectileMover.prototype.notifyTriggerListeners = function (self, other) {
+            other.entity.getComponents("ITriggerListener", this._tempTriggerList);
+            for (var i = 0; i < this._tempTriggerList.length; i++) {
+                this._tempTriggerList[i].onTriggerEnter(self, other);
+            }
+            this._tempTriggerList.length = 0;
+            this.entity.getComponents("ITriggerListener", this._tempTriggerList);
+            for (var i = 0; i < this._tempTriggerList.length; i++) {
+                this._tempTriggerList[i].onTriggerEnter(other, self);
+            }
+            this._tempTriggerList.length = 0;
+        };
+        return ProjectileMover;
+    }(es.Component));
+    es.ProjectileMover = ProjectileMover;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Collider = (function (_super) {
+        __extends(Collider, _super);
+        function Collider() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.physicsLayer = 1 << 0;
+            _this.collidesWithLayers = es.Physics.allLayers;
+            _this.shouldColliderScaleAndRotateWithTransform = true;
+            _this.registeredPhysicsBounds = new es.Rectangle();
+            _this._localOffset = es.Vector2.zero;
+            return _this;
+        }
+        Object.defineProperty(Collider.prototype, "localOffset", {
+            get: function () {
+                return this._localOffset;
+            },
+            set: function (value) {
+                this.setLocalOffset(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Collider.prototype, "absolutePosition", {
+            get: function () {
+                return es.Vector2.add(this.entity.transform.position, this._localOffset);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Collider.prototype, "rotation", {
+            get: function () {
+                if (this.shouldColliderScaleAndRotateWithTransform && this.entity)
+                    return this.entity.transform.rotation;
+                return 0;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Collider.prototype, "bounds", {
+            get: function () {
+                this.shape.recalculateBounds(this);
+                return this.shape.bounds;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Collider.prototype.setLocalOffset = function (offset) {
+            if (this._localOffset != offset) {
+                this.unregisterColliderWithPhysicsSystem();
+                this._localOffset = offset;
+                this._localOffsetLength = this._localOffset.length();
+                this.registerColliderWithPhysicsSystem();
+            }
+            return this;
+        };
+        Collider.prototype.setShouldColliderScaleAndRotateWithTransform = function (shouldColliderScaleAndRotationWithTransform) {
+            this.shouldColliderScaleAndRotateWithTransform = shouldColliderScaleAndRotationWithTransform;
+            return this;
+        };
+        Collider.prototype.onAddedToEntity = function () {
+            if (this._colliderRequiresAutoSizing) {
+                if (!(this instanceof es.BoxCollider || this instanceof es.CircleCollider)) {
+                    console.error("Only box and circle colliders can be created automatically");
+                    return;
+                }
+                var renderable = this.entity.getComponent(es.RenderableComponent);
+                if (renderable) {
+                    var bounds = renderable.bounds;
+                    var width = bounds.width / this.entity.scale.x;
+                    var height = bounds.height / this.entity.scale.y;
+                    if (this instanceof es.CircleCollider) {
+                        var circleCollider = this;
+                        circleCollider.radius = Math.max(width, height) * 0.5;
+                    }
+                    else {
+                        this.width = width;
+                        this.height = height;
+                    }
+                    this.localOffset = es.Vector2.subtract(bounds.center, this.entity.transform.position);
+                }
+                else {
+                    console.warn("Collider has no shape and no RenderableComponent. Can't figure out how to size it.");
+                }
+            }
+            this._isParentEntityAddedToScene = true;
+            this.registerColliderWithPhysicsSystem();
+        };
+        Collider.prototype.onRemovedFromEntity = function () {
+            this.unregisterColliderWithPhysicsSystem();
+            this._isParentEntityAddedToScene = false;
+        };
+        Collider.prototype.onEntityTransformChanged = function (comp) {
+            if (this._isColliderRegistered)
+                es.Physics.updateCollider(this);
+        };
+        Collider.prototype.onEnabled = function () {
+            this.registerColliderWithPhysicsSystem();
+        };
+        Collider.prototype.onDisabled = function () {
+            this.unregisterColliderWithPhysicsSystem();
+        };
+        Collider.prototype.registerColliderWithPhysicsSystem = function () {
+            if (this._isParentEntityAddedToScene && !this._isColliderRegistered) {
+                es.Physics.addCollider(this);
+                this._isColliderRegistered = true;
+            }
+        };
+        Collider.prototype.unregisterColliderWithPhysicsSystem = function () {
+            if (this._isParentEntityAddedToScene && this._isColliderRegistered) {
+                es.Physics.removeCollider(this);
+            }
+            this._isColliderRegistered = false;
+        };
+        Collider.prototype.overlaps = function (other) {
+            return this.shape.overlaps(other.shape);
+        };
+        Collider.prototype.collidesWith = function (collider, motion) {
+            var oldPosition = this.entity.position;
+            this.entity.position = es.Vector2.add(this.entity.position, motion);
+            var result = this.shape.collidesWithShape(collider.shape);
+            if (result)
+                result.collider = collider;
+            this.entity.position = oldPosition;
+            return result;
+        };
+        return Collider;
+    }(es.Component));
+    es.Collider = Collider;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var BoxCollider = (function (_super) {
+        __extends(BoxCollider, _super);
+        function BoxCollider() {
+            var _this = _super.call(this) || this;
+            _this.shape = new es.Box(1, 1);
+            _this._colliderRequiresAutoSizing = true;
+            return _this;
+        }
+        Object.defineProperty(BoxCollider.prototype, "width", {
+            get: function () {
+                return this.shape.width;
+            },
+            set: function (value) {
+                this.setWidth(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(BoxCollider.prototype, "height", {
+            get: function () {
+                return this.shape.height;
+            },
+            set: function (value) {
+                this.setHeight(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        BoxCollider.prototype.setSize = function (width, height) {
+            this._colliderRequiresAutoSizing = false;
+            var box = this.shape;
+            if (width != box.width || height != box.height) {
+                box.updateBox(width, height);
+                if (this.entity && this._isParentEntityAddedToScene)
+                    es.Physics.updateCollider(this);
+            }
+            return this;
+        };
+        BoxCollider.prototype.setWidth = function (width) {
+            this._colliderRequiresAutoSizing = false;
+            var box = this.shape;
+            if (width != box.width) {
+                box.updateBox(width, box.height);
+                if (this.entity && this._isParentEntityAddedToScene)
+                    es.Physics.updateCollider(this);
+            }
+            return this;
+        };
+        BoxCollider.prototype.setHeight = function (height) {
+            this._colliderRequiresAutoSizing = false;
+            var box = this.shape;
+            if (height != box.height) {
+                box.updateBox(box.width, height);
+                if (this.entity && this._isParentEntityAddedToScene)
+                    es.Physics.updateCollider(this);
+            }
+        };
+        BoxCollider.prototype.toString = function () {
+            return "[BoxCollider: bounds: " + this.bounds + "]";
+        };
+        return BoxCollider;
+    }(es.Collider));
+    es.BoxCollider = BoxCollider;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var CircleCollider = (function (_super) {
+        __extends(CircleCollider, _super);
+        function CircleCollider(radius) {
+            var _this = _super.call(this) || this;
+            if (radius)
+                _this._colliderRequiresAutoSizing = true;
+            _this.shape = new es.Circle(radius ? radius : 1);
+            return _this;
+        }
+        Object.defineProperty(CircleCollider.prototype, "radius", {
+            get: function () {
+                return this.shape.radius;
+            },
+            set: function (value) {
+                this.setRadius(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        CircleCollider.prototype.setRadius = function (radius) {
+            this._colliderRequiresAutoSizing = false;
+            var circle = this.shape;
+            if (radius != circle.radius) {
+                circle.radius = radius;
+                circle._originalRadius = radius;
+                if (this.entity && this._isParentEntityAddedToScene)
+                    es.Physics.updateCollider(this);
+            }
+            return this;
+        };
+        CircleCollider.prototype.toString = function () {
+            return "[CircleCollider: bounds: " + this.bounds + ", radius: " + this.shape.radius + "]";
+        };
+        return CircleCollider;
+    }(es.Collider));
+    es.CircleCollider = CircleCollider;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var PolygonCollider = (function (_super) {
+        __extends(PolygonCollider, _super);
+        function PolygonCollider(points) {
+            var _this = _super.call(this) || this;
+            var isPolygonClosed = points[0] == points[points.length - 1];
+            if (isPolygonClosed)
+                points.splice(points.length - 1, 1);
+            var center = es.Polygon.findPolygonCenter(points);
+            _this.setLocalOffset(center);
+            es.Polygon.recenterPolygonVerts(points);
+            _this.shape = new es.Polygon(points);
+            return _this;
+        }
+        return PolygonCollider;
+    }(es.Collider));
+    es.PolygonCollider = PolygonCollider;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var EntitySystem = (function () {
+        function EntitySystem(matcher) {
+            this._entities = [];
+            this._matcher = matcher ? matcher : es.Matcher.empty();
+        }
+        Object.defineProperty(EntitySystem.prototype, "matcher", {
+            get: function () {
+                return this._matcher;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(EntitySystem.prototype, "scene", {
+            get: function () {
+                return this._scene;
+            },
+            set: function (value) {
+                this._scene = value;
+                this._entities = [];
+            },
+            enumerable: true,
+            configurable: true
+        });
+        EntitySystem.prototype.initialize = function () {
+        };
+        EntitySystem.prototype.onChanged = function (entity) {
+            var contains = this._entities.contains(entity);
+            var interest = this._matcher.IsIntersted(entity);
+            if (interest && !contains)
+                this.add(entity);
+            else if (!interest && contains)
+                this.remove(entity);
+        };
+        EntitySystem.prototype.add = function (entity) {
+            this._entities.push(entity);
+            this.onAdded(entity);
+        };
+        EntitySystem.prototype.onAdded = function (entity) {
+        };
+        EntitySystem.prototype.remove = function (entity) {
+            this._entities.remove(entity);
+            this.onRemoved(entity);
+        };
+        EntitySystem.prototype.onRemoved = function (entity) {
+        };
+        EntitySystem.prototype.update = function () {
+            this.begin();
+            this.process(this._entities);
+        };
+        EntitySystem.prototype.lateUpdate = function () {
+            this.lateProcess(this._entities);
+            this.end();
+        };
+        EntitySystem.prototype.begin = function () {
+        };
+        EntitySystem.prototype.process = function (entities) {
+        };
+        EntitySystem.prototype.lateProcess = function (entities) {
+        };
+        EntitySystem.prototype.end = function () {
+        };
+        return EntitySystem;
+    }());
+    es.EntitySystem = EntitySystem;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var EntityProcessingSystem = (function (_super) {
+        __extends(EntityProcessingSystem, _super);
+        function EntityProcessingSystem(matcher) {
+            return _super.call(this, matcher) || this;
+        }
+        EntityProcessingSystem.prototype.lateProcessEntity = function (entity) {
+        };
+        EntityProcessingSystem.prototype.process = function (entities) {
+            var _this = this;
+            entities.forEach(function (entity) { return _this.processEntity(entity); });
+        };
+        EntityProcessingSystem.prototype.lateProcess = function (entities) {
+            var _this = this;
+            entities.forEach(function (entity) { return _this.lateProcessEntity(entity); });
+        };
+        return EntityProcessingSystem;
+    }(es.EntitySystem));
+    es.EntityProcessingSystem = EntityProcessingSystem;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var PassiveSystem = (function (_super) {
+        __extends(PassiveSystem, _super);
+        function PassiveSystem() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        PassiveSystem.prototype.onChanged = function (entity) {
+        };
+        PassiveSystem.prototype.process = function (entities) {
+            this.begin();
+            this.end();
+        };
+        return PassiveSystem;
+    }(es.EntitySystem));
+    es.PassiveSystem = PassiveSystem;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var ProcessingSystem = (function (_super) {
+        __extends(ProcessingSystem, _super);
+        function ProcessingSystem() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        ProcessingSystem.prototype.onChanged = function (entity) {
+        };
+        ProcessingSystem.prototype.process = function (entities) {
+            this.begin();
+            this.processSystem();
+            this.end();
+        };
+        return ProcessingSystem;
+    }(es.EntitySystem));
+    es.ProcessingSystem = ProcessingSystem;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var BitSet = (function () {
+        function BitSet(nbits) {
+            if (nbits === void 0) { nbits = 64; }
+            var length = nbits >> 6;
+            if ((nbits & BitSet.LONG_MASK) != 0)
+                length++;
+            this._bits = new Array(length);
+        }
+        BitSet.prototype.and = function (bs) {
+            var max = Math.min(this._bits.length, bs._bits.length);
+            var i;
+            for (var i_1 = 0; i_1 < max; ++i_1)
+                this._bits[i_1] &= bs._bits[i_1];
+            while (i < this._bits.length)
+                this._bits[i++] = 0;
+        };
+        BitSet.prototype.andNot = function (bs) {
+            var i = Math.min(this._bits.length, bs._bits.length);
+            while (--i >= 0)
+                this._bits[i] &= ~bs._bits[i];
+        };
+        BitSet.prototype.cardinality = function () {
+            var card = 0;
+            for (var i = this._bits.length - 1; i >= 0; i--) {
+                var a = this._bits[i];
+                if (a == 0)
+                    continue;
+                if (a == -1) {
+                    card += 64;
+                    continue;
+                }
+                a = ((a >> 1) & 0x5555555555555555) + (a & 0x5555555555555555);
+                a = ((a >> 2) & 0x3333333333333333) + (a & 0x3333333333333333);
+                var b = ((a >> 32) + a);
+                b = ((b >> 4) & 0x0f0f0f0f) + (b & 0x0f0f0f0f);
+                b = ((b >> 8) & 0x00ff00ff) + (b & 0x00ff00ff);
+                card += ((b >> 16) & 0x0000ffff) + (b & 0x0000ffff);
+            }
+            return card;
+        };
+        BitSet.prototype.clear = function (pos) {
+            if (pos != undefined) {
+                var offset = pos >> 6;
+                this.ensure(offset);
+                this._bits[offset] &= ~(1 << pos);
+            }
+            else {
+                for (var i = 0; i < this._bits.length; i++)
+                    this._bits[i] = 0;
+            }
+        };
+        BitSet.prototype.ensure = function (lastElt) {
+            if (lastElt >= this._bits.length) {
+                var nd = new Number[lastElt + 1];
+                nd = this._bits.copyWithin(0, 0, this._bits.length);
+                this._bits = nd;
+            }
+        };
+        BitSet.prototype.get = function (pos) {
+            var offset = pos >> 6;
+            if (offset >= this._bits.length)
+                return false;
+            return (this._bits[offset] & (1 << pos)) != 0;
+        };
+        BitSet.prototype.intersects = function (set) {
+            var i = Math.min(this._bits.length, set._bits.length);
+            while (--i >= 0) {
+                if ((this._bits[i] & set._bits[i]) != 0)
+                    return true;
+            }
+            return false;
+        };
+        BitSet.prototype.isEmpty = function () {
+            for (var i = this._bits.length - 1; i >= 0; i--) {
+                if (this._bits[i])
+                    return false;
+            }
+            return true;
+        };
+        BitSet.prototype.nextSetBit = function (from) {
+            var offset = from >> 6;
+            var mask = 1 << from;
+            while (offset < this._bits.length) {
+                var h = this._bits[offset];
+                do {
+                    if ((h & mask) != 0)
+                        return from;
+                    mask <<= 1;
+                    from++;
+                } while (mask != 0);
+                mask = 1;
+                offset++;
+            }
+            return -1;
+        };
+        BitSet.prototype.set = function (pos, value) {
+            if (value === void 0) { value = true; }
+            if (value) {
+                var offset = pos >> 6;
+                this.ensure(offset);
+                this._bits[offset] |= 1 << pos;
+            }
+            else {
+                this.clear(pos);
+            }
+        };
+        BitSet.LONG_MASK = 0x3f;
+        return BitSet;
+    }());
+    es.BitSet = BitSet;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var ComponentList = (function () {
+        function ComponentList(entity) {
+            this._components = [];
+            this._componentsToAdd = [];
+            this._componentsToRemove = [];
+            this._tempBufferList = [];
+            this._entity = entity;
+        }
+        Object.defineProperty(ComponentList.prototype, "count", {
+            get: function () {
+                return this._components.length;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ComponentList.prototype, "buffer", {
+            get: function () {
+                return this._components;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        ComponentList.prototype.markEntityListUnsorted = function () {
+            this._isComponentListUnsorted = true;
+        };
+        ComponentList.prototype.add = function (component) {
+            this._componentsToAdd.push(component);
+        };
+        ComponentList.prototype.remove = function (component) {
+            if (this._componentsToRemove.contains(component))
+                console.warn("You are trying to remove a Component (" + component + ") that you already removed");
+            if (this._componentsToAdd.contains(component)) {
+                this._componentsToAdd.remove(component);
+                return;
+            }
+            this._componentsToRemove.push(component);
+        };
+        ComponentList.prototype.removeAllComponents = function () {
+            for (var i = 0; i < this._components.length; i++) {
+                this.handleRemove(this._components[i]);
+            }
+            this._components.length = 0;
+            this._componentsToAdd.length = 0;
+            this._componentsToRemove.length = 0;
+        };
+        ComponentList.prototype.deregisterAllComponents = function () {
+            for (var i = 0; i < this._components.length; i++) {
+                var component = this._components[i];
+                if (component instanceof es.RenderableComponent)
+                    this._entity.scene.renderableComponents.remove(component);
+                this._entity.componentBits.set(es.ComponentTypeManager.getIndexFor(component), false);
+                this._entity.scene.entityProcessors.onComponentRemoved(this._entity);
+            }
+        };
+        ComponentList.prototype.registerAllComponents = function () {
+            for (var i = 0; i < this._components.length; i++) {
+                var component = this._components[i];
+                if (component instanceof es.RenderableComponent)
+                    this._entity.scene.renderableComponents.add(component);
+                this._entity.componentBits.set(es.ComponentTypeManager.getIndexFor(component));
+                this._entity.scene.entityProcessors.onComponentAdded(this._entity);
+            }
+        };
+        ComponentList.prototype.updateLists = function () {
+            if (this._componentsToRemove.length > 0) {
+                for (var i = 0; i < this._componentsToRemove.length; i++) {
+                    this.handleRemove(this._componentsToRemove[i]);
+                    this._components.remove(this._componentsToRemove[i]);
+                }
+                this._componentsToRemove.length = 0;
+            }
+            if (this._componentsToAdd.length > 0) {
+                for (var i = 0, count = this._componentsToAdd.length; i < count; i++) {
+                    var component = this._componentsToAdd[i];
+                    if (component instanceof es.RenderableComponent)
+                        this._entity.scene.renderableComponents.add(component);
+                    this._entity.componentBits.set(es.ComponentTypeManager.getIndexFor(component));
+                    this._entity.scene.entityProcessors.onComponentAdded(this._entity);
+                    this._components.push(component);
+                    this._tempBufferList.push(component);
+                }
+                this._componentsToAdd.length = 0;
+                this._isComponentListUnsorted = true;
+                for (var i = 0; i < this._tempBufferList.length; i++) {
+                    var component = this._tempBufferList[i];
+                    component.onAddedToEntity();
+                    if (component.enabled) {
+                        component.onEnabled();
+                    }
+                }
+                this._tempBufferList.length = 0;
+            }
+            if (this._isComponentListUnsorted) {
+                this._components.sort(ComponentList.compareUpdatableOrder.compare);
+                this._isComponentListUnsorted = false;
+            }
+        };
+        ComponentList.prototype.handleRemove = function (component) {
+            if (component instanceof es.RenderableComponent)
+                this._entity.scene.renderableComponents.remove(component);
+            this._entity.componentBits.set(es.ComponentTypeManager.getIndexFor(component), false);
+            this._entity.scene.entityProcessors.onComponentRemoved(this._entity);
+            component.onRemovedFromEntity();
+            component.entity = null;
+        };
+        ComponentList.prototype.getComponent = function (type, onlyReturnInitializedComponents) {
+            for (var i = 0; i < this._components.length; i++) {
+                var component = this._components[i];
                 if (component instanceof type)
                     return component;
             }
-        }
-        return null;
-    };
-    ComponentList.prototype.getComponents = function (typeName, components) {
-        if (!components)
-            components = [];
-        for (var i = 0; i < this._components.length; i++) {
-            var component = this._components[i];
-            if (typeof (typeName) == "string") {
-                if (egret.is(component, typeName)) {
-                    components.push(component);
+            if (!onlyReturnInitializedComponents) {
+                for (var i = 0; i < this._componentsToAdd.length; i++) {
+                    var component = this._componentsToAdd[i];
+                    if (component instanceof type)
+                        return component;
                 }
             }
-            else {
-                if (component instanceof typeName) {
-                    components.push(component);
+            return null;
+        };
+        ComponentList.prototype.getComponents = function (typeName, components) {
+            if (!components)
+                components = [];
+            for (var i = 0; i < this._components.length; i++) {
+                var component = this._components[i];
+                if (typeof (typeName) == "string") {
+                    if (egret.is(component, typeName)) {
+                        components.push(component);
+                    }
+                }
+                else {
+                    if (component instanceof typeName) {
+                        components.push(component);
+                    }
                 }
             }
-        }
-        for (var i = 0; i < this._componentsToAdd.length; i++) {
-            var component = this._componentsToAdd[i];
-            if (typeof (typeName) == "string") {
-                if (egret.is(component, typeName)) {
-                    components.push(component);
+            for (var i = 0; i < this._componentsToAdd.length; i++) {
+                var component = this._componentsToAdd[i];
+                if (typeof (typeName) == "string") {
+                    if (egret.is(component, typeName)) {
+                        components.push(component);
+                    }
+                }
+                else {
+                    if (component instanceof typeName) {
+                        components.push(component);
+                    }
                 }
             }
-            else {
-                if (component instanceof typeName) {
-                    components.push(component);
-                }
+            return components;
+        };
+        ComponentList.prototype.update = function () {
+            this.updateLists();
+            for (var i = 0; i < this._components.length; i++) {
+                var updatableComponent = this._components[i];
+                if (updatableComponent.enabled &&
+                    (updatableComponent.updateInterval == 1 ||
+                        es.Time.frameCount % updatableComponent.updateInterval == 0))
+                    updatableComponent.update();
             }
-        }
-        return components;
-    };
-    ComponentList.prototype.update = function () {
-        this.updateLists();
-        for (var i = 0; i < this._components.length; i++) {
-            var updatable = this._components[i];
-            var updateableComponent = void 0;
-            if (updatable instanceof Component)
-                updateableComponent = updatable;
-            if (updatable.enabled &&
-                updateableComponent.enabled &&
-                (updateableComponent.updateInterval == 1 ||
-                    Time.frameCount % updateableComponent.updateInterval == 0))
-                updatable.update();
-        }
-    };
-    return ComponentList;
-}());
-var ComponentTypeManager = (function () {
-    function ComponentTypeManager() {
-    }
-    ComponentTypeManager.add = function (type) {
-        if (!this._componentTypesMask.has(type))
-            this._componentTypesMask[type] = this._componentTypesMask.size;
-    };
-    ComponentTypeManager.getIndexFor = function (type) {
-        var v = -1;
-        if (!this._componentTypesMask.has(type)) {
-            this.add(type);
-            v = this._componentTypesMask.get(type);
-        }
-        return v;
-    };
-    ComponentTypeManager._componentTypesMask = new Map();
-    return ComponentTypeManager;
-}());
-var EntityList = (function () {
-    function EntityList(scene) {
-        this._entitiesToRemove = [];
-        this._entitiesToAdded = [];
-        this._tempEntityList = [];
-        this._entities = [];
-        this._entityDict = new Map();
-        this._unsortedTags = [];
-        this.scene = scene;
-    }
-    Object.defineProperty(EntityList.prototype, "count", {
-        get: function () {
-            return this._entities.length;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(EntityList.prototype, "buffer", {
-        get: function () {
-            return this._entities;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    EntityList.prototype.add = function (entity) {
-        if (this._entitiesToAdded.indexOf(entity) == -1)
-            this._entitiesToAdded.push(entity);
-    };
-    EntityList.prototype.remove = function (entity) {
-        if (this._entitiesToAdded.contains(entity)) {
-            this._entitiesToAdded.remove(entity);
-            return;
-        }
-        if (!this._entitiesToRemove.contains(entity))
-            this._entitiesToRemove.push(entity);
-    };
-    EntityList.prototype.findEntity = function (name) {
-        for (var i = 0; i < this._entities.length; i++) {
-            if (this._entities[i].name == name)
-                return this._entities[i];
-        }
-        return this._entitiesToAdded.firstOrDefault(function (entity) { return entity.name == name; });
-    };
-    EntityList.prototype.getTagList = function (tag) {
-        var list = this._entityDict.get(tag);
-        if (!list) {
-            list = [];
-            this._entityDict.set(tag, list);
-        }
-        return this._entityDict.get(tag);
-    };
-    EntityList.prototype.addToTagList = function (entity) {
-        var list = this.getTagList(entity.tag);
-        if (!list.contains(entity)) {
-            list.push(entity);
-            this._unsortedTags.push(entity.tag);
-        }
-    };
-    EntityList.prototype.removeFromTagList = function (entity) {
-        var list = this._entityDict.get(entity.tag);
-        if (list) {
-            list.remove(entity);
-        }
-    };
-    EntityList.prototype.update = function () {
-        for (var i = 0; i < this._entities.length; i++) {
-            var entity = this._entities[i];
-            if (entity.enabled)
-                entity.update();
-        }
-    };
-    EntityList.prototype.removeAllEntities = function () {
-        this._entitiesToAdded.length = 0;
-        this.updateLists();
-        for (var i = 0; i < this._entities.length; i++) {
-            this._entities[i]._isDestoryed = true;
-            this._entities[i].onRemovedFromScene();
-            this._entities[i].scene = null;
-        }
-        this._entities.length = 0;
-        this._entityDict.clear();
-    };
-    EntityList.prototype.updateLists = function () {
-        var _this = this;
-        if (this._entitiesToRemove.length > 0) {
-            var temp = this._entitiesToRemove;
-            this._entitiesToRemove = this._tempEntityList;
-            this._tempEntityList = temp;
-            this._tempEntityList.forEach(function (entity) {
-                _this._entities.remove(entity);
-                entity.scene = null;
-                _this.scene.entityProcessors.onEntityRemoved(entity);
-            });
-            this._tempEntityList.length = 0;
-        }
-        if (this._entitiesToAdded.length > 0) {
-            var temp = this._entitiesToAdded;
-            this._entitiesToAdded = this._tempEntityList;
-            this._tempEntityList = temp;
-            this._tempEntityList.forEach(function (entity) {
-                if (!_this._entities.contains(entity)) {
-                    _this._entities.push(entity);
-                    entity.scene = _this.scene;
-                    _this.scene.entityProcessors.onEntityAdded(entity);
-                }
-            });
-            this._tempEntityList.forEach(function (entity) { return entity.onAddedToScene(); });
-            this._tempEntityList.length = 0;
-        }
-        if (this._unsortedTags.length > 0) {
-            this._unsortedTags.forEach(function (tag) {
-                _this._entityDict.get(tag).sort();
-            });
-            this._unsortedTags.length = 0;
-        }
-    };
-    return EntityList;
-}());
-var EntityProcessorList = (function () {
-    function EntityProcessorList() {
-        this._processors = [];
-    }
-    EntityProcessorList.prototype.add = function (processor) {
-        this._processors.push(processor);
-    };
-    EntityProcessorList.prototype.remove = function (processor) {
-        this._processors.remove(processor);
-    };
-    EntityProcessorList.prototype.onComponentAdded = function (entity) {
-        this.notifyEntityChanged(entity);
-    };
-    EntityProcessorList.prototype.onComponentRemoved = function (entity) {
-        this.notifyEntityChanged(entity);
-    };
-    EntityProcessorList.prototype.onEntityAdded = function (entity) {
-        this.notifyEntityChanged(entity);
-    };
-    EntityProcessorList.prototype.onEntityRemoved = function (entity) {
-        this.removeFromProcessors(entity);
-    };
-    EntityProcessorList.prototype.notifyEntityChanged = function (entity) {
-        for (var i = 0; i < this._processors.length; i++) {
-            this._processors[i].onChanged(entity);
-        }
-    };
-    EntityProcessorList.prototype.removeFromProcessors = function (entity) {
-        for (var i = 0; i < this._processors.length; i++) {
-            this._processors[i].remove(entity);
-        }
-    };
-    EntityProcessorList.prototype.begin = function () {
-    };
-    EntityProcessorList.prototype.update = function () {
-        for (var i = 0; i < this._processors.length; i++) {
-            this._processors[i].update();
-        }
-    };
-    EntityProcessorList.prototype.lateUpdate = function () {
-        for (var i = 0; i < this._processors.length; i++) {
-            this._processors[i].lateUpdate();
-        }
-    };
-    EntityProcessorList.prototype.end = function () {
-    };
-    EntityProcessorList.prototype.getProcessor = function () {
-        for (var i = 0; i < this._processors.length; i++) {
-            var processor = this._processors[i];
-            if (processor instanceof EntitySystem)
-                return processor;
-        }
-        return null;
-    };
-    return EntityProcessorList;
-}());
-var Matcher = (function () {
-    function Matcher() {
-        this.allSet = new BitSet();
-        this.exclusionSet = new BitSet();
-        this.oneSet = new BitSet();
-    }
-    Matcher.empty = function () {
-        return new Matcher();
-    };
-    Matcher.prototype.getAllSet = function () {
-        return this.allSet;
-    };
-    Matcher.prototype.getExclusionSet = function () {
-        return this.exclusionSet;
-    };
-    Matcher.prototype.getOneSet = function () {
-        return this.oneSet;
-    };
-    Matcher.prototype.IsIntersted = function (e) {
-        if (!this.allSet.isEmpty()) {
-            for (var i = this.allSet.nextSetBit(0); i >= 0; i = this.allSet.nextSetBit(i + 1)) {
-                if (!e.componentBits.get(i))
-                    return false;
+        };
+        ComponentList.prototype.onEntityTransformChanged = function (comp) {
+            for (var i = 0; i < this._components.length; i++) {
+                if (this._components[i].enabled)
+                    this._components[i].onEntityTransformChanged(comp);
             }
+            for (var i = 0; i < this._componentsToAdd.length; i++) {
+                if (this._componentsToAdd[i].enabled)
+                    this._componentsToAdd[i].onEntityTransformChanged(comp);
+            }
+        };
+        ComponentList.prototype.onEntityEnabled = function () {
+            for (var i = 0; i < this._components.length; i++)
+                this._components[i].onEnabled();
+        };
+        ComponentList.prototype.onEntityDisabled = function () {
+            for (var i = 0; i < this._components.length; i++)
+                this._components[i].onDisabled();
+        };
+        ComponentList.compareUpdatableOrder = new es.IUpdatableComparer();
+        return ComponentList;
+    }());
+    es.ComponentList = ComponentList;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var ComponentTypeManager = (function () {
+        function ComponentTypeManager() {
         }
-        if (!this.exclusionSet.isEmpty() && this.exclusionSet.intersects(e.componentBits))
-            return false;
-        if (!this.oneSet.isEmpty() && !this.oneSet.intersects(e.componentBits))
-            return false;
-        return true;
-    };
-    Matcher.prototype.all = function () {
-        var _this = this;
-        var types = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            types[_i] = arguments[_i];
+        ComponentTypeManager.add = function (type) {
+            if (!this._componentTypesMask.has(type))
+                this._componentTypesMask[type] = this._componentTypesMask.size;
+        };
+        ComponentTypeManager.getIndexFor = function (type) {
+            var v = -1;
+            if (!this._componentTypesMask.has(type)) {
+                this.add(type);
+                v = this._componentTypesMask.get(type);
+            }
+            return v;
+        };
+        ComponentTypeManager._componentTypesMask = new Map();
+        return ComponentTypeManager;
+    }());
+    es.ComponentTypeManager = ComponentTypeManager;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var EntityList = (function () {
+        function EntityList(scene) {
+            this._entitiesToRemove = [];
+            this._entitiesToAdded = [];
+            this._tempEntityList = [];
+            this._entities = [];
+            this._entityDict = new Map();
+            this._unsortedTags = [];
+            this.scene = scene;
         }
-        types.forEach(function (type) {
-            _this.allSet.set(ComponentTypeManager.getIndexFor(type));
+        Object.defineProperty(EntityList.prototype, "count", {
+            get: function () {
+                return this._entities.length;
+            },
+            enumerable: true,
+            configurable: true
         });
-        return this;
-    };
-    Matcher.prototype.exclude = function () {
-        var _this = this;
-        var types = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            types[_i] = arguments[_i];
-        }
-        types.forEach(function (type) {
-            _this.exclusionSet.set(ComponentTypeManager.getIndexFor(type));
+        Object.defineProperty(EntityList.prototype, "buffer", {
+            get: function () {
+                return this._entities;
+            },
+            enumerable: true,
+            configurable: true
         });
-        return this;
-    };
-    Matcher.prototype.one = function () {
-        var _this = this;
-        var types = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            types[_i] = arguments[_i];
+        EntityList.prototype.add = function (entity) {
+            if (this._entitiesToAdded.indexOf(entity) == -1)
+                this._entitiesToAdded.push(entity);
+        };
+        EntityList.prototype.remove = function (entity) {
+            if (this._entitiesToAdded.contains(entity)) {
+                this._entitiesToAdded.remove(entity);
+                return;
+            }
+            if (!this._entitiesToRemove.contains(entity))
+                this._entitiesToRemove.push(entity);
+        };
+        EntityList.prototype.findEntity = function (name) {
+            for (var i = 0; i < this._entities.length; i++) {
+                if (this._entities[i].name == name)
+                    return this._entities[i];
+            }
+            return this._entitiesToAdded.firstOrDefault(function (entity) { return entity.name == name; });
+        };
+        EntityList.prototype.entitiesWithTag = function (tag) {
+            var list = this.getTagList(tag);
+            var returnList = es.ListPool.obtain();
+            for (var i = 0; i < list.length; i++)
+                returnList.push(list[i]);
+            return returnList;
+        };
+        EntityList.prototype.entitiesOfType = function (type) {
+            var list = es.ListPool.obtain();
+            for (var i = 0; i < this._entities.length; i++) {
+                if (this._entities[i] instanceof type)
+                    list.push(this._entities[i]);
+            }
+            this._entitiesToAdded.forEach(function (entity) {
+                if (entity instanceof type)
+                    list.push(entity);
+            });
+            return list;
+        };
+        EntityList.prototype.findComponentOfType = function (type) {
+            for (var i = 0; i < this._entities.length; i++) {
+                if (this._entities[i].enabled) {
+                    var comp = this._entities[i].getComponent(type);
+                    if (comp)
+                        return comp;
+                }
+            }
+            for (var i = 0; i < this._entitiesToAdded.length; i++) {
+                var entity = this._entitiesToAdded[i];
+                if (entity.enabled) {
+                    var comp = entity.getComponent(type);
+                    if (comp)
+                        return comp;
+                }
+            }
+            return null;
+        };
+        EntityList.prototype.findComponentsOfType = function (type) {
+            var comps = es.ListPool.obtain();
+            for (var i = 0; i < this._entities.length; i++) {
+                if (this._entities[i].enabled)
+                    this._entities[i].getComponents(type, comps);
+            }
+            for (var i = 0; i < this._entitiesToAdded.length; i++) {
+                var entity = this._entitiesToAdded[i];
+                if (entity.enabled)
+                    entity.getComponents(type, comps);
+            }
+            return comps;
+        };
+        EntityList.prototype.getTagList = function (tag) {
+            var list = this._entityDict.get(tag);
+            if (!list) {
+                list = [];
+                this._entityDict.set(tag, list);
+            }
+            return this._entityDict.get(tag);
+        };
+        EntityList.prototype.addToTagList = function (entity) {
+            var list = this.getTagList(entity.tag);
+            if (!list.contains(entity)) {
+                list.push(entity);
+                this._unsortedTags.push(entity.tag);
+            }
+        };
+        EntityList.prototype.removeFromTagList = function (entity) {
+            var list = this._entityDict.get(entity.tag);
+            if (list) {
+                list.remove(entity);
+            }
+        };
+        EntityList.prototype.update = function () {
+            for (var i = 0; i < this._entities.length; i++) {
+                var entity = this._entities[i];
+                if (entity.enabled)
+                    entity.update();
+            }
+        };
+        EntityList.prototype.removeAllEntities = function () {
+            this._entitiesToAdded.length = 0;
+            this.updateLists();
+            for (var i = 0; i < this._entities.length; i++) {
+                this._entities[i]._isDestroyed = true;
+                this._entities[i].onRemovedFromScene();
+                this._entities[i].scene = null;
+            }
+            this._entities.length = 0;
+            this._entityDict.clear();
+        };
+        EntityList.prototype.updateLists = function () {
+            var _this = this;
+            if (this._entitiesToRemove.length > 0) {
+                var temp = this._entitiesToRemove;
+                this._entitiesToRemove = this._tempEntityList;
+                this._tempEntityList = temp;
+                this._tempEntityList.forEach(function (entity) {
+                    _this._entities.remove(entity);
+                    entity.scene = null;
+                    _this.scene.entityProcessors.onEntityRemoved(entity);
+                });
+                this._tempEntityList.length = 0;
+            }
+            if (this._entitiesToAdded.length > 0) {
+                var temp = this._entitiesToAdded;
+                this._entitiesToAdded = this._tempEntityList;
+                this._tempEntityList = temp;
+                this._tempEntityList.forEach(function (entity) {
+                    if (!_this._entities.contains(entity)) {
+                        _this._entities.push(entity);
+                        entity.scene = _this.scene;
+                        _this.scene.entityProcessors.onEntityAdded(entity);
+                    }
+                });
+                this._tempEntityList.forEach(function (entity) { return entity.onAddedToScene(); });
+                this._tempEntityList.length = 0;
+            }
+            if (this._unsortedTags.length > 0) {
+                this._unsortedTags.forEach(function (tag) {
+                    _this._entityDict.get(tag).sort();
+                });
+                this._unsortedTags.length = 0;
+            }
+        };
+        return EntityList;
+    }());
+    es.EntityList = EntityList;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var EntityProcessorList = (function () {
+        function EntityProcessorList() {
+            this._processors = [];
         }
-        types.forEach(function (type) {
-            _this.oneSet.set(ComponentTypeManager.getIndexFor(type));
-        });
-        return this;
-    };
-    return Matcher;
-}());
+        EntityProcessorList.prototype.add = function (processor) {
+            this._processors.push(processor);
+        };
+        EntityProcessorList.prototype.remove = function (processor) {
+            this._processors.remove(processor);
+        };
+        EntityProcessorList.prototype.onComponentAdded = function (entity) {
+            this.notifyEntityChanged(entity);
+        };
+        EntityProcessorList.prototype.onComponentRemoved = function (entity) {
+            this.notifyEntityChanged(entity);
+        };
+        EntityProcessorList.prototype.onEntityAdded = function (entity) {
+            this.notifyEntityChanged(entity);
+        };
+        EntityProcessorList.prototype.onEntityRemoved = function (entity) {
+            this.removeFromProcessors(entity);
+        };
+        EntityProcessorList.prototype.notifyEntityChanged = function (entity) {
+            for (var i = 0; i < this._processors.length; i++) {
+                this._processors[i].onChanged(entity);
+            }
+        };
+        EntityProcessorList.prototype.removeFromProcessors = function (entity) {
+            for (var i = 0; i < this._processors.length; i++) {
+                this._processors[i].remove(entity);
+            }
+        };
+        EntityProcessorList.prototype.begin = function () {
+        };
+        EntityProcessorList.prototype.update = function () {
+            for (var i = 0; i < this._processors.length; i++) {
+                this._processors[i].update();
+            }
+        };
+        EntityProcessorList.prototype.lateUpdate = function () {
+            for (var i = 0; i < this._processors.length; i++) {
+                this._processors[i].lateUpdate();
+            }
+        };
+        EntityProcessorList.prototype.end = function () {
+        };
+        EntityProcessorList.prototype.getProcessor = function () {
+            for (var i = 0; i < this._processors.length; i++) {
+                var processor = this._processors[i];
+                if (processor instanceof es.EntitySystem)
+                    return processor;
+            }
+            return null;
+        };
+        return EntityProcessorList;
+    }());
+    es.EntityProcessorList = EntityProcessorList;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Matcher = (function () {
+        function Matcher() {
+            this.allSet = new es.BitSet();
+            this.exclusionSet = new es.BitSet();
+            this.oneSet = new es.BitSet();
+        }
+        Matcher.empty = function () {
+            return new Matcher();
+        };
+        Matcher.prototype.getAllSet = function () {
+            return this.allSet;
+        };
+        Matcher.prototype.getExclusionSet = function () {
+            return this.exclusionSet;
+        };
+        Matcher.prototype.getOneSet = function () {
+            return this.oneSet;
+        };
+        Matcher.prototype.IsIntersted = function (e) {
+            if (!this.allSet.isEmpty()) {
+                for (var i = this.allSet.nextSetBit(0); i >= 0; i = this.allSet.nextSetBit(i + 1)) {
+                    if (!e.componentBits.get(i))
+                        return false;
+                }
+            }
+            if (!this.exclusionSet.isEmpty() && this.exclusionSet.intersects(e.componentBits))
+                return false;
+            if (!this.oneSet.isEmpty() && !this.oneSet.intersects(e.componentBits))
+                return false;
+            return true;
+        };
+        Matcher.prototype.all = function () {
+            var _this = this;
+            var types = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                types[_i] = arguments[_i];
+            }
+            types.forEach(function (type) {
+                _this.allSet.set(es.ComponentTypeManager.getIndexFor(type));
+            });
+            return this;
+        };
+        Matcher.prototype.exclude = function () {
+            var _this = this;
+            var types = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                types[_i] = arguments[_i];
+            }
+            types.forEach(function (type) {
+                _this.exclusionSet.set(es.ComponentTypeManager.getIndexFor(type));
+            });
+            return this;
+        };
+        Matcher.prototype.one = function () {
+            var _this = this;
+            var types = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                types[_i] = arguments[_i];
+            }
+            types.forEach(function (type) {
+                _this.oneSet.set(es.ComponentTypeManager.getIndexFor(type));
+            });
+            return this;
+        };
+        return Matcher;
+    }());
+    es.Matcher = Matcher;
+})(es || (es = {}));
 var ObjectUtils = (function () {
     function ObjectUtils() {
     }
@@ -3058,34 +3568,100 @@ var ObjectUtils = (function () {
     };
     return ObjectUtils;
 }());
-var RenderableComponentList = (function () {
-    function RenderableComponentList() {
-        this._components = [];
-    }
-    Object.defineProperty(RenderableComponentList.prototype, "count", {
-        get: function () {
-            return this._components.length;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(RenderableComponentList.prototype, "buffer", {
-        get: function () {
-            return this._components;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    RenderableComponentList.prototype.add = function (component) {
-        this._components.push(component);
-    };
-    RenderableComponentList.prototype.remove = function (component) {
-        this._components.remove(component);
-    };
-    RenderableComponentList.prototype.updateList = function () {
-    };
-    return RenderableComponentList;
-}());
+var es;
+(function (es) {
+    var RenderableComparer = (function () {
+        function RenderableComparer() {
+        }
+        RenderableComparer.prototype.compare = function (self, other) {
+            return other.renderLayer - self.renderLayer;
+        };
+        return RenderableComparer;
+    }());
+    es.RenderableComparer = RenderableComparer;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var RenderableComponentList = (function () {
+        function RenderableComponentList() {
+            this._components = [];
+            this._componentsByRenderLayer = new Map();
+            this._unsortedRenderLayers = [];
+            this._componentsNeedSort = true;
+        }
+        Object.defineProperty(RenderableComponentList.prototype, "count", {
+            get: function () {
+                return this._components.length;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(RenderableComponentList.prototype, "buffer", {
+            get: function () {
+                return this._components;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        RenderableComponentList.prototype.add = function (component) {
+            this._components.push(component);
+            this.addToRenderLayerList(component, component.renderLayer);
+        };
+        RenderableComponentList.prototype.remove = function (component) {
+            this._components.remove(component);
+            this._componentsByRenderLayer.get(component.renderLayer).remove(component);
+        };
+        RenderableComponentList.prototype.updateRenderableRenderLayer = function (component, oldRenderLayer, newRenderLayer) {
+            if (this._componentsByRenderLayer.has(oldRenderLayer) && this._componentsByRenderLayer.get(oldRenderLayer).contains(component)) {
+                this._componentsByRenderLayer.get(oldRenderLayer).remove(component);
+                this.addToRenderLayerList(component, newRenderLayer);
+            }
+        };
+        RenderableComponentList.prototype.setRenderLayerNeedsComponentSort = function (renderLayer) {
+            if (!this._unsortedRenderLayers.contains(renderLayer))
+                this._unsortedRenderLayers.push(renderLayer);
+            this._componentsNeedSort = true;
+        };
+        RenderableComponentList.prototype.setNeedsComponentSort = function () {
+            this._componentsNeedSort = true;
+        };
+        RenderableComponentList.prototype.addToRenderLayerList = function (component, renderLayer) {
+            var list = this.componentsWithRenderLayer(renderLayer);
+            if (!list.contains(component)) {
+                console.warn("Component renderLayer list already contains this component");
+                return;
+            }
+            list.push(component);
+            if (!this._unsortedRenderLayers.contains(renderLayer))
+                this._unsortedRenderLayers.push(renderLayer);
+            this._componentsNeedSort = true;
+        };
+        RenderableComponentList.prototype.componentsWithRenderLayer = function (renderLayer) {
+            if (!this._componentsByRenderLayer.get(renderLayer)) {
+                this._componentsByRenderLayer.set(renderLayer, []);
+            }
+            return this._componentsByRenderLayer.get(renderLayer);
+        };
+        RenderableComponentList.prototype.updateList = function () {
+            if (this._componentsNeedSort) {
+                this._components.sort(RenderableComponentList.compareUpdatableOrder.compare);
+                this._componentsNeedSort = false;
+            }
+            if (this._unsortedRenderLayers.length > 0) {
+                for (var i = 0, count = this._unsortedRenderLayers.length; i < count; i++) {
+                    var renderLayerComponents = this._componentsByRenderLayer.get(this._unsortedRenderLayers[i]);
+                    if (renderLayerComponents) {
+                        renderLayerComponents.sort(RenderableComponentList.compareUpdatableOrder.compare);
+                    }
+                }
+                this._unsortedRenderLayers.length = 0;
+            }
+        };
+        RenderableComponentList.compareUpdatableOrder = new es.RenderableComparer();
+        return RenderableComponentList;
+    }());
+    es.RenderableComponentList = RenderableComponentList;
+})(es || (es = {}));
 var StringUtils = (function () {
     function StringUtils() {
     }
@@ -3230,155 +3806,163 @@ var StringUtils = (function () {
     ];
     return StringUtils;
 }());
-var TextureUtils = (function () {
-    function TextureUtils() {
-    }
-    TextureUtils.convertImageToCanvas = function (texture, rect) {
-        if (!this.sharedCanvas) {
-            this.sharedCanvas = egret.sys.createCanvas();
-            this.sharedContext = this.sharedCanvas.getContext("2d");
+var es;
+(function (es) {
+    var TextureUtils = (function () {
+        function TextureUtils() {
         }
-        var w = texture.$getTextureWidth();
-        var h = texture.$getTextureHeight();
-        if (!rect) {
-            rect = egret.$TempRectangle;
-            rect.x = 0;
-            rect.y = 0;
-            rect.width = w;
-            rect.height = h;
-        }
-        rect.x = Math.min(rect.x, w - 1);
-        rect.y = Math.min(rect.y, h - 1);
-        rect.width = Math.min(rect.width, w - rect.x);
-        rect.height = Math.min(rect.height, h - rect.y);
-        var iWidth = Math.floor(rect.width);
-        var iHeight = Math.floor(rect.height);
-        var surface = this.sharedCanvas;
-        surface["style"]["width"] = iWidth + "px";
-        surface["style"]["height"] = iHeight + "px";
-        this.sharedCanvas.width = iWidth;
-        this.sharedCanvas.height = iHeight;
-        if (egret.Capabilities.renderMode == "webgl") {
-            var renderTexture = void 0;
-            if (!texture.$renderBuffer) {
-                if (egret.sys.systemRenderer["renderClear"]) {
-                    egret.sys.systemRenderer["renderClear"]();
+        TextureUtils.convertImageToCanvas = function (texture, rect) {
+            if (!this.sharedCanvas) {
+                this.sharedCanvas = egret.sys.createCanvas();
+                this.sharedContext = this.sharedCanvas.getContext("2d");
+            }
+            var w = texture.$getTextureWidth();
+            var h = texture.$getTextureHeight();
+            if (!rect) {
+                rect = egret.$TempRectangle;
+                rect.x = 0;
+                rect.y = 0;
+                rect.width = w;
+                rect.height = h;
+            }
+            rect.x = Math.min(rect.x, w - 1);
+            rect.y = Math.min(rect.y, h - 1);
+            rect.width = Math.min(rect.width, w - rect.x);
+            rect.height = Math.min(rect.height, h - rect.y);
+            var iWidth = Math.floor(rect.width);
+            var iHeight = Math.floor(rect.height);
+            var surface = this.sharedCanvas;
+            surface["style"]["width"] = iWidth + "px";
+            surface["style"]["height"] = iHeight + "px";
+            this.sharedCanvas.width = iWidth;
+            this.sharedCanvas.height = iHeight;
+            if (egret.Capabilities.renderMode == "webgl") {
+                var renderTexture = void 0;
+                if (!texture.$renderBuffer) {
+                    if (egret.sys.systemRenderer["renderClear"]) {
+                        egret.sys.systemRenderer["renderClear"]();
+                    }
+                    renderTexture = new egret.RenderTexture();
+                    renderTexture.drawToTexture(new egret.Bitmap(texture));
                 }
-                renderTexture = new egret.RenderTexture();
-                renderTexture.drawToTexture(new egret.Bitmap(texture));
+                else {
+                    renderTexture = texture;
+                }
+                var pixels = renderTexture.$renderBuffer.getPixels(rect.x, rect.y, iWidth, iHeight);
+                var x = 0;
+                var y = 0;
+                for (var i = 0; i < pixels.length; i += 4) {
+                    this.sharedContext.fillStyle =
+                        'rgba(' + pixels[i]
+                            + ',' + pixels[i + 1]
+                            + ',' + pixels[i + 2]
+                            + ',' + (pixels[i + 3] / 255) + ')';
+                    this.sharedContext.fillRect(x, y, 1, 1);
+                    x++;
+                    if (x == iWidth) {
+                        x = 0;
+                        y++;
+                    }
+                }
+                if (!texture.$renderBuffer) {
+                    renderTexture.dispose();
+                }
+                return surface;
             }
             else {
-                renderTexture = texture;
+                var bitmapData = texture;
+                var offsetX = Math.round(bitmapData.$offsetX);
+                var offsetY = Math.round(bitmapData.$offsetY);
+                var bitmapWidth = bitmapData.$bitmapWidth;
+                var bitmapHeight = bitmapData.$bitmapHeight;
+                var $TextureScaleFactor = es.SceneManager.stage.textureScaleFactor;
+                this.sharedContext.drawImage(bitmapData.$bitmapData.source, bitmapData.$bitmapX + rect.x / $TextureScaleFactor, bitmapData.$bitmapY + rect.y / $TextureScaleFactor, bitmapWidth * rect.width / w, bitmapHeight * rect.height / h, offsetX, offsetY, rect.width, rect.height);
+                return surface;
             }
-            var pixels = renderTexture.$renderBuffer.getPixels(rect.x, rect.y, iWidth, iHeight);
-            var x = 0;
-            var y = 0;
-            for (var i = 0; i < pixels.length; i += 4) {
-                this.sharedContext.fillStyle =
-                    'rgba(' + pixels[i]
-                        + ',' + pixels[i + 1]
-                        + ',' + pixels[i + 2]
-                        + ',' + (pixels[i + 3] / 255) + ')';
-                this.sharedContext.fillRect(x, y, 1, 1);
-                x++;
-                if (x == iWidth) {
-                    x = 0;
-                    y++;
-                }
+        };
+        TextureUtils.toDataURL = function (type, texture, rect, encoderOptions) {
+            try {
+                var surface = this.convertImageToCanvas(texture, rect);
+                var result = surface.toDataURL(type, encoderOptions);
+                return result;
             }
-            if (!texture.$renderBuffer) {
-                renderTexture.dispose();
+            catch (e) {
+                egret.$error(1033);
             }
-            return surface;
-        }
-        else {
-            var bitmapData = texture;
-            var offsetX = Math.round(bitmapData.$offsetX);
-            var offsetY = Math.round(bitmapData.$offsetY);
-            var bitmapWidth = bitmapData.$bitmapWidth;
-            var bitmapHeight = bitmapData.$bitmapHeight;
-            var $TextureScaleFactor = SceneManager.stage.textureScaleFactor;
-            this.sharedContext.drawImage(bitmapData.$bitmapData.source, bitmapData.$bitmapX + rect.x / $TextureScaleFactor, bitmapData.$bitmapY + rect.y / $TextureScaleFactor, bitmapWidth * rect.width / w, bitmapHeight * rect.height / h, offsetX, offsetY, rect.width, rect.height);
-            return surface;
-        }
-    };
-    TextureUtils.toDataURL = function (type, texture, rect, encoderOptions) {
-        try {
+            return null;
+        };
+        TextureUtils.eliFoTevas = function (type, texture, filePath, rect, encoderOptions) {
             var surface = this.convertImageToCanvas(texture, rect);
-            var result = surface.toDataURL(type, encoderOptions);
+            var result = surface.toTempFilePathSync({
+                fileType: type.indexOf("png") >= 0 ? "png" : "jpg"
+            });
+            wx.getFileSystemManager().saveFile({
+                tempFilePath: result,
+                filePath: wx.env.USER_DATA_PATH + "/" + filePath,
+                success: function (res) {
+                }
+            });
             return result;
-        }
-        catch (e) {
-            egret.$error(1033);
-        }
-        return null;
-    };
-    TextureUtils.eliFoTevas = function (type, texture, filePath, rect, encoderOptions) {
-        var surface = this.convertImageToCanvas(texture, rect);
-        var result = surface.toTempFilePathSync({
-            fileType: type.indexOf("png") >= 0 ? "png" : "jpg"
-        });
-        wx.getFileSystemManager().saveFile({
-            tempFilePath: result,
-            filePath: wx.env.USER_DATA_PATH + "/" + filePath,
-            success: function (res) {
+        };
+        TextureUtils.getPixel32 = function (texture, x, y) {
+            egret.$warn(1041, "getPixel32", "getPixels");
+            return texture.getPixels(x, y);
+        };
+        TextureUtils.getPixels = function (texture, x, y, width, height) {
+            if (width === void 0) { width = 1; }
+            if (height === void 0) { height = 1; }
+            if (egret.Capabilities.renderMode == "webgl") {
+                var renderTexture = void 0;
+                if (!texture.$renderBuffer) {
+                    renderTexture = new egret.RenderTexture();
+                    renderTexture.drawToTexture(new egret.Bitmap(texture));
+                }
+                else {
+                    renderTexture = texture;
+                }
+                var pixels = renderTexture.$renderBuffer.getPixels(x, y, width, height);
+                return pixels;
             }
-        });
-        return result;
-    };
-    TextureUtils.getPixel32 = function (texture, x, y) {
-        egret.$warn(1041, "getPixel32", "getPixels");
-        return texture.getPixels(x, y);
-    };
-    TextureUtils.getPixels = function (texture, x, y, width, height) {
-        if (width === void 0) { width = 1; }
-        if (height === void 0) { height = 1; }
-        if (egret.Capabilities.renderMode == "webgl") {
-            var renderTexture = void 0;
-            if (!texture.$renderBuffer) {
-                renderTexture = new egret.RenderTexture();
-                renderTexture.drawToTexture(new egret.Bitmap(texture));
+            try {
+                var surface = this.convertImageToCanvas(texture);
+                var result = this.sharedContext.getImageData(x, y, width, height).data;
+                return result;
             }
-            else {
-                renderTexture = texture;
+            catch (e) {
+                egret.$error(1039);
             }
-            var pixels = renderTexture.$renderBuffer.getPixels(x, y, width, height);
-            return pixels;
+        };
+        return TextureUtils;
+    }());
+    es.TextureUtils = TextureUtils;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Time = (function () {
+        function Time() {
         }
-        try {
-            var surface = this.convertImageToCanvas(texture);
-            var result = this.sharedContext.getImageData(x, y, width, height).data;
-            return result;
-        }
-        catch (e) {
-            egret.$error(1039);
-        }
-    };
-    return TextureUtils;
-}());
-var Time = (function () {
-    function Time() {
-    }
-    Time.update = function (currentTime) {
-        var dt = (currentTime - this._lastTime) / 1000;
-        this.deltaTime = dt * this.timeScale;
-        this.unscaledDeltaTime = dt;
-        this._timeSinceSceneLoad += dt;
-        this.frameCount++;
-        this._lastTime = currentTime;
-    };
-    Time.sceneChanged = function () {
-        this._timeSinceSceneLoad = 0;
-    };
-    Time.checkEvery = function (interval) {
-        return (this._timeSinceSceneLoad / interval) > ((this._timeSinceSceneLoad - this.deltaTime) / interval);
-    };
-    Time.deltaTime = 0;
-    Time.timeScale = 1;
-    Time.frameCount = 0;
-    Time._lastTime = 0;
-    return Time;
-}());
+        Time.update = function (currentTime) {
+            var dt = (currentTime - this._lastTime) / 1000;
+            this.deltaTime = dt * this.timeScale;
+            this.unscaledDeltaTime = dt;
+            this._timeSinceSceneLoad += dt;
+            this.frameCount++;
+            this._lastTime = currentTime;
+        };
+        Time.sceneChanged = function () {
+            this._timeSinceSceneLoad = 0;
+        };
+        Time.checkEvery = function (interval) {
+            return (this._timeSinceSceneLoad / interval) > ((this._timeSinceSceneLoad - this.deltaTime) / interval);
+        };
+        Time.deltaTime = 0;
+        Time.timeScale = 1;
+        Time.frameCount = 0;
+        Time._lastTime = 0;
+        return Time;
+    }());
+    es.Time = Time;
+})(es || (es = {}));
 var TimeUtils = (function () {
     function TimeUtils() {
     }
@@ -3532,405 +4116,143 @@ var TimeUtils = (function () {
     };
     return TimeUtils;
 }());
-var GraphicsCapabilities = (function (_super) {
-    __extends(GraphicsCapabilities, _super);
-    function GraphicsCapabilities() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    GraphicsCapabilities.prototype.initialize = function (device) {
-        this.platformInitialize(device);
-    };
-    GraphicsCapabilities.prototype.platformInitialize = function (device) {
-        var capabilities = this;
-        capabilities["isMobile"] = true;
-        var systemInfo = wx.getSystemInfoSync();
-        var systemStr = systemInfo.system.toLowerCase();
-        if (systemStr.indexOf("ios") > -1) {
-            capabilities["os"] = "iOS";
+var es;
+(function (es) {
+    var GraphicsCapabilities = (function (_super) {
+        __extends(GraphicsCapabilities, _super);
+        function GraphicsCapabilities() {
+            return _super !== null && _super.apply(this, arguments) || this;
         }
-        else if (systemStr.indexOf("android") > -1) {
-            capabilities["os"] = "Android";
-        }
-        var language = systemInfo.language;
-        if (language.indexOf('zh') > -1) {
-            language = "zh-CN";
-        }
-        else {
-            language = "en-US";
-        }
-        capabilities["language"] = language;
-    };
-    return GraphicsCapabilities;
-}(egret.Capabilities));
-var GraphicsDevice = (function () {
-    function GraphicsDevice() {
-        this.graphicsCapabilities = new GraphicsCapabilities();
-        this.graphicsCapabilities.initialize(this);
-    }
-    return GraphicsDevice;
-}());
-var Viewport = (function () {
-    function Viewport(x, y, width, height) {
-        this._x = x;
-        this._y = y;
-        this._width = width;
-        this._height = height;
-        this._minDepth = 0;
-        this._maxDepth = 1;
-    }
-    Object.defineProperty(Viewport.prototype, "aspectRatio", {
-        get: function () {
-            if ((this._height != 0) && (this._width != 0))
-                return (this._width / this._height);
-            return 0;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Viewport.prototype, "bounds", {
-        get: function () {
-            return new Rectangle(this._x, this._y, this._width, this._height);
-        },
-        set: function (value) {
-            this._x = value.x;
-            this._y = value.y;
-            this._width = value.width;
-            this._height = value.height;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    return Viewport;
-}());
-var GaussianBlurEffect = (function (_super) {
-    __extends(GaussianBlurEffect, _super);
-    function GaussianBlurEffect() {
-        return _super.call(this, PostProcessor.default_vert, GaussianBlurEffect.blur_frag, {
-            screenWidth: SceneManager.stage.stageWidth,
-            screenHeight: SceneManager.stage.stageHeight
-        }) || this;
-    }
-    GaussianBlurEffect.blur_frag = "precision mediump float;\n" +
-        "uniform sampler2D uSampler;\n" +
-        "uniform float screenWidth;\n" +
-        "uniform float screenHeight;\n" +
-        "float normpdf(in float x, in float sigma)\n" +
-        "{\n" +
-        "return 0.39894*exp(-0.5*x*x/(sigma*sigma))/sigma;\n" +
-        "}\n" +
-        "void main()\n" +
-        "{\n" +
-        "vec3 c = texture2D(uSampler, gl_FragCoord.xy / vec2(screenWidth, screenHeight).xy).rgb;\n" +
-        "const int mSize = 11;\n" +
-        "const int kSize = (mSize - 1)/2;\n" +
-        "float kernel[mSize];\n" +
-        "vec3 final_colour = vec3(0.0);\n" +
-        "float sigma = 7.0;\n" +
-        "float z = 0.0;\n" +
-        "for (int j = 0; j <= kSize; ++j)\n" +
-        "{\n" +
-        "kernel[kSize+j] = kernel[kSize-j] = normpdf(float(j),sigma);\n" +
-        "}\n" +
-        "for (int j = 0; j < mSize; ++j)\n" +
-        "{\n" +
-        "z += kernel[j];\n" +
-        "}\n" +
-        "for (int i = -kSize; i <= kSize; ++i)\n" +
-        "{\n" +
-        "for (int j = -kSize; j <= kSize; ++j)\n" +
-        "{\n" +
-        "final_colour += kernel[kSize+j]*kernel[kSize+i]*texture2D(uSampler, (gl_FragCoord.xy+vec2(float(i),float(j))) / vec2(screenWidth, screenHeight).xy).rgb;\n" +
-        "}\n}\n" +
-        "gl_FragColor = vec4(final_colour/(z*z), 1.0);\n" +
-        "}";
-    return GaussianBlurEffect;
-}(egret.CustomFilter));
-var PolygonLightEffect = (function (_super) {
-    __extends(PolygonLightEffect, _super);
-    function PolygonLightEffect() {
-        return _super.call(this, PolygonLightEffect.vertSrc, PolygonLightEffect.fragmentSrc) || this;
-    }
-    PolygonLightEffect.vertSrc = "attribute vec2 aVertexPosition;\n" +
-        "attribute vec2 aTextureCoord;\n" +
-        "uniform vec2 projectionVector;\n" +
-        "varying vec2 vTextureCoord;\n" +
-        "const vec2 center = vec2(-1.0, 1.0);\n" +
-        "void main(void) {\n" +
-        "   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n" +
-        "   vTextureCoord = aTextureCoord;\n" +
-        "}";
-    PolygonLightEffect.fragmentSrc = "precision lowp float;\n" +
-        "varying vec2 vTextureCoord;\n" +
-        "uniform sampler2D uSampler;\n" +
-        "#define SAMPLE_COUNT 15\n" +
-        "uniform vec2 _sampleOffsets[SAMPLE_COUNT];\n" +
-        "uniform float _sampleWeights[SAMPLE_COUNT];\n" +
-        "void main(void) {\n" +
-        "vec4 c = vec4(0, 0, 0, 0);\n" +
-        "for( int i = 0; i < SAMPLE_COUNT; i++ )\n" +
-        "   c += texture2D( uSampler, vTextureCoord + _sampleOffsets[i] ) * _sampleWeights[i];\n" +
-        "gl_FragColor = c;\n" +
-        "}";
-    return PolygonLightEffect;
-}(egret.CustomFilter));
-var PostProcessor = (function () {
-    function PostProcessor(effect) {
-        if (effect === void 0) { effect = null; }
-        this.enable = true;
-        this.effect = effect;
-    }
-    PostProcessor.prototype.onAddedToScene = function (scene) {
-        this.scene = scene;
-        this.shape = new egret.Shape();
-        this.shape.graphics.beginFill(0xFFFFFF, 1);
-        this.shape.graphics.drawRect(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-        this.shape.graphics.endFill();
-        scene.addChild(this.shape);
-    };
-    PostProcessor.prototype.process = function () {
-        this.drawFullscreenQuad();
-    };
-    PostProcessor.prototype.onSceneBackBufferSizeChanged = function (newWidth, newHeight) { };
-    PostProcessor.prototype.drawFullscreenQuad = function () {
-        this.scene.filters = [this.effect];
-    };
-    PostProcessor.prototype.unload = function () {
-        if (this.effect) {
-            this.effect = null;
-        }
-        this.scene.removeChild(this.shape);
-        this.scene = null;
-    };
-    PostProcessor.default_vert = "attribute vec2 aVertexPosition;\n" +
-        "attribute vec2 aTextureCoord;\n" +
-        "attribute vec2 aColor;\n" +
-        "uniform vec2 projectionVector;\n" +
-        "varying vec2 vTextureCoord;\n" +
-        "varying vec4 vColor;\n" +
-        "const vec2 center = vec2(-1.0, 1.0);\n" +
-        "void main(void) {\n" +
-        "gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n" +
-        "vTextureCoord = aTextureCoord;\n" +
-        "vColor = vec4(aColor.x, aColor.x, aColor.x, aColor.x);\n" +
-        "}";
-    return PostProcessor;
-}());
-var GaussianBlurPostProcessor = (function (_super) {
-    __extends(GaussianBlurPostProcessor, _super);
-    function GaussianBlurPostProcessor() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    GaussianBlurPostProcessor.prototype.onAddedToScene = function (scene) {
-        _super.prototype.onAddedToScene.call(this, scene);
-        this.effect = new GaussianBlurEffect();
-    };
-    return GaussianBlurPostProcessor;
-}(PostProcessor));
-var Renderer = (function () {
-    function Renderer() {
-    }
-    Renderer.prototype.onAddedToScene = function (scene) { };
-    Renderer.prototype.beginRender = function (cam) {
-    };
-    Renderer.prototype.unload = function () { };
-    Renderer.prototype.renderAfterStateCheck = function (renderable, cam) {
-        renderable.render(cam);
-    };
-    return Renderer;
-}());
-var DefaultRenderer = (function (_super) {
-    __extends(DefaultRenderer, _super);
-    function DefaultRenderer() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    DefaultRenderer.prototype.render = function (scene) {
-        var cam = this.camera ? this.camera : scene.camera;
-        this.beginRender(cam);
-        for (var i = 0; i < scene.renderableComponents.count; i++) {
-            var renderable = scene.renderableComponents.buffer[i];
-            if (renderable.enabled && renderable.isVisibleFromCamera(cam))
-                this.renderAfterStateCheck(renderable, cam);
-        }
-    };
-    return DefaultRenderer;
-}(Renderer));
-var ScreenSpaceRenderer = (function (_super) {
-    __extends(ScreenSpaceRenderer, _super);
-    function ScreenSpaceRenderer() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ScreenSpaceRenderer.prototype.render = function (scene) {
-    };
-    return ScreenSpaceRenderer;
-}(Renderer));
-var PolyLight = (function (_super) {
-    __extends(PolyLight, _super);
-    function PolyLight(radius, color, power) {
-        var _this = _super.call(this) || this;
-        _this._indices = [];
-        _this.radius = radius;
-        _this.power = power;
-        _this.color = color;
-        _this.computeTriangleIndices();
-        return _this;
-    }
-    Object.defineProperty(PolyLight.prototype, "radius", {
-        get: function () {
-            return this._radius;
-        },
-        set: function (value) {
-            this.setRadius(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    PolyLight.prototype.computeTriangleIndices = function (totalTris) {
-        if (totalTris === void 0) { totalTris = 20; }
-        this._indices.length = 0;
-        for (var i = 0; i < totalTris; i += 2) {
-            this._indices.push(0);
-            this._indices.push(i + 2);
-            this._indices.push(i + 1);
-        }
-    };
-    PolyLight.prototype.setRadius = function (radius) {
-        if (radius != this._radius) {
-            this._radius = radius;
-            this._areBoundsDirty = true;
-        }
-    };
-    PolyLight.prototype.render = function (camera) {
-    };
-    PolyLight.prototype.reset = function () {
-    };
-    return PolyLight;
-}(RenderableComponent));
-var SceneTransition = (function () {
-    function SceneTransition(sceneLoadAction) {
-        this.sceneLoadAction = sceneLoadAction;
-        this.loadsNewScene = sceneLoadAction != null;
-    }
-    Object.defineProperty(SceneTransition.prototype, "hasPreviousSceneRender", {
-        get: function () {
-            if (!this._hasPreviousSceneRender) {
-                this._hasPreviousSceneRender = true;
-                return false;
+        GraphicsCapabilities.prototype.initialize = function (device) {
+            this.platformInitialize(device);
+        };
+        GraphicsCapabilities.prototype.platformInitialize = function (device) {
+            var capabilities = this;
+            capabilities["isMobile"] = true;
+            var systemInfo = wx.getSystemInfoSync();
+            var systemStr = systemInfo.system.toLowerCase();
+            if (systemStr.indexOf("ios") > -1) {
+                capabilities["os"] = "iOS";
             }
-            return true;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    SceneTransition.prototype.preRender = function () { };
-    SceneTransition.prototype.render = function () {
-    };
-    SceneTransition.prototype.onBeginTransition = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4, this.loadNextScene()];
-                    case 1:
-                        _a.sent();
-                        this.transitionComplete();
-                        return [2];
-                }
-            });
-        });
-    };
-    SceneTransition.prototype.transitionComplete = function () {
-        SceneManager.sceneTransition = null;
-        if (this.onTransitionCompleted) {
-            this.onTransitionCompleted();
+            else if (systemStr.indexOf("android") > -1) {
+                capabilities["os"] = "Android";
+            }
+            var language = systemInfo.language;
+            if (language.indexOf('zh') > -1) {
+                language = "zh-CN";
+            }
+            else {
+                language = "en-US";
+            }
+            capabilities["language"] = language;
+        };
+        return GraphicsCapabilities;
+    }(egret.Capabilities));
+    es.GraphicsCapabilities = GraphicsCapabilities;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var GraphicsDevice = (function () {
+        function GraphicsDevice() {
+            this.graphicsCapabilities = new es.GraphicsCapabilities();
+            this.graphicsCapabilities.initialize(this);
         }
-    };
-    SceneTransition.prototype.loadNextScene = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (this.onScreenObscured)
-                            this.onScreenObscured();
-                        if (!this.loadsNewScene) {
-                            this.isNewSceneLoaded = true;
-                        }
-                        _a = SceneManager;
-                        return [4, this.sceneLoadAction()];
-                    case 1:
-                        _a.scene = _b.sent();
-                        this.isNewSceneLoaded = true;
-                        return [2];
-                }
-            });
+        return GraphicsDevice;
+    }());
+    es.GraphicsDevice = GraphicsDevice;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Viewport = (function () {
+        function Viewport(x, y, width, height) {
+            this._x = x;
+            this._y = y;
+            this._width = width;
+            this._height = height;
+            this._minDepth = 0;
+            this._maxDepth = 1;
+        }
+        Object.defineProperty(Viewport.prototype, "aspectRatio", {
+            get: function () {
+                if ((this._height != 0) && (this._width != 0))
+                    return (this._width / this._height);
+                return 0;
+            },
+            enumerable: true,
+            configurable: true
         });
-    };
-    SceneTransition.prototype.tickEffectProgressProperty = function (filter, duration, easeType, reverseDirection) {
-        if (reverseDirection === void 0) { reverseDirection = false; }
-        return new Promise(function (resolve) {
-            var start = reverseDirection ? 1 : 0;
-            var end = reverseDirection ? 0 : 1;
-            egret.Tween.get(filter.uniforms).set({ _progress: start }).to({ _progress: end }, duration * 1000, easeType).call(function () {
-                resolve();
-            });
+        Object.defineProperty(Viewport.prototype, "bounds", {
+            get: function () {
+                return new es.Rectangle(this._x, this._y, this._width, this._height);
+            },
+            set: function (value) {
+                this._x = value.x;
+                this._y = value.y;
+                this._width = value.width;
+                this._height = value.height;
+            },
+            enumerable: true,
+            configurable: true
         });
-    };
-    return SceneTransition;
-}());
-var FadeTransition = (function (_super) {
-    __extends(FadeTransition, _super);
-    function FadeTransition(sceneLoadAction) {
-        var _this = _super.call(this, sceneLoadAction) || this;
-        _this.fadeToColor = 0x000000;
-        _this.fadeOutDuration = 0.4;
-        _this.fadeEaseType = egret.Ease.quadInOut;
-        _this.delayBeforeFadeInDuration = 0.1;
-        _this._alpha = 0;
-        _this._mask = new egret.Shape();
-        return _this;
-    }
-    FadeTransition.prototype.onBeginTransition = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                this._mask.graphics.beginFill(this.fadeToColor, 1);
-                this._mask.graphics.drawRect(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-                this._mask.graphics.endFill();
-                SceneManager.stage.addChild(this._mask);
-                egret.Tween.get(this).to({ _alpha: 1 }, this.fadeOutDuration * 1000, this.fadeEaseType)
-                    .call(function () { return __awaiter(_this, void 0, void 0, function () {
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0: return [4, this.loadNextScene()];
-                            case 1:
-                                _a.sent();
-                                return [2];
-                        }
-                    });
-                }); }).wait(this.delayBeforeFadeInDuration).call(function () {
-                    egret.Tween.get(_this).to({ _alpha: 0 }, _this.fadeOutDuration * 1000, _this.fadeEaseType).call(function () {
-                        _this.transitionComplete();
-                        SceneManager.stage.removeChild(_this._mask);
-                    });
-                });
-                return [2];
-            });
-        });
-    };
-    FadeTransition.prototype.render = function () {
-        this._mask.graphics.clear();
-        this._mask.graphics.beginFill(this.fadeToColor, this._alpha);
-        this._mask.graphics.drawRect(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-        this._mask.graphics.endFill();
-    };
-    return FadeTransition;
-}(SceneTransition));
-var WindTransition = (function (_super) {
-    __extends(WindTransition, _super);
-    function WindTransition(sceneLoadAction) {
-        var _this = _super.call(this, sceneLoadAction) || this;
-        _this.duration = 1;
-        _this.easeType = egret.Ease.quadOut;
-        var vertexSrc = "attribute vec2 aVertexPosition;\n" +
+        return Viewport;
+    }());
+    es.Viewport = Viewport;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var GaussianBlurEffect = (function (_super) {
+        __extends(GaussianBlurEffect, _super);
+        function GaussianBlurEffect() {
+            return _super.call(this, es.PostProcessor.default_vert, GaussianBlurEffect.blur_frag, {
+                screenWidth: es.SceneManager.stage.stageWidth,
+                screenHeight: es.SceneManager.stage.stageHeight
+            }) || this;
+        }
+        GaussianBlurEffect.blur_frag = "precision mediump float;\n" +
+            "uniform sampler2D uSampler;\n" +
+            "uniform float screenWidth;\n" +
+            "uniform float screenHeight;\n" +
+            "float normpdf(in float x, in float sigma)\n" +
+            "{\n" +
+            "return 0.39894*exp(-0.5*x*x/(sigma*sigma))/sigma;\n" +
+            "}\n" +
+            "void main()\n" +
+            "{\n" +
+            "vec3 c = texture2D(uSampler, gl_FragCoord.xy / vec2(screenWidth, screenHeight).xy).rgb;\n" +
+            "const int mSize = 11;\n" +
+            "const int kSize = (mSize - 1)/2;\n" +
+            "float kernel[mSize];\n" +
+            "vec3 final_colour = vec3(0.0);\n" +
+            "float sigma = 7.0;\n" +
+            "float z = 0.0;\n" +
+            "for (int j = 0; j <= kSize; ++j)\n" +
+            "{\n" +
+            "kernel[kSize+j] = kernel[kSize-j] = normpdf(float(j),sigma);\n" +
+            "}\n" +
+            "for (int j = 0; j < mSize; ++j)\n" +
+            "{\n" +
+            "z += kernel[j];\n" +
+            "}\n" +
+            "for (int i = -kSize; i <= kSize; ++i)\n" +
+            "{\n" +
+            "for (int j = -kSize; j <= kSize; ++j)\n" +
+            "{\n" +
+            "final_colour += kernel[kSize+j]*kernel[kSize+i]*texture2D(uSampler, (gl_FragCoord.xy+vec2(float(i),float(j))) / vec2(screenWidth, screenHeight).xy).rgb;\n" +
+            "}\n}\n" +
+            "gl_FragColor = vec4(final_colour/(z*z), 1.0);\n" +
+            "}";
+        return GaussianBlurEffect;
+    }(egret.CustomFilter));
+    es.GaussianBlurEffect = GaussianBlurEffect;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var PolygonLightEffect = (function (_super) {
+        __extends(PolygonLightEffect, _super);
+        function PolygonLightEffect() {
+            return _super.call(this, PolygonLightEffect.vertSrc, PolygonLightEffect.fragmentSrc) || this;
+        }
+        PolygonLightEffect.vertSrc = "attribute vec2 aVertexPosition;\n" +
             "attribute vec2 aTextureCoord;\n" +
             "uniform vec2 projectionVector;\n" +
             "varying vec2 vTextureCoord;\n" +
@@ -3939,1369 +4261,1761 @@ var WindTransition = (function (_super) {
             "   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n" +
             "   vTextureCoord = aTextureCoord;\n" +
             "}";
-        var fragmentSrc = "precision lowp float;\n" +
+        PolygonLightEffect.fragmentSrc = "precision lowp float;\n" +
             "varying vec2 vTextureCoord;\n" +
             "uniform sampler2D uSampler;\n" +
-            "uniform float _progress;\n" +
-            "uniform float _size;\n" +
-            "uniform float _windSegments;\n" +
+            "#define SAMPLE_COUNT 15\n" +
+            "uniform vec2 _sampleOffsets[SAMPLE_COUNT];\n" +
+            "uniform float _sampleWeights[SAMPLE_COUNT];\n" +
             "void main(void) {\n" +
-            "vec2 co = floor(vec2(0.0, vTextureCoord.y * _windSegments));\n" +
-            "float x = sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453;\n" +
-            "float r = x - floor(x);\n" +
-            "float m = smoothstep(0.0, -_size, vTextureCoord.x * (1.0 - _size) + _size * r - (_progress * (1.0 + _size)));\n" +
-            "vec4 fg = texture2D(uSampler, vTextureCoord);\n" +
-            "gl_FragColor = mix(fg, vec4(0, 0, 0, 0), m);\n" +
+            "vec4 c = vec4(0, 0, 0, 0);\n" +
+            "for( int i = 0; i < SAMPLE_COUNT; i++ )\n" +
+            "   c += texture2D( uSampler, vTextureCoord + _sampleOffsets[i] ) * _sampleWeights[i];\n" +
+            "gl_FragColor = c;\n" +
             "}";
-        _this._windEffect = new egret.CustomFilter(vertexSrc, fragmentSrc, {
-            _progress: 0,
-            _size: 0.3,
-            _windSegments: 100
-        });
-        _this._mask = new egret.Shape();
-        _this._mask.graphics.beginFill(0xFFFFFF, 1);
-        _this._mask.graphics.drawRect(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-        _this._mask.graphics.endFill();
-        _this._mask.filters = [_this._windEffect];
-        SceneManager.stage.addChild(_this._mask);
-        return _this;
-    }
-    Object.defineProperty(WindTransition.prototype, "windSegments", {
-        set: function (value) {
-            this._windEffect.uniforms._windSegments = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(WindTransition.prototype, "size", {
-        set: function (value) {
-            this._windEffect.uniforms._size = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    WindTransition.prototype.onBeginTransition = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.loadNextScene();
-                        return [4, this.tickEffectProgressProperty(this._windEffect, this.duration, this.easeType)];
-                    case 1:
-                        _a.sent();
-                        this.transitionComplete();
-                        SceneManager.stage.removeChild(this._mask);
-                        return [2];
-                }
-            });
-        });
-    };
-    return WindTransition;
-}(SceneTransition));
-var Bezier = (function () {
-    function Bezier() {
-    }
-    Bezier.getPoint = function (p0, p1, p2, t) {
-        t = MathHelper.clamp01(t);
-        var oneMinusT = 1 - t;
-        return Vector2.add(Vector2.add(Vector2.multiply(new Vector2(oneMinusT * oneMinusT), p0), Vector2.multiply(new Vector2(2 * oneMinusT * t), p1)), Vector2.multiply(new Vector2(t * t), p2));
-    };
-    Bezier.getFirstDerivative = function (p0, p1, p2, t) {
-        return Vector2.add(Vector2.multiply(new Vector2(2 * (1 - t)), Vector2.subtract(p1, p0)), Vector2.multiply(new Vector2(2 * t), Vector2.subtract(p2, p1)));
-    };
-    Bezier.getFirstDerivativeThree = function (start, firstControlPoint, secondControlPoint, end, t) {
-        t = MathHelper.clamp01(t);
-        var oneMunusT = 1 - t;
-        return Vector2.add(Vector2.add(Vector2.multiply(new Vector2(3 * oneMunusT * oneMunusT), Vector2.subtract(firstControlPoint, start)), Vector2.multiply(new Vector2(6 * oneMunusT * t), Vector2.subtract(secondControlPoint, firstControlPoint))), Vector2.multiply(new Vector2(3 * t * t), Vector2.subtract(end, secondControlPoint)));
-    };
-    Bezier.getPointThree = function (start, firstControlPoint, secondControlPoint, end, t) {
-        t = MathHelper.clamp01(t);
-        var oneMunusT = 1 - t;
-        return Vector2.add(Vector2.add(Vector2.add(Vector2.multiply(new Vector2(oneMunusT * oneMunusT * oneMunusT), start), Vector2.multiply(new Vector2(3 * oneMunusT * oneMunusT * t), firstControlPoint)), Vector2.multiply(new Vector2(3 * oneMunusT * t * t), secondControlPoint)), Vector2.multiply(new Vector2(t * t * t), end));
-    };
-    Bezier.getOptimizedDrawingPoints = function (start, firstCtrlPoint, secondCtrlPoint, end, distanceTolerance) {
-        if (distanceTolerance === void 0) { distanceTolerance = 1; }
-        var points = ListPool.obtain();
-        points.push(start);
-        this.recursiveGetOptimizedDrawingPoints(start, firstCtrlPoint, secondCtrlPoint, end, points, distanceTolerance);
-        points.push(end);
-        return points;
-    };
-    Bezier.recursiveGetOptimizedDrawingPoints = function (start, firstCtrlPoint, secondCtrlPoint, end, points, distanceTolerance) {
-        var pt12 = Vector2.divide(Vector2.add(start, firstCtrlPoint), new Vector2(2));
-        var pt23 = Vector2.divide(Vector2.add(firstCtrlPoint, secondCtrlPoint), new Vector2(2));
-        var pt34 = Vector2.divide(Vector2.add(secondCtrlPoint, end), new Vector2(2));
-        var pt123 = Vector2.divide(Vector2.add(pt12, pt23), new Vector2(2));
-        var pt234 = Vector2.divide(Vector2.add(pt23, pt34), new Vector2(2));
-        var pt1234 = Vector2.divide(Vector2.add(pt123, pt234), new Vector2(2));
-        var deltaLine = Vector2.subtract(end, start);
-        var d2 = Math.abs(((firstCtrlPoint.x, end.x) * deltaLine.y - (firstCtrlPoint.y - end.y) * deltaLine.x));
-        var d3 = Math.abs(((secondCtrlPoint.x - end.x) * deltaLine.y - (secondCtrlPoint.y - end.y) * deltaLine.x));
-        if ((d2 + d3) * (d2 + d3) < distanceTolerance * (deltaLine.x * deltaLine.x + deltaLine.y * deltaLine.y)) {
-            points.push(pt1234);
-            return;
+        return PolygonLightEffect;
+    }(egret.CustomFilter));
+    es.PolygonLightEffect = PolygonLightEffect;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var PostProcessor = (function () {
+        function PostProcessor(effect) {
+            if (effect === void 0) { effect = null; }
+            this.enabled = true;
+            this.effect = effect;
         }
-        this.recursiveGetOptimizedDrawingPoints(start, pt12, pt123, pt1234, points, distanceTolerance);
-        this.recursiveGetOptimizedDrawingPoints(pt1234, pt234, pt34, end, points, distanceTolerance);
-    };
-    return Bezier;
-}());
-var Flags = (function () {
-    function Flags() {
-    }
-    Flags.isFlagSet = function (self, flag) {
-        return (self & flag) != 0;
-    };
-    Flags.isUnshiftedFlagSet = function (self, flag) {
-        flag = 1 << flag;
-        return (self & flag) != 0;
-    };
-    Flags.setFlagExclusive = function (self, flag) {
-        return 1 << flag;
-    };
-    Flags.setFlag = function (self, flag) {
-        return (self | 1 << flag);
-    };
-    Flags.unsetFlag = function (self, flag) {
-        flag = 1 << flag;
-        return (self & (~flag));
-    };
-    Flags.invertFlags = function (self) {
-        return ~self;
-    };
-    return Flags;
-}());
-var MathHelper = (function () {
-    function MathHelper() {
-    }
-    MathHelper.toDegrees = function (radians) {
-        return radians * 57.295779513082320876798154814105;
-    };
-    MathHelper.toRadians = function (degrees) {
-        return degrees * 0.017453292519943295769236907684886;
-    };
-    MathHelper.map = function (value, leftMin, leftMax, rightMin, rightMax) {
-        return rightMin + (value - leftMin) * (rightMax - rightMin) / (leftMax - leftMin);
-    };
-    MathHelper.lerp = function (value1, value2, amount) {
-        return value1 + (value2 - value1) * amount;
-    };
-    MathHelper.clamp = function (value, min, max) {
-        if (value < min)
-            return min;
-        if (value > max)
-            return max;
-        return value;
-    };
-    MathHelper.pointOnCirlce = function (circleCenter, radius, angleInDegrees) {
-        var radians = MathHelper.toRadians(angleInDegrees);
-        return new Vector2(Math.cos(radians) * radians + circleCenter.x, Math.sin(radians) * radians + circleCenter.y);
-    };
-    MathHelper.isEven = function (value) {
-        return value % 2 == 0;
-    };
-    MathHelper.clamp01 = function (value) {
-        if (value < 0)
-            return 0;
-        if (value > 1)
-            return 1;
-        return value;
-    };
-    MathHelper.angleBetweenVectors = function (from, to) {
-        return Math.atan2(to.y - from.y, to.x - from.x);
-    };
-    MathHelper.Epsilon = 0.00001;
-    MathHelper.Rad2Deg = 57.29578;
-    MathHelper.Deg2Rad = 0.0174532924;
-    return MathHelper;
-}());
-var Matrix2D = (function () {
-    function Matrix2D(m11, m12, m21, m22, m31, m32) {
-        this.m11 = 0;
-        this.m12 = 0;
-        this.m21 = 0;
-        this.m22 = 0;
-        this.m31 = 0;
-        this.m32 = 0;
-        this.m11 = m11 ? m11 : 1;
-        this.m12 = m12 ? m12 : 0;
-        this.m21 = m21 ? m21 : 0;
-        this.m22 = m22 ? m22 : 1;
-        this.m31 = m31 ? m31 : 0;
-        this.m32 = m32 ? m32 : 0;
-    }
-    Object.defineProperty(Matrix2D, "identity", {
-        get: function () {
-            return Matrix2D._identity;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Matrix2D.prototype, "translation", {
-        get: function () {
-            return new Vector2(this.m31, this.m32);
-        },
-        set: function (value) {
-            this.m31 = value.x;
-            this.m32 = value.y;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Matrix2D.prototype, "rotation", {
-        get: function () {
-            return Math.atan2(this.m21, this.m11);
-        },
-        set: function (value) {
-            var val1 = Math.cos(value);
-            var val2 = Math.sin(value);
-            this.m11 = val1;
-            this.m12 = val2;
-            this.m21 = -val2;
-            this.m22 = val1;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Matrix2D.prototype, "rotationDegrees", {
-        get: function () {
-            return MathHelper.toDegrees(this.rotation);
-        },
-        set: function (value) {
-            this.rotation = MathHelper.toRadians(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Matrix2D.prototype, "scale", {
-        get: function () {
-            return new Vector2(this.m11, this.m22);
-        },
-        set: function (value) {
-            this.m11 = value.x;
-            this.m12 = value.y;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Matrix2D.add = function (matrix1, matrix2) {
-        matrix1.m11 += matrix2.m11;
-        matrix1.m12 += matrix2.m12;
-        matrix1.m21 += matrix2.m21;
-        matrix1.m22 += matrix2.m22;
-        matrix1.m31 += matrix2.m31;
-        matrix1.m32 += matrix2.m32;
-        return matrix1;
-    };
-    Matrix2D.divide = function (matrix1, matrix2) {
-        matrix1.m11 /= matrix2.m11;
-        matrix1.m12 /= matrix2.m12;
-        matrix1.m21 /= matrix2.m21;
-        matrix1.m22 /= matrix2.m22;
-        matrix1.m31 /= matrix2.m31;
-        matrix1.m32 /= matrix2.m32;
-        return matrix1;
-    };
-    Matrix2D.multiply = function (matrix1, matrix2) {
-        var result = new Matrix2D();
-        var m11 = (matrix1.m11 * matrix2.m11) + (matrix1.m12 * matrix2.m21);
-        var m12 = (matrix1.m11 * matrix2.m12) + (matrix1.m12 * matrix2.m22);
-        var m21 = (matrix1.m21 * matrix2.m11) + (matrix1.m22 * matrix2.m21);
-        var m22 = (matrix1.m21 * matrix2.m12) + (matrix1.m22 * matrix2.m22);
-        var m31 = (matrix1.m31 * matrix2.m11) + (matrix1.m32 * matrix2.m21) + matrix2.m31;
-        var m32 = (matrix1.m31 * matrix2.m12) + (matrix1.m32 * matrix2.m22) + matrix2.m32;
-        result.m11 = m11;
-        result.m12 = m12;
-        result.m21 = m21;
-        result.m22 = m22;
-        result.m31 = m31;
-        result.m32 = m32;
-        return result;
-    };
-    Matrix2D.multiplyTranslation = function (matrix, x, y) {
-        var trans = Matrix2D.createTranslation(x, y);
-        return Matrix2D.multiply(matrix, trans);
-    };
-    Matrix2D.prototype.determinant = function () {
-        return this.m11 * this.m22 - this.m12 * this.m21;
-    };
-    Matrix2D.invert = function (matrix, result) {
-        if (result === void 0) { result = new Matrix2D(); }
-        var det = 1 / matrix.determinant();
-        result.m11 = matrix.m22 * det;
-        result.m12 = -matrix.m12 * det;
-        result.m21 = -matrix.m21 * det;
-        result.m22 = matrix.m11 * det;
-        result.m31 = (matrix.m32 * matrix.m21 - matrix.m31 * matrix.m22) * det;
-        result.m32 = -(matrix.m32 * matrix.m11 - matrix.m31 * matrix.m12) * det;
-        return result;
-    };
-    Matrix2D.createTranslation = function (xPosition, yPosition) {
-        var result = new Matrix2D();
-        result.m11 = 1;
-        result.m12 = 0;
-        result.m21 = 0;
-        result.m22 = 1;
-        result.m31 = xPosition;
-        result.m32 = yPosition;
-        return result;
-    };
-    Matrix2D.createTranslationVector = function (position) {
-        return this.createTranslation(position.x, position.y);
-    };
-    Matrix2D.createRotation = function (radians, result) {
-        result = new Matrix2D();
-        var val1 = Math.cos(radians);
-        var val2 = Math.sin(radians);
-        result.m11 = val1;
-        result.m12 = val2;
-        result.m21 = -val2;
-        result.m22 = val1;
-        return result;
-    };
-    Matrix2D.createScale = function (xScale, yScale, result) {
-        if (result === void 0) { result = new Matrix2D(); }
-        result.m11 = xScale;
-        result.m12 = 0;
-        result.m21 = 0;
-        result.m22 = yScale;
-        result.m31 = 0;
-        result.m32 = 0;
-        return result;
-    };
-    Matrix2D.prototype.toEgretMatrix = function () {
-        var matrix = new egret.Matrix(this.m11, this.m12, this.m21, this.m22, this.m31, this.m32);
-        return matrix;
-    };
-    Matrix2D._identity = new Matrix2D(1, 0, 0, 1, 0, 0);
-    return Matrix2D;
-}());
-var Rectangle = (function (_super) {
-    __extends(Rectangle, _super);
-    function Rectangle() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Object.defineProperty(Rectangle.prototype, "max", {
-        get: function () {
-            return new Vector2(this.right, this.bottom);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Rectangle.prototype, "center", {
-        get: function () {
-            return new Vector2(this.x + (this.width / 2), this.y + (this.height / 2));
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Rectangle.prototype, "location", {
-        get: function () {
-            return new Vector2(this.x, this.y);
-        },
-        set: function (value) {
-            this.x = value.x;
-            this.y = value.y;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Rectangle.prototype, "size", {
-        get: function () {
-            return new Vector2(this.width, this.height);
-        },
-        set: function (value) {
-            this.width = value.x;
-            this.height = value.y;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Rectangle.prototype.intersects = function (value) {
-        return value.left < this.right &&
-            this.left < value.right &&
-            value.top < this.bottom &&
-            this.top < value.bottom;
-    };
-    Rectangle.prototype.containsRect = function (value) {
-        return ((((this.x <= value.x) && (value.x < (this.x + this.width))) &&
-            (this.y <= value.y)) &&
-            (value.y < (this.y + this.height)));
-    };
-    Rectangle.prototype.getHalfSize = function () {
-        return new Vector2(this.width * 0.5, this.height * 0.5);
-    };
-    Rectangle.fromMinMax = function (minX, minY, maxX, maxY) {
-        return new Rectangle(minX, minY, maxX - minX, maxY - minY);
-    };
-    Rectangle.prototype.getClosestPointOnRectangleBorderToPoint = function (point) {
-        var edgeNormal = Vector2.zero;
-        var res = new Vector2();
-        res.x = MathHelper.clamp(point.x, this.left, this.right);
-        res.y = MathHelper.clamp(point.y, this.top, this.bottom);
-        if (this.contains(res.x, res.y)) {
-            var dl = res.x - this.left;
-            var dr = this.right - res.x;
-            var dt = res.y - this.top;
-            var db = this.bottom - res.y;
-            var min = Math.min(dl, dr, dt, db);
-            if (min == dt) {
-                res.y = this.top;
-                edgeNormal.y = -1;
-            }
-            else if (min == db) {
-                res.y = this.bottom;
-                edgeNormal.y = 1;
-            }
-            else if (min == dl) {
-                res.x = this.left;
-                edgeNormal.x = -1;
-            }
-            else {
-                res.x = this.right;
-                edgeNormal.x = 1;
-            }
-        }
-        else {
-            if (res.x == this.left)
-                edgeNormal.x = -1;
-            if (res.x == this.right)
-                edgeNormal.x = 1;
-            if (res.y == this.top)
-                edgeNormal.y = -1;
-            if (res.y == this.bottom)
-                edgeNormal.y = 1;
-        }
-        return { res: res, edgeNormal: edgeNormal };
-    };
-    Rectangle.prototype.getClosestPointOnBoundsToOrigin = function () {
-        var max = this.max;
-        var minDist = Math.abs(this.location.x);
-        var boundsPoint = new Vector2(this.location.x, 0);
-        if (Math.abs(max.x) < minDist) {
-            minDist = Math.abs(max.x);
-            boundsPoint.x = max.x;
-            boundsPoint.y = 0;
-        }
-        if (Math.abs(max.y) < minDist) {
-            minDist = Math.abs(max.y);
-            boundsPoint.x = 0;
-            boundsPoint.y = max.y;
-        }
-        if (Math.abs(this.location.y) < minDist) {
-            minDist = Math.abs(this.location.y);
-            boundsPoint.x = 0;
-            boundsPoint.y = this.location.y;
-        }
-        return boundsPoint;
-    };
-    Rectangle.prototype.setEgretRect = function (rect) {
-        this.x = rect.x;
-        this.y = rect.y;
-        this.width = rect.width;
-        this.height = rect.height;
-        return this;
-    };
-    Rectangle.rectEncompassingPoints = function (points) {
-        var minX = Number.POSITIVE_INFINITY;
-        var minY = Number.POSITIVE_INFINITY;
-        var maxX = Number.NEGATIVE_INFINITY;
-        var maxY = Number.NEGATIVE_INFINITY;
-        for (var i = 0; i < points.length; i++) {
-            var pt = points[i];
-            if (pt.x < minX)
-                minX = pt.x;
-            if (pt.x > maxX)
-                maxX = pt.x;
-            if (pt.y < minY)
-                minY = pt.y;
-            if (pt.y > maxY)
-                maxY = pt.y;
-        }
-        return this.fromMinMax(minX, minY, maxX, maxY);
-    };
-    return Rectangle;
-}(egret.Rectangle));
-var Vector3 = (function () {
-    function Vector3(x, y, z) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-    }
-    return Vector3;
-}());
-var ColliderTriggerHelper = (function () {
-    function ColliderTriggerHelper(entity) {
-        this._activeTriggerIntersections = [];
-        this._previousTriggerIntersections = [];
-        this._tempTriggerList = [];
-        this._entity = entity;
-    }
-    ColliderTriggerHelper.prototype.update = function () {
-        var colliders = this._entity.getComponents(Collider);
-        for (var i = 0; i < colliders.length; i++) {
-            var collider = colliders[i];
-            var boxcastResult = Physics.boxcastBroadphase(collider.bounds, collider.collidesWithLayers);
-            collider.bounds = boxcastResult.rect;
-            var neighbors = boxcastResult.colliders;
-            var _loop_5 = function (j) {
-                var neighbor = neighbors[j];
-                if (!collider.isTrigger && !neighbor.isTrigger)
-                    return "continue";
-                if (collider.overlaps(neighbor)) {
-                    var pair_1 = new Pair(collider, neighbor);
-                    var shouldReportTriggerEvent = this_1._activeTriggerIntersections.findIndex(function (value) {
-                        return value.first == pair_1.first && value.second == pair_1.second;
-                    }) == -1 && this_1._previousTriggerIntersections.findIndex(function (value) {
-                        return value.first == pair_1.first && value.second == pair_1.second;
-                    }) == -1;
-                    if (shouldReportTriggerEvent)
-                        this_1.notifyTriggerListeners(pair_1, true);
-                    if (!this_1._activeTriggerIntersections.contains(pair_1))
-                        this_1._activeTriggerIntersections.push(pair_1);
-                }
-            };
-            var this_1 = this;
-            for (var j = 0; j < neighbors.length; j++) {
-                _loop_5(j);
-            }
-        }
-        ListPool.free(colliders);
-        this.checkForExitedColliders();
-    };
-    ColliderTriggerHelper.prototype.checkForExitedColliders = function () {
-        var _this = this;
-        var _loop_6 = function (i) {
-            var index = this_2._previousTriggerIntersections.findIndex(function (value) {
-                if (value.first == _this._activeTriggerIntersections[i].first && value.second == _this._activeTriggerIntersections[i].second)
-                    return true;
-                return false;
-            });
-            if (index != -1)
-                this_2._previousTriggerIntersections.removeAt(index);
+        PostProcessor.prototype.onAddedToScene = function (scene) {
+            this.scene = scene;
+            this.shape = new egret.Shape();
+            this.shape.graphics.beginFill(0xFFFFFF, 1);
+            this.shape.graphics.drawRect(0, 0, es.SceneManager.stage.stageWidth, es.SceneManager.stage.stageHeight);
+            this.shape.graphics.endFill();
+            scene.addChild(this.shape);
         };
-        var this_2 = this;
-        for (var i = 0; i < this._activeTriggerIntersections.length; i++) {
-            _loop_6(i);
-        }
-        for (var i = 0; i < this._previousTriggerIntersections.length; i++) {
-            this.notifyTriggerListeners(this._previousTriggerIntersections[i], false);
-        }
-        this._previousTriggerIntersections.length = 0;
-        for (var i = 0; i < this._activeTriggerIntersections.length; i++) {
-            if (!this._previousTriggerIntersections.contains(this._activeTriggerIntersections[i])) {
-                this._previousTriggerIntersections.push(this._activeTriggerIntersections[i]);
+        PostProcessor.prototype.process = function () {
+            this.drawFullscreenQuad();
+        };
+        PostProcessor.prototype.onSceneBackBufferSizeChanged = function (newWidth, newHeight) { };
+        PostProcessor.prototype.drawFullscreenQuad = function () {
+            this.scene.filters = [this.effect];
+        };
+        PostProcessor.prototype.unload = function () {
+            if (this.effect) {
+                this.effect = null;
             }
+            this.scene.removeChild(this.shape);
+            this.scene = null;
+        };
+        PostProcessor.default_vert = "attribute vec2 aVertexPosition;\n" +
+            "attribute vec2 aTextureCoord;\n" +
+            "attribute vec2 aColor;\n" +
+            "uniform vec2 projectionVector;\n" +
+            "varying vec2 vTextureCoord;\n" +
+            "varying vec4 vColor;\n" +
+            "const vec2 center = vec2(-1.0, 1.0);\n" +
+            "void main(void) {\n" +
+            "gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n" +
+            "vTextureCoord = aTextureCoord;\n" +
+            "vColor = vec4(aColor.x, aColor.x, aColor.x, aColor.x);\n" +
+            "}";
+        return PostProcessor;
+    }());
+    es.PostProcessor = PostProcessor;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var GaussianBlurPostProcessor = (function (_super) {
+        __extends(GaussianBlurPostProcessor, _super);
+        function GaussianBlurPostProcessor() {
+            return _super !== null && _super.apply(this, arguments) || this;
         }
-        this._activeTriggerIntersections.length = 0;
-    };
-    ColliderTriggerHelper.prototype.notifyTriggerListeners = function (collisionPair, isEntering) {
-        collisionPair.first.entity.getComponents("ITriggerListener", this._tempTriggerList);
-        for (var i = 0; i < this._tempTriggerList.length; i++) {
-            if (isEntering) {
-                this._tempTriggerList[i].onTriggerEnter(collisionPair.second, collisionPair.first);
+        GaussianBlurPostProcessor.prototype.onAddedToScene = function (scene) {
+            _super.prototype.onAddedToScene.call(this, scene);
+            this.effect = new es.GaussianBlurEffect();
+        };
+        return GaussianBlurPostProcessor;
+    }(es.PostProcessor));
+    es.GaussianBlurPostProcessor = GaussianBlurPostProcessor;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Renderer = (function () {
+        function Renderer() {
+        }
+        Renderer.prototype.onAddedToScene = function (scene) { };
+        Renderer.prototype.beginRender = function (cam) {
+        };
+        Renderer.prototype.unload = function () { };
+        Renderer.prototype.renderAfterStateCheck = function (renderable, cam) {
+            renderable.render(cam);
+        };
+        return Renderer;
+    }());
+    es.Renderer = Renderer;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var DefaultRenderer = (function (_super) {
+        __extends(DefaultRenderer, _super);
+        function DefaultRenderer() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        DefaultRenderer.prototype.render = function (scene) {
+            var cam = this.camera ? this.camera : scene.camera;
+            this.beginRender(cam);
+            for (var i = 0; i < scene.renderableComponents.count; i++) {
+                var renderable = scene.renderableComponents.buffer[i];
+                if (renderable.enabled && renderable.isVisibleFromCamera(cam))
+                    this.renderAfterStateCheck(renderable, cam);
+            }
+        };
+        return DefaultRenderer;
+    }(es.Renderer));
+    es.DefaultRenderer = DefaultRenderer;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var ScreenSpaceRenderer = (function (_super) {
+        __extends(ScreenSpaceRenderer, _super);
+        function ScreenSpaceRenderer() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        ScreenSpaceRenderer.prototype.render = function (scene) {
+        };
+        return ScreenSpaceRenderer;
+    }(es.Renderer));
+    es.ScreenSpaceRenderer = ScreenSpaceRenderer;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var PolyLight = (function (_super) {
+        __extends(PolyLight, _super);
+        function PolyLight(radius, color, power) {
+            var _this = _super.call(this) || this;
+            _this._indices = [];
+            _this.radius = radius;
+            _this.power = power;
+            _this.color = color;
+            _this.computeTriangleIndices();
+            return _this;
+        }
+        Object.defineProperty(PolyLight.prototype, "radius", {
+            get: function () {
+                return this._radius;
+            },
+            set: function (value) {
+                this.setRadius(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        PolyLight.prototype.computeTriangleIndices = function (totalTris) {
+            if (totalTris === void 0) { totalTris = 20; }
+            this._indices.length = 0;
+            for (var i = 0; i < totalTris; i += 2) {
+                this._indices.push(0);
+                this._indices.push(i + 2);
+                this._indices.push(i + 1);
+            }
+        };
+        PolyLight.prototype.setRadius = function (radius) {
+            if (radius != this._radius) {
+                this._radius = radius;
+                this._areBoundsDirty = true;
+            }
+        };
+        PolyLight.prototype.render = function (camera) {
+        };
+        PolyLight.prototype.reset = function () {
+        };
+        return PolyLight;
+    }(es.RenderableComponent));
+    es.PolyLight = PolyLight;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var SceneTransition = (function () {
+        function SceneTransition(sceneLoadAction) {
+            this.sceneLoadAction = sceneLoadAction;
+            this.loadsNewScene = sceneLoadAction != null;
+        }
+        Object.defineProperty(SceneTransition.prototype, "hasPreviousSceneRender", {
+            get: function () {
+                if (!this._hasPreviousSceneRender) {
+                    this._hasPreviousSceneRender = true;
+                    return false;
+                }
+                return true;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        SceneTransition.prototype.preRender = function () { };
+        SceneTransition.prototype.render = function () {
+        };
+        SceneTransition.prototype.onBeginTransition = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4, this.loadNextScene()];
+                        case 1:
+                            _a.sent();
+                            this.transitionComplete();
+                            return [2];
+                    }
+                });
+            });
+        };
+        SceneTransition.prototype.transitionComplete = function () {
+            es.SceneManager.sceneTransition = null;
+            if (this.onTransitionCompleted) {
+                this.onTransitionCompleted();
+            }
+        };
+        SceneTransition.prototype.loadNextScene = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            if (this.onScreenObscured)
+                                this.onScreenObscured();
+                            if (!this.loadsNewScene) {
+                                this.isNewSceneLoaded = true;
+                            }
+                            _a = es.SceneManager;
+                            return [4, this.sceneLoadAction()];
+                        case 1:
+                            _a.scene = _b.sent();
+                            this.isNewSceneLoaded = true;
+                            return [2];
+                    }
+                });
+            });
+        };
+        SceneTransition.prototype.tickEffectProgressProperty = function (filter, duration, easeType, reverseDirection) {
+            if (reverseDirection === void 0) { reverseDirection = false; }
+            return new Promise(function (resolve) {
+                var start = reverseDirection ? 1 : 0;
+                var end = reverseDirection ? 0 : 1;
+                egret.Tween.get(filter.uniforms).set({ _progress: start }).to({ _progress: end }, duration * 1000, easeType).call(function () {
+                    resolve();
+                });
+            });
+        };
+        return SceneTransition;
+    }());
+    es.SceneTransition = SceneTransition;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var FadeTransition = (function (_super) {
+        __extends(FadeTransition, _super);
+        function FadeTransition(sceneLoadAction) {
+            var _this = _super.call(this, sceneLoadAction) || this;
+            _this.fadeToColor = 0x000000;
+            _this.fadeOutDuration = 0.4;
+            _this.fadeEaseType = egret.Ease.quadInOut;
+            _this.delayBeforeFadeInDuration = 0.1;
+            _this._alpha = 0;
+            _this._mask = new egret.Shape();
+            return _this;
+        }
+        FadeTransition.prototype.onBeginTransition = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var _this = this;
+                return __generator(this, function (_a) {
+                    this._mask.graphics.beginFill(this.fadeToColor, 1);
+                    this._mask.graphics.drawRect(0, 0, es.SceneManager.stage.stageWidth, es.SceneManager.stage.stageHeight);
+                    this._mask.graphics.endFill();
+                    es.SceneManager.stage.addChild(this._mask);
+                    egret.Tween.get(this).to({ _alpha: 1 }, this.fadeOutDuration * 1000, this.fadeEaseType)
+                        .call(function () { return __awaiter(_this, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4, this.loadNextScene()];
+                                case 1:
+                                    _a.sent();
+                                    return [2];
+                            }
+                        });
+                    }); }).wait(this.delayBeforeFadeInDuration).call(function () {
+                        egret.Tween.get(_this).to({ _alpha: 0 }, _this.fadeOutDuration * 1000, _this.fadeEaseType).call(function () {
+                            _this.transitionComplete();
+                            es.SceneManager.stage.removeChild(_this._mask);
+                        });
+                    });
+                    return [2];
+                });
+            });
+        };
+        FadeTransition.prototype.render = function () {
+            this._mask.graphics.clear();
+            this._mask.graphics.beginFill(this.fadeToColor, this._alpha);
+            this._mask.graphics.drawRect(0, 0, es.SceneManager.stage.stageWidth, es.SceneManager.stage.stageHeight);
+            this._mask.graphics.endFill();
+        };
+        return FadeTransition;
+    }(es.SceneTransition));
+    es.FadeTransition = FadeTransition;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var WindTransition = (function (_super) {
+        __extends(WindTransition, _super);
+        function WindTransition(sceneLoadAction) {
+            var _this = _super.call(this, sceneLoadAction) || this;
+            _this.duration = 1;
+            _this.easeType = egret.Ease.quadOut;
+            var vertexSrc = "attribute vec2 aVertexPosition;\n" +
+                "attribute vec2 aTextureCoord;\n" +
+                "uniform vec2 projectionVector;\n" +
+                "varying vec2 vTextureCoord;\n" +
+                "const vec2 center = vec2(-1.0, 1.0);\n" +
+                "void main(void) {\n" +
+                "   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n" +
+                "   vTextureCoord = aTextureCoord;\n" +
+                "}";
+            var fragmentSrc = "precision lowp float;\n" +
+                "varying vec2 vTextureCoord;\n" +
+                "uniform sampler2D uSampler;\n" +
+                "uniform float _progress;\n" +
+                "uniform float _size;\n" +
+                "uniform float _windSegments;\n" +
+                "void main(void) {\n" +
+                "vec2 co = floor(vec2(0.0, vTextureCoord.y * _windSegments));\n" +
+                "float x = sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453;\n" +
+                "float r = x - floor(x);\n" +
+                "float m = smoothstep(0.0, -_size, vTextureCoord.x * (1.0 - _size) + _size * r - (_progress * (1.0 + _size)));\n" +
+                "vec4 fg = texture2D(uSampler, vTextureCoord);\n" +
+                "gl_FragColor = mix(fg, vec4(0, 0, 0, 0), m);\n" +
+                "}";
+            _this._windEffect = new egret.CustomFilter(vertexSrc, fragmentSrc, {
+                _progress: 0,
+                _size: 0.3,
+                _windSegments: 100
+            });
+            _this._mask = new egret.Shape();
+            _this._mask.graphics.beginFill(0xFFFFFF, 1);
+            _this._mask.graphics.drawRect(0, 0, es.SceneManager.stage.stageWidth, es.SceneManager.stage.stageHeight);
+            _this._mask.graphics.endFill();
+            _this._mask.filters = [_this._windEffect];
+            es.SceneManager.stage.addChild(_this._mask);
+            return _this;
+        }
+        Object.defineProperty(WindTransition.prototype, "windSegments", {
+            set: function (value) {
+                this._windEffect.uniforms._windSegments = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(WindTransition.prototype, "size", {
+            set: function (value) {
+                this._windEffect.uniforms._size = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        WindTransition.prototype.onBeginTransition = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            this.loadNextScene();
+                            return [4, this.tickEffectProgressProperty(this._windEffect, this.duration, this.easeType)];
+                        case 1:
+                            _a.sent();
+                            this.transitionComplete();
+                            es.SceneManager.stage.removeChild(this._mask);
+                            return [2];
+                    }
+                });
+            });
+        };
+        return WindTransition;
+    }(es.SceneTransition));
+    es.WindTransition = WindTransition;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Bezier = (function () {
+        function Bezier() {
+        }
+        Bezier.getPoint = function (p0, p1, p2, t) {
+            t = es.MathHelper.clamp01(t);
+            var oneMinusT = 1 - t;
+            return es.Vector2.add(es.Vector2.add(es.Vector2.multiply(new es.Vector2(oneMinusT * oneMinusT), p0), es.Vector2.multiply(new es.Vector2(2 * oneMinusT * t), p1)), es.Vector2.multiply(new es.Vector2(t * t), p2));
+        };
+        Bezier.getFirstDerivative = function (p0, p1, p2, t) {
+            return es.Vector2.add(es.Vector2.multiply(new es.Vector2(2 * (1 - t)), es.Vector2.subtract(p1, p0)), es.Vector2.multiply(new es.Vector2(2 * t), es.Vector2.subtract(p2, p1)));
+        };
+        Bezier.getFirstDerivativeThree = function (start, firstControlPoint, secondControlPoint, end, t) {
+            t = es.MathHelper.clamp01(t);
+            var oneMunusT = 1 - t;
+            return es.Vector2.add(es.Vector2.add(es.Vector2.multiply(new es.Vector2(3 * oneMunusT * oneMunusT), es.Vector2.subtract(firstControlPoint, start)), es.Vector2.multiply(new es.Vector2(6 * oneMunusT * t), es.Vector2.subtract(secondControlPoint, firstControlPoint))), es.Vector2.multiply(new es.Vector2(3 * t * t), es.Vector2.subtract(end, secondControlPoint)));
+        };
+        Bezier.getPointThree = function (start, firstControlPoint, secondControlPoint, end, t) {
+            t = es.MathHelper.clamp01(t);
+            var oneMunusT = 1 - t;
+            return es.Vector2.add(es.Vector2.add(es.Vector2.add(es.Vector2.multiply(new es.Vector2(oneMunusT * oneMunusT * oneMunusT), start), es.Vector2.multiply(new es.Vector2(3 * oneMunusT * oneMunusT * t), firstControlPoint)), es.Vector2.multiply(new es.Vector2(3 * oneMunusT * t * t), secondControlPoint)), es.Vector2.multiply(new es.Vector2(t * t * t), end));
+        };
+        Bezier.getOptimizedDrawingPoints = function (start, firstCtrlPoint, secondCtrlPoint, end, distanceTolerance) {
+            if (distanceTolerance === void 0) { distanceTolerance = 1; }
+            var points = es.ListPool.obtain();
+            points.push(start);
+            this.recursiveGetOptimizedDrawingPoints(start, firstCtrlPoint, secondCtrlPoint, end, points, distanceTolerance);
+            points.push(end);
+            return points;
+        };
+        Bezier.recursiveGetOptimizedDrawingPoints = function (start, firstCtrlPoint, secondCtrlPoint, end, points, distanceTolerance) {
+            var pt12 = es.Vector2.divide(es.Vector2.add(start, firstCtrlPoint), new es.Vector2(2));
+            var pt23 = es.Vector2.divide(es.Vector2.add(firstCtrlPoint, secondCtrlPoint), new es.Vector2(2));
+            var pt34 = es.Vector2.divide(es.Vector2.add(secondCtrlPoint, end), new es.Vector2(2));
+            var pt123 = es.Vector2.divide(es.Vector2.add(pt12, pt23), new es.Vector2(2));
+            var pt234 = es.Vector2.divide(es.Vector2.add(pt23, pt34), new es.Vector2(2));
+            var pt1234 = es.Vector2.divide(es.Vector2.add(pt123, pt234), new es.Vector2(2));
+            var deltaLine = es.Vector2.subtract(end, start);
+            var d2 = Math.abs(((firstCtrlPoint.x, end.x) * deltaLine.y - (firstCtrlPoint.y - end.y) * deltaLine.x));
+            var d3 = Math.abs(((secondCtrlPoint.x - end.x) * deltaLine.y - (secondCtrlPoint.y - end.y) * deltaLine.x));
+            if ((d2 + d3) * (d2 + d3) < distanceTolerance * (deltaLine.x * deltaLine.x + deltaLine.y * deltaLine.y)) {
+                points.push(pt1234);
+                return;
+            }
+            this.recursiveGetOptimizedDrawingPoints(start, pt12, pt123, pt1234, points, distanceTolerance);
+            this.recursiveGetOptimizedDrawingPoints(pt1234, pt234, pt34, end, points, distanceTolerance);
+        };
+        return Bezier;
+    }());
+    es.Bezier = Bezier;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Flags = (function () {
+        function Flags() {
+        }
+        Flags.isFlagSet = function (self, flag) {
+            return (self & flag) != 0;
+        };
+        Flags.isUnshiftedFlagSet = function (self, flag) {
+            flag = 1 << flag;
+            return (self & flag) != 0;
+        };
+        Flags.setFlagExclusive = function (self, flag) {
+            return 1 << flag;
+        };
+        Flags.setFlag = function (self, flag) {
+            return (self | 1 << flag);
+        };
+        Flags.unsetFlag = function (self, flag) {
+            flag = 1 << flag;
+            return (self & (~flag));
+        };
+        Flags.invertFlags = function (self) {
+            return ~self;
+        };
+        return Flags;
+    }());
+    es.Flags = Flags;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var MathHelper = (function () {
+        function MathHelper() {
+        }
+        MathHelper.toDegrees = function (radians) {
+            return radians * 57.295779513082320876798154814105;
+        };
+        MathHelper.toRadians = function (degrees) {
+            return degrees * 0.017453292519943295769236907684886;
+        };
+        MathHelper.map = function (value, leftMin, leftMax, rightMin, rightMax) {
+            return rightMin + (value - leftMin) * (rightMax - rightMin) / (leftMax - leftMin);
+        };
+        MathHelper.lerp = function (value1, value2, amount) {
+            return value1 + (value2 - value1) * amount;
+        };
+        MathHelper.clamp = function (value, min, max) {
+            if (value < min)
+                return min;
+            if (value > max)
+                return max;
+            return value;
+        };
+        MathHelper.pointOnCirlce = function (circleCenter, radius, angleInDegrees) {
+            var radians = MathHelper.toRadians(angleInDegrees);
+            return new es.Vector2(Math.cos(radians) * radians + circleCenter.x, Math.sin(radians) * radians + circleCenter.y);
+        };
+        MathHelper.isEven = function (value) {
+            return value % 2 == 0;
+        };
+        MathHelper.clamp01 = function (value) {
+            if (value < 0)
+                return 0;
+            if (value > 1)
+                return 1;
+            return value;
+        };
+        MathHelper.angleBetweenVectors = function (from, to) {
+            return Math.atan2(to.y - from.y, to.x - from.x);
+        };
+        MathHelper.Epsilon = 0.00001;
+        MathHelper.Rad2Deg = 57.29578;
+        MathHelper.Deg2Rad = 0.0174532924;
+        return MathHelper;
+    }());
+    es.MathHelper = MathHelper;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Matrix2D = (function () {
+        function Matrix2D(m11, m12, m21, m22, m31, m32) {
+            this.m11 = 0;
+            this.m12 = 0;
+            this.m21 = 0;
+            this.m22 = 0;
+            this.m31 = 0;
+            this.m32 = 0;
+            this.m11 = m11 ? m11 : 1;
+            this.m12 = m12 ? m12 : 0;
+            this.m21 = m21 ? m21 : 0;
+            this.m22 = m22 ? m22 : 1;
+            this.m31 = m31 ? m31 : 0;
+            this.m32 = m32 ? m32 : 0;
+        }
+        Object.defineProperty(Matrix2D, "identity", {
+            get: function () {
+                return Matrix2D._identity;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Matrix2D.prototype, "translation", {
+            get: function () {
+                return new es.Vector2(this.m31, this.m32);
+            },
+            set: function (value) {
+                this.m31 = value.x;
+                this.m32 = value.y;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Matrix2D.prototype, "rotation", {
+            get: function () {
+                return Math.atan2(this.m21, this.m11);
+            },
+            set: function (value) {
+                var val1 = Math.cos(value);
+                var val2 = Math.sin(value);
+                this.m11 = val1;
+                this.m12 = val2;
+                this.m21 = -val2;
+                this.m22 = val1;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Matrix2D.prototype, "rotationDegrees", {
+            get: function () {
+                return es.MathHelper.toDegrees(this.rotation);
+            },
+            set: function (value) {
+                this.rotation = es.MathHelper.toRadians(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Matrix2D.prototype, "scale", {
+            get: function () {
+                return new es.Vector2(this.m11, this.m22);
+            },
+            set: function (value) {
+                this.m11 = value.x;
+                this.m12 = value.y;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Matrix2D.add = function (matrix1, matrix2) {
+            matrix1.m11 += matrix2.m11;
+            matrix1.m12 += matrix2.m12;
+            matrix1.m21 += matrix2.m21;
+            matrix1.m22 += matrix2.m22;
+            matrix1.m31 += matrix2.m31;
+            matrix1.m32 += matrix2.m32;
+            return matrix1;
+        };
+        Matrix2D.divide = function (matrix1, matrix2) {
+            matrix1.m11 /= matrix2.m11;
+            matrix1.m12 /= matrix2.m12;
+            matrix1.m21 /= matrix2.m21;
+            matrix1.m22 /= matrix2.m22;
+            matrix1.m31 /= matrix2.m31;
+            matrix1.m32 /= matrix2.m32;
+            return matrix1;
+        };
+        Matrix2D.multiply = function (matrix1, matrix2) {
+            var result = new Matrix2D();
+            var m11 = (matrix1.m11 * matrix2.m11) + (matrix1.m12 * matrix2.m21);
+            var m12 = (matrix1.m11 * matrix2.m12) + (matrix1.m12 * matrix2.m22);
+            var m21 = (matrix1.m21 * matrix2.m11) + (matrix1.m22 * matrix2.m21);
+            var m22 = (matrix1.m21 * matrix2.m12) + (matrix1.m22 * matrix2.m22);
+            var m31 = (matrix1.m31 * matrix2.m11) + (matrix1.m32 * matrix2.m21) + matrix2.m31;
+            var m32 = (matrix1.m31 * matrix2.m12) + (matrix1.m32 * matrix2.m22) + matrix2.m32;
+            result.m11 = m11;
+            result.m12 = m12;
+            result.m21 = m21;
+            result.m22 = m22;
+            result.m31 = m31;
+            result.m32 = m32;
+            return result;
+        };
+        Matrix2D.multiplyTranslation = function (matrix, x, y) {
+            var trans = Matrix2D.createTranslation(x, y);
+            return Matrix2D.multiply(matrix, trans);
+        };
+        Matrix2D.prototype.determinant = function () {
+            return this.m11 * this.m22 - this.m12 * this.m21;
+        };
+        Matrix2D.invert = function (matrix, result) {
+            if (result === void 0) { result = new Matrix2D(); }
+            var det = 1 / matrix.determinant();
+            result.m11 = matrix.m22 * det;
+            result.m12 = -matrix.m12 * det;
+            result.m21 = -matrix.m21 * det;
+            result.m22 = matrix.m11 * det;
+            result.m31 = (matrix.m32 * matrix.m21 - matrix.m31 * matrix.m22) * det;
+            result.m32 = -(matrix.m32 * matrix.m11 - matrix.m31 * matrix.m12) * det;
+            return result;
+        };
+        Matrix2D.createTranslation = function (xPosition, yPosition) {
+            var result = new Matrix2D();
+            result.m11 = 1;
+            result.m12 = 0;
+            result.m21 = 0;
+            result.m22 = 1;
+            result.m31 = xPosition;
+            result.m32 = yPosition;
+            return result;
+        };
+        Matrix2D.createTranslationVector = function (position) {
+            return this.createTranslation(position.x, position.y);
+        };
+        Matrix2D.createRotation = function (radians, result) {
+            result = new Matrix2D();
+            var val1 = Math.cos(radians);
+            var val2 = Math.sin(radians);
+            result.m11 = val1;
+            result.m12 = val2;
+            result.m21 = -val2;
+            result.m22 = val1;
+            return result;
+        };
+        Matrix2D.createScale = function (xScale, yScale, result) {
+            if (result === void 0) { result = new Matrix2D(); }
+            result.m11 = xScale;
+            result.m12 = 0;
+            result.m21 = 0;
+            result.m22 = yScale;
+            result.m31 = 0;
+            result.m32 = 0;
+            return result;
+        };
+        Matrix2D.prototype.toEgretMatrix = function () {
+            var matrix = new egret.Matrix(this.m11, this.m12, this.m21, this.m22, this.m31, this.m32);
+            return matrix;
+        };
+        Matrix2D._identity = new Matrix2D(1, 0, 0, 1, 0, 0);
+        return Matrix2D;
+    }());
+    es.Matrix2D = Matrix2D;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Rectangle = (function (_super) {
+        __extends(Rectangle, _super);
+        function Rectangle() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        Object.defineProperty(Rectangle.prototype, "max", {
+            get: function () {
+                return new es.Vector2(this.right, this.bottom);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Rectangle.prototype, "center", {
+            get: function () {
+                return new es.Vector2(this.x + (this.width / 2), this.y + (this.height / 2));
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Rectangle.prototype, "location", {
+            get: function () {
+                return new es.Vector2(this.x, this.y);
+            },
+            set: function (value) {
+                this.x = value.x;
+                this.y = value.y;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Rectangle.prototype, "size", {
+            get: function () {
+                return new es.Vector2(this.width, this.height);
+            },
+            set: function (value) {
+                this.width = value.x;
+                this.height = value.y;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Rectangle.prototype.intersects = function (value) {
+            return value.left < this.right &&
+                this.left < value.right &&
+                value.top < this.bottom &&
+                this.top < value.bottom;
+        };
+        Rectangle.prototype.containsRect = function (value) {
+            return ((((this.x <= value.x) && (value.x < (this.x + this.width))) &&
+                (this.y <= value.y)) &&
+                (value.y < (this.y + this.height)));
+        };
+        Rectangle.prototype.getHalfSize = function () {
+            return new es.Vector2(this.width * 0.5, this.height * 0.5);
+        };
+        Rectangle.fromMinMax = function (minX, minY, maxX, maxY) {
+            return new Rectangle(minX, minY, maxX - minX, maxY - minY);
+        };
+        Rectangle.prototype.getClosestPointOnRectangleBorderToPoint = function (point) {
+            var edgeNormal = es.Vector2.zero;
+            var res = new es.Vector2();
+            res.x = es.MathHelper.clamp(point.x, this.left, this.right);
+            res.y = es.MathHelper.clamp(point.y, this.top, this.bottom);
+            if (this.contains(res.x, res.y)) {
+                var dl = res.x - this.left;
+                var dr = this.right - res.x;
+                var dt = res.y - this.top;
+                var db = this.bottom - res.y;
+                var min = Math.min(dl, dr, dt, db);
+                if (min == dt) {
+                    res.y = this.top;
+                    edgeNormal.y = -1;
+                }
+                else if (min == db) {
+                    res.y = this.bottom;
+                    edgeNormal.y = 1;
+                }
+                else if (min == dl) {
+                    res.x = this.left;
+                    edgeNormal.x = -1;
+                }
+                else {
+                    res.x = this.right;
+                    edgeNormal.x = 1;
+                }
             }
             else {
-                this._tempTriggerList[i].onTriggerExit(collisionPair.second, collisionPair.first);
+                if (res.x == this.left)
+                    edgeNormal.x = -1;
+                if (res.x == this.right)
+                    edgeNormal.x = 1;
+                if (res.y == this.top)
+                    edgeNormal.y = -1;
+                if (res.y == this.bottom)
+                    edgeNormal.y = 1;
             }
-            this._tempTriggerList.length = 0;
-            if (collisionPair.second.entity) {
-                collisionPair.second.entity.getComponents("ITriggerListener", this._tempTriggerList);
-                for (var i_2 = 0; i_2 < this._tempTriggerList.length; i_2++) {
-                    if (isEntering) {
-                        this._tempTriggerList[i_2].onTriggerEnter(collisionPair.first, collisionPair.second);
-                    }
-                    else {
-                        this._tempTriggerList[i_2].onTriggerExit(collisionPair.first, collisionPair.second);
+            return { res: res, edgeNormal: edgeNormal };
+        };
+        Rectangle.prototype.getClosestPointOnBoundsToOrigin = function () {
+            var max = this.max;
+            var minDist = Math.abs(this.location.x);
+            var boundsPoint = new es.Vector2(this.location.x, 0);
+            if (Math.abs(max.x) < minDist) {
+                minDist = Math.abs(max.x);
+                boundsPoint.x = max.x;
+                boundsPoint.y = 0;
+            }
+            if (Math.abs(max.y) < minDist) {
+                minDist = Math.abs(max.y);
+                boundsPoint.x = 0;
+                boundsPoint.y = max.y;
+            }
+            if (Math.abs(this.location.y) < minDist) {
+                minDist = Math.abs(this.location.y);
+                boundsPoint.x = 0;
+                boundsPoint.y = this.location.y;
+            }
+            return boundsPoint;
+        };
+        Rectangle.prototype.calculateBounds = function (parentPosition, position, origin, scale, rotation, width, height) {
+            this.x = parentPosition.x + position.x - origin.x * scale.x;
+            this.y = parentPosition.y + position.y - origin.y * scale.y;
+            this.width = width * scale.x;
+            this.height = height * scale.y;
+        };
+        Rectangle.prototype.setEgretRect = function (rect) {
+            this.x = rect.x;
+            this.y = rect.y;
+            this.width = rect.width;
+            this.height = rect.height;
+            return this;
+        };
+        Rectangle.rectEncompassingPoints = function (points) {
+            var minX = Number.POSITIVE_INFINITY;
+            var minY = Number.POSITIVE_INFINITY;
+            var maxX = Number.NEGATIVE_INFINITY;
+            var maxY = Number.NEGATIVE_INFINITY;
+            for (var i = 0; i < points.length; i++) {
+                var pt = points[i];
+                if (pt.x < minX)
+                    minX = pt.x;
+                if (pt.x > maxX)
+                    maxX = pt.x;
+                if (pt.y < minY)
+                    minY = pt.y;
+                if (pt.y > maxY)
+                    maxY = pt.y;
+            }
+            return this.fromMinMax(minX, minY, maxX, maxY);
+        };
+        return Rectangle;
+    }(egret.Rectangle));
+    es.Rectangle = Rectangle;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Vector3 = (function () {
+        function Vector3(x, y, z) {
+            this.x = x;
+            this.y = y;
+            this.z = z;
+        }
+        return Vector3;
+    }());
+    es.Vector3 = Vector3;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var ColliderTriggerHelper = (function () {
+        function ColliderTriggerHelper(entity) {
+            this._activeTriggerIntersections = [];
+            this._previousTriggerIntersections = [];
+            this._tempTriggerList = [];
+            this._entity = entity;
+        }
+        ColliderTriggerHelper.prototype.update = function () {
+            var colliders = this._entity.getComponents(es.Collider);
+            for (var i = 0; i < colliders.length; i++) {
+                var collider = colliders[i];
+                var boxcastResult = es.Physics.boxcastBroadphase(collider.bounds, collider.collidesWithLayers);
+                collider.bounds = boxcastResult.rect;
+                var neighbors = boxcastResult.colliders;
+                var _loop_5 = function (j) {
+                    var neighbor = neighbors[j];
+                    if (!collider.isTrigger && !neighbor.isTrigger)
+                        return "continue";
+                    if (collider.overlaps(neighbor)) {
+                        var pair_1 = new es.Pair(collider, neighbor);
+                        var shouldReportTriggerEvent = this_1._activeTriggerIntersections.findIndex(function (value) {
+                            return value.first == pair_1.first && value.second == pair_1.second;
+                        }) == -1 && this_1._previousTriggerIntersections.findIndex(function (value) {
+                            return value.first == pair_1.first && value.second == pair_1.second;
+                        }) == -1;
+                        if (shouldReportTriggerEvent)
+                            this_1.notifyTriggerListeners(pair_1, true);
+                        if (!this_1._activeTriggerIntersections.contains(pair_1))
+                            this_1._activeTriggerIntersections.push(pair_1);
                     }
+                };
+                var this_1 = this;
+                for (var j = 0; j < neighbors.length; j++) {
+                    _loop_5(j);
+                }
+            }
+            es.ListPool.free(colliders);
+            this.checkForExitedColliders();
+        };
+        ColliderTriggerHelper.prototype.checkForExitedColliders = function () {
+            var _this = this;
+            var _loop_6 = function (i) {
+                var index = this_2._previousTriggerIntersections.findIndex(function (value) {
+                    if (value.first == _this._activeTriggerIntersections[i].first && value.second == _this._activeTriggerIntersections[i].second)
+                        return true;
+                    return false;
+                });
+                if (index != -1)
+                    this_2._previousTriggerIntersections.removeAt(index);
+            };
+            var this_2 = this;
+            for (var i = 0; i < this._activeTriggerIntersections.length; i++) {
+                _loop_6(i);
+            }
+            for (var i = 0; i < this._previousTriggerIntersections.length; i++) {
+                this.notifyTriggerListeners(this._previousTriggerIntersections[i], false);
+            }
+            this._previousTriggerIntersections.length = 0;
+            for (var i = 0; i < this._activeTriggerIntersections.length; i++) {
+                if (!this._previousTriggerIntersections.contains(this._activeTriggerIntersections[i])) {
+                    this._previousTriggerIntersections.push(this._activeTriggerIntersections[i]);
+                }
+            }
+            this._activeTriggerIntersections.length = 0;
+        };
+        ColliderTriggerHelper.prototype.notifyTriggerListeners = function (collisionPair, isEntering) {
+            collisionPair.first.entity.getComponents("ITriggerListener", this._tempTriggerList);
+            for (var i = 0; i < this._tempTriggerList.length; i++) {
+                if (isEntering) {
+                    this._tempTriggerList[i].onTriggerEnter(collisionPair.second, collisionPair.first);
+                }
+                else {
+                    this._tempTriggerList[i].onTriggerExit(collisionPair.second, collisionPair.first);
                 }
                 this._tempTriggerList.length = 0;
+                if (collisionPair.second.entity) {
+                    collisionPair.second.entity.getComponents("ITriggerListener", this._tempTriggerList);
+                    for (var i_2 = 0; i_2 < this._tempTriggerList.length; i_2++) {
+                        if (isEntering) {
+                            this._tempTriggerList[i_2].onTriggerEnter(collisionPair.first, collisionPair.second);
+                        }
+                        else {
+                            this._tempTriggerList[i_2].onTriggerExit(collisionPair.first, collisionPair.second);
+                        }
+                    }
+                    this._tempTriggerList.length = 0;
+                }
             }
+        };
+        return ColliderTriggerHelper;
+    }());
+    es.ColliderTriggerHelper = ColliderTriggerHelper;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var PointSectors;
+    (function (PointSectors) {
+        PointSectors[PointSectors["center"] = 0] = "center";
+        PointSectors[PointSectors["top"] = 1] = "top";
+        PointSectors[PointSectors["bottom"] = 2] = "bottom";
+        PointSectors[PointSectors["topLeft"] = 9] = "topLeft";
+        PointSectors[PointSectors["topRight"] = 5] = "topRight";
+        PointSectors[PointSectors["left"] = 8] = "left";
+        PointSectors[PointSectors["right"] = 4] = "right";
+        PointSectors[PointSectors["bottomLeft"] = 10] = "bottomLeft";
+        PointSectors[PointSectors["bottomRight"] = 6] = "bottomRight";
+    })(PointSectors = es.PointSectors || (es.PointSectors = {}));
+    var Collisions = (function () {
+        function Collisions() {
         }
-    };
-    return ColliderTriggerHelper;
-}());
-var PointSectors;
-(function (PointSectors) {
-    PointSectors[PointSectors["center"] = 0] = "center";
-    PointSectors[PointSectors["top"] = 1] = "top";
-    PointSectors[PointSectors["bottom"] = 2] = "bottom";
-    PointSectors[PointSectors["topLeft"] = 9] = "topLeft";
-    PointSectors[PointSectors["topRight"] = 5] = "topRight";
-    PointSectors[PointSectors["left"] = 8] = "left";
-    PointSectors[PointSectors["right"] = 4] = "right";
-    PointSectors[PointSectors["bottomLeft"] = 10] = "bottomLeft";
-    PointSectors[PointSectors["bottomRight"] = 6] = "bottomRight";
-})(PointSectors || (PointSectors = {}));
-var Collisions = (function () {
-    function Collisions() {
-    }
-    Collisions.isLineToLine = function (a1, a2, b1, b2) {
-        var b = Vector2.subtract(a2, a1);
-        var d = Vector2.subtract(b2, b1);
-        var bDotDPerp = b.x * d.y - b.y * d.x;
-        if (bDotDPerp == 0)
-            return false;
-        var c = Vector2.subtract(b1, a1);
-        var t = (c.x * d.y - c.y * d.x) / bDotDPerp;
-        if (t < 0 || t > 1)
-            return false;
-        var u = (c.x * b.y - c.y * b.x) / bDotDPerp;
-        if (u < 0 || u > 1)
-            return false;
-        return true;
-    };
-    Collisions.lineToLineIntersection = function (a1, a2, b1, b2) {
-        var intersection = new Vector2(0, 0);
-        var b = Vector2.subtract(a2, a1);
-        var d = Vector2.subtract(b2, b1);
-        var bDotDPerp = b.x * d.y - b.y * d.x;
-        if (bDotDPerp == 0)
-            return intersection;
-        var c = Vector2.subtract(b1, a1);
-        var t = (c.x * d.y - c.y * d.x) / bDotDPerp;
-        if (t < 0 || t > 1)
-            return intersection;
-        var u = (c.x * b.y - c.y * b.x) / bDotDPerp;
-        if (u < 0 || u > 1)
-            return intersection;
-        intersection = Vector2.add(a1, new Vector2(t * b.x, t * b.y));
-        return intersection;
-    };
-    Collisions.closestPointOnLine = function (lineA, lineB, closestTo) {
-        var v = Vector2.subtract(lineB, lineA);
-        var w = Vector2.subtract(closestTo, lineA);
-        var t = Vector2.dot(w, v) / Vector2.dot(v, v);
-        t = MathHelper.clamp(t, 0, 1);
-        return Vector2.add(lineA, new Vector2(v.x * t, v.y * t));
-    };
-    Collisions.isCircleToCircle = function (circleCenter1, circleRadius1, circleCenter2, circleRadius2) {
-        return Vector2.distanceSquared(circleCenter1, circleCenter2) < (circleRadius1 + circleRadius2) * (circleRadius1 + circleRadius2);
-    };
-    Collisions.isCircleToLine = function (circleCenter, radius, lineFrom, lineTo) {
-        return Vector2.distanceSquared(circleCenter, this.closestPointOnLine(lineFrom, lineTo, circleCenter)) < radius * radius;
-    };
-    Collisions.isCircleToPoint = function (circleCenter, radius, point) {
-        return Vector2.distanceSquared(circleCenter, point) < radius * radius;
-    };
-    Collisions.isRectToCircle = function (rect, cPosition, cRadius) {
-        var ew = rect.width * 0.5;
-        var eh = rect.height * 0.5;
-        var vx = Math.max(0, Math.max(cPosition.x - rect.x) - ew);
-        var vy = Math.max(0, Math.max(cPosition.y - rect.y) - eh);
-        return vx * vx + vy * vy < cRadius * cRadius;
-    };
-    Collisions.isRectToLine = function (rect, lineFrom, lineTo) {
-        var fromSector = this.getSector(rect.x, rect.y, rect.width, rect.height, lineFrom);
-        var toSector = this.getSector(rect.x, rect.y, rect.width, rect.height, lineTo);
-        if (fromSector == PointSectors.center || toSector == PointSectors.center) {
+        Collisions.isLineToLine = function (a1, a2, b1, b2) {
+            var b = es.Vector2.subtract(a2, a1);
+            var d = es.Vector2.subtract(b2, b1);
+            var bDotDPerp = b.x * d.y - b.y * d.x;
+            if (bDotDPerp == 0)
+                return false;
+            var c = es.Vector2.subtract(b1, a1);
+            var t = (c.x * d.y - c.y * d.x) / bDotDPerp;
+            if (t < 0 || t > 1)
+                return false;
+            var u = (c.x * b.y - c.y * b.x) / bDotDPerp;
+            if (u < 0 || u > 1)
+                return false;
             return true;
-        }
-        else if ((fromSector & toSector) != 0) {
+        };
+        Collisions.lineToLineIntersection = function (a1, a2, b1, b2) {
+            var intersection = new es.Vector2(0, 0);
+            var b = es.Vector2.subtract(a2, a1);
+            var d = es.Vector2.subtract(b2, b1);
+            var bDotDPerp = b.x * d.y - b.y * d.x;
+            if (bDotDPerp == 0)
+                return intersection;
+            var c = es.Vector2.subtract(b1, a1);
+            var t = (c.x * d.y - c.y * d.x) / bDotDPerp;
+            if (t < 0 || t > 1)
+                return intersection;
+            var u = (c.x * b.y - c.y * b.x) / bDotDPerp;
+            if (u < 0 || u > 1)
+                return intersection;
+            intersection = es.Vector2.add(a1, new es.Vector2(t * b.x, t * b.y));
+            return intersection;
+        };
+        Collisions.closestPointOnLine = function (lineA, lineB, closestTo) {
+            var v = es.Vector2.subtract(lineB, lineA);
+            var w = es.Vector2.subtract(closestTo, lineA);
+            var t = es.Vector2.dot(w, v) / es.Vector2.dot(v, v);
+            t = es.MathHelper.clamp(t, 0, 1);
+            return es.Vector2.add(lineA, new es.Vector2(v.x * t, v.y * t));
+        };
+        Collisions.isCircleToCircle = function (circleCenter1, circleRadius1, circleCenter2, circleRadius2) {
+            return es.Vector2.distanceSquared(circleCenter1, circleCenter2) < (circleRadius1 + circleRadius2) * (circleRadius1 + circleRadius2);
+        };
+        Collisions.isCircleToLine = function (circleCenter, radius, lineFrom, lineTo) {
+            return es.Vector2.distanceSquared(circleCenter, this.closestPointOnLine(lineFrom, lineTo, circleCenter)) < radius * radius;
+        };
+        Collisions.isCircleToPoint = function (circleCenter, radius, point) {
+            return es.Vector2.distanceSquared(circleCenter, point) < radius * radius;
+        };
+        Collisions.isRectToCircle = function (rect, cPosition, cRadius) {
+            var ew = rect.width * 0.5;
+            var eh = rect.height * 0.5;
+            var vx = Math.max(0, Math.max(cPosition.x - rect.x) - ew);
+            var vy = Math.max(0, Math.max(cPosition.y - rect.y) - eh);
+            return vx * vx + vy * vy < cRadius * cRadius;
+        };
+        Collisions.isRectToLine = function (rect, lineFrom, lineTo) {
+            var fromSector = this.getSector(rect.x, rect.y, rect.width, rect.height, lineFrom);
+            var toSector = this.getSector(rect.x, rect.y, rect.width, rect.height, lineTo);
+            if (fromSector == PointSectors.center || toSector == PointSectors.center) {
+                return true;
+            }
+            else if ((fromSector & toSector) != 0) {
+                return false;
+            }
+            else {
+                var both = fromSector | toSector;
+                var edgeFrom = void 0;
+                var edgeTo = void 0;
+                if ((both & PointSectors.top) != 0) {
+                    edgeFrom = new es.Vector2(rect.x, rect.y);
+                    edgeTo = new es.Vector2(rect.x + rect.width, rect.y);
+                    if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
+                        return true;
+                }
+                if ((both & PointSectors.bottom) != 0) {
+                    edgeFrom = new es.Vector2(rect.x, rect.y + rect.height);
+                    edgeTo = new es.Vector2(rect.x + rect.width, rect.y + rect.height);
+                    if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
+                        return true;
+                }
+                if ((both & PointSectors.left) != 0) {
+                    edgeFrom = new es.Vector2(rect.x, rect.y);
+                    edgeTo = new es.Vector2(rect.x, rect.y + rect.height);
+                    if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
+                        return true;
+                }
+                if ((both & PointSectors.right) != 0) {
+                    edgeFrom = new es.Vector2(rect.x + rect.width, rect.y);
+                    edgeTo = new es.Vector2(rect.x + rect.width, rect.y + rect.height);
+                    if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
+                        return true;
+                }
+            }
             return false;
+        };
+        Collisions.isRectToPoint = function (rX, rY, rW, rH, point) {
+            return point.x >= rX && point.y >= rY && point.x < rX + rW && point.y < rY + rH;
+        };
+        Collisions.getSector = function (rX, rY, rW, rH, point) {
+            var sector = PointSectors.center;
+            if (point.x < rX)
+                sector |= PointSectors.left;
+            else if (point.x >= rX + rW)
+                sector |= PointSectors.right;
+            if (point.y < rY)
+                sector |= PointSectors.top;
+            else if (point.y >= rY + rH)
+                sector |= PointSectors.bottom;
+            return sector;
+        };
+        return Collisions;
+    }());
+    es.Collisions = Collisions;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Physics = (function () {
+        function Physics() {
         }
-        else {
-            var both = fromSector | toSector;
-            var edgeFrom = void 0;
-            var edgeTo = void 0;
-            if ((both & PointSectors.top) != 0) {
-                edgeFrom = new Vector2(rect.x, rect.y);
-                edgeTo = new Vector2(rect.x + rect.width, rect.y);
-                if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
-                    return true;
+        Physics.reset = function () {
+            this._spatialHash = new es.SpatialHash(this.spatialHashCellSize);
+        };
+        Physics.clear = function () {
+            this._spatialHash.clear();
+        };
+        Physics.overlapCircleAll = function (center, randius, results, layerMask) {
+            if (layerMask === void 0) { layerMask = -1; }
+            return this._spatialHash.overlapCircle(center, randius, results, layerMask);
+        };
+        Physics.boxcastBroadphase = function (rect, layerMask) {
+            if (layerMask === void 0) { layerMask = this.allLayers; }
+            var boxcastResult = this._spatialHash.aabbBroadphase(rect, null, layerMask);
+            return { colliders: boxcastResult.tempHashSet, rect: boxcastResult.bounds };
+        };
+        Physics.boxcastBroadphaseExcludingSelf = function (collider, rect, layerMask) {
+            if (layerMask === void 0) { layerMask = this.allLayers; }
+            return this._spatialHash.aabbBroadphase(rect, collider, layerMask);
+        };
+        Physics.addCollider = function (collider) {
+            Physics._spatialHash.register(collider);
+        };
+        Physics.removeCollider = function (collider) {
+            Physics._spatialHash.remove(collider);
+        };
+        Physics.updateCollider = function (collider) {
+            this._spatialHash.remove(collider);
+            this._spatialHash.register(collider);
+        };
+        Physics.debugDraw = function (secondsToDisplay) {
+            this._spatialHash.debugDraw(secondsToDisplay, 2);
+        };
+        Physics.spatialHashCellSize = 100;
+        Physics.allLayers = -1;
+        return Physics;
+    }());
+    es.Physics = Physics;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Shape = (function () {
+        function Shape() {
+        }
+        return Shape;
+    }());
+    es.Shape = Shape;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Polygon = (function (_super) {
+        __extends(Polygon, _super);
+        function Polygon(points, isBox) {
+            var _this = _super.call(this) || this;
+            _this._areEdgeNormalsDirty = true;
+            _this.isUnrotated = true;
+            _this.setPoints(points);
+            _this.isBox = isBox;
+            return _this;
+        }
+        Object.defineProperty(Polygon.prototype, "edgeNormals", {
+            get: function () {
+                if (this._areEdgeNormalsDirty)
+                    this.buildEdgeNormals();
+                return this._edgeNormals;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Polygon.prototype.setPoints = function (points) {
+            this.points = points;
+            this.recalculateCenterAndEdgeNormals();
+            this._originalPoints = [];
+            for (var i = 0; i < this.points.length; i++) {
+                this._originalPoints.push(this.points[i]);
             }
-            if ((both & PointSectors.bottom) != 0) {
-                edgeFrom = new Vector2(rect.x, rect.y + rect.height);
-                edgeTo = new Vector2(rect.x + rect.width, rect.y + rect.height);
-                if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
-                    return true;
+        };
+        Polygon.prototype.recalculateCenterAndEdgeNormals = function () {
+            this._polygonCenter = Polygon.findPolygonCenter(this.points);
+            this._areEdgeNormalsDirty = true;
+        };
+        Polygon.prototype.buildEdgeNormals = function () {
+            var totalEdges = this.isBox ? 2 : this.points.length;
+            if (this._edgeNormals == null || this._edgeNormals.length != totalEdges)
+                this._edgeNormals = new Array(totalEdges);
+            var p2;
+            for (var i = 0; i < totalEdges; i++) {
+                var p1 = this.points[i];
+                if (i + 1 >= this.points.length)
+                    p2 = this.points[0];
+                else
+                    p2 = this.points[i + 1];
+                var perp = es.Vector2Ext.perpendicular(p1, p2);
+                perp = es.Vector2.normalize(perp);
+                this._edgeNormals[i] = perp;
             }
-            if ((both & PointSectors.left) != 0) {
-                edgeFrom = new Vector2(rect.x, rect.y);
-                edgeTo = new Vector2(rect.x, rect.y + rect.height);
-                if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
-                    return true;
+        };
+        Polygon.buildSymmetricalPolygon = function (vertCount, radius) {
+            var verts = new Array(vertCount);
+            for (var i = 0; i < vertCount; i++) {
+                var a = 2 * Math.PI * (i / vertCount);
+                verts[i] = new es.Vector2(Math.cos(a), Math.sin(a) * radius);
             }
-            if ((both & PointSectors.right) != 0) {
-                edgeFrom = new Vector2(rect.x + rect.width, rect.y);
-                edgeTo = new Vector2(rect.x + rect.width, rect.y + rect.height);
-                if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
-                    return true;
+            return verts;
+        };
+        Polygon.recenterPolygonVerts = function (points) {
+            var center = this.findPolygonCenter(points);
+            for (var i = 0; i < points.length; i++)
+                points[i] = es.Vector2.subtract(points[i], center);
+        };
+        Polygon.findPolygonCenter = function (points) {
+            var x = 0, y = 0;
+            for (var i = 0; i < points.length; i++) {
+                x += points[i].x;
+                y += points[i].y;
             }
+            return new es.Vector2(x / points.length, y / points.length);
+        };
+        Polygon.getClosestPointOnPolygonToPoint = function (points, point) {
+            var distanceSquared = Number.MAX_VALUE;
+            var edgeNormal = new es.Vector2(0, 0);
+            var closestPoint = new es.Vector2(0, 0);
+            var tempDistanceSquared;
+            for (var i = 0; i < points.length; i++) {
+                var j = i + 1;
+                if (j == points.length)
+                    j = 0;
+                var closest = es.ShapeCollisions.closestPointOnLine(points[i], points[j], point);
+                tempDistanceSquared = es.Vector2.distanceSquared(point, closest);
+                if (tempDistanceSquared < distanceSquared) {
+                    distanceSquared = tempDistanceSquared;
+                    closestPoint = closest;
+                    var line = es.Vector2.subtract(points[j], points[i]);
+                    edgeNormal.x = -line.y;
+                    edgeNormal.y = line.x;
+                }
+            }
+            edgeNormal = es.Vector2.normalize(edgeNormal);
+            return { closestPoint: closestPoint, distanceSquared: distanceSquared, edgeNormal: edgeNormal };
+        };
+        Polygon.prototype.recalculateBounds = function (collider) {
+            this.center = collider.localOffset;
+            if (collider.shouldColliderScaleAndRotateWithTransform) {
+                this.isUnrotated = collider.entity.transform.rotation == 0;
+            }
+            this.position = es.Vector2.add(collider.entity.transform.position, this.center);
+            this.bounds = es.Rectangle.rectEncompassingPoints(this.points);
+            this.bounds.location = es.Vector2.add(this.bounds.location, this.position);
+        };
+        Polygon.prototype.overlaps = function (other) {
+            var result;
+            if (other instanceof Polygon)
+                return es.ShapeCollisions.polygonToPolygon(this, other);
+            if (other instanceof es.Circle) {
+                result = es.ShapeCollisions.circleToPolygon(other, this);
+                if (result) {
+                    result.invertResult();
+                    return true;
+                }
+                return false;
+            }
+            throw new Error("overlaps of Pologon to " + other + " are not supported");
+        };
+        Polygon.prototype.collidesWithShape = function (other) {
+            var result = new es.CollisionResult();
+            if (other instanceof Polygon) {
+                return es.ShapeCollisions.polygonToPolygon(this, other);
+            }
+            if (other instanceof es.Circle) {
+                result = es.ShapeCollisions.circleToPolygon(other, this);
+                if (result) {
+                    result.invertResult();
+                    return result;
+                }
+                return null;
+            }
+            throw new Error("overlaps of Polygon to " + other + " are not supported");
+        };
+        Polygon.prototype.containsPoint = function (point) {
+            point = es.Vector2.subtract(point, this.position);
+            var isInside = false;
+            for (var i = 0, j = this.points.length - 1; i < this.points.length; j = i++) {
+                if (((this.points[i].y > point.y) != (this.points[j].y > point.y)) &&
+                    (point.x < (this.points[j].x - this.points[i].x) * (point.y - this.points[i].y) / (this.points[j].y - this.points[i].y) +
+                        this.points[i].x)) {
+                    isInside = !isInside;
+                }
+            }
+            return isInside;
+        };
+        Polygon.prototype.pointCollidesWithShape = function (point) {
+            return es.ShapeCollisions.pointToPoly(point, this);
+        };
+        return Polygon;
+    }(es.Shape));
+    es.Polygon = Polygon;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Box = (function (_super) {
+        __extends(Box, _super);
+        function Box(width, height) {
+            var _this = _super.call(this, Box.buildBox(width, height), true) || this;
+            _this.width = width;
+            _this.height = height;
+            return _this;
         }
-        return false;
-    };
-    Collisions.isRectToPoint = function (rX, rY, rW, rH, point) {
-        return point.x >= rX && point.y >= rY && point.x < rX + rW && point.y < rY + rH;
-    };
-    Collisions.getSector = function (rX, rY, rW, rH, point) {
-        var sector = PointSectors.center;
-        if (point.x < rX)
-            sector |= PointSectors.left;
-        else if (point.x >= rX + rW)
-            sector |= PointSectors.right;
-        if (point.y < rY)
-            sector |= PointSectors.top;
-        else if (point.y >= rY + rH)
-            sector |= PointSectors.bottom;
-        return sector;
-    };
-    return Collisions;
-}());
-var Physics = (function () {
-    function Physics() {
-    }
-    Physics.reset = function () {
-        this._spatialHash = new SpatialHash(this.spatialHashCellSize);
-    };
-    Physics.clear = function () {
-        this._spatialHash.clear();
-    };
-    Physics.overlapCircleAll = function (center, randius, results, layerMask) {
-        if (layerMask === void 0) { layerMask = -1; }
-        return this._spatialHash.overlapCircle(center, randius, results, layerMask);
-    };
-    Physics.boxcastBroadphase = function (rect, layerMask) {
-        if (layerMask === void 0) { layerMask = this.allLayers; }
-        var boxcastResult = this._spatialHash.aabbBroadphase(rect, null, layerMask);
-        return { colliders: boxcastResult.tempHashSet, rect: boxcastResult.bounds };
-    };
-    Physics.boxcastBroadphaseExcludingSelf = function (collider, rect, layerMask) {
-        if (layerMask === void 0) { layerMask = this.allLayers; }
-        return this._spatialHash.aabbBroadphase(rect, collider, layerMask);
-    };
-    Physics.addCollider = function (collider) {
-        Physics._spatialHash.register(collider);
-    };
-    Physics.removeCollider = function (collider) {
-        Physics._spatialHash.remove(collider);
-    };
-    Physics.updateCollider = function (collider) {
-        this._spatialHash.remove(collider);
-        this._spatialHash.register(collider);
-    };
-    Physics.debugDraw = function (secondsToDisplay) {
-        this._spatialHash.debugDraw(secondsToDisplay, 2);
-    };
-    Physics.spatialHashCellSize = 100;
-    Physics.allLayers = -1;
-    return Physics;
-}());
-var Shape = (function (_super) {
-    __extends(Shape, _super);
-    function Shape() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return Shape;
-}(egret.DisplayObject));
-var Polygon = (function (_super) {
-    __extends(Polygon, _super);
-    function Polygon(points, isBox) {
-        var _this = _super.call(this) || this;
-        _this._areEdgeNormalsDirty = true;
-        _this.center = new Vector2();
-        _this.setPoints(points);
-        _this.isBox = isBox;
-        return _this;
-    }
-    Object.defineProperty(Polygon.prototype, "position", {
-        get: function () {
-            return new Vector2(this.parent.x, this.parent.y);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Polygon.prototype, "bounds", {
-        get: function () {
-            return new Rectangle(this.x, this.y, this.width, this.height);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Polygon.prototype, "edgeNormals", {
-        get: function () {
-            if (this._areEdgeNormalsDirty)
-                this.buildEdgeNormals();
-            return this._edgeNormals;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Polygon.prototype.buildEdgeNormals = function () {
-        var totalEdges = this.isBox ? 2 : this.points.length;
-        if (this._edgeNormals == null || this._edgeNormals.length != totalEdges)
-            this._edgeNormals = new Array(totalEdges);
-        var p2;
-        for (var i = 0; i < totalEdges; i++) {
-            var p1 = this.points[i];
-            if (i + 1 >= this.points.length)
-                p2 = this.points[0];
-            else
-                p2 = this.points[i + 1];
-            var perp = Vector2Ext.perpendicular(p1, p2);
-            perp = Vector2.normalize(perp);
-            this._edgeNormals[i] = perp;
+        Box.buildBox = function (width, height) {
+            var halfWidth = width / 2;
+            var halfHeight = height / 2;
+            var verts = new Array(4);
+            verts[0] = new es.Vector2(-halfWidth, -halfHeight);
+            verts[1] = new es.Vector2(halfWidth, -halfHeight);
+            verts[2] = new es.Vector2(halfWidth, halfHeight);
+            verts[3] = new es.Vector2(-halfWidth, halfHeight);
+            return verts;
+        };
+        Box.prototype.updateBox = function (width, height) {
+            this.width = width;
+            this.height = height;
+            var halfWidth = width / 2;
+            var halfHeight = height / 2;
+            this.points[0] = new es.Vector2(-halfWidth, -halfHeight);
+            this.points[1] = new es.Vector2(halfWidth, -halfHeight);
+            this.points[2] = new es.Vector2(halfWidth, halfHeight);
+            this.points[3] = new es.Vector2(-halfWidth, halfHeight);
+            for (var i = 0; i < this.points.length; i++)
+                this._originalPoints[i] = this.points[i];
+        };
+        Box.prototype.overlaps = function (other) {
+            if (this.isUnrotated) {
+                if (other instanceof Box)
+                    return this.bounds.intersects(other.bounds);
+                if (other instanceof es.Circle)
+                    return es.Collisions.isRectToCircle(this.bounds, other.position, other.radius);
+            }
+            return _super.prototype.overlaps.call(this, other);
+        };
+        Box.prototype.collidesWithShape = function (other) {
+            if (other instanceof Box && other.isUnrotated) {
+                return es.ShapeCollisions.boxToBox(this, other);
+            }
+            return _super.prototype.collidesWithShape.call(this, other);
+        };
+        Box.prototype.containsPoint = function (point) {
+            if (this.isUnrotated)
+                return this.bounds.contains(point.x, point.y);
+            return _super.prototype.containsPoint.call(this, point);
+        };
+        return Box;
+    }(es.Polygon));
+    es.Box = Box;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Circle = (function (_super) {
+        __extends(Circle, _super);
+        function Circle(radius) {
+            var _this = _super.call(this) || this;
+            _this.radius = radius;
+            _this._originalRadius = radius;
+            return _this;
         }
-    };
-    Polygon.prototype.setPoints = function (points) {
-        this.points = points;
-        this.recalculateCenterAndEdgeNormals();
-        this._originalPoints = [];
-        for (var i = 0; i < this.points.length; i++) {
-            this._originalPoints.push(this.points[i]);
+        Circle.prototype.recalculateBounds = function (collider) {
+            this.center = collider.localOffset;
+            if (collider.shouldColliderScaleAndRotateWithTransform) {
+                var scale = collider.entity.transform.scale;
+                var hasUnitScale = scale.x == 1 && scale.y == 1;
+                var maxScale = Math.max(scale.x, scale.y);
+                this.radius = this._originalRadius * maxScale;
+                if (collider.entity.transform.rotation != 0) {
+                    var offsetAngle = Math.atan2(collider.localOffset.y, collider.localOffset.x) * es.MathHelper.Rad2Deg;
+                    var offsetLength = hasUnitScale ? collider._localOffsetLength : es.Vector2.multiply(collider.localOffset, collider.entity.transform.scale).length();
+                    this.center = es.MathHelper.pointOnCirlce(es.Vector2.zero, offsetLength, collider.entity.transform.rotation + offsetAngle);
+                }
+            }
+            this.position = es.Vector2.add(collider.transform.position, this.center);
+            this.bounds = new es.Rectangle(this.position.x - this.radius, this.position.y - this.radius, this.radius * 2, this.radius * 2);
+        };
+        Circle.prototype.overlaps = function (other) {
+            if (other instanceof es.Box && other.isUnrotated)
+                return es.Collisions.isRectToCircle(other.bounds, this.position, this.radius);
+            if (other instanceof Circle)
+                return es.Collisions.isCircleToCircle(this.position, this.radius, other.position, other.radius);
+            if (other instanceof es.Polygon)
+                return es.ShapeCollisions.circleToPolygon(this, other);
+            throw new Error("overlaps of circle to " + other + " are not supported");
+        };
+        Circle.prototype.collidesWithShape = function (other) {
+            if (other instanceof es.Box && other.isUnrotated) {
+                return es.ShapeCollisions.circleToBox(this, other);
+            }
+            if (other instanceof Circle) {
+                return es.ShapeCollisions.circleToCircle(this, other);
+            }
+            if (other instanceof es.Polygon) {
+                return es.ShapeCollisions.circleToPolygon(this, other);
+            }
+            throw new Error("Collisions of Circle to " + other + " are not supported");
+        };
+        Circle.prototype.pointCollidesWithShape = function (point) {
+            return es.ShapeCollisions.pointToCircle(point, this);
+        };
+        return Circle;
+    }(es.Shape));
+    es.Circle = Circle;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var CollisionResult = (function () {
+        function CollisionResult() {
+            this.minimumTranslationVector = es.Vector2.zero;
+            this.normal = es.Vector2.zero;
+            this.point = es.Vector2.zero;
         }
-    };
-    Polygon.prototype.collidesWithShape = function (other) {
-        var result = new CollisionResult();
-        if (other instanceof Polygon) {
-            return ShapeCollisions.polygonToPolygon(this, other);
+        CollisionResult.prototype.invertResult = function () {
+            this.minimumTranslationVector = es.Vector2.negate(this.minimumTranslationVector);
+            this.normal = es.Vector2.negate(this.normal);
+        };
+        return CollisionResult;
+    }());
+    es.CollisionResult = CollisionResult;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var ShapeCollisions = (function () {
+        function ShapeCollisions() {
         }
-        if (other instanceof Circle) {
-            result = ShapeCollisions.circleToPolygon(other, this);
-            if (result) {
-                result.invertResult();
+        ShapeCollisions.polygonToPolygon = function (first, second) {
+            var result = new es.CollisionResult();
+            var isIntersecting = true;
+            var firstEdges = first.edgeNormals;
+            var secondEdges = second.edgeNormals;
+            var minIntervalDistance = Number.POSITIVE_INFINITY;
+            var translationAxis = new es.Vector2();
+            var polygonOffset = es.Vector2.subtract(first.position, second.position);
+            var axis;
+            for (var edgeIndex = 0; edgeIndex < firstEdges.length + secondEdges.length; edgeIndex++) {
+                if (edgeIndex < firstEdges.length) {
+                    axis = firstEdges[edgeIndex];
+                }
+                else {
+                    axis = secondEdges[edgeIndex - firstEdges.length];
+                }
+                var minA = 0;
+                var minB = 0;
+                var maxA = 0;
+                var maxB = 0;
+                var intervalDist = 0;
+                var ta = this.getInterval(axis, first, minA, maxA);
+                minA = ta.min;
+                minB = ta.max;
+                var tb = this.getInterval(axis, second, minB, maxB);
+                minB = tb.min;
+                maxB = tb.max;
+                var relativeIntervalOffset = es.Vector2.dot(polygonOffset, axis);
+                minA += relativeIntervalOffset;
+                maxA += relativeIntervalOffset;
+                intervalDist = this.intervalDistance(minA, maxA, minB, maxB);
+                if (intervalDist > 0)
+                    isIntersecting = false;
+                if (!isIntersecting)
+                    return null;
+                intervalDist = Math.abs(intervalDist);
+                if (intervalDist < minIntervalDistance) {
+                    minIntervalDistance = intervalDist;
+                    translationAxis = axis;
+                    if (es.Vector2.dot(translationAxis, polygonOffset) < 0)
+                        translationAxis = new es.Vector2(-translationAxis);
+                }
+            }
+            result.normal = translationAxis;
+            result.minimumTranslationVector = es.Vector2.multiply(new es.Vector2(-translationAxis.x, -translationAxis.y), new es.Vector2(minIntervalDistance));
+            return result;
+        };
+        ShapeCollisions.intervalDistance = function (minA, maxA, minB, maxB) {
+            if (minA < minB)
+                return minB - maxA;
+            return minA - minB;
+        };
+        ShapeCollisions.getInterval = function (axis, polygon, min, max) {
+            var dot = es.Vector2.dot(polygon.points[0], axis);
+            min = max = dot;
+            for (var i = 1; i < polygon.points.length; i++) {
+                dot = es.Vector2.dot(polygon.points[i], axis);
+                if (dot < min) {
+                    min = dot;
+                }
+                else if (dot > max) {
+                    max = dot;
+                }
+            }
+            return { min: min, max: max };
+        };
+        ShapeCollisions.circleToPolygon = function (circle, polygon) {
+            var result = new es.CollisionResult();
+            var poly2Circle = es.Vector2.subtract(circle.position, polygon.position);
+            var gpp = es.Polygon.getClosestPointOnPolygonToPoint(polygon.points, poly2Circle);
+            var closestPoint = gpp.closestPoint;
+            var distanceSquared = gpp.distanceSquared;
+            result.normal = gpp.edgeNormal;
+            var circleCenterInsidePoly = polygon.containsPoint(circle.position);
+            if (distanceSquared > circle.radius * circle.radius && !circleCenterInsidePoly)
+                return null;
+            var mtv;
+            if (circleCenterInsidePoly) {
+                mtv = es.Vector2.multiply(result.normal, new es.Vector2(Math.sqrt(distanceSquared) - circle.radius));
+            }
+            else {
+                if (distanceSquared == 0) {
+                    mtv = es.Vector2.multiply(result.normal, new es.Vector2(circle.radius));
+                }
+                else {
+                    var distance = Math.sqrt(distanceSquared);
+                    mtv = es.Vector2.multiply(new es.Vector2(-es.Vector2.subtract(poly2Circle, closestPoint)), new es.Vector2((circle.radius - distanceSquared) / distance));
+                }
+            }
+            result.minimumTranslationVector = mtv;
+            result.point = es.Vector2.add(closestPoint, polygon.position);
+            return result;
+        };
+        ShapeCollisions.circleToBox = function (circle, box) {
+            var result = new es.CollisionResult();
+            var closestPointOnBounds = box.bounds.getClosestPointOnRectangleBorderToPoint(circle.position).res;
+            if (box.containsPoint(circle.position)) {
+                result.point = closestPointOnBounds;
+                var safePlace = es.Vector2.add(closestPointOnBounds, es.Vector2.subtract(result.normal, new es.Vector2(circle.radius)));
+                result.minimumTranslationVector = es.Vector2.subtract(circle.position, safePlace);
+                return result;
+            }
+            var sqrDistance = es.Vector2.distanceSquared(closestPointOnBounds, circle.position);
+            if (sqrDistance == 0) {
+                result.minimumTranslationVector = es.Vector2.multiply(result.normal, new es.Vector2(circle.radius));
+            }
+            else if (sqrDistance <= circle.radius * circle.radius) {
+                result.normal = es.Vector2.subtract(circle.position, closestPointOnBounds);
+                var depth = result.normal.length() - circle.radius;
+                result.normal = es.Vector2Ext.normalize(result.normal);
+                result.minimumTranslationVector = es.Vector2.multiply(new es.Vector2(depth), result.normal);
                 return result;
             }
             return null;
-        }
-        throw new Error("overlaps of Polygon to " + other + " are not supported");
-    };
-    Polygon.prototype.recalculateCenterAndEdgeNormals = function () {
-        this._polygonCenter = Polygon.findPolygonCenter(this.points);
-        this._areEdgeNormalsDirty = true;
-    };
-    Polygon.prototype.overlaps = function (other) {
-        var result;
-        if (other instanceof Polygon)
-            return ShapeCollisions.polygonToPolygon(this, other);
-        if (other instanceof Circle) {
-            result = ShapeCollisions.circleToPolygon(other, this);
-            if (result) {
-                result.invertResult();
-                return true;
+        };
+        ShapeCollisions.pointToCircle = function (point, circle) {
+            var result = new es.CollisionResult();
+            var distanceSquared = es.Vector2.distanceSquared(point, circle.position);
+            var sumOfRadii = 1 + circle.radius;
+            var collided = distanceSquared < sumOfRadii * sumOfRadii;
+            if (collided) {
+                result.normal = es.Vector2.normalize(es.Vector2.subtract(point, circle.position));
+                var depth = sumOfRadii - Math.sqrt(distanceSquared);
+                result.minimumTranslationVector = es.Vector2.multiply(new es.Vector2(-depth, -depth), result.normal);
+                result.point = es.Vector2.add(circle.position, es.Vector2.multiply(result.normal, new es.Vector2(circle.radius, circle.radius)));
+                return result;
             }
-            return false;
-        }
-        throw new Error("overlaps of Pologon to " + other + " are not supported");
-    };
-    Polygon.findPolygonCenter = function (points) {
-        var x = 0, y = 0;
-        for (var i = 0; i < points.length; i++) {
-            x += points[i].x;
-            y += points[i].y;
-        }
-        return new Vector2(x / points.length, y / points.length);
-    };
-    Polygon.recenterPolygonVerts = function (points) {
-        var center = this.findPolygonCenter(points);
-        for (var i = 0; i < points.length; i++)
-            points[i] = Vector2.subtract(points[i], center);
-    };
-    Polygon.getClosestPointOnPolygonToPoint = function (points, point) {
-        var distanceSquared = Number.MAX_VALUE;
-        var edgeNormal = new Vector2(0, 0);
-        var closestPoint = new Vector2(0, 0);
-        var tempDistanceSquared;
-        for (var i = 0; i < points.length; i++) {
-            var j = i + 1;
-            if (j == points.length)
-                j = 0;
-            var closest = ShapeCollisions.closestPointOnLine(points[i], points[j], point);
-            tempDistanceSquared = Vector2.distanceSquared(point, closest);
-            if (tempDistanceSquared < distanceSquared) {
-                distanceSquared = tempDistanceSquared;
-                closestPoint = closest;
-                var line = Vector2.subtract(points[j], points[i]);
-                edgeNormal.x = -line.y;
-                edgeNormal.y = line.x;
-            }
-        }
-        edgeNormal = Vector2.normalize(edgeNormal);
-        return { closestPoint: closestPoint, distanceSquared: distanceSquared, edgeNormal: edgeNormal };
-    };
-    Polygon.prototype.pointCollidesWithShape = function (point) {
-        return ShapeCollisions.pointToPoly(point, this);
-    };
-    Polygon.prototype.containsPoint = function (point) {
-        point = Vector2.subtract(point, this.position);
-        var isInside = false;
-        for (var i = 0, j = this.points.length - 1; i < this.points.length; j = i++) {
-            if (((this.points[i].y > point.y) != (this.points[j].y > point.y)) &&
-                (point.x < (this.points[j].x - this.points[i].x) * (point.y - this.points[i].y) / (this.points[j].y - this.points[i].y) +
-                    this.points[i].x)) {
-                isInside = !isInside;
-            }
-        }
-        return isInside;
-    };
-    Polygon.buildSymmertricalPolygon = function (vertCount, radius) {
-        var verts = new Array(vertCount);
-        for (var i = 0; i < vertCount; i++) {
-            var a = 2 * Math.PI * (i / vertCount);
-            verts[i] = new Vector2(Math.cos(a), Math.sin(a) * radius);
-        }
-        return verts;
-    };
-    return Polygon;
-}(Shape));
-var Box = (function (_super) {
-    __extends(Box, _super);
-    function Box(width, height) {
-        var _this = _super.call(this, Box.buildBox(width, height), true) || this;
-        _this.width = width;
-        _this.height = height;
-        return _this;
-    }
-    Box.buildBox = function (width, height) {
-        var halfWidth = width / 2;
-        var halfHeight = height / 2;
-        var verts = new Array(4);
-        verts[0] = new Vector2(-halfWidth, -halfHeight);
-        verts[1] = new Vector2(halfWidth, -halfHeight);
-        verts[2] = new Vector2(halfWidth, halfHeight);
-        verts[3] = new Vector2(-halfWidth, halfHeight);
-        return verts;
-    };
-    Box.prototype.overlaps = function (other) {
-        if (other instanceof Box)
-            return this.bounds.intersects(other.bounds);
-        if (other instanceof Circle)
-            return Collisions.isRectToCircle(this.bounds, other.position, other.radius);
-        return _super.prototype.overlaps.call(this, other);
-    };
-    Box.prototype.collidesWithShape = function (other) {
-        if (other instanceof Box) {
-            return ShapeCollisions.boxToBox(this, other);
-        }
-        return _super.prototype.collidesWithShape.call(this, other);
-    };
-    Box.prototype.updateBox = function (width, height) {
-        this.width = width;
-        this.height = height;
-        var halfWidth = width / 2;
-        var halfHeight = height / 2;
-        this.points[0] = new Vector2(-halfWidth, -halfHeight);
-        this.points[1] = new Vector2(halfWidth, -halfHeight);
-        this.points[2] = new Vector2(halfWidth, halfHeight);
-        this.points[3] = new Vector2(-halfWidth, halfHeight);
-        for (var i = 0; i < this.points.length; i++)
-            this._originalPoints[i] = this.points[i];
-    };
-    Box.prototype.containsPoint = function (point) {
-        return this.bounds.contains(point.x, point.y);
-    };
-    return Box;
-}(Polygon));
-var Circle = (function (_super) {
-    __extends(Circle, _super);
-    function Circle(radius) {
-        var _this = _super.call(this) || this;
-        _this.center = new Vector2();
-        _this.radius = radius;
-        _this._originalRadius = radius;
-        return _this;
-    }
-    Object.defineProperty(Circle.prototype, "position", {
-        get: function () {
-            return new Vector2(this.parent.x, this.parent.y);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Circle.prototype, "bounds", {
-        get: function () {
-            return new Rectangle().setEgretRect(this.getBounds());
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Circle.prototype.pointCollidesWithShape = function (point) {
-        return ShapeCollisions.pointToCircle(point, this);
-    };
-    Circle.prototype.collidesWithShape = function (other) {
-        if (other instanceof Box) {
-            return ShapeCollisions.circleToBox(this, other);
-        }
-        if (other instanceof Circle) {
-            return ShapeCollisions.circleToCircle(this, other);
-        }
-        if (other instanceof Polygon) {
-            return ShapeCollisions.circleToPolygon(this, other);
-        }
-        throw new Error("Collisions of Circle to " + other + " are not supported");
-    };
-    Circle.prototype.overlaps = function (other) {
-        if (other instanceof Box)
-            return Collisions.isRectToCircle(other.bounds, this.position, this.radius);
-        if (other instanceof Circle)
-            return Collisions.isCircleToCircle(this.position, this.radius, other.position, other.radius);
-        if (other instanceof Polygon)
-            return ShapeCollisions.circleToPolygon(this, other);
-        throw new Error("overlaps of circle to " + other + " are not supported");
-    };
-    return Circle;
-}(Shape));
-var CollisionResult = (function () {
-    function CollisionResult() {
-        this.minimumTranslationVector = Vector2.zero;
-        this.normal = Vector2.zero;
-        this.point = Vector2.zero;
-    }
-    CollisionResult.prototype.invertResult = function () {
-        this.minimumTranslationVector = Vector2.negate(this.minimumTranslationVector);
-        this.normal = Vector2.negate(this.normal);
-    };
-    return CollisionResult;
-}());
-var ShapeCollisions = (function () {
-    function ShapeCollisions() {
-    }
-    ShapeCollisions.polygonToPolygon = function (first, second) {
-        var result = new CollisionResult();
-        var isIntersecting = true;
-        var firstEdges = first.edgeNormals;
-        var secondEdges = second.edgeNormals;
-        var minIntervalDistance = Number.POSITIVE_INFINITY;
-        var translationAxis = new Vector2();
-        var polygonOffset = Vector2.subtract(first.position, second.position);
-        var axis;
-        for (var edgeIndex = 0; edgeIndex < firstEdges.length + secondEdges.length; edgeIndex++) {
-            if (edgeIndex < firstEdges.length) {
-                axis = firstEdges[edgeIndex];
-            }
-            else {
-                axis = secondEdges[edgeIndex - firstEdges.length];
-            }
-            var minA = 0;
-            var minB = 0;
-            var maxA = 0;
-            var maxB = 0;
-            var intervalDist = 0;
-            var ta = this.getInterval(axis, first, minA, maxA);
-            minA = ta.min;
-            minB = ta.max;
-            var tb = this.getInterval(axis, second, minB, maxB);
-            minB = tb.min;
-            maxB = tb.max;
-            var relativeIntervalOffset = Vector2.dot(polygonOffset, axis);
-            minA += relativeIntervalOffset;
-            maxA += relativeIntervalOffset;
-            intervalDist = this.intervalDistance(minA, maxA, minB, maxB);
-            if (intervalDist > 0)
-                isIntersecting = false;
-            if (!isIntersecting)
-                return null;
-            intervalDist = Math.abs(intervalDist);
-            if (intervalDist < minIntervalDistance) {
-                minIntervalDistance = intervalDist;
-                translationAxis = axis;
-                if (Vector2.dot(translationAxis, polygonOffset) < 0)
-                    translationAxis = new Vector2(-translationAxis);
-            }
-        }
-        result.normal = translationAxis;
-        result.minimumTranslationVector = Vector2.multiply(new Vector2(-translationAxis.x, -translationAxis.y), new Vector2(minIntervalDistance));
-        return result;
-    };
-    ShapeCollisions.intervalDistance = function (minA, maxA, minB, maxB) {
-        if (minA < minB)
-            return minB - maxA;
-        return minA - minB;
-    };
-    ShapeCollisions.getInterval = function (axis, polygon, min, max) {
-        var dot = Vector2.dot(polygon.points[0], axis);
-        min = max = dot;
-        for (var i = 1; i < polygon.points.length; i++) {
-            dot = Vector2.dot(polygon.points[i], axis);
-            if (dot < min) {
-                min = dot;
-            }
-            else if (dot > max) {
-                max = dot;
-            }
-        }
-        return { min: min, max: max };
-    };
-    ShapeCollisions.circleToPolygon = function (circle, polygon) {
-        var result = new CollisionResult();
-        var poly2Circle = Vector2.subtract(circle.position, polygon.position);
-        var gpp = Polygon.getClosestPointOnPolygonToPoint(polygon.points, poly2Circle);
-        var closestPoint = gpp.closestPoint;
-        var distanceSquared = gpp.distanceSquared;
-        result.normal = gpp.edgeNormal;
-        var circleCenterInsidePoly = polygon.containsPoint(circle.position);
-        if (distanceSquared > circle.radius * circle.radius && !circleCenterInsidePoly)
             return null;
-        var mtv;
-        if (circleCenterInsidePoly) {
-            mtv = Vector2.multiply(result.normal, new Vector2(Math.sqrt(distanceSquared) - circle.radius));
-        }
-        else {
-            if (distanceSquared == 0) {
-                mtv = Vector2.multiply(result.normal, new Vector2(circle.radius));
+        };
+        ShapeCollisions.closestPointOnLine = function (lineA, lineB, closestTo) {
+            var v = es.Vector2.subtract(lineB, lineA);
+            var w = es.Vector2.subtract(closestTo, lineA);
+            var t = es.Vector2.dot(w, v) / es.Vector2.dot(v, v);
+            t = es.MathHelper.clamp(t, 0, 1);
+            return es.Vector2.add(lineA, es.Vector2.multiply(v, new es.Vector2(t, t)));
+        };
+        ShapeCollisions.pointToPoly = function (point, poly) {
+            var result = new es.CollisionResult();
+            if (poly.containsPoint(point)) {
+                var distanceSquared = void 0;
+                var gpp = es.Polygon.getClosestPointOnPolygonToPoint(poly.points, es.Vector2.subtract(point, poly.position));
+                var closestPoint = gpp.closestPoint;
+                distanceSquared = gpp.distanceSquared;
+                result.normal = gpp.edgeNormal;
+                result.minimumTranslationVector = es.Vector2.multiply(result.normal, new es.Vector2(Math.sqrt(distanceSquared), Math.sqrt(distanceSquared)));
+                result.point = es.Vector2.add(closestPoint, poly.position);
+                return result;
             }
-            else {
-                var distance = Math.sqrt(distanceSquared);
-                mtv = Vector2.multiply(new Vector2(-Vector2.subtract(poly2Circle, closestPoint)), new Vector2((circle.radius - distanceSquared) / distance));
+            return null;
+        };
+        ShapeCollisions.circleToCircle = function (first, second) {
+            var result = new es.CollisionResult();
+            var distanceSquared = es.Vector2.distanceSquared(first.position, second.position);
+            var sumOfRadii = first.radius + second.radius;
+            var collided = distanceSquared < sumOfRadii * sumOfRadii;
+            if (collided) {
+                result.normal = es.Vector2.normalize(es.Vector2.subtract(first.position, second.position));
+                var depth = sumOfRadii - Math.sqrt(distanceSquared);
+                result.minimumTranslationVector = es.Vector2.multiply(new es.Vector2(-depth), result.normal);
+                result.point = es.Vector2.add(second.position, es.Vector2.multiply(result.normal, new es.Vector2(second.radius)));
+                return result;
             }
-        }
-        result.minimumTranslationVector = mtv;
-        result.point = Vector2.add(closestPoint, polygon.position);
-        return result;
-    };
-    ShapeCollisions.circleToBox = function (circle, box) {
-        var result = new CollisionResult();
-        var closestPointOnBounds = box.bounds.getClosestPointOnRectangleBorderToPoint(circle.position).res;
-        if (box.containsPoint(circle.position)) {
-            result.point = closestPointOnBounds;
-            var safePlace = Vector2.add(closestPointOnBounds, Vector2.subtract(result.normal, new Vector2(circle.radius)));
-            result.minimumTranslationVector = Vector2.subtract(circle.position, safePlace);
-            return result;
-        }
-        var sqrDistance = Vector2.distanceSquared(closestPointOnBounds, circle.position);
-        if (sqrDistance == 0) {
-            result.minimumTranslationVector = Vector2.multiply(result.normal, new Vector2(circle.radius));
-        }
-        else if (sqrDistance <= circle.radius * circle.radius) {
-            result.normal = Vector2.subtract(circle.position, closestPointOnBounds);
-            var depth = result.normal.length() - circle.radius;
-            result.normal = Vector2Ext.normalize(result.normal);
-            result.minimumTranslationVector = Vector2.multiply(new Vector2(depth), result.normal);
-            return result;
-        }
-        return null;
-    };
-    ShapeCollisions.pointToCircle = function (point, circle) {
-        var result = new CollisionResult();
-        var distanceSquared = Vector2.distanceSquared(point, circle.position);
-        var sumOfRadii = 1 + circle.radius;
-        var collided = distanceSquared < sumOfRadii * sumOfRadii;
-        if (collided) {
-            result.normal = Vector2.normalize(Vector2.subtract(point, circle.position));
-            var depth = sumOfRadii - Math.sqrt(distanceSquared);
-            result.minimumTranslationVector = Vector2.multiply(new Vector2(-depth, -depth), result.normal);
-            result.point = Vector2.add(circle.position, Vector2.multiply(result.normal, new Vector2(circle.radius, circle.radius)));
-            return result;
-        }
-        return null;
-    };
-    ShapeCollisions.closestPointOnLine = function (lineA, lineB, closestTo) {
-        var v = Vector2.subtract(lineB, lineA);
-        var w = Vector2.subtract(closestTo, lineA);
-        var t = Vector2.dot(w, v) / Vector2.dot(v, v);
-        t = MathHelper.clamp(t, 0, 1);
-        return Vector2.add(lineA, Vector2.multiply(v, new Vector2(t, t)));
-    };
-    ShapeCollisions.pointToPoly = function (point, poly) {
-        var result = new CollisionResult();
-        if (poly.containsPoint(point)) {
-            var distanceSquared = void 0;
-            var gpp = Polygon.getClosestPointOnPolygonToPoint(poly.points, Vector2.subtract(point, poly.position));
-            var closestPoint = gpp.closestPoint;
-            distanceSquared = gpp.distanceSquared;
-            result.normal = gpp.edgeNormal;
-            result.minimumTranslationVector = Vector2.multiply(result.normal, new Vector2(Math.sqrt(distanceSquared), Math.sqrt(distanceSquared)));
-            result.point = Vector2.add(closestPoint, poly.position);
-            return result;
-        }
-        return null;
-    };
-    ShapeCollisions.circleToCircle = function (first, second) {
-        var result = new CollisionResult();
-        var distanceSquared = Vector2.distanceSquared(first.position, second.position);
-        var sumOfRadii = first.radius + second.radius;
-        var collided = distanceSquared < sumOfRadii * sumOfRadii;
-        if (collided) {
-            result.normal = Vector2.normalize(Vector2.subtract(first.position, second.position));
-            var depth = sumOfRadii - Math.sqrt(distanceSquared);
-            result.minimumTranslationVector = Vector2.multiply(new Vector2(-depth), result.normal);
-            result.point = Vector2.add(second.position, Vector2.multiply(result.normal, new Vector2(second.radius)));
-            return result;
-        }
-        return null;
-    };
-    ShapeCollisions.boxToBox = function (first, second) {
-        var result = new CollisionResult();
-        var minkowskiDiff = this.minkowskiDifference(first, second);
-        if (minkowskiDiff.contains(0, 0)) {
-            result.minimumTranslationVector = minkowskiDiff.getClosestPointOnBoundsToOrigin();
-            if (result.minimumTranslationVector.x == 0 && result.minimumTranslationVector.y == 0)
-                return null;
-            result.normal = new Vector2(-result.minimumTranslationVector.x, -result.minimumTranslationVector.y);
-            result.normal.normalize();
-            return result;
-        }
-        return null;
-    };
-    ShapeCollisions.minkowskiDifference = function (first, second) {
-        var positionOffset = Vector2.subtract(first.position, Vector2.add(first.bounds.location, Vector2.divide(first.bounds.size, new Vector2(2))));
-        var topLeft = Vector2.subtract(Vector2.add(first.bounds.location, positionOffset), second.bounds.max);
-        var fullSize = Vector2.add(first.bounds.size, second.bounds.size);
-        return new Rectangle(topLeft.x, topLeft.y, fullSize.x, fullSize.y);
-    };
-    return ShapeCollisions;
-}());
-var SpatialHash = (function () {
-    function SpatialHash(cellSize) {
-        if (cellSize === void 0) { cellSize = 100; }
-        this.gridBounds = new Rectangle();
-        this._overlapTestCircle = new Circle(0);
-        this._tempHashSet = [];
-        this._cellDict = new NumberDictionary();
-        this._cellSize = cellSize;
-        this._inverseCellSize = 1 / this._cellSize;
-        this._raycastParser = new RaycastResultParser();
-    }
-    SpatialHash.prototype.remove = function (collider) {
-        var bounds = collider.registeredPhysicsBounds;
-        var p1 = this.cellCoords(bounds.x, bounds.y);
-        var p2 = this.cellCoords(bounds.right, bounds.bottom);
-        for (var x = p1.x; x <= p2.x; x++) {
-            for (var y = p1.y; y <= p2.y; y++) {
-                var cell = this.cellAtPosition(x, y);
-                if (!cell)
-                    console.error("removing Collider [" + collider + "] from a cell that it is not present in");
-                else
-                    cell.remove(collider);
+            return null;
+        };
+        ShapeCollisions.boxToBox = function (first, second) {
+            var result = new es.CollisionResult();
+            var minkowskiDiff = this.minkowskiDifference(first, second);
+            if (minkowskiDiff.contains(0, 0)) {
+                result.minimumTranslationVector = minkowskiDiff.getClosestPointOnBoundsToOrigin();
+                if (result.minimumTranslationVector.x == 0 && result.minimumTranslationVector.y == 0)
+                    return null;
+                result.normal = new es.Vector2(-result.minimumTranslationVector.x, -result.minimumTranslationVector.y);
+                result.normal.normalize();
+                return result;
             }
+            return null;
+        };
+        ShapeCollisions.minkowskiDifference = function (first, second) {
+            var positionOffset = es.Vector2.subtract(first.position, es.Vector2.add(first.bounds.location, es.Vector2.divide(first.bounds.size, new es.Vector2(2))));
+            var topLeft = es.Vector2.subtract(es.Vector2.add(first.bounds.location, positionOffset), second.bounds.max);
+            var fullSize = es.Vector2.add(first.bounds.size, second.bounds.size);
+            return new es.Rectangle(topLeft.x, topLeft.y, fullSize.x, fullSize.y);
+        };
+        return ShapeCollisions;
+    }());
+    es.ShapeCollisions = ShapeCollisions;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var SpatialHash = (function () {
+        function SpatialHash(cellSize) {
+            if (cellSize === void 0) { cellSize = 100; }
+            this.gridBounds = new es.Rectangle();
+            this._overlapTestCircle = new es.Circle(0);
+            this._cellDict = new NumberDictionary();
+            this._tempHashSet = [];
+            this._cellSize = cellSize;
+            this._inverseCellSize = 1 / this._cellSize;
+            this._raycastParser = new RaycastResultParser();
         }
-    };
-    SpatialHash.prototype.register = function (collider) {
-        var bounds = collider.bounds;
-        collider.registeredPhysicsBounds = bounds;
-        var p1 = this.cellCoords(bounds.x, bounds.y);
-        var p2 = this.cellCoords(bounds.right, bounds.bottom);
-        if (!this.gridBounds.contains(p1.x, p1.y)) {
-            this.gridBounds = RectangleExt.union(this.gridBounds, p1);
-        }
-        if (!this.gridBounds.contains(p2.x, p2.y)) {
-            this.gridBounds = RectangleExt.union(this.gridBounds, p2);
-        }
-        for (var x = p1.x; x <= p2.x; x++) {
-            for (var y = p1.y; y <= p2.y; y++) {
-                var c = this.cellAtPosition(x, y, true);
-                if (c.indexOf(collider) == -1)
-                    c.push(collider);
-            }
-        }
-    };
-    SpatialHash.prototype.clear = function () {
-        this._cellDict.clear();
-    };
-    SpatialHash.prototype.overlapCircle = function (circleCenter, radius, results, layerMask) {
-        var bounds = new Rectangle(circleCenter.x - radius, circleCenter.y - radius, radius * 2, radius * 2);
-        this._overlapTestCircle.radius = radius;
-        var resultCounter = 0;
-        var aabbBroadphaseResult = this.aabbBroadphase(bounds, null, layerMask);
-        bounds = aabbBroadphaseResult.bounds;
-        var potentials = aabbBroadphaseResult.tempHashSet;
-        for (var i = 0; i < potentials.length; i++) {
-            var collider = potentials[i];
-            if (collider instanceof BoxCollider) {
-                results[resultCounter] = collider;
-                resultCounter++;
-            }
-            else if (collider instanceof CircleCollider) {
-                if (collider.shape.overlaps(this._overlapTestCircle)) {
-                    results[resultCounter] = collider;
-                    resultCounter++;
+        SpatialHash.prototype.cellCoords = function (x, y) {
+            return new es.Vector2(Math.floor(x * this._inverseCellSize), Math.floor(y * this._inverseCellSize));
+        };
+        SpatialHash.prototype.cellAtPosition = function (x, y, createCellIfEmpty) {
+            if (createCellIfEmpty === void 0) { createCellIfEmpty = false; }
+            var cell = this._cellDict.tryGetValue(x, y);
+            if (!cell) {
+                if (createCellIfEmpty) {
+                    cell = [];
+                    this._cellDict.add(x, y, cell);
                 }
             }
-            else if (collider instanceof PolygonCollider) {
-                if (collider.shape.overlaps(this._overlapTestCircle)) {
-                    results[resultCounter] = collider;
-                    resultCounter++;
+            return cell;
+        };
+        SpatialHash.prototype.register = function (collider) {
+            var bounds = collider.bounds;
+            collider.registeredPhysicsBounds = bounds;
+            var p1 = this.cellCoords(bounds.x, bounds.y);
+            var p2 = this.cellCoords(bounds.right, bounds.bottom);
+            if (!this.gridBounds.contains(p1.x, p1.y)) {
+                this.gridBounds = es.RectangleExt.union(this.gridBounds, p1);
+            }
+            if (!this.gridBounds.contains(p2.x, p2.y)) {
+                this.gridBounds = es.RectangleExt.union(this.gridBounds, p2);
+            }
+            for (var x = p1.x; x <= p2.x; x++) {
+                for (var y = p1.y; y <= p2.y; y++) {
+                    var c = this.cellAtPosition(x, y, true);
+                    if (c.indexOf(collider) == -1)
+                        c.push(collider);
                 }
             }
-            else {
-                throw new Error("overlapCircle against this collider type is not implemented!");
+        };
+        SpatialHash.prototype.remove = function (collider) {
+            var bounds = collider.registeredPhysicsBounds;
+            var p1 = this.cellCoords(bounds.x, bounds.y);
+            var p2 = this.cellCoords(bounds.right, bounds.bottom);
+            for (var x = p1.x; x <= p2.x; x++) {
+                for (var y = p1.y; y <= p2.y; y++) {
+                    var cell = this.cellAtPosition(x, y);
+                    if (!cell)
+                        console.error("removing Collider [" + collider + "] from a cell that it is not present in");
+                    else
+                        cell.remove(collider);
+                }
             }
-            if (resultCounter == results.length)
-                return resultCounter;
-        }
-        return resultCounter;
-    };
-    SpatialHash.prototype.aabbBroadphase = function (bounds, excludeCollider, layerMask) {
-        this._tempHashSet.length = 0;
-        var p1 = this.cellCoords(bounds.x, bounds.y);
-        var p2 = this.cellCoords(bounds.right, bounds.bottom);
-        for (var x = p1.x; x <= p2.x; x++) {
-            for (var y = p1.y; y <= p2.y; y++) {
-                var cell = this.cellAtPosition(x, y);
-                if (!cell)
-                    continue;
-                for (var i = 0; i < cell.length; i++) {
-                    var collider = cell[i];
-                    if (collider == excludeCollider || !Flags.isFlagSet(layerMask, collider.physicsLayer))
+        };
+        SpatialHash.prototype.removeWithBruteForce = function (obj) {
+            this._cellDict.remove(obj);
+        };
+        SpatialHash.prototype.clear = function () {
+            this._cellDict.clear();
+        };
+        SpatialHash.prototype.debugDraw = function (secondsToDisplay, textScale) {
+            if (textScale === void 0) { textScale = 1; }
+            for (var x = this.gridBounds.x; x <= this.gridBounds.right; x++) {
+                for (var y = this.gridBounds.y; y <= this.gridBounds.bottom; y++) {
+                    var cell = this.cellAtPosition(x, y);
+                    if (cell && cell.length > 0)
+                        this.debugDrawCellDetails(x, y, cell.length, secondsToDisplay, textScale);
+                }
+            }
+        };
+        SpatialHash.prototype.debugDrawCellDetails = function (x, y, cellCount, secondsToDisplay, textScale) {
+            if (secondsToDisplay === void 0) { secondsToDisplay = 0.5; }
+            if (textScale === void 0) { textScale = 1; }
+        };
+        SpatialHash.prototype.aabbBroadphase = function (bounds, excludeCollider, layerMask) {
+            this._tempHashSet.length = 0;
+            var p1 = this.cellCoords(bounds.x, bounds.y);
+            var p2 = this.cellCoords(bounds.right, bounds.bottom);
+            for (var x = p1.x; x <= p2.x; x++) {
+                for (var y = p1.y; y <= p2.y; y++) {
+                    var cell = this.cellAtPosition(x, y);
+                    if (!cell)
                         continue;
-                    if (bounds.intersects(collider.bounds)) {
-                        if (this._tempHashSet.indexOf(collider) == -1)
-                            this._tempHashSet.push(collider);
+                    for (var i = 0; i < cell.length; i++) {
+                        var collider = cell[i];
+                        if (collider == excludeCollider || !es.Flags.isFlagSet(layerMask, collider.physicsLayer))
+                            continue;
+                        if (bounds.intersects(collider.bounds)) {
+                            if (this._tempHashSet.indexOf(collider) == -1)
+                                this._tempHashSet.push(collider);
+                        }
                     }
                 }
             }
-        }
-        return { tempHashSet: this._tempHashSet, bounds: bounds };
-    };
-    SpatialHash.prototype.cellAtPosition = function (x, y, createCellIfEmpty) {
-        if (createCellIfEmpty === void 0) { createCellIfEmpty = false; }
-        var cell = this._cellDict.tryGetValue(x, y);
-        if (!cell) {
-            if (createCellIfEmpty) {
-                cell = [];
-                this._cellDict.add(x, y, cell);
+            return { tempHashSet: this._tempHashSet, bounds: bounds };
+        };
+        SpatialHash.prototype.overlapCircle = function (circleCenter, radius, results, layerMask) {
+            var bounds = new es.Rectangle(circleCenter.x - radius, circleCenter.y - radius, radius * 2, radius * 2);
+            this._overlapTestCircle.radius = radius;
+            this._overlapTestCircle.position = circleCenter;
+            var resultCounter = 0;
+            var aabbBroadphaseResult = this.aabbBroadphase(bounds, null, layerMask);
+            bounds = aabbBroadphaseResult.bounds;
+            var potentials = aabbBroadphaseResult.tempHashSet;
+            for (var i = 0; i < potentials.length; i++) {
+                var collider = potentials[i];
+                if (collider instanceof es.BoxCollider) {
+                    results[resultCounter] = collider;
+                    resultCounter++;
+                }
+                else if (collider instanceof es.CircleCollider) {
+                    if (collider.shape.overlaps(this._overlapTestCircle)) {
+                        results[resultCounter] = collider;
+                        resultCounter++;
+                    }
+                }
+                else if (collider instanceof es.PolygonCollider) {
+                    if (collider.shape.overlaps(this._overlapTestCircle)) {
+                        results[resultCounter] = collider;
+                        resultCounter++;
+                    }
+                }
+                else {
+                    throw new Error("overlapCircle against this collider type is not implemented!");
+                }
+                if (resultCounter == results.length)
+                    return resultCounter;
             }
+            return resultCounter;
+        };
+        return SpatialHash;
+    }());
+    es.SpatialHash = SpatialHash;
+    var NumberDictionary = (function () {
+        function NumberDictionary() {
+            this._store = new Map();
         }
-        return cell;
-    };
-    SpatialHash.prototype.cellCoords = function (x, y) {
-        return new Vector2(Math.floor(x * this._inverseCellSize), Math.floor(y * this._inverseCellSize));
-    };
-    SpatialHash.prototype.debugDraw = function (secondsToDisplay, textScale) {
-        if (textScale === void 0) { textScale = 1; }
-        for (var x = this.gridBounds.x; x <= this.gridBounds.right; x++) {
-            for (var y = this.gridBounds.y; y <= this.gridBounds.bottom; y++) {
-                var cell = this.cellAtPosition(x, y);
-                if (cell && cell.length > 0)
-                    this.debugDrawCellDetails(x, y, cell.length, secondsToDisplay, textScale);
-            }
+        NumberDictionary.prototype.getKey = function (x, y) {
+            return Long.fromNumber(x).shiftLeft(32).or(Long.fromNumber(y, false)).toString();
+        };
+        NumberDictionary.prototype.add = function (x, y, list) {
+            this._store.set(this.getKey(x, y), list);
+        };
+        NumberDictionary.prototype.remove = function (obj) {
+            this._store.forEach(function (list) {
+                if (list.contains(obj))
+                    list.remove(obj);
+            });
+        };
+        NumberDictionary.prototype.tryGetValue = function (x, y) {
+            return this._store.get(this.getKey(x, y));
+        };
+        NumberDictionary.prototype.clear = function () {
+            this._store.clear();
+        };
+        return NumberDictionary;
+    }());
+    es.NumberDictionary = NumberDictionary;
+    var RaycastResultParser = (function () {
+        function RaycastResultParser() {
         }
-    };
-    SpatialHash.prototype.debugDrawCellDetails = function (x, y, cellCount, secondsToDisplay, textScale) {
-        if (secondsToDisplay === void 0) { secondsToDisplay = 0.5; }
-        if (textScale === void 0) { textScale = 1; }
-    };
-    return SpatialHash;
-}());
-var RaycastResultParser = (function () {
-    function RaycastResultParser() {
-    }
-    return RaycastResultParser;
-}());
-var NumberDictionary = (function () {
-    function NumberDictionary() {
-        this._store = new Map();
-    }
-    NumberDictionary.prototype.getKey = function (x, y) {
-        return Long.fromNumber(x).shiftLeft(32).or(Long.fromNumber(y, false)).toString();
-    };
-    NumberDictionary.prototype.add = function (x, y, list) {
-        this._store.set(this.getKey(x, y), list);
-    };
-    NumberDictionary.prototype.remove = function (obj) {
-        this._store.forEach(function (list) {
-            if (list.contains(obj))
-                list.remove(obj);
-        });
-    };
-    NumberDictionary.prototype.tryGetValue = function (x, y) {
-        return this._store.get(this.getKey(x, y));
-    };
-    NumberDictionary.prototype.clear = function () {
-        this._store.clear();
-    };
-    return NumberDictionary;
-}());
+        return RaycastResultParser;
+    }());
+    es.RaycastResultParser = RaycastResultParser;
+})(es || (es = {}));
 var ArrayUtils = (function () {
     function ArrayUtils() {
     }
@@ -5588,329 +6302,363 @@ var Base64Utils = (function () {
     };
     return Base64Utils;
 }());
-var ContentManager = (function () {
-    function ContentManager() {
-        this.loadedAssets = new Map();
-    }
-    ContentManager.prototype.loadRes = function (name, local) {
-        var _this = this;
-        if (local === void 0) { local = true; }
-        return new Promise(function (resolve, reject) {
-            var res = _this.loadedAssets.get(name);
-            if (res) {
-                resolve(res);
+var es;
+(function (es) {
+    var ContentManager = (function () {
+        function ContentManager() {
+            this.loadedAssets = new Map();
+        }
+        ContentManager.prototype.loadRes = function (name, local) {
+            var _this = this;
+            if (local === void 0) { local = true; }
+            return new Promise(function (resolve, reject) {
+                var res = _this.loadedAssets.get(name);
+                if (res) {
+                    resolve(res);
+                    return;
+                }
+                if (local) {
+                    RES.getResAsync(name).then(function (data) {
+                        _this.loadedAssets.set(name, data);
+                        resolve(data);
+                    }).catch(function (err) {
+                        console.error("资源加载错误:", name, err);
+                        reject(err);
+                    });
+                }
+                else {
+                    RES.getResByUrl(name).then(function (data) {
+                        _this.loadedAssets.set(name, data);
+                        resolve(data);
+                    }).catch(function (err) {
+                        console.error("资源加载错误:", name, err);
+                        reject(err);
+                    });
+                }
+            });
+        };
+        ContentManager.prototype.dispose = function () {
+            this.loadedAssets.forEach(function (value) {
+                var assetsToRemove = value;
+                assetsToRemove.dispose();
+            });
+            this.loadedAssets.clear();
+        };
+        return ContentManager;
+    }());
+    es.ContentManager = ContentManager;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var DrawUtils = (function () {
+        function DrawUtils() {
+        }
+        DrawUtils.drawLine = function (shape, start, end, color, thickness) {
+            if (thickness === void 0) { thickness = 1; }
+            this.drawLineAngle(shape, start, es.MathHelper.angleBetweenVectors(start, end), es.Vector2.distance(start, end), color, thickness);
+        };
+        DrawUtils.drawLineAngle = function (shape, start, radians, length, color, thickness) {
+            if (thickness === void 0) { thickness = 1; }
+            shape.graphics.beginFill(color);
+            shape.graphics.drawRect(start.x, start.y, 1, 1);
+            shape.graphics.endFill();
+            shape.scaleX = length;
+            shape.scaleY = thickness;
+            shape.$anchorOffsetX = 0;
+            shape.$anchorOffsetY = 0;
+            shape.rotation = radians;
+        };
+        DrawUtils.drawHollowRect = function (shape, rect, color, thickness) {
+            if (thickness === void 0) { thickness = 1; }
+            this.drawHollowRectR(shape, rect.x, rect.y, rect.width, rect.height, color, thickness);
+        };
+        DrawUtils.drawHollowRectR = function (shape, x, y, width, height, color, thickness) {
+            if (thickness === void 0) { thickness = 1; }
+            var tl = new es.Vector2(x, y).round();
+            var tr = new es.Vector2(x + width, y).round();
+            var br = new es.Vector2(x + width, y + height).round();
+            var bl = new es.Vector2(x, y + height).round();
+            this.drawLine(shape, tl, tr, color, thickness);
+            this.drawLine(shape, tr, br, color, thickness);
+            this.drawLine(shape, br, bl, color, thickness);
+            this.drawLine(shape, bl, tl, color, thickness);
+        };
+        DrawUtils.drawPixel = function (shape, position, color, size) {
+            if (size === void 0) { size = 1; }
+            var destRect = new es.Rectangle(position.x, position.y, size, size);
+            if (size != 1) {
+                destRect.x -= size * 0.5;
+                destRect.y -= size * 0.5;
+            }
+            shape.graphics.beginFill(color);
+            shape.graphics.drawRect(destRect.x, destRect.y, destRect.width, destRect.height);
+            shape.graphics.endFill();
+        };
+        DrawUtils.getColorMatrix = function (color) {
+            var colorMatrix = [
+                1, 0, 0, 0, 0,
+                0, 1, 0, 0, 0,
+                0, 0, 1, 0, 0,
+                0, 0, 0, 1, 0
+            ];
+            colorMatrix[0] = Math.floor(color / 256 / 256) / 255;
+            colorMatrix[6] = Math.floor(color / 256 % 256) / 255;
+            colorMatrix[12] = color % 256 / 255;
+            return new egret.ColorMatrixFilter(colorMatrix);
+        };
+        return DrawUtils;
+    }());
+    es.DrawUtils = DrawUtils;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var FuncPack = (function () {
+        function FuncPack(func, context) {
+            this.func = func;
+            this.context = context;
+        }
+        return FuncPack;
+    }());
+    es.FuncPack = FuncPack;
+    var Emitter = (function () {
+        function Emitter() {
+            this._messageTable = new Map();
+        }
+        Emitter.prototype.addObserver = function (eventType, handler, context) {
+            var list = this._messageTable.get(eventType);
+            if (!list) {
+                list = [];
+                this._messageTable.set(eventType, list);
+            }
+            if (list.contains(handler))
+                console.warn("您试图添加相同的观察者两次");
+            list.push(new FuncPack(handler, context));
+        };
+        Emitter.prototype.removeObserver = function (eventType, handler) {
+            var messageData = this._messageTable.get(eventType);
+            var index = messageData.findIndex(function (data) { return data.func == handler; });
+            if (index != -1)
+                messageData.removeAt(index);
+        };
+        Emitter.prototype.emit = function (eventType, data) {
+            var list = this._messageTable.get(eventType);
+            if (list) {
+                for (var i = list.length - 1; i >= 0; i--)
+                    list[i].func.call(list[i].context, data);
+            }
+        };
+        return Emitter;
+    }());
+    es.Emitter = Emitter;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var GlobalManager = (function () {
+        function GlobalManager() {
+        }
+        Object.defineProperty(GlobalManager.prototype, "enabled", {
+            get: function () {
+                return this._enabled;
+            },
+            set: function (value) {
+                this.setEnabled(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GlobalManager.prototype.setEnabled = function (isEnabled) {
+            if (this._enabled != isEnabled) {
+                this._enabled = isEnabled;
+                if (this._enabled) {
+                    this.onEnabled();
+                }
+                else {
+                    this.onDisabled();
+                }
+            }
+        };
+        GlobalManager.prototype.onEnabled = function () { };
+        GlobalManager.prototype.onDisabled = function () { };
+        GlobalManager.prototype.update = function () { };
+        GlobalManager.registerGlobalManager = function (manager) {
+            this.globalManagers.push(manager);
+            manager.enabled = true;
+        };
+        GlobalManager.unregisterGlobalManager = function (manager) {
+            this.globalManagers.remove(manager);
+            manager.enabled = false;
+        };
+        GlobalManager.getGlobalManager = function (type) {
+            for (var i = 0; i < this.globalManagers.length; i++) {
+                if (this.globalManagers[i] instanceof type)
+                    return this.globalManagers[i];
+            }
+            return null;
+        };
+        GlobalManager.globalManagers = [];
+        return GlobalManager;
+    }());
+    es.GlobalManager = GlobalManager;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var TouchState = (function () {
+        function TouchState() {
+            this.x = 0;
+            this.y = 0;
+            this.touchPoint = -1;
+            this.touchDown = false;
+        }
+        Object.defineProperty(TouchState.prototype, "position", {
+            get: function () {
+                return new es.Vector2(this.x, this.y);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        TouchState.prototype.reset = function () {
+            this.x = 0;
+            this.y = 0;
+            this.touchDown = false;
+            this.touchPoint = -1;
+        };
+        return TouchState;
+    }());
+    es.TouchState = TouchState;
+    var Input = (function () {
+        function Input() {
+        }
+        Object.defineProperty(Input, "touchPosition", {
+            get: function () {
+                if (!this._gameTouchs[0])
+                    return es.Vector2.zero;
+                return this._gameTouchs[0].position;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Input, "maxSupportedTouch", {
+            get: function () {
+                return this._stage.maxTouches;
+            },
+            set: function (value) {
+                this._stage.maxTouches = value;
+                this.initTouchCache();
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Input, "resolutionScale", {
+            get: function () {
+                return this._resolutionScale;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Input, "totalTouchCount", {
+            get: function () {
+                return this._totalTouchCount;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Input, "gameTouchs", {
+            get: function () {
+                return this._gameTouchs;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Input, "touchPositionDelta", {
+            get: function () {
+                var delta = es.Vector2.subtract(this.touchPosition, this._previousTouchState.position);
+                if (delta.length() > 0) {
+                    this.setpreviousTouchState(this._gameTouchs[0]);
+                }
+                return delta;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Input.initialize = function (stage) {
+            if (this._init)
                 return;
-            }
-            if (local) {
-                RES.getResAsync(name).then(function (data) {
-                    _this.loadedAssets.set(name, data);
-                    resolve(data);
-                }).catch(function (err) {
-                    console.error("资源加载错误:", name, err);
-                    reject(err);
-                });
-            }
-            else {
-                RES.getResByUrl(name).then(function (data) {
-                    _this.loadedAssets.set(name, data);
-                    resolve(data);
-                }).catch(function (err) {
-                    console.error("资源加载错误:", name, err);
-                    reject(err);
-                });
-            }
-        });
-    };
-    ContentManager.prototype.dispose = function () {
-        this.loadedAssets.forEach(function (value) {
-            var assetsToRemove = value;
-            assetsToRemove.dispose();
-        });
-        this.loadedAssets.clear();
-    };
-    return ContentManager;
-}());
-var DrawUtils = (function () {
-    function DrawUtils() {
-    }
-    DrawUtils.drawLine = function (shape, start, end, color, thickness) {
-        if (thickness === void 0) { thickness = 1; }
-        this.drawLineAngle(shape, start, MathHelper.angleBetweenVectors(start, end), Vector2.distance(start, end), color, thickness);
-    };
-    DrawUtils.drawLineAngle = function (shape, start, radians, length, color, thickness) {
-        if (thickness === void 0) { thickness = 1; }
-        shape.graphics.beginFill(color);
-        shape.graphics.drawRect(start.x, start.y, 1, 1);
-        shape.graphics.endFill();
-        shape.scaleX = length;
-        shape.scaleY = thickness;
-        shape.$anchorOffsetX = 0;
-        shape.$anchorOffsetY = 0;
-        shape.rotation = radians;
-    };
-    DrawUtils.drawHollowRect = function (shape, rect, color, thickness) {
-        if (thickness === void 0) { thickness = 1; }
-        this.drawHollowRectR(shape, rect.x, rect.y, rect.width, rect.height, color, thickness);
-    };
-    DrawUtils.drawHollowRectR = function (shape, x, y, width, height, color, thickness) {
-        if (thickness === void 0) { thickness = 1; }
-        var tl = new Vector2(x, y).round();
-        var tr = new Vector2(x + width, y).round();
-        var br = new Vector2(x + width, y + height).round();
-        var bl = new Vector2(x, y + height).round();
-        this.drawLine(shape, tl, tr, color, thickness);
-        this.drawLine(shape, tr, br, color, thickness);
-        this.drawLine(shape, br, bl, color, thickness);
-        this.drawLine(shape, bl, tl, color, thickness);
-    };
-    DrawUtils.drawPixel = function (shape, position, color, size) {
-        if (size === void 0) { size = 1; }
-        var destRect = new Rectangle(position.x, position.y, size, size);
-        if (size != 1) {
-            destRect.x -= size * 0.5;
-            destRect.y -= size * 0.5;
-        }
-        shape.graphics.beginFill(color);
-        shape.graphics.drawRect(destRect.x, destRect.y, destRect.width, destRect.height);
-        shape.graphics.endFill();
-    };
-    return DrawUtils;
-}());
-var Emitter = (function () {
-    function Emitter() {
-        this._messageTable = new Map();
-    }
-    Emitter.prototype.addObserver = function (eventType, handler, context) {
-        var list = this._messageTable.get(eventType);
-        if (!list) {
-            list = [];
-            this._messageTable.set(eventType, list);
-        }
-        if (list.contains(handler))
-            console.warn("您试图添加相同的观察者两次");
-        list.push(new FuncPack(handler, context));
-    };
-    Emitter.prototype.removeObserver = function (eventType, handler) {
-        var messageData = this._messageTable.get(eventType);
-        var index = messageData.findIndex(function (data) { return data.func == handler; });
-        if (index != -1)
-            messageData.removeAt(index);
-    };
-    Emitter.prototype.emit = function (eventType, data) {
-        var list = this._messageTable.get(eventType);
-        if (list) {
-            for (var i = list.length - 1; i >= 0; i--)
-                list[i].func.call(list[i].context, data);
-        }
-    };
-    return Emitter;
-}());
-var FuncPack = (function () {
-    function FuncPack(func, context) {
-        this.func = func;
-        this.context = context;
-    }
-    return FuncPack;
-}());
-var GlobalManager = (function () {
-    function GlobalManager() {
-    }
-    Object.defineProperty(GlobalManager.prototype, "enabled", {
-        get: function () {
-            return this._enabled;
-        },
-        set: function (value) {
-            this.setEnabled(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    GlobalManager.prototype.setEnabled = function (isEnabled) {
-        if (this._enabled != isEnabled) {
-            this._enabled = isEnabled;
-            if (this._enabled) {
-                this.onEnabled();
-            }
-            else {
-                this.onDisabled();
-            }
-        }
-    };
-    GlobalManager.prototype.onEnabled = function () { };
-    GlobalManager.prototype.onDisabled = function () { };
-    GlobalManager.prototype.update = function () { };
-    GlobalManager.registerGlobalManager = function (manager) {
-        this.globalManagers.push(manager);
-        manager.enabled = true;
-    };
-    GlobalManager.unregisterGlobalManager = function (manager) {
-        this.globalManagers.remove(manager);
-        manager.enabled = false;
-    };
-    GlobalManager.getGlobalManager = function (type) {
-        for (var i = 0; i < this.globalManagers.length; i++) {
-            if (this.globalManagers[i] instanceof type)
-                return this.globalManagers[i];
-        }
-        return null;
-    };
-    GlobalManager.globalManagers = [];
-    return GlobalManager;
-}());
-var TouchState = (function () {
-    function TouchState() {
-        this.x = 0;
-        this.y = 0;
-        this.touchPoint = -1;
-        this.touchDown = false;
-    }
-    Object.defineProperty(TouchState.prototype, "position", {
-        get: function () {
-            return new Vector2(this.x, this.y);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    TouchState.prototype.reset = function () {
-        this.x = 0;
-        this.y = 0;
-        this.touchDown = false;
-        this.touchPoint = -1;
-    };
-    return TouchState;
-}());
-var Input = (function () {
-    function Input() {
-    }
-    Object.defineProperty(Input, "touchPosition", {
-        get: function () {
-            if (!this._gameTouchs[0])
-                return Vector2.zero;
-            return this._gameTouchs[0].position;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Input, "maxSupportedTouch", {
-        get: function () {
-            return this._stage.maxTouches;
-        },
-        set: function (value) {
-            this._stage.maxTouches = value;
+            this._init = true;
+            this._stage = stage;
+            this._stage.addEventListener(egret.TouchEvent.TOUCH_BEGIN, this.touchBegin, this);
+            this._stage.addEventListener(egret.TouchEvent.TOUCH_MOVE, this.touchMove, this);
+            this._stage.addEventListener(egret.TouchEvent.TOUCH_END, this.touchEnd, this);
+            this._stage.addEventListener(egret.TouchEvent.TOUCH_CANCEL, this.touchEnd, this);
+            this._stage.addEventListener(egret.TouchEvent.TOUCH_RELEASE_OUTSIDE, this.touchEnd, this);
             this.initTouchCache();
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Input, "resolutionScale", {
-        get: function () {
-            return this._resolutionScale;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Input, "totalTouchCount", {
-        get: function () {
-            return this._totalTouchCount;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Input, "gameTouchs", {
-        get: function () {
-            return this._gameTouchs;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Input, "touchPositionDelta", {
-        get: function () {
-            var delta = Vector2.subtract(this.touchPosition, this._previousTouchState.position);
-            if (delta.length() > 0) {
+        };
+        Input.initTouchCache = function () {
+            this._totalTouchCount = 0;
+            this._touchIndex = 0;
+            this._gameTouchs.length = 0;
+            for (var i = 0; i < this.maxSupportedTouch; i++) {
+                this._gameTouchs.push(new TouchState());
+            }
+        };
+        Input.touchBegin = function (evt) {
+            if (this._touchIndex < this.maxSupportedTouch) {
+                this._gameTouchs[this._touchIndex].touchPoint = evt.touchPointID;
+                this._gameTouchs[this._touchIndex].touchDown = evt.touchDown;
+                this._gameTouchs[this._touchIndex].x = evt.stageX;
+                this._gameTouchs[this._touchIndex].y = evt.stageY;
+                if (this._touchIndex == 0) {
+                    this.setpreviousTouchState(this._gameTouchs[0]);
+                }
+                this._touchIndex++;
+                this._totalTouchCount++;
+            }
+        };
+        Input.touchMove = function (evt) {
+            if (evt.touchPointID == this._gameTouchs[0].touchPoint) {
                 this.setpreviousTouchState(this._gameTouchs[0]);
             }
-            return delta;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Input.initialize = function (stage) {
-        if (this._init)
-            return;
-        this._init = true;
-        this._stage = stage;
-        this._stage.addEventListener(egret.TouchEvent.TOUCH_BEGIN, this.touchBegin, this);
-        this._stage.addEventListener(egret.TouchEvent.TOUCH_MOVE, this.touchMove, this);
-        this._stage.addEventListener(egret.TouchEvent.TOUCH_END, this.touchEnd, this);
-        this._stage.addEventListener(egret.TouchEvent.TOUCH_CANCEL, this.touchEnd, this);
-        this._stage.addEventListener(egret.TouchEvent.TOUCH_RELEASE_OUTSIDE, this.touchEnd, this);
-        this.initTouchCache();
-    };
-    Input.initTouchCache = function () {
-        this._totalTouchCount = 0;
-        this._touchIndex = 0;
-        this._gameTouchs.length = 0;
-        for (var i = 0; i < this.maxSupportedTouch; i++) {
-            this._gameTouchs.push(new TouchState());
-        }
-    };
-    Input.touchBegin = function (evt) {
-        if (this._touchIndex < this.maxSupportedTouch) {
-            this._gameTouchs[this._touchIndex].touchPoint = evt.touchPointID;
-            this._gameTouchs[this._touchIndex].touchDown = evt.touchDown;
-            this._gameTouchs[this._touchIndex].x = evt.stageX;
-            this._gameTouchs[this._touchIndex].y = evt.stageY;
-            if (this._touchIndex == 0) {
-                this.setpreviousTouchState(this._gameTouchs[0]);
+            var touchIndex = this._gameTouchs.findIndex(function (touch) { return touch.touchPoint == evt.touchPointID; });
+            if (touchIndex != -1) {
+                var touchData = this._gameTouchs[touchIndex];
+                touchData.x = evt.stageX;
+                touchData.y = evt.stageY;
             }
-            this._touchIndex++;
-            this._totalTouchCount++;
-        }
-    };
-    Input.touchMove = function (evt) {
-        if (evt.touchPointID == this._gameTouchs[0].touchPoint) {
-            this.setpreviousTouchState(this._gameTouchs[0]);
-        }
-        var touchIndex = this._gameTouchs.findIndex(function (touch) { return touch.touchPoint == evt.touchPointID; });
-        if (touchIndex != -1) {
-            var touchData = this._gameTouchs[touchIndex];
-            touchData.x = evt.stageX;
-            touchData.y = evt.stageY;
-        }
-    };
-    Input.touchEnd = function (evt) {
-        var touchIndex = this._gameTouchs.findIndex(function (touch) { return touch.touchPoint == evt.touchPointID; });
-        if (touchIndex != -1) {
-            var touchData = this._gameTouchs[touchIndex];
-            touchData.reset();
-            if (touchIndex == 0)
-                this._previousTouchState.reset();
-            this._totalTouchCount--;
-            if (this.totalTouchCount == 0) {
-                this._touchIndex = 0;
+        };
+        Input.touchEnd = function (evt) {
+            var touchIndex = this._gameTouchs.findIndex(function (touch) { return touch.touchPoint == evt.touchPointID; });
+            if (touchIndex != -1) {
+                var touchData = this._gameTouchs[touchIndex];
+                touchData.reset();
+                if (touchIndex == 0)
+                    this._previousTouchState.reset();
+                this._totalTouchCount--;
+                if (this.totalTouchCount == 0) {
+                    this._touchIndex = 0;
+                }
             }
-        }
-    };
-    Input.setpreviousTouchState = function (touchState) {
-        this._previousTouchState = new TouchState();
-        this._previousTouchState.x = touchState.position.x;
-        this._previousTouchState.y = touchState.position.y;
-        this._previousTouchState.touchPoint = touchState.touchPoint;
-        this._previousTouchState.touchDown = touchState.touchDown;
-    };
-    Input.scaledPosition = function (position) {
-        var scaledPos = new Vector2(position.x - this._resolutionOffset.x, position.y - this._resolutionOffset.y);
-        return Vector2.multiply(scaledPos, this.resolutionScale);
-    };
-    Input._init = false;
-    Input._previousTouchState = new TouchState();
-    Input._gameTouchs = [];
-    Input._resolutionOffset = new Vector2();
-    Input._resolutionScale = Vector2.one;
-    Input._touchIndex = 0;
-    Input._totalTouchCount = 0;
-    return Input;
-}());
+        };
+        Input.setpreviousTouchState = function (touchState) {
+            this._previousTouchState = new TouchState();
+            this._previousTouchState.x = touchState.position.x;
+            this._previousTouchState.y = touchState.position.y;
+            this._previousTouchState.touchPoint = touchState.touchPoint;
+            this._previousTouchState.touchDown = touchState.touchDown;
+        };
+        Input.scaledPosition = function (position) {
+            var scaledPos = new es.Vector2(position.x - this._resolutionOffset.x, position.y - this._resolutionOffset.y);
+            return es.Vector2.multiply(scaledPos, this.resolutionScale);
+        };
+        Input._init = false;
+        Input._previousTouchState = new TouchState();
+        Input._gameTouchs = [];
+        Input._resolutionOffset = new es.Vector2();
+        Input._resolutionScale = es.Vector2.one;
+        Input._touchIndex = 0;
+        Input._totalTouchCount = 0;
+        return Input;
+    }());
+    es.Input = Input;
+})(es || (es = {}));
 var KeyboardUtils = (function () {
     function KeyboardUtils() {
     }
@@ -6111,36 +6859,40 @@ var KeyboardUtils = (function () {
     KeyboardUtils.WINDOWS = "Windows";
     return KeyboardUtils;
 }());
-var ListPool = (function () {
-    function ListPool() {
-    }
-    ListPool.warmCache = function (cacheCount) {
-        cacheCount -= this._objectQueue.length;
-        if (cacheCount > 0) {
-            for (var i = 0; i < cacheCount; i++) {
-                this._objectQueue.unshift([]);
-            }
+var es;
+(function (es) {
+    var ListPool = (function () {
+        function ListPool() {
         }
-    };
-    ListPool.trimCache = function (cacheCount) {
-        while (cacheCount > this._objectQueue.length)
-            this._objectQueue.shift();
-    };
-    ListPool.clearCache = function () {
-        this._objectQueue.length = 0;
-    };
-    ListPool.obtain = function () {
-        if (this._objectQueue.length > 0)
-            return this._objectQueue.shift();
-        return [];
-    };
-    ListPool.free = function (obj) {
-        this._objectQueue.unshift(obj);
-        obj.length = 0;
-    };
-    ListPool._objectQueue = [];
-    return ListPool;
-}());
+        ListPool.warmCache = function (cacheCount) {
+            cacheCount -= this._objectQueue.length;
+            if (cacheCount > 0) {
+                for (var i = 0; i < cacheCount; i++) {
+                    this._objectQueue.unshift([]);
+                }
+            }
+        };
+        ListPool.trimCache = function (cacheCount) {
+            while (cacheCount > this._objectQueue.length)
+                this._objectQueue.shift();
+        };
+        ListPool.clearCache = function () {
+            this._objectQueue.length = 0;
+        };
+        ListPool.obtain = function () {
+            if (this._objectQueue.length > 0)
+                return this._objectQueue.shift();
+            return [];
+        };
+        ListPool.free = function (obj) {
+            this._objectQueue.unshift(obj);
+            obj.length = 0;
+        };
+        ListPool._objectQueue = [];
+        return ListPool;
+    }());
+    es.ListPool = ListPool;
+})(es || (es = {}));
 var THREAD_ID = Math.floor(Math.random() * 1000) + "-" + Date.now();
 var setItem = egret.localStorage.setItem.bind(localStorage);
 var getItem = egret.localStorage.getItem.bind(localStorage);
@@ -6182,19 +6934,23 @@ var LockUtils = (function () {
     };
     return LockUtils;
 }());
-var Pair = (function () {
-    function Pair(first, second) {
-        this.first = first;
-        this.second = second;
-    }
-    Pair.prototype.clear = function () {
-        this.first = this.second = null;
-    };
-    Pair.prototype.equals = function (other) {
-        return this.first == other.first && this.second == other.second;
-    };
-    return Pair;
-}());
+var es;
+(function (es) {
+    var Pair = (function () {
+        function Pair(first, second) {
+            this.first = first;
+            this.second = second;
+        }
+        Pair.prototype.clear = function () {
+            this.first = this.second = null;
+        };
+        Pair.prototype.equals = function (other) {
+            return this.first == other.first && this.second == other.second;
+        };
+        return Pair;
+    }());
+    es.Pair = Pair;
+})(es || (es = {}));
 var RandomUtils = (function () {
     function RandomUtils() {
     }
@@ -6262,142 +7018,154 @@ var RandomUtils = (function () {
     };
     return RandomUtils;
 }());
-var RectangleExt = (function () {
-    function RectangleExt() {
-    }
-    RectangleExt.union = function (first, point) {
-        var rect = new Rectangle(point.x, point.y, 0, 0);
-        var result = new Rectangle();
-        result.x = Math.min(first.x, rect.x);
-        result.y = Math.min(first.y, rect.y);
-        result.width = Math.max(first.right, rect.right) - result.x;
-        result.height = Math.max(first.bottom, result.bottom) - result.y;
-        return result;
-    };
-    return RectangleExt;
-}());
-var Triangulator = (function () {
-    function Triangulator() {
-        this.triangleIndices = [];
-        this._triPrev = new Array(12);
-        this._triNext = new Array(12);
-    }
-    Triangulator.prototype.triangulate = function (points, arePointsCCW) {
-        if (arePointsCCW === void 0) { arePointsCCW = true; }
-        var count = points.length;
-        this.initialize(count);
-        var iterations = 0;
-        var index = 0;
-        while (count > 3 && iterations < 500) {
-            iterations++;
-            var isEar = true;
-            var a = points[this._triPrev[index]];
-            var b = points[index];
-            var c = points[this._triNext[index]];
-            if (Vector2Ext.isTriangleCCW(a, b, c)) {
-                var k = this._triNext[this._triNext[index]];
-                do {
-                    if (Triangulator.testPointTriangle(points[k], a, b, c)) {
-                        isEar = false;
-                        break;
-                    }
-                    k = this._triNext[k];
-                } while (k != this._triPrev[index]);
+var es;
+(function (es) {
+    var RectangleExt = (function () {
+        function RectangleExt() {
+        }
+        RectangleExt.union = function (first, point) {
+            var rect = new es.Rectangle(point.x, point.y, 0, 0);
+            var result = new es.Rectangle();
+            result.x = Math.min(first.x, rect.x);
+            result.y = Math.min(first.y, rect.y);
+            result.width = Math.max(first.right, rect.right) - result.x;
+            result.height = Math.max(first.bottom, result.bottom) - result.y;
+            return result;
+        };
+        return RectangleExt;
+    }());
+    es.RectangleExt = RectangleExt;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Triangulator = (function () {
+        function Triangulator() {
+            this.triangleIndices = [];
+            this._triPrev = new Array(12);
+            this._triNext = new Array(12);
+        }
+        Triangulator.prototype.triangulate = function (points, arePointsCCW) {
+            if (arePointsCCW === void 0) { arePointsCCW = true; }
+            var count = points.length;
+            this.initialize(count);
+            var iterations = 0;
+            var index = 0;
+            while (count > 3 && iterations < 500) {
+                iterations++;
+                var isEar = true;
+                var a = points[this._triPrev[index]];
+                var b = points[index];
+                var c = points[this._triNext[index]];
+                if (es.Vector2Ext.isTriangleCCW(a, b, c)) {
+                    var k = this._triNext[this._triNext[index]];
+                    do {
+                        if (Triangulator.testPointTriangle(points[k], a, b, c)) {
+                            isEar = false;
+                            break;
+                        }
+                        k = this._triNext[k];
+                    } while (k != this._triPrev[index]);
+                }
+                else {
+                    isEar = false;
+                }
+                if (isEar) {
+                    this.triangleIndices.push(this._triPrev[index]);
+                    this.triangleIndices.push(index);
+                    this.triangleIndices.push(this._triNext[index]);
+                    this._triNext[this._triPrev[index]] = this._triNext[index];
+                    this._triPrev[this._triNext[index]] = this._triPrev[index];
+                    count--;
+                    index = this._triPrev[index];
+                }
+                else {
+                    index = this._triNext[index];
+                }
+            }
+            this.triangleIndices.push(this._triPrev[index]);
+            this.triangleIndices.push(index);
+            this.triangleIndices.push(this._triNext[index]);
+            if (!arePointsCCW)
+                this.triangleIndices.reverse();
+        };
+        Triangulator.prototype.initialize = function (count) {
+            this.triangleIndices.length = 0;
+            if (this._triNext.length < count) {
+                this._triNext.reverse();
+                this._triNext = new Array(Math.max(this._triNext.length * 2, count));
+            }
+            if (this._triPrev.length < count) {
+                this._triPrev.reverse();
+                this._triPrev = new Array(Math.max(this._triPrev.length * 2, count));
+            }
+            for (var i = 0; i < count; i++) {
+                this._triPrev[i] = i - 1;
+                this._triNext[i] = i + 1;
+            }
+            this._triPrev[0] = count - 1;
+            this._triNext[count - 1] = 0;
+        };
+        Triangulator.testPointTriangle = function (point, a, b, c) {
+            if (es.Vector2Ext.cross(es.Vector2.subtract(point, a), es.Vector2.subtract(b, a)) < 0)
+                return false;
+            if (es.Vector2Ext.cross(es.Vector2.subtract(point, b), es.Vector2.subtract(c, b)) < 0)
+                return false;
+            if (es.Vector2Ext.cross(es.Vector2.subtract(point, c), es.Vector2.subtract(a, c)) < 0)
+                return false;
+            return true;
+        };
+        return Triangulator;
+    }());
+    es.Triangulator = Triangulator;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Vector2Ext = (function () {
+        function Vector2Ext() {
+        }
+        Vector2Ext.isTriangleCCW = function (a, center, c) {
+            return this.cross(es.Vector2.subtract(center, a), es.Vector2.subtract(c, center)) < 0;
+        };
+        Vector2Ext.cross = function (u, v) {
+            return u.y * v.x - u.x * v.y;
+        };
+        Vector2Ext.perpendicular = function (first, second) {
+            return new es.Vector2(-1 * (second.y - first.y), second.x - first.x);
+        };
+        Vector2Ext.normalize = function (vec) {
+            var magnitude = Math.sqrt((vec.x * vec.x) + (vec.y * vec.y));
+            if (magnitude > es.MathHelper.Epsilon) {
+                vec = es.Vector2.divide(vec, new es.Vector2(magnitude));
             }
             else {
-                isEar = false;
+                vec.x = vec.y = 0;
             }
-            if (isEar) {
-                this.triangleIndices.push(this._triPrev[index]);
-                this.triangleIndices.push(index);
-                this.triangleIndices.push(this._triNext[index]);
-                this._triNext[this._triPrev[index]] = this._triNext[index];
-                this._triPrev[this._triNext[index]] = this._triPrev[index];
-                count--;
-                index = this._triPrev[index];
+            return vec;
+        };
+        Vector2Ext.transformA = function (sourceArray, sourceIndex, matrix, destinationArray, destinationIndex, length) {
+            for (var i = 0; i < length; i++) {
+                var position = sourceArray[sourceIndex + i];
+                var destination = destinationArray[destinationIndex + i];
+                destination.x = (position.x * matrix.m11) + (position.y * matrix.m21) + matrix.m31;
+                destination.y = (position.x * matrix.m12) + (position.y * matrix.m22) + matrix.m32;
+                destinationArray[destinationIndex + i] = destination;
             }
-            else {
-                index = this._triNext[index];
-            }
-        }
-        this.triangleIndices.push(this._triPrev[index]);
-        this.triangleIndices.push(index);
-        this.triangleIndices.push(this._triNext[index]);
-        if (!arePointsCCW)
-            this.triangleIndices.reverse();
-    };
-    Triangulator.prototype.initialize = function (count) {
-        this.triangleIndices.length = 0;
-        if (this._triNext.length < count) {
-            this._triNext.reverse();
-            this._triNext = new Array(Math.max(this._triNext.length * 2, count));
-        }
-        if (this._triPrev.length < count) {
-            this._triPrev.reverse();
-            this._triPrev = new Array(Math.max(this._triPrev.length * 2, count));
-        }
-        for (var i = 0; i < count; i++) {
-            this._triPrev[i] = i - 1;
-            this._triNext[i] = i + 1;
-        }
-        this._triPrev[0] = count - 1;
-        this._triNext[count - 1] = 0;
-    };
-    Triangulator.testPointTriangle = function (point, a, b, c) {
-        if (Vector2Ext.cross(Vector2.subtract(point, a), Vector2.subtract(b, a)) < 0)
-            return false;
-        if (Vector2Ext.cross(Vector2.subtract(point, b), Vector2.subtract(c, b)) < 0)
-            return false;
-        if (Vector2Ext.cross(Vector2.subtract(point, c), Vector2.subtract(a, c)) < 0)
-            return false;
-        return true;
-    };
-    return Triangulator;
-}());
-var Vector2Ext = (function () {
-    function Vector2Ext() {
-    }
-    Vector2Ext.isTriangleCCW = function (a, center, c) {
-        return this.cross(Vector2.subtract(center, a), Vector2.subtract(c, center)) < 0;
-    };
-    Vector2Ext.cross = function (u, v) {
-        return u.y * v.x - u.x * v.y;
-    };
-    Vector2Ext.perpendicular = function (first, second) {
-        return new Vector2(-1 * (second.y - first.y), second.x - first.x);
-    };
-    Vector2Ext.normalize = function (vec) {
-        var magnitude = Math.sqrt((vec.x * vec.x) + (vec.y * vec.y));
-        if (magnitude > MathHelper.Epsilon) {
-            vec = Vector2.divide(vec, new Vector2(magnitude));
-        }
-        else {
-            vec.x = vec.y = 0;
-        }
-        return vec;
-    };
-    Vector2Ext.transformA = function (sourceArray, sourceIndex, matrix, destinationArray, destinationIndex, length) {
-        for (var i = 0; i < length; i++) {
-            var position = sourceArray[sourceIndex + i];
-            var destination = destinationArray[destinationIndex + i];
-            destination.x = (position.x * matrix.m11) + (position.y * matrix.m21) + matrix.m31;
-            destination.y = (position.x * matrix.m12) + (position.y * matrix.m22) + matrix.m32;
-            destinationArray[destinationIndex + i] = destination;
-        }
-    };
-    Vector2Ext.transformR = function (position, matrix) {
-        var x = (position.x * matrix.m11) + (position.y * matrix.m21) + matrix.m31;
-        var y = (position.x * matrix.m12) + (position.y * matrix.m22) + matrix.m32;
-        return new Vector2(x, y);
-    };
-    Vector2Ext.transform = function (sourceArray, matrix, destinationArray) {
-        this.transformA(sourceArray, 0, matrix, destinationArray, 0, sourceArray.length);
-    };
-    Vector2Ext.round = function (vec) {
-        return new Vector2(Math.round(vec.x), Math.round(vec.y));
-    };
-    return Vector2Ext;
-}());
+        };
+        Vector2Ext.transformR = function (position, matrix) {
+            var x = (position.x * matrix.m11) + (position.y * matrix.m21) + matrix.m31;
+            var y = (position.x * matrix.m12) + (position.y * matrix.m22) + matrix.m32;
+            return new es.Vector2(x, y);
+        };
+        Vector2Ext.transform = function (sourceArray, matrix, destinationArray) {
+            this.transformA(sourceArray, 0, matrix, destinationArray, 0, sourceArray.length);
+        };
+        Vector2Ext.round = function (vec) {
+            return new es.Vector2(Math.round(vec.x), Math.round(vec.y));
+        };
+        return Vector2Ext;
+    }());
+    es.Vector2Ext = Vector2Ext;
+})(es || (es = {}));
 var WebGLUtils = (function () {
     function WebGLUtils() {
     }
@@ -6407,66 +7175,70 @@ var WebGLUtils = (function () {
     };
     return WebGLUtils;
 }());
-var Layout = (function () {
-    function Layout() {
-        this.clientArea = new Rectangle(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-        this.safeArea = this.clientArea;
-    }
-    Layout.prototype.place = function (size, horizontalMargin, verticalMargine, alignment) {
-        var rc = new Rectangle(0, 0, size.x, size.y);
-        if ((alignment & Alignment.left) != 0) {
-            rc.x = this.clientArea.x + (this.clientArea.width * horizontalMargin);
+var es;
+(function (es) {
+    var Layout = (function () {
+        function Layout() {
+            this.clientArea = new es.Rectangle(0, 0, es.SceneManager.stage.stageWidth, es.SceneManager.stage.stageHeight);
+            this.safeArea = this.clientArea;
         }
-        else if ((alignment & Alignment.right) != 0) {
-            rc.x = this.clientArea.x + (this.clientArea.width * (1 - horizontalMargin)) - rc.width;
-        }
-        else if ((alignment & Alignment.horizontalCenter) != 0) {
-            rc.x = this.clientArea.x + (this.clientArea.width - rc.width) / 2 + (horizontalMargin * this.clientArea.width);
-        }
-        else {
-        }
-        if ((alignment & Alignment.top) != 0) {
-            rc.y = this.clientArea.y + (this.clientArea.height * verticalMargine);
-        }
-        else if ((alignment & Alignment.bottom) != 0) {
-            rc.y = this.clientArea.y + (this.clientArea.height * (1 - verticalMargine)) - rc.height;
-        }
-        else if ((alignment & Alignment.verticalCenter) != 0) {
-            rc.y = this.clientArea.y + (this.clientArea.height - rc.height) / 2 + (verticalMargine * this.clientArea.height);
-        }
-        else {
-        }
-        if (rc.left < this.safeArea.left)
-            rc.x = this.safeArea.left;
-        if (rc.right > this.safeArea.right)
-            rc.x = this.safeArea.right - rc.width;
-        if (rc.top < this.safeArea.top)
-            rc.y = this.safeArea.top;
-        if (rc.bottom > this.safeArea.bottom)
-            rc.y = this.safeArea.bottom - rc.height;
-        return rc;
-    };
-    return Layout;
-}());
-var Alignment;
-(function (Alignment) {
-    Alignment[Alignment["none"] = 0] = "none";
-    Alignment[Alignment["left"] = 1] = "left";
-    Alignment[Alignment["right"] = 2] = "right";
-    Alignment[Alignment["horizontalCenter"] = 4] = "horizontalCenter";
-    Alignment[Alignment["top"] = 8] = "top";
-    Alignment[Alignment["bottom"] = 16] = "bottom";
-    Alignment[Alignment["verticalCenter"] = 32] = "verticalCenter";
-    Alignment[Alignment["topLeft"] = 9] = "topLeft";
-    Alignment[Alignment["topRight"] = 10] = "topRight";
-    Alignment[Alignment["topCenter"] = 12] = "topCenter";
-    Alignment[Alignment["bottomLeft"] = 17] = "bottomLeft";
-    Alignment[Alignment["bottomRight"] = 18] = "bottomRight";
-    Alignment[Alignment["bottomCenter"] = 20] = "bottomCenter";
-    Alignment[Alignment["centerLeft"] = 33] = "centerLeft";
-    Alignment[Alignment["centerRight"] = 34] = "centerRight";
-    Alignment[Alignment["center"] = 36] = "center";
-})(Alignment || (Alignment = {}));
+        Layout.prototype.place = function (size, horizontalMargin, verticalMargine, alignment) {
+            var rc = new es.Rectangle(0, 0, size.x, size.y);
+            if ((alignment & Alignment.left) != 0) {
+                rc.x = this.clientArea.x + (this.clientArea.width * horizontalMargin);
+            }
+            else if ((alignment & Alignment.right) != 0) {
+                rc.x = this.clientArea.x + (this.clientArea.width * (1 - horizontalMargin)) - rc.width;
+            }
+            else if ((alignment & Alignment.horizontalCenter) != 0) {
+                rc.x = this.clientArea.x + (this.clientArea.width - rc.width) / 2 + (horizontalMargin * this.clientArea.width);
+            }
+            else {
+            }
+            if ((alignment & Alignment.top) != 0) {
+                rc.y = this.clientArea.y + (this.clientArea.height * verticalMargine);
+            }
+            else if ((alignment & Alignment.bottom) != 0) {
+                rc.y = this.clientArea.y + (this.clientArea.height * (1 - verticalMargine)) - rc.height;
+            }
+            else if ((alignment & Alignment.verticalCenter) != 0) {
+                rc.y = this.clientArea.y + (this.clientArea.height - rc.height) / 2 + (verticalMargine * this.clientArea.height);
+            }
+            else {
+            }
+            if (rc.left < this.safeArea.left)
+                rc.x = this.safeArea.left;
+            if (rc.right > this.safeArea.right)
+                rc.x = this.safeArea.right - rc.width;
+            if (rc.top < this.safeArea.top)
+                rc.y = this.safeArea.top;
+            if (rc.bottom > this.safeArea.bottom)
+                rc.y = this.safeArea.bottom - rc.height;
+            return rc;
+        };
+        return Layout;
+    }());
+    es.Layout = Layout;
+    var Alignment;
+    (function (Alignment) {
+        Alignment[Alignment["none"] = 0] = "none";
+        Alignment[Alignment["left"] = 1] = "left";
+        Alignment[Alignment["right"] = 2] = "right";
+        Alignment[Alignment["horizontalCenter"] = 4] = "horizontalCenter";
+        Alignment[Alignment["top"] = 8] = "top";
+        Alignment[Alignment["bottom"] = 16] = "bottom";
+        Alignment[Alignment["verticalCenter"] = 32] = "verticalCenter";
+        Alignment[Alignment["topLeft"] = 9] = "topLeft";
+        Alignment[Alignment["topRight"] = 10] = "topRight";
+        Alignment[Alignment["topCenter"] = 12] = "topCenter";
+        Alignment[Alignment["bottomLeft"] = 17] = "bottomLeft";
+        Alignment[Alignment["bottomRight"] = 18] = "bottomRight";
+        Alignment[Alignment["bottomCenter"] = 20] = "bottomCenter";
+        Alignment[Alignment["centerLeft"] = 33] = "centerLeft";
+        Alignment[Alignment["centerRight"] = 34] = "centerRight";
+        Alignment[Alignment["center"] = 36] = "center";
+    })(Alignment = es.Alignment || (es.Alignment = {}));
+})(es || (es = {}));
 var stopwatch;
 (function (stopwatch) {
     var Stopwatch = (function () {
@@ -6598,251 +7370,260 @@ var stopwatch;
     stopwatch.setDefaultSystemTimeGetter = setDefaultSystemTimeGetter;
     var _defaultSystemTimeGetter = Date.now;
 })(stopwatch || (stopwatch = {}));
-var TimeRuler = (function () {
-    function TimeRuler() {
-        this._frameKey = 'frame';
-        this._logKey = 'log';
-        this.markers = [];
-        this.stopwacth = new stopwatch.Stopwatch();
-        this._markerNameToIdMap = new Map();
-        this.showLog = false;
-        TimeRuler.Instance = this;
-        this._logs = new Array(2);
-        for (var i = 0; i < this._logs.length; ++i)
-            this._logs[i] = new FrameLog();
-        this.sampleFrames = this.targetSampleFrames = 1;
-        this.width = SceneManager.stage.stageWidth * 0.8;
-        this.onGraphicsDeviceReset();
-    }
-    TimeRuler.prototype.onGraphicsDeviceReset = function () {
-        var layout = new Layout();
-        this._position = layout.place(new Vector2(this.width, TimeRuler.barHeight), 0, 0.01, Alignment.bottomCenter).location;
-    };
-    TimeRuler.prototype.startFrame = function () {
-        var _this = this;
-        var lock = new LockUtils(this._frameKey);
-        lock.lock().then(function () {
-            _this._updateCount = parseInt(egret.localStorage.getItem(_this._frameKey), 10);
-            if (isNaN(_this._updateCount))
-                _this._updateCount = 0;
-            var count = _this._updateCount;
-            count += 1;
-            egret.localStorage.setItem(_this._frameKey, count.toString());
-            if (_this.enabled && (1 < count && count < TimeRuler.maxSampleFrames))
-                return;
-            _this._prevLog = _this._logs[_this.frameCount++ & 0x1];
-            _this._curLog = _this._logs[_this.frameCount & 0x1];
-            var endFrameTime = _this.stopwacth.getTime();
-            for (var barIndex = 0; barIndex < _this._prevLog.bars.length; ++barIndex) {
-                var prevBar = _this._prevLog.bars[barIndex];
-                var nextBar = _this._curLog.bars[barIndex];
-                for (var nest = 0; nest < prevBar.nestCount; ++nest) {
-                    var markerIdx = prevBar.markerNests[nest];
-                    prevBar.markers[markerIdx].endTime = endFrameTime;
-                    nextBar.markerNests[nest] = nest;
-                    nextBar.markers[nest].markerId = prevBar.markers[markerIdx].markerId;
-                    nextBar.markers[nest].beginTime = 0;
-                    nextBar.markers[nest].endTime = -1;
-                    nextBar.markers[nest].color = prevBar.markers[markerIdx].color;
-                }
-                for (var markerIdx = 0; markerIdx < prevBar.markCount; ++markerIdx) {
-                    var duration = prevBar.markers[markerIdx].endTime - prevBar.markers[markerIdx].beginTime;
-                    var markerId = prevBar.markers[markerIdx].markerId;
-                    var m = _this.markers[markerId];
-                    m.logs[barIndex].color = prevBar.markers[markerIdx].color;
-                    if (!m.logs[barIndex].initialized) {
-                        m.logs[barIndex].min = duration;
-                        m.logs[barIndex].max = duration;
-                        m.logs[barIndex].avg = duration;
-                        m.logs[barIndex].initialized = true;
+var es;
+(function (es) {
+    var TimeRuler = (function () {
+        function TimeRuler() {
+            this._frameKey = 'frame';
+            this._logKey = 'log';
+            this.markers = [];
+            this.stopwacth = new stopwatch.Stopwatch();
+            this._markerNameToIdMap = new Map();
+            this.showLog = false;
+            TimeRuler.Instance = this;
+            this._logs = new Array(2);
+            for (var i = 0; i < this._logs.length; ++i)
+                this._logs[i] = new FrameLog();
+            this.sampleFrames = this.targetSampleFrames = 1;
+            this.width = es.SceneManager.stage.stageWidth * 0.8;
+            this.onGraphicsDeviceReset();
+        }
+        TimeRuler.prototype.onGraphicsDeviceReset = function () {
+            var layout = new es.Layout();
+            this._position = layout.place(new es.Vector2(this.width, TimeRuler.barHeight), 0, 0.01, es.Alignment.bottomCenter).location;
+        };
+        TimeRuler.prototype.startFrame = function () {
+            var _this = this;
+            var lock = new LockUtils(this._frameKey);
+            lock.lock().then(function () {
+                _this._updateCount = parseInt(egret.localStorage.getItem(_this._frameKey), 10);
+                if (isNaN(_this._updateCount))
+                    _this._updateCount = 0;
+                var count = _this._updateCount;
+                count += 1;
+                egret.localStorage.setItem(_this._frameKey, count.toString());
+                if (_this.enabled && (1 < count && count < TimeRuler.maxSampleFrames))
+                    return;
+                _this._prevLog = _this._logs[_this.frameCount++ & 0x1];
+                _this._curLog = _this._logs[_this.frameCount & 0x1];
+                var endFrameTime = _this.stopwacth.getTime();
+                for (var barIndex = 0; barIndex < _this._prevLog.bars.length; ++barIndex) {
+                    var prevBar = _this._prevLog.bars[barIndex];
+                    var nextBar = _this._curLog.bars[barIndex];
+                    for (var nest = 0; nest < prevBar.nestCount; ++nest) {
+                        var markerIdx = prevBar.markerNests[nest];
+                        prevBar.markers[markerIdx].endTime = endFrameTime;
+                        nextBar.markerNests[nest] = nest;
+                        nextBar.markers[nest].markerId = prevBar.markers[markerIdx].markerId;
+                        nextBar.markers[nest].beginTime = 0;
+                        nextBar.markers[nest].endTime = -1;
+                        nextBar.markers[nest].color = prevBar.markers[markerIdx].color;
                     }
-                    else {
-                        m.logs[barIndex].min = Math.min(m.logs[barIndex].min, duration);
-                        m.logs[barIndex].max = Math.min(m.logs[barIndex].max, duration);
-                        m.logs[barIndex].avg += duration;
-                        m.logs[barIndex].avg *= 0.5;
-                        if (m.logs[barIndex].samples++ >= TimeRuler.logSnapDuration) {
-                            m.logs[barIndex].snapMin = m.logs[barIndex].min;
-                            m.logs[barIndex].snapMax = m.logs[barIndex].max;
-                            m.logs[barIndex].snapAvg = m.logs[barIndex].avg;
-                            m.logs[barIndex].samples = 0;
+                    for (var markerIdx = 0; markerIdx < prevBar.markCount; ++markerIdx) {
+                        var duration = prevBar.markers[markerIdx].endTime - prevBar.markers[markerIdx].beginTime;
+                        var markerId = prevBar.markers[markerIdx].markerId;
+                        var m = _this.markers[markerId];
+                        m.logs[barIndex].color = prevBar.markers[markerIdx].color;
+                        if (!m.logs[barIndex].initialized) {
+                            m.logs[barIndex].min = duration;
+                            m.logs[barIndex].max = duration;
+                            m.logs[barIndex].avg = duration;
+                            m.logs[barIndex].initialized = true;
+                        }
+                        else {
+                            m.logs[barIndex].min = Math.min(m.logs[barIndex].min, duration);
+                            m.logs[barIndex].max = Math.min(m.logs[barIndex].max, duration);
+                            m.logs[barIndex].avg += duration;
+                            m.logs[barIndex].avg *= 0.5;
+                            if (m.logs[barIndex].samples++ >= TimeRuler.logSnapDuration) {
+                                m.logs[barIndex].snapMin = m.logs[barIndex].min;
+                                m.logs[barIndex].snapMax = m.logs[barIndex].max;
+                                m.logs[barIndex].snapAvg = m.logs[barIndex].avg;
+                                m.logs[barIndex].samples = 0;
+                            }
                         }
                     }
+                    nextBar.markCount = prevBar.nestCount;
+                    nextBar.nestCount = prevBar.nestCount;
                 }
-                nextBar.markCount = prevBar.nestCount;
-                nextBar.nestCount = prevBar.nestCount;
-            }
-            _this.stopwacth.reset();
-            _this.stopwacth.start();
-        });
-    };
-    TimeRuler.prototype.beginMark = function (markerName, color, barIndex) {
-        var _this = this;
-        if (barIndex === void 0) { barIndex = 0; }
-        var lock = new LockUtils(this._frameKey);
-        lock.lock().then(function () {
-            if (barIndex < 0 || barIndex >= TimeRuler.maxBars)
+                _this.stopwacth.reset();
+                _this.stopwacth.start();
+            });
+        };
+        TimeRuler.prototype.beginMark = function (markerName, color, barIndex) {
+            var _this = this;
+            if (barIndex === void 0) { barIndex = 0; }
+            var lock = new LockUtils(this._frameKey);
+            lock.lock().then(function () {
+                if (barIndex < 0 || barIndex >= TimeRuler.maxBars)
+                    throw new Error("barIndex argument out of range");
+                var bar = _this._curLog.bars[barIndex];
+                if (bar.markCount >= TimeRuler.maxSamples) {
+                    throw new Error("exceeded sample count. either set larger number to timeruler.maxsaple or lower sample count");
+                }
+                if (bar.nestCount >= TimeRuler.maxNestCall) {
+                    throw new Error("exceeded nest count. either set larger number to timeruler.maxnestcall or lower nest calls");
+                }
+                var markerId = _this._markerNameToIdMap.get(markerName);
+                if (isNaN(markerId)) {
+                    markerId = _this.markers.length;
+                    _this._markerNameToIdMap.set(markerName, markerId);
+                }
+                bar.markerNests[bar.nestCount++] = bar.markCount;
+                bar.markers[bar.markCount].markerId = markerId;
+                bar.markers[bar.markCount].color = color;
+                bar.markers[bar.markCount].beginTime = _this.stopwacth.getTime();
+                bar.markers[bar.markCount].endTime = -1;
+            });
+        };
+        TimeRuler.prototype.endMark = function (markerName, barIndex) {
+            var _this = this;
+            if (barIndex === void 0) { barIndex = 0; }
+            var lock = new LockUtils(this._frameKey);
+            lock.lock().then(function () {
+                if (barIndex < 0 || barIndex >= TimeRuler.maxBars)
+                    throw new Error("barIndex argument out of range");
+                var bar = _this._curLog.bars[barIndex];
+                if (bar.nestCount <= 0) {
+                    throw new Error("call beginMark method before calling endMark method");
+                }
+                var markerId = _this._markerNameToIdMap.get(markerName);
+                if (isNaN(markerId)) {
+                    throw new Error("Marker " + markerName + " is not registered. Make sure you specifed same name as you used for beginMark method");
+                }
+                var markerIdx = bar.markerNests[--bar.nestCount];
+                if (bar.markers[markerIdx].markerId != markerId) {
+                    throw new Error("Incorrect call order of beginMark/endMark method. beginMark(A), beginMark(B), endMark(B), endMark(A) But you can't called it like beginMark(A), beginMark(B), endMark(A), endMark(B).");
+                }
+                bar.markers[markerIdx].endTime = _this.stopwacth.getTime();
+            });
+        };
+        TimeRuler.prototype.getAverageTime = function (barIndex, markerName) {
+            if (barIndex < 0 || barIndex >= TimeRuler.maxBars) {
                 throw new Error("barIndex argument out of range");
-            var bar = _this._curLog.bars[barIndex];
-            if (bar.markCount >= TimeRuler.maxSamples) {
-                throw new Error("exceeded sample count. either set larger number to timeruler.maxsaple or lower sample count");
             }
-            if (bar.nestCount >= TimeRuler.maxNestCall) {
-                throw new Error("exceeded nest count. either set larger number to timeruler.maxnestcall or lower nest calls");
+            var result = 0;
+            var markerId = this._markerNameToIdMap.get(markerName);
+            if (markerId) {
+                result = this.markers[markerId].logs[barIndex].avg;
             }
-            var markerId = _this._markerNameToIdMap.get(markerName);
-            if (isNaN(markerId)) {
-                markerId = _this.markers.length;
-                _this._markerNameToIdMap.set(markerName, markerId);
-            }
-            bar.markerNests[bar.nestCount++] = bar.markCount;
-            bar.markers[bar.markCount].markerId = markerId;
-            bar.markers[bar.markCount].color = color;
-            bar.markers[bar.markCount].beginTime = _this.stopwacth.getTime();
-            bar.markers[bar.markCount].endTime = -1;
-        });
-    };
-    TimeRuler.prototype.endMark = function (markerName, barIndex) {
-        var _this = this;
-        if (barIndex === void 0) { barIndex = 0; }
-        var lock = new LockUtils(this._frameKey);
-        lock.lock().then(function () {
-            if (barIndex < 0 || barIndex >= TimeRuler.maxBars)
-                throw new Error("barIndex argument out of range");
-            var bar = _this._curLog.bars[barIndex];
-            if (bar.nestCount <= 0) {
-                throw new Error("call beginMark method before calling endMark method");
-            }
-            var markerId = _this._markerNameToIdMap.get(markerName);
-            if (isNaN(markerId)) {
-                throw new Error("Marker " + markerName + " is not registered. Make sure you specifed same name as you used for beginMark method");
-            }
-            var markerIdx = bar.markerNests[--bar.nestCount];
-            if (bar.markers[markerIdx].markerId != markerId) {
-                throw new Error("Incorrect call order of beginMark/endMark method. beginMark(A), beginMark(B), endMark(B), endMark(A) But you can't called it like beginMark(A), beginMark(B), endMark(A), endMark(B).");
-            }
-            bar.markers[markerIdx].endTime = _this.stopwacth.getTime();
-        });
-    };
-    TimeRuler.prototype.getAverageTime = function (barIndex, markerName) {
-        if (barIndex < 0 || barIndex >= TimeRuler.maxBars) {
-            throw new Error("barIndex argument out of range");
-        }
-        var result = 0;
-        var markerId = this._markerNameToIdMap.get(markerName);
-        if (markerId) {
-            result = this.markers[markerId].logs[barIndex].avg;
-        }
-        return result;
-    };
-    TimeRuler.prototype.resetLog = function () {
-        var _this = this;
-        var lock = new LockUtils(this._logKey);
-        lock.lock().then(function () {
-            var count = parseInt(egret.localStorage.getItem(_this._logKey), 10);
-            count += 1;
-            egret.localStorage.setItem(_this._logKey, count.toString());
-            _this.markers.forEach(function (markerInfo) {
-                for (var i = 0; i < markerInfo.logs.length; ++i) {
-                    markerInfo.logs[i].initialized = false;
-                    markerInfo.logs[i].snapMin = 0;
-                    markerInfo.logs[i].snapMax = 0;
-                    markerInfo.logs[i].snapAvg = 0;
-                    markerInfo.logs[i].min = 0;
-                    markerInfo.logs[i].max = 0;
-                    markerInfo.logs[i].avg = 0;
-                    markerInfo.logs[i].samples = 0;
+            return result;
+        };
+        TimeRuler.prototype.resetLog = function () {
+            var _this = this;
+            var lock = new LockUtils(this._logKey);
+            lock.lock().then(function () {
+                var count = parseInt(egret.localStorage.getItem(_this._logKey), 10);
+                count += 1;
+                egret.localStorage.setItem(_this._logKey, count.toString());
+                _this.markers.forEach(function (markerInfo) {
+                    for (var i = 0; i < markerInfo.logs.length; ++i) {
+                        markerInfo.logs[i].initialized = false;
+                        markerInfo.logs[i].snapMin = 0;
+                        markerInfo.logs[i].snapMax = 0;
+                        markerInfo.logs[i].snapAvg = 0;
+                        markerInfo.logs[i].min = 0;
+                        markerInfo.logs[i].max = 0;
+                        markerInfo.logs[i].avg = 0;
+                        markerInfo.logs[i].samples = 0;
+                    }
+                });
+            });
+        };
+        TimeRuler.prototype.render = function (position, width) {
+            if (position === void 0) { position = this._position; }
+            if (width === void 0) { width = this.width; }
+            egret.localStorage.setItem(this._frameKey, "0");
+            if (!this.showLog)
+                return;
+            var height = 0;
+            var maxTime = 0;
+            this._prevLog.bars.forEach(function (bar) {
+                if (bar.markCount > 0) {
+                    height += TimeRuler.barHeight + TimeRuler.barPadding * 2;
+                    maxTime = Math.max(maxTime, bar.markers[bar.markCount - 1].endTime);
                 }
             });
-        });
-    };
-    TimeRuler.prototype.render = function (position, width) {
-        if (position === void 0) { position = this._position; }
-        if (width === void 0) { width = this.width; }
-        egret.localStorage.setItem(this._frameKey, "0");
-        if (!this.showLog)
-            return;
-        var height = 0;
-        var maxTime = 0;
-        this._prevLog.bars.forEach(function (bar) {
-            if (bar.markCount > 0) {
-                height += TimeRuler.barHeight + TimeRuler.barPadding * 2;
-                maxTime = Math.max(maxTime, bar.markers[bar.markCount - 1].endTime);
+            var frameSpan = 1 / 60 * 1000;
+            var sampleSpan = this.sampleFrames * frameSpan;
+            if (maxTime > sampleSpan) {
+                this._frameAdjust = Math.max(0, this._frameAdjust) + 1;
             }
-        });
-        var frameSpan = 1 / 60 * 1000;
-        var sampleSpan = this.sampleFrames * frameSpan;
-        if (maxTime > sampleSpan) {
-            this._frameAdjust = Math.max(0, this._frameAdjust) + 1;
+            else {
+                this._frameAdjust = Math.min(0, this._frameAdjust) - 1;
+            }
+            if (Math.max(this._frameAdjust) > TimeRuler.autoAdjustDelay) {
+                this.sampleFrames = Math.min(TimeRuler.maxSampleFrames, this.sampleFrames);
+                this.sampleFrames = Math.max(this.targetSampleFrames, (maxTime / frameSpan) + 1);
+                this._frameAdjust = 0;
+            }
+            var msToPs = width / sampleSpan;
+            var startY = position.y - (height - TimeRuler.barHeight);
+            var y = startY;
+        };
+        TimeRuler.maxBars = 8;
+        TimeRuler.maxSamples = 256;
+        TimeRuler.maxNestCall = 32;
+        TimeRuler.barHeight = 8;
+        TimeRuler.maxSampleFrames = 4;
+        TimeRuler.logSnapDuration = 120;
+        TimeRuler.barPadding = 2;
+        TimeRuler.autoAdjustDelay = 30;
+        return TimeRuler;
+    }());
+    es.TimeRuler = TimeRuler;
+    var FrameLog = (function () {
+        function FrameLog() {
+            this.bars = new Array(TimeRuler.maxBars);
+            this.bars.fill(new MarkerCollection(), 0, TimeRuler.maxBars);
         }
-        else {
-            this._frameAdjust = Math.min(0, this._frameAdjust) - 1;
+        return FrameLog;
+    }());
+    es.FrameLog = FrameLog;
+    var MarkerCollection = (function () {
+        function MarkerCollection() {
+            this.markers = new Array(TimeRuler.maxSamples);
+            this.markCount = 0;
+            this.markerNests = new Array(TimeRuler.maxNestCall);
+            this.nestCount = 0;
+            this.markers.fill(new Marker(), 0, TimeRuler.maxSamples);
+            this.markerNests.fill(0, 0, TimeRuler.maxNestCall);
         }
-        if (Math.max(this._frameAdjust) > TimeRuler.autoAdjustDelay) {
-            this.sampleFrames = Math.min(TimeRuler.maxSampleFrames, this.sampleFrames);
-            this.sampleFrames = Math.max(this.targetSampleFrames, (maxTime / frameSpan) + 1);
-            this._frameAdjust = 0;
+        return MarkerCollection;
+    }());
+    es.MarkerCollection = MarkerCollection;
+    var Marker = (function () {
+        function Marker() {
+            this.markerId = 0;
+            this.beginTime = 0;
+            this.endTime = 0;
+            this.color = 0x000000;
         }
-        var msToPs = width / sampleSpan;
-        var startY = position.y - (height - TimeRuler.barHeight);
-        var y = startY;
-    };
-    TimeRuler.maxBars = 8;
-    TimeRuler.maxSamples = 256;
-    TimeRuler.maxNestCall = 32;
-    TimeRuler.barHeight = 8;
-    TimeRuler.maxSampleFrames = 4;
-    TimeRuler.logSnapDuration = 120;
-    TimeRuler.barPadding = 2;
-    TimeRuler.autoAdjustDelay = 30;
-    return TimeRuler;
-}());
-var FrameLog = (function () {
-    function FrameLog() {
-        this.bars = new Array(TimeRuler.maxBars);
-        this.bars.fill(new MarkerCollection(), 0, TimeRuler.maxBars);
-    }
-    return FrameLog;
-}());
-var MarkerCollection = (function () {
-    function MarkerCollection() {
-        this.markers = new Array(TimeRuler.maxSamples);
-        this.markCount = 0;
-        this.markerNests = new Array(TimeRuler.maxNestCall);
-        this.nestCount = 0;
-        this.markers.fill(new Marker(), 0, TimeRuler.maxSamples);
-        this.markerNests.fill(0, 0, TimeRuler.maxNestCall);
-    }
-    return MarkerCollection;
-}());
-var Marker = (function () {
-    function Marker() {
-        this.markerId = 0;
-        this.beginTime = 0;
-        this.endTime = 0;
-        this.color = 0x000000;
-    }
-    return Marker;
-}());
-var MarkerInfo = (function () {
-    function MarkerInfo(name) {
-        this.logs = new Array(TimeRuler.maxBars);
-        this.name = name;
-        this.logs.fill(new MarkerLog(), 0, TimeRuler.maxBars);
-    }
-    return MarkerInfo;
-}());
-var MarkerLog = (function () {
-    function MarkerLog() {
-        this.snapMin = 0;
-        this.snapMax = 0;
-        this.snapAvg = 0;
-        this.min = 0;
-        this.max = 0;
-        this.avg = 0;
-        this.samples = 0;
-        this.color = 0x000000;
-        this.initialized = false;
-    }
-    return MarkerLog;
-}());
+        return Marker;
+    }());
+    es.Marker = Marker;
+    var MarkerInfo = (function () {
+        function MarkerInfo(name) {
+            this.logs = new Array(TimeRuler.maxBars);
+            this.name = name;
+            this.logs.fill(new MarkerLog(), 0, TimeRuler.maxBars);
+        }
+        return MarkerInfo;
+    }());
+    es.MarkerInfo = MarkerInfo;
+    var MarkerLog = (function () {
+        function MarkerLog() {
+            this.snapMin = 0;
+            this.snapMax = 0;
+            this.snapAvg = 0;
+            this.min = 0;
+            this.max = 0;
+            this.avg = 0;
+            this.samples = 0;
+            this.color = 0x000000;
+            this.initialized = false;
+        }
+        return MarkerLog;
+    }());
+    es.MarkerLog = MarkerLog;
+})(es || (es = {}));
diff --git a/demo/libs/framework/framework.min.js b/demo/libs/framework/framework.min.js
index d6c96e6d..21b482eb 100644
--- a/demo/libs/framework/framework.min.js
+++ b/demo/libs/framework/framework.min.js
@@ -1 +1 @@
-window.framework={},window.__extends=this&&this.__extends||function(){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n])};return function(e,n){function i(){this.constructor=e}t(e,n),e.prototype=null===n?Object.create(n):(i.prototype=n.prototype,new i)}}();var __awaiter=this&&this.__awaiter||function(t,e,n,i){return new(n||(n=Promise))(function(r,o){function s(t){try{c(i.next(t))}catch(t){o(t)}}function a(t){try{c(i.throw(t))}catch(t){o(t)}}function c(t){t.done?r(t.value):new n(function(e){e(t.value)}).then(s,a)}c((i=i.apply(t,e||[])).next())})},__generator=this&&this.__generator||function(t,e){var n,i,r,o,s={label:0,sent:function(){if(1&r[0])throw r[1];return r[1]},trys:[],ops:[]};return o={next:a(0),throw:a(1),return:a(2)},"function"==typeof Symbol&&(o[Symbol.iterator]=function(){return this}),o;function a(o){return function(a){return function(o){if(n)throw new TypeError("Generator is already executing.");for(;s;)try{if(n=1,i&&(r=2&o[0]?i.return:o[0]?i.throw||((r=i.return)&&r.call(i),0):i.next)&&!(r=r.call(i,o[1])).done)return r;switch(i=0,r&&(o=[2&o[0],r.value]),o[0]){case 0:case 1:r=o;break;case 4:return s.label++,{value:o[1],done:!1};case 5:s.label++,i=o[1],o=[0];continue;case 7:o=s.ops.pop(),s.trys.pop();continue;default:if(!(r=(r=s.trys).length>0&&r[r.length-1])&&(6===o[0]||2===o[0])){s=0;continue}if(3===o[0]&&(!r||o[1]>r[0]&&o[1]<r[3])){s.label=o[1];break}if(6===o[0]&&s.label<r[1]){s.label=r[1],r=o;break}if(r&&s.label<r[2]){s.label=r[2],s.ops.push(o);break}r[2]&&s.ops.pop(),s.trys.pop();continue}o=e.call(t,s)}catch(t){o=[6,t],i=0}finally{n=r=0}if(5&o[0])throw o[1];return{value:o[0]?o[1]:void 0,done:!0}}([o,a])}}};Array.prototype.findIndex=function(t){return function(t,e){for(var n=0,i=t.length;n<i;n++)if(e.call(arguments[2],t[n],n,t))return n;return-1}(this,t)},Array.prototype.any=function(t){return function(t,e){return t.findIndex(e)>-1}(this,t)},Array.prototype.firstOrDefault=function(t){return function(t,e){var n=t.findIndex(e);return-1==n?null:t[n]}(this,t)},Array.prototype.find=function(t){return function(t,e){return t.firstOrDefault(e)}(this,t)},Array.prototype.where=function(t){return function(t,e){if("function"==typeof t.reduce)return t.reduce(function(n,i,r){return e.call(arguments[2],i,r,t)&&n.push(i),n},[]);for(var n=[],i=0,r=t.length;i<r;i++){var o=t[i];e.call(arguments[2],o,i,t)&&n.push(o)}return n}(this,t)},Array.prototype.count=function(t){return function(t,e){return t.where(e).length}(this,t)},Array.prototype.findAll=function(t){return function(t,e){return t.where(e)}(this,t)},Array.prototype.contains=function(t){return function(t,e){for(var n=0,i=t.length;n<i;n++)if(t[n]==e)return!0;return!1}(this,t)},Array.prototype.removeAll=function(t){!function(t,e){var n;do{(n=t.findIndex(e))>=0&&t.splice(n,1)}while(n>=0)}(this,t)},Array.prototype.remove=function(t){return function(t,e){var n=t.findIndex(function(t){return t===e});return n>=0&&(t.splice(n,1),!0)}(this,t)},Array.prototype.removeAt=function(t){return function(t,e){t.splice(e,1)}(this,t)},Array.prototype.removeRange=function(t,e){return function(t,e,n){t.splice(e,n)}(this,t,e)},Array.prototype.select=function(t){return function(t,e){if("function"==typeof t.reduce)return t.reduce(function(n,i,r){return n.push(e.call(arguments[2],i,r,t)),n},[]);for(var n=[],i=0,r=t.length;i<r;i++)n.push(e.call(arguments[2],t[i],i,t));return n}(this,t)},Array.prototype.orderBy=function(t,e){return function(t,e,n){return t.sort(function(t,i){var r=e(t),o=e(i);return n?n(r,o):r>o?1:-1}),t}(this,t,e)},Array.prototype.orderByDescending=function(t,e){return function(t,e,n){return t.sort(function(t,i){var r=e(t),o=e(i);return n?-n(r,o):r<o?1:-1}),t}(this,t,e)},Array.prototype.groupBy=function(t){return function(t,e){if("function"==typeof t.reduce){var n=[];return t.reduce(function(i,r,o){var s=JSON.stringify(e.call(arguments[1],r,o,t)),a=n.findIndex(function(t){return t===s});return a<0&&(a=n.push(s)-1),i[a]||(i[a]=[]),i[a].push(r),i},[])}for(var i=[],r=[],o=function(n,o){var a=JSON.stringify(e.call(s[1],t[n],n,t)),c=r.findIndex(function(t){return t===a});c<0&&(c=r.push(a)-1),i[c]||(i[c]=[]),i[c].push(t[n])},s=arguments,a=0,c=t.length;a<c;a++)o(a);return i}(this,t)},Array.prototype.sum=function(t){return function(t,e){for(var n,i=0,r=t.length;i<r;i++)0==i?n=e?e.call(arguments[2],t[i],i,t):t[i]:n+=e?e.call(arguments[2],t[i],i,t):t[i];return n}(this,t)};var DebugDrawType,PriorityQueueNode=function(){return function(){this.priority=0,this.insertionIndex=0,this.queueIndex=0}}(),AStarPathfinder=function(){function t(){}return t.search=function(t,e,n){var i=this,r=!1,o=new Map;o.set(e,e);var s=new Map,a=new PriorityQueue(1e3);a.enqueue(new AStarNode(e),0),s.set(e,0);for(var c=function(){var e=a.dequeue();if(JSON.stringify(e.data)==JSON.stringify(n))return r=!0,"break";t.getNeighbors(e.data).forEach(function(r){var c=s.get(e.data)+t.cost(e.data,r);if(!i.hasKey(s,r)||c<s.get(r)){s.set(r,c);var h=c+t.heuristic(r,n);a.enqueue(new AStarNode(r),h),o.set(r,e.data)}})};a.count>0;){if("break"===c())break}return r?this.recontructPath(o,e,n):null},t.hasKey=function(t,e){for(var n,i=t.keys();!(n=i.next()).done;)if(JSON.stringify(n.value)==JSON.stringify(e))return!0;return!1},t.getKey=function(t,e){for(var n,i,r=t.keys(),o=t.values();n=r.next(),i=o.next(),!n.done;)if(JSON.stringify(n.value)==JSON.stringify(e))return i.value;return null},t.recontructPath=function(t,e,n){var i=[],r=n;for(i.push(n);r!=e;)r=this.getKey(t,r),i.push(r);return i.reverse(),i},t}(),AStarNode=function(t){function e(e){var n=t.call(this)||this;return n.data=e,n}return __extends(e,t),e}(PriorityQueueNode),AstarGridGraph=function(){function t(t,e){this.dirs=[new Vector2(1,0),new Vector2(0,-1),new Vector2(-1,0),new Vector2(0,1)],this.walls=[],this.weightedNodes=[],this.defaultWeight=1,this.weightedNodeWeight=5,this._neighbors=new Array(4),this._width=t,this._height=e}return t.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._height},t.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},t.prototype.search=function(t,e){return AStarPathfinder.search(this,t,e)},t.prototype.getNeighbors=function(t){var e=this;return this._neighbors.length=0,this.dirs.forEach(function(n){var i=new Vector2(t.x+n.x,t.y+n.y);e.isNodeInBounds(i)&&e.isNodePassable(i)&&e._neighbors.push(i)}),this._neighbors},t.prototype.cost=function(t,e){return this.weightedNodes.find(function(t){return JSON.stringify(t)==JSON.stringify(e)})?this.weightedNodeWeight:this.defaultWeight},t.prototype.heuristic=function(t,e){return Math.abs(t.x-e.x)+Math.abs(t.y-e.y)},t}(),PriorityQueue=function(){function t(t){this._numNodes=0,this._nodes=new Array(t+1),this._numNodesEverEnqueued=0}return t.prototype.clear=function(){this._nodes.splice(1,this._numNodes),this._numNodes=0},Object.defineProperty(t.prototype,"count",{get:function(){return this._numNodes},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"maxSize",{get:function(){return this._nodes.length-1},enumerable:!0,configurable:!0}),t.prototype.contains=function(t){return t?t.queueIndex<0||t.queueIndex>=this._nodes.length?(console.error("node.QueueIndex has been corrupted. Did you change it manually? Or add this node to another queue?"),!1):this._nodes[t.queueIndex]==t:(console.error("node cannot be null"),!1)},t.prototype.enqueue=function(t,e){t.priority=e,this._numNodes++,this._nodes[this._numNodes]=t,t.queueIndex=this._numNodes,t.insertionIndex=this._numNodesEverEnqueued++,this.cascadeUp(this._nodes[this._numNodes])},t.prototype.dequeue=function(){var t=this._nodes[1];return this.remove(t),t},t.prototype.remove=function(t){if(t.queueIndex==this._numNodes)return this._nodes[this._numNodes]=null,void this._numNodes--;var e=this._nodes[this._numNodes];this.swap(t,e),delete this._nodes[this._numNodes],this._numNodes--,this.onNodeUpdated(e)},t.prototype.isValidQueue=function(){for(var t=1;t<this._nodes.length;t++)if(this._nodes[t]){var e=2*t;if(e<this._nodes.length&&this._nodes[e]&&this.hasHigherPriority(this._nodes[e],this._nodes[t]))return!1;var n=e+1;if(n<this._nodes.length&&this._nodes[n]&&this.hasHigherPriority(this._nodes[n],this._nodes[t]))return!1}return!0},t.prototype.onNodeUpdated=function(t){var e=Math.floor(t.queueIndex/2),n=this._nodes[e];e>0&&this.hasHigherPriority(t,n)?this.cascadeUp(t):this.cascadeDown(t)},t.prototype.cascadeDown=function(t){for(var e,n=t.queueIndex;;){e=t;var i=2*n;if(i>this._numNodes){t.queueIndex=n,this._nodes[n]=t;break}var r=this._nodes[i];this.hasHigherPriority(r,e)&&(e=r);var o=i+1;if(o<=this._numNodes){var s=this._nodes[o];this.hasHigherPriority(s,e)&&(e=s)}if(e==t){t.queueIndex=n,this._nodes[n]=t;break}this._nodes[n]=e;var a=e.queueIndex;e.queueIndex=n,n=a}},t.prototype.cascadeUp=function(t){for(var e=Math.floor(t.queueIndex/2);e>=1;){var n=this._nodes[e];if(this.hasHigherPriority(n,t))break;this.swap(t,n),e=Math.floor(t.queueIndex/2)}},t.prototype.swap=function(t,e){this._nodes[t.queueIndex]=e,this._nodes[e.queueIndex]=t;var n=t.queueIndex;t.queueIndex=e.queueIndex,e.queueIndex=n},t.prototype.hasHigherPriority=function(t,e){return t.priority<e.priority||t.priority==e.priority&&t.insertionIndex<e.insertionIndex},t}(),BreadthFirstPathfinder=function(){function t(){}return t.search=function(t,e,n){var i=this,r=!1,o=[];o.unshift(e);var s=new Map;s.set(e,e);for(var a=function(){var e=o.shift();if(JSON.stringify(e)==JSON.stringify(n))return r=!0,"break";t.getNeighbors(e).forEach(function(t){i.hasKey(s,t)||(o.unshift(t),s.set(t,e))})};o.length>0;){if("break"===a())break}return r?AStarPathfinder.recontructPath(s,e,n):null},t.hasKey=function(t,e){for(var n,i=t.keys();!(n=i.next()).done;)if(JSON.stringify(n.value)==JSON.stringify(e))return!0;return!1},t}(),UnweightedGraph=function(){function t(){this.edges=new Map}return t.prototype.addEdgesForNode=function(t,e){return this.edges.set(t,e),this},t.prototype.getNeighbors=function(t){return this.edges.get(t)},t}(),Vector2=function(){function t(t,e){this.x=0,this.y=0,this.x=t||0,this.y=e||this.x}return Object.defineProperty(t,"zero",{get:function(){return t.zeroVector2},enumerable:!0,configurable:!0}),Object.defineProperty(t,"one",{get:function(){return t.unitVector2},enumerable:!0,configurable:!0}),Object.defineProperty(t,"unitX",{get:function(){return t.unitXVector},enumerable:!0,configurable:!0}),Object.defineProperty(t,"unitY",{get:function(){return t.unitYVector},enumerable:!0,configurable:!0}),t.add=function(e,n){var i=new t(0,0);return i.x=e.x+n.x,i.y=e.y+n.y,i},t.divide=function(e,n){var i=new t(0,0);return i.x=e.x/n.x,i.y=e.y/n.y,i},t.multiply=function(e,n){var i=new t(0,0);return i.x=e.x*n.x,i.y=e.y*n.y,i},t.subtract=function(e,n){var i=new t(0,0);return i.x=e.x-n.x,i.y=e.y-n.y,i},t.prototype.normalize=function(){var t=1/Math.sqrt(this.x*this.x+this.y*this.y);this.x*=t,this.y*=t},t.prototype.length=function(){return Math.sqrt(this.x*this.x+this.y*this.y)},t.prototype.round=function(){return new t(Math.round(this.x),Math.round(this.y))},t.normalize=function(t){var e=1/Math.sqrt(t.x*t.x+t.y*t.y);return t.x*=e,t.y*=e,t},t.dot=function(t,e){return t.x*e.x+t.y*e.y},t.distanceSquared=function(t,e){var n=t.x-e.x,i=t.y-e.y;return n*n+i*i},t.clamp=function(e,n,i){return new t(MathHelper.clamp(e.x,n.x,i.x),MathHelper.clamp(e.y,n.y,i.y))},t.lerp=function(e,n,i){return new t(MathHelper.lerp(e.x,n.x,i),MathHelper.lerp(e.y,n.y,i))},t.transform=function(e,n){return new t(e.x*n.m11+e.y*n.m21,e.x*n.m12+e.y*n.m22)},t.distance=function(t,e){var n=t.x-e.x,i=t.y-e.y;return Math.sqrt(n*n+i*i)},t.negate=function(e){var n=new t;return n.x=-e.x,n.y=-e.y,n},t.unitYVector=new t(0,1),t.unitXVector=new t(1,0),t.unitVector2=new t(1,1),t.zeroVector2=new t(0,0),t}(),UnweightedGridGraph=function(){function t(e,n,i){void 0===i&&(i=!1),this.walls=[],this._neighbors=new Array(4),this._width=e,this._hegiht=n,this._dirs=i?t.COMPASS_DIRS:t.CARDINAL_DIRS}return t.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._hegiht},t.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},t.prototype.getNeighbors=function(t){var e=this;return this._neighbors.length=0,this._dirs.forEach(function(n){var i=new Vector2(t.x+n.x,t.y+n.y);e.isNodeInBounds(i)&&e.isNodePassable(i)&&e._neighbors.push(i)}),this._neighbors},t.prototype.search=function(t,e){return BreadthFirstPathfinder.search(this,t,e)},t.CARDINAL_DIRS=[new Vector2(1,0),new Vector2(0,-1),new Vector2(-1,0),new Vector2(0,-1)],t.COMPASS_DIRS=[new Vector2(1,0),new Vector2(1,-1),new Vector2(0,-1),new Vector2(-1,-1),new Vector2(-1,0),new Vector2(-1,1),new Vector2(0,1),new Vector2(1,1)],t}(),WeightedGridGraph=function(){function t(e,n,i){void 0===i&&(i=!1),this.walls=[],this.weightedNodes=[],this.defaultWeight=1,this.weightedNodeWeight=5,this._neighbors=new Array(4),this._width=e,this._height=n,this._dirs=i?t.COMPASS_DIRS:t.CARDINAL_DIRS}return t.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._height},t.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},t.prototype.search=function(t,e){return WeightedPathfinder.search(this,t,e)},t.prototype.getNeighbors=function(t){var e=this;return this._neighbors.length=0,this._dirs.forEach(function(n){var i=new Vector2(t.x+n.x,t.y+n.y);e.isNodeInBounds(i)&&e.isNodePassable(i)&&e._neighbors.push(i)}),this._neighbors},t.prototype.cost=function(t,e){return this.weightedNodes.find(function(t){return JSON.stringify(t)==JSON.stringify(e)})?this.weightedNodeWeight:this.defaultWeight},t.CARDINAL_DIRS=[new Vector2(1,0),new Vector2(0,-1),new Vector2(-1,0),new Vector2(0,1)],t.COMPASS_DIRS=[new Vector2(1,0),new Vector2(1,-1),new Vector2(0,-1),new Vector2(-1,-1),new Vector2(-1,0),new Vector2(-1,1),new Vector2(0,1),new Vector2(1,1)],t}(),WeightedNode=function(t){function e(e){var n=t.call(this)||this;return n.data=e,n}return __extends(e,t),e}(PriorityQueueNode),WeightedPathfinder=function(){function t(){}return t.search=function(t,e,n){var i=this,r=!1,o=new Map;o.set(e,e);var s=new Map,a=new PriorityQueue(1e3);a.enqueue(new WeightedNode(e),0),s.set(e,0);for(var c=function(){var e=a.dequeue();if(JSON.stringify(e.data)==JSON.stringify(n))return r=!0,"break";t.getNeighbors(e.data).forEach(function(n){var r=s.get(e.data)+t.cost(e.data,n);if(!i.hasKey(s,n)||r<s.get(n)){s.set(n,r);var c=r;a.enqueue(new WeightedNode(n),c),o.set(n,e.data)}})};a.count>0;){if("break"===c())break}return r?this.recontructPath(o,e,n):null},t.hasKey=function(t,e){for(var n,i=t.keys();!(n=i.next()).done;)if(JSON.stringify(n.value)==JSON.stringify(e))return!0;return!1},t.getKey=function(t,e){for(var n,i,r=t.keys(),o=t.values();n=r.next(),i=o.next(),!n.done;)if(JSON.stringify(n.value)==JSON.stringify(e))return i.value;return null},t.recontructPath=function(t,e,n){var i=[],r=n;for(i.push(n);r!=e;)r=this.getKey(t,r),i.push(r);return i.reverse(),i},t}(),Debug=function(){function t(){}return t.drawHollowRect=function(t,e,n){void 0===n&&(n=0),this._debugDrawItems.push(new DebugDrawItem(t,e,n))},t.render=function(){if(this._debugDrawItems.length>0){var t=new egret.Shape;SceneManager.scene&&SceneManager.scene.addChild(t);for(var e=this._debugDrawItems.length-1;e>=0;e--){this._debugDrawItems[e].draw(t)&&this._debugDrawItems.removeAt(e)}}},t._debugDrawItems=[],t}(),DebugDefaults=function(){function t(){}return t.verletParticle=14431326,t.verletConstraintEdge=4406838,t}();!function(t){t[t.line=0]="line",t[t.hollowRectangle=1]="hollowRectangle",t[t.pixel=2]="pixel",t[t.text=3]="text"}(DebugDrawType||(DebugDrawType={}));var CoreEvents,DebugDrawItem=function(){function t(t,e,n){this.rectangle=t,this.color=e,this.duration=n,this.drawType=DebugDrawType.hollowRectangle}return t.prototype.draw=function(t){switch(this.drawType){case DebugDrawType.line:DrawUtils.drawLine(t,this.start,this.end,this.color);break;case DebugDrawType.hollowRectangle:DrawUtils.drawHollowRect(t,this.rectangle,this.color);break;case DebugDrawType.pixel:DrawUtils.drawPixel(t,new Vector2(this.x,this.y),this.color,this.size);break;case DebugDrawType.text:}return this.duration-=Time.deltaTime,this.duration<0},t}(),Component=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e._enabled=!0,e.updateInterval=1,e._updateOrder=0,e}return __extends(e,t),Object.defineProperty(e.prototype,"enabled",{get:function(){return this.entity?this.entity.enabled&&this._enabled:this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"localPosition",{get:function(){return new Vector2(this.entity.x+this.x,this.entity.y+this.y)},enumerable:!0,configurable:!0}),e.prototype.setEnabled=function(t){return this._enabled!=t&&(this._enabled=t,this._enabled?this.onEnabled():this.onDisabled()),this},Object.defineProperty(e.prototype,"updateOrder",{get:function(){return this._updateOrder},set:function(t){this.setUpdateOrder(t)},enumerable:!0,configurable:!0}),e.prototype.setUpdateOrder=function(t){return this._updateOrder!=t&&(this._updateOrder=t),this},e.prototype.initialize=function(){},e.prototype.onAddedToEntity=function(){},e.prototype.onRemovedFromEntity=function(){},e.prototype.onEnabled=function(){},e.prototype.onDisabled=function(){},e.prototype.debugRender=function(){},e.prototype.update=function(){},e.prototype.onEntityTransformChanged=function(t){},e.prototype.registerComponent=function(){this.entity.componentBits.set(ComponentTypeManager.getIndexFor(this),!1),this.entity.scene.entityProcessors.onComponentAdded(this.entity)},e.prototype.deregisterComponent=function(){this.entity.componentBits.set(ComponentTypeManager.getIndexFor(this)),this.entity.scene.entityProcessors.onComponentRemoved(this.entity)},e}(egret.DisplayObjectContainer);!function(t){t[t.SceneChanged=0]="SceneChanged"}(CoreEvents||(CoreEvents={}));var TransformComponent,Entity=function(t){function e(n){var i=t.call(this)||this;return i._updateOrder=0,i._enabled=!0,i._tag=0,i.name=n,i.components=new ComponentList(i),i.id=e._idGenerator++,i.componentBits=new BitSet,i.addEventListener(egret.Event.ADDED_TO_STAGE,i.onAddToStage,i),i}return __extends(e,t),Object.defineProperty(e.prototype,"isDestoryed",{get:function(){return this._isDestoryed},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"position",{get:function(){return new Vector2(this.x,this.y)},set:function(t){this.$setX(t.x),this.$setY(t.y),this.onEntityTransformChanged(TransformComponent.position)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"scale",{get:function(){return new Vector2(this.scaleX,this.scaleY)},set:function(t){this.$setScaleX(t.x),this.$setScaleY(t.y),this.onEntityTransformChanged(TransformComponent.scale)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"rotation",{get:function(){return this.$getRotation()},set:function(t){this.$setRotation(t),this.onEntityTransformChanged(TransformComponent.rotation)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"enabled",{get:function(){return this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),e.prototype.setEnabled=function(t){return this._enabled!=t&&(this._enabled=t),this},Object.defineProperty(e.prototype,"tag",{get:function(){return this._tag},set:function(t){this.setTag(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"stage",{get:function(){return this.scene?this.scene.stage:null},enumerable:!0,configurable:!0}),e.prototype.onAddToStage=function(){this.onEntityTransformChanged(TransformComponent.position)},Object.defineProperty(e.prototype,"updateOrder",{get:function(){return this._updateOrder},set:function(t){this.setUpdateOrder(t)},enumerable:!0,configurable:!0}),e.prototype.roundPosition=function(){this.position=Vector2Ext.round(this.position)},e.prototype.setUpdateOrder=function(t){if(this._updateOrder!=t)return this._updateOrder=t,this.scene,this},e.prototype.setTag=function(t){return this._tag!=t&&(this.scene&&this.scene.entities.removeFromTagList(this),this._tag=t,this.scene&&this.scene.entities.addToTagList(this)),this},e.prototype.attachToScene=function(t){this.scene=t,t.entities.add(this),this.components.registerAllComponents();for(var e=0;e<this.numChildren;e++)this.getChildAt(e).entity.attachToScene(t)},e.prototype.detachFromScene=function(){this.scene.entities.remove(this),this.components.deregisterAllComponents();for(var t=0;t<this.numChildren;t++)this.getChildAt(t).entity.detachFromScene()},e.prototype.addComponent=function(t){return t.entity=this,this.components.add(t),this.addChild(t),t.initialize(),t},e.prototype.hasComponent=function(t){return null!=this.components.getComponent(t,!1)},e.prototype.getOrCreateComponent=function(t){var e=this.components.getComponent(t,!0);return e||(e=this.addComponent(t)),e},e.prototype.getComponent=function(t){return this.components.getComponent(t,!1)},e.prototype.getComponents=function(t,e){return this.components.getComponents(t,e)},e.prototype.onEntityTransformChanged=function(t){this.components.onEntityTransformChanged(t)},e.prototype.removeComponentForType=function(t){var e=this.getComponent(t);return!!e&&(this.removeComponent(e),!0)},e.prototype.removeComponent=function(t){this.components.remove(t)},e.prototype.removeAllComponents=function(){for(var t=0;t<this.components.count;t++)this.removeComponent(this.components.buffer[t])},e.prototype.update=function(){this.components.update()},e.prototype.onAddedToScene=function(){},e.prototype.onRemovedFromScene=function(){this._isDestoryed&&this.components.removeAllComponents()},e.prototype.destroy=function(){this._isDestoryed=!0,this.removeEventListener(egret.Event.ADDED_TO_STAGE,this.onAddToStage,this),this.scene.entities.remove(this),this.removeChildren(),this.parent&&this.parent.removeChild(this);for(var t=this.numChildren-1;t>=0;t--){this.getChildAt(t).entity.destroy()}},e}(egret.DisplayObjectContainer);!function(t){t[t.rotation=0]="rotation",t[t.scale=1]="scale",t[t.position=2]="position"}(TransformComponent||(TransformComponent={}));var CameraStyle,Scene=function(t){function e(){var e=t.call(this)||this;return e.enablePostProcessing=!0,e._renderers=[],e._postProcessors=[],e.entityProcessors=new EntityProcessorList,e.renderableComponents=new RenderableComponentList,e.entities=new EntityList(e),e.content=new ContentManager,e.width=SceneManager.stage.stageWidth,e.height=SceneManager.stage.stageHeight,e.addEventListener(egret.Event.ACTIVATE,e.onActive,e),e.addEventListener(egret.Event.DEACTIVATE,e.onDeactive,e),e}return __extends(e,t),e.prototype.createEntity=function(t){var e=new Entity(t);return e.position=new Vector2(0,0),this.addEntity(e)},e.prototype.addEntity=function(t){this.entities.add(t),t.scene=this,this.addChild(t);for(var e=0;e<t.numChildren;e++)this.addEntity(t.getChildAt(e).entity);return t},e.prototype.destroyAllEntities=function(){for(var t=0;t<this.entities.count;t++)this.entities.buffer[t].destroy()},e.prototype.findEntity=function(t){return this.entities.findEntity(t)},e.prototype.addEntityProcessor=function(t){return t.scene=this,this.entityProcessors.add(t),t},e.prototype.removeEntityProcessor=function(t){this.entityProcessors.remove(t)},e.prototype.getEntityProcessor=function(){return this.entityProcessors.getProcessor()},e.prototype.addRenderer=function(t){return this._renderers.push(t),this._renderers.sort(),t.onAddedToScene(this),t},e.prototype.getRenderer=function(t){for(var e=0;e<this._renderers.length;e++)if(this._renderers[e]instanceof t)return this._renderers[e];return null},e.prototype.removeRenderer=function(t){this._renderers.remove(t),t.unload()},e.prototype.begin=function(){SceneManager.sceneTransition?SceneManager.stage.addChildAt(this,SceneManager.stage.numChildren-1):SceneManager.stage.addChild(this),0==this._renderers.length&&(this.addRenderer(new DefaultRenderer),console.warn("场景开始时没有渲染器 自动添加DefaultRenderer以保证能够正常渲染")),this.camera=this.createEntity("camera").getOrCreateComponent(new Camera),Physics.reset(),this.entityProcessors&&this.entityProcessors.begin(),this.camera.onSceneSizeChanged(this.stage.stageWidth,this.stage.stageHeight),this._didSceneBegin=!0,this.onStart()},e.prototype.end=function(){this._didSceneBegin=!1,this.removeEventListener(egret.Event.DEACTIVATE,this.onDeactive,this),this.removeEventListener(egret.Event.ACTIVATE,this.onActive,this);for(var t=0;t<this._renderers.length;t++)this._renderers[t].unload();for(t=0;t<this._postProcessors.length;t++)this._postProcessors[t].unload();this.entities.removeAllEntities(),this.removeChildren(),Physics.clear(),this.camera=null,this.content.dispose(),this.entityProcessors&&this.entityProcessors.end(),this.unload(),this.parent&&this.parent.removeChild(this)},e.prototype.onStart=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(t){return[2]})})},e.prototype.onActive=function(){},e.prototype.onDeactive=function(){},e.prototype.unload=function(){},e.prototype.update=function(){this.entities.updateLists(),this.entityProcessors&&this.entityProcessors.update(),this.entities.update(),this.entityProcessors&&this.entityProcessors.lateUpdate(),this.renderableComponents.updateList()},e.prototype.postRender=function(){var t=0;if(this.enablePostProcessing)for(var e=0;e<this._postProcessors.length;e++)if(this._postProcessors[e].enable){MathHelper.isEven(t);t++,this._postProcessors[e].process()}},e.prototype.render=function(){for(var t=0;t<this._renderers.length;t++)this._renderers[t].render(this)},e.prototype.addPostProcessor=function(t){return this._postProcessors.push(t),this._postProcessors.sort(),t.onAddedToScene(this),this._didSceneBegin&&t.onSceneBackBufferSizeChanged(this.stage.stageWidth,this.stage.stageHeight),t},e}(egret.DisplayObjectContainer),SceneManager=function(){function t(e){e.addEventListener(egret.Event.ENTER_FRAME,t.update,this),t._instnace=this,t.emitter=new Emitter,t.content=new ContentManager,t.stage=e,t.initialize(e),t.timerRuler=new TimeRuler}return Object.defineProperty(t,"Instance",{get:function(){return this._instnace},enumerable:!0,configurable:!0}),Object.defineProperty(t,"scene",{get:function(){return this._scene},set:function(e){if(!e)throw new Error("场景不能为空");null==this._scene?(this._scene=e,this._scene.begin(),t.Instance.onSceneChanged()):this._nextScene=e,this.registerActiveSceneChanged(this._scene,this._nextScene)},enumerable:!0,configurable:!0}),t.initialize=function(t){Input.initialize(t)},t.update=function(){if(t.startDebugUpdate(),Time.update(egret.getTimer()),t._scene){for(var e=GlobalManager.globalManagers.length-1;e>=0;e--)GlobalManager.globalManagers[e].enabled&&GlobalManager.globalManagers[e].update();t.sceneTransition&&(!t.sceneTransition||t.sceneTransition.loadsNewScene&&!t.sceneTransition.isNewSceneLoaded)||t._scene.update(),t._nextScene&&(t._scene.end(),t._scene=t._nextScene,t._nextScene=null,t._instnace.onSceneChanged(),t._scene.begin())}t.endDebugUpdate(),t.render()},t.render=function(){this.sceneTransition?(this.sceneTransition.preRender(),this._scene&&!this.sceneTransition.hasPreviousSceneRender?(this._scene.render(),this._scene.postRender(),this.sceneTransition.onBeginTransition()):this.sceneTransition&&(this._scene&&this.sceneTransition.isNewSceneLoaded&&(this._scene.render(),this._scene.postRender()),this.sceneTransition.render())):this._scene&&(this._scene.render(),Debug.render(),this._scene.postRender())},t.startSceneTransition=function(t){if(!this.sceneTransition)return this.sceneTransition=t,t;console.warn("在前一个场景完成之前，不能开始一个新的场景转换。")},t.registerActiveSceneChanged=function(t,e){this.activeSceneChanged&&this.activeSceneChanged(t,e)},t.prototype.onSceneChanged=function(){t.emitter.emit(CoreEvents.SceneChanged),Time.sceneChanged()},t.startDebugUpdate=function(){TimeRuler.Instance.startFrame(),TimeRuler.Instance.beginMark("update",65280)},t.endDebugUpdate=function(){TimeRuler.Instance.endMark("update")},t}(),Camera=function(t){function e(){var e=t.call(this)||this;return e._origin=Vector2.zero,e._minimumZoom=.3,e._maximumZoom=3,e._position=Vector2.zero,e.followLerp=.1,e.deadzone=new Rectangle,e.focusOffset=new Vector2,e.mapLockEnabled=!1,e.mapSize=new Vector2,e._worldSpaceDeadZone=new Rectangle,e._desiredPositionDelta=new Vector2,e.cameraStyle=CameraStyle.lockOn,e.width=SceneManager.stage.stageWidth,e.height=SceneManager.stage.stageHeight,e.setZoom(0),e}return __extends(e,t),Object.defineProperty(e.prototype,"zoom",{get:function(){return 0==this._zoom?1:this._zoom<1?MathHelper.map(this._zoom,this._minimumZoom,1,-1,0):MathHelper.map(this._zoom,1,this._maximumZoom,0,1)},set:function(t){this.setZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"minimumZoom",{get:function(){return this._minimumZoom},set:function(t){this.setMinimumZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"maximumZoom",{get:function(){return this._maximumZoom},set:function(t){this.setMaximumZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"origin",{get:function(){return this._origin},set:function(t){this._origin!=t&&(this._origin=t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"position",{get:function(){return this._position},set:function(t){this._position=t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"x",{get:function(){return this._position.x},set:function(t){this._position.x=t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"y",{get:function(){return this._position.y},set:function(t){this._position.y=t},enumerable:!0,configurable:!0}),e.prototype.onSceneSizeChanged=function(t,e){var n=this._origin;this.origin=new Vector2(t/2,e/2),this.entity.position=Vector2.add(this.entity.position,Vector2.subtract(this._origin,n))},e.prototype.setMinimumZoom=function(t){return this._zoom<t&&(this._zoom=this.minimumZoom),this._minimumZoom=t,this},e.prototype.setMaximumZoom=function(t){return this._zoom>t&&(this._zoom=t),this._maximumZoom=t,this},e.prototype.setZoom=function(t){var e=MathHelper.clamp(t,-1,1);return this._zoom=0==e?1:e<0?MathHelper.map(e,-1,0,this._minimumZoom,1):MathHelper.map(e,0,1,1,this._maximumZoom),SceneManager.scene.scaleX=this._zoom,SceneManager.scene.scaleY=this._zoom,this},e.prototype.setRotation=function(t){return SceneManager.scene.rotation=t,this},e.prototype.setPosition=function(t){return this.entity.position=t,this},e.prototype.follow=function(t,e){void 0===e&&(e=CameraStyle.cameraWindow),this.targetEntity=t,this.cameraStyle=e;var n=new Rectangle(0,0,SceneManager.stage.stageWidth,SceneManager.stage.stageHeight);switch(this.cameraStyle){case CameraStyle.cameraWindow:var i=n.width/6,r=n.height/3;this.deadzone=new Rectangle((n.width-i)/2,(n.height-r)/2,i,r);break;case CameraStyle.lockOn:this.deadzone=new Rectangle(n.width/2,n.height/2,10,10)}},e.prototype.update=function(){var t=new Rectangle(0,0,SceneManager.stage.stageWidth,SceneManager.stage.stageHeight),e=Vector2.multiply(new Vector2(t.width,t.height),new Vector2(.5));this._worldSpaceDeadZone.x=this.position.x-e.x*SceneManager.scene.scaleX+this.deadzone.x+this.focusOffset.x,this._worldSpaceDeadZone.y=this.position.y-e.y*SceneManager.scene.scaleY+this.deadzone.y+this.focusOffset.y,this._worldSpaceDeadZone.width=this.deadzone.width,this._worldSpaceDeadZone.height=this.deadzone.height,this.targetEntity&&this.updateFollow(),this.position=Vector2.lerp(this.position,Vector2.add(this.position,this._desiredPositionDelta),this.followLerp),this.entity.roundPosition(),this.mapLockEnabled&&(this.position=this.clampToMapSize(this.position),this.entity.roundPosition())},e.prototype.clampToMapSize=function(t){var e=new Rectangle(0,0,SceneManager.stage.stageWidth,SceneManager.stage.stageHeight),n=Vector2.multiply(new Vector2(e.width,e.height),new Vector2(.5)),i=new Vector2(this.mapSize.x-n.x,this.mapSize.y-n.y);return Vector2.clamp(t,n,i)},e.prototype.updateFollow=function(){if(this._desiredPositionDelta.x=this._desiredPositionDelta.y=0,this.cameraStyle==CameraStyle.lockOn){var t=this.targetEntity.position.x,e=this.targetEntity.position.y;this._worldSpaceDeadZone.x>t?this._desiredPositionDelta.x=t-this._worldSpaceDeadZone.x:this._worldSpaceDeadZone.x<t&&(this._desiredPositionDelta.x=t-this._worldSpaceDeadZone.x),this._worldSpaceDeadZone.y<e?this._desiredPositionDelta.y=e-this._worldSpaceDeadZone.y:this._worldSpaceDeadZone.y>e&&(this._desiredPositionDelta.y=e-this._worldSpaceDeadZone.y)}else{if(!this._targetCollider&&(this._targetCollider=this.targetEntity.getComponent(Collider),!this._targetCollider))return;var n=this.targetEntity.getComponent(Collider).bounds;this._worldSpaceDeadZone.containsRect(n)||(this._worldSpaceDeadZone.left>n.left?this._desiredPositionDelta.x=n.left-this._worldSpaceDeadZone.left:this._worldSpaceDeadZone.right<n.right&&(this._desiredPositionDelta.x=n.right-this._worldSpaceDeadZone.right),this._worldSpaceDeadZone.bottom<n.bottom?this._desiredPositionDelta.y=n.bottom-this._worldSpaceDeadZone.bottom:this._worldSpaceDeadZone.top>n.top&&(this._desiredPositionDelta.y=n.top-this._worldSpaceDeadZone.top))}},e}(Component);!function(t){t[t.lockOn=0]="lockOn",t[t.cameraWindow=1]="cameraWindow"}(CameraStyle||(CameraStyle={}));var LoopMode,State,ComponentPool=function(){function t(t){this._type=t,this._cache=[]}return t.prototype.obtain=function(){try{return this._cache.length>0?this._cache.shift():new this._type}catch(t){throw new Error(this._type+t)}},t.prototype.free=function(t){t.reset(),this._cache.push(t)},t}(),PooledComponent=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e}(Component),RenderableComponent=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e._areBoundsDirty=!0,e._bounds=new Rectangle,e._localOffset=Vector2.zero,e.color=0,e}return __extends(e,t),Object.defineProperty(e.prototype,"width",{get:function(){return this.getWidth()},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"height",{get:function(){return this.getHeight()},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isVisible",{get:function(){return this._isVisible},set:function(t){this._isVisible=t,this._isVisible?this.onBecameVisible():this.onBecameInvisible()},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"bounds",{get:function(){return new Rectangle(this.getBounds().x,this.getBounds().y,this.getBounds().width,this.getBounds().height)},enumerable:!0,configurable:!0}),e.prototype.getWidth=function(){return this.bounds.width},e.prototype.getHeight=function(){return this.bounds.height},e.prototype.onBecameVisible=function(){},e.prototype.onBecameInvisible=function(){},e.prototype.isVisibleFromCamera=function(t){return this.isVisible=t.getBounds().intersects(this.getBounds()),this.isVisible},e}(PooledComponent),Mesh=function(t){function e(){var e=t.call(this)||this;return e._mesh=new egret.Mesh,e}return __extends(e,t),e.prototype.setTexture=function(t){return this._mesh.texture=t,this},e.prototype.onAddedToEntity=function(){this.addChild(this._mesh)},e.prototype.onRemovedFromEntity=function(){this.removeChild(this._mesh)},e.prototype.render=function(t){this.x=this.entity.position.x-t.position.x+t.origin.x,this.y=this.entity.position.y-t.position.y+t.origin.y},e.prototype.reset=function(){},e}(RenderableComponent),SpriteRenderer=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),Object.defineProperty(e.prototype,"sprite",{get:function(){return this._sprite},set:function(t){this.setSprite(t)},enumerable:!0,configurable:!0}),e.prototype.setSprite=function(t){return this.removeChildren(),this._sprite=t,this._sprite&&(this.anchorOffsetX=this._sprite.origin.x/this._sprite.sourceRect.width,this.anchorOffsetY=this._sprite.origin.y/this._sprite.sourceRect.height),this.bitmap=new egret.Bitmap(t.texture2D),this.addChild(this.bitmap),this},e.prototype.setColor=function(t){var e=[1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0];e[0]=Math.floor(t/256/256)/255,e[6]=Math.floor(t/256%256)/255,e[12]=t%256/255;var n=new egret.ColorMatrixFilter(e);return this.filters=[n],this},e.prototype.isVisibleFromCamera=function(t){return this.isVisible=new Rectangle(0,0,this.stage.stageWidth,this.stage.stageHeight).intersects(this.bounds),this.visible=this.isVisible,this.isVisible},e.prototype.render=function(t){this.x==-t.position.x+t.origin.x&&this.y==-t.position.y+t.origin.y||(this.x=-t.position.x+t.origin.x,this.y=-t.position.y+t.origin.y,this.entity.onEntityTransformChanged(TransformComponent.position))},e.prototype.onRemovedFromEntity=function(){this.parent&&this.parent.removeChild(this)},e.prototype.reset=function(){},e}(RenderableComponent),TiledSpriteRenderer=function(t){function e(e){var n=t.call(this)||this;return n.leftTexture=new egret.Bitmap,n.rightTexture=new egret.Bitmap,n.leftTexture.texture=e.texture2D,n.rightTexture.texture=e.texture2D,n.setSprite(e),n.sourceRect=e.sourceRect,n}return __extends(e,t),Object.defineProperty(e.prototype,"scrollX",{get:function(){return this.sourceRect.x},set:function(t){this.sourceRect.x=t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"scrollY",{get:function(){return this.sourceRect.y},set:function(t){this.sourceRect.y=t},enumerable:!0,configurable:!0}),e.prototype.render=function(e){if(this.sprite){t.prototype.render.call(this,e);var n=new egret.RenderTexture,i=new egret.DisplayObjectContainer;i.removeChildren(),i.addChild(this.leftTexture),i.addChild(this.rightTexture),this.leftTexture.x=this.sourceRect.x,this.rightTexture.x=this.sourceRect.x-this.sourceRect.width,this.leftTexture.y=this.sourceRect.y,this.rightTexture.y=this.sourceRect.y,i.cacheAsBitmap=!0,n.drawToTexture(i,new egret.Rectangle(0,0,this.sourceRect.width,this.sourceRect.height)),this.bitmap.texture=n}},e}(SpriteRenderer),ScrollingSpriteRenderer=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.scrollSpeedX=15,e.scroolSpeedY=0,e._scrollX=0,e._scrollY=0,e}return __extends(e,t),e.prototype.update=function(){this._scrollX+=this.scrollSpeedX*Time.deltaTime,this._scrollY+=this.scroolSpeedY*Time.deltaTime,this.sourceRect.x=this._scrollX,this.sourceRect.y=this._scrollY},e.prototype.render=function(e){if(this.sprite){t.prototype.render.call(this,e);var n=new egret.RenderTexture,i=new egret.DisplayObjectContainer;i.removeChildren(),i.addChild(this.leftTexture),i.addChild(this.rightTexture),this.leftTexture.x=this.sourceRect.x,this.rightTexture.x=this.sourceRect.x-this.sourceRect.width,this.leftTexture.y=this.sourceRect.y,this.rightTexture.y=this.sourceRect.y,i.cacheAsBitmap=!0,n.drawToTexture(i,new egret.Rectangle(0,0,this.sourceRect.width,this.sourceRect.height)),this.bitmap.texture=n}},e}(TiledSpriteRenderer),Sprite=function(){return function(t,e,n){void 0===e&&(e=new Rectangle(0,0,t.textureWidth,t.textureHeight)),void 0===n&&(n=e.getHalfSize()),this.uvs=new Rectangle,this.texture2D=t,this.sourceRect=e,this.center=new Vector2(.5*e.width,.5*e.height),this.origin=n;var i=1/t.textureWidth,r=1/t.textureHeight;this.uvs.x=e.x*i,this.uvs.y=e.y*r,this.uvs.width=e.width*i,this.uvs.height=e.height*r}}(),SpriteAnimation=function(){return function(t,e){this.sprites=t,this.frameRate=e}}(),SpriteAnimator=function(t){function e(e){var n=t.call(this)||this;return n.speed=1,n.animationState=State.none,n._animations=new Map,n._elapsedTime=0,e&&n.setSprite(e),n}return __extends(e,t),Object.defineProperty(e.prototype,"isRunning",{get:function(){return this.animationState==State.running},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"animations",{get:function(){return this._animations},enumerable:!0,configurable:!0}),e.prototype.addAnimation=function(t,e){return!this.sprite&&e.sprites.length>0&&this.setSprite(e.sprites[0]),this._animations[t]=e,this},e.prototype.play=function(t,e){void 0===e&&(e=null),this.currentAnimation=this._animations[t],this.currentAnimationName=t,this.currentFrame=0,this.animationState=State.running,this.sprite=this.currentAnimation.sprites[0],this._elapsedTime=0,this._loopMode=e||LoopMode.loop},e.prototype.isAnimationActive=function(t){return this.currentAnimation&&this.currentAnimationName==t},e.prototype.pause=function(){this.animationState=State.paused},e.prototype.unPause=function(){this.animationState=State.running},e.prototype.stop=function(){this.currentAnimation=null,this.currentAnimationName=null,this.currentFrame=0,this.animationState=State.none},e.prototype.update=function(){if(this.animationState==State.running&&this.currentAnimation){var t=this.currentAnimation,e=1/(t.frameRate*this.speed),n=e*t.sprites.length;this._elapsedTime+=Time.deltaTime;var i=Math.abs(this._elapsedTime);if(this._loopMode==LoopMode.once&&i>n||this._loopMode==LoopMode.pingPongOnce&&i>2*n)return this.animationState=State.completed,this._elapsedTime=0,this.currentFrame=0,void(this.sprite=t.sprites[this.currentFrame]);var r=Math.floor(i/e),o=t.sprites.length;if(o>2&&(this._loopMode==LoopMode.pingPong||this._loopMode==LoopMode.pingPongOnce)){var s=o-1;this.currentFrame=s-Math.abs(s-r%(2*s))}else this.currentFrame=r%o;this.sprite=t.sprites[this.currentFrame]}},e}(SpriteRenderer);!function(t){t[t.loop=0]="loop",t[t.once=1]="once",t[t.clampForever=2]="clampForever",t[t.pingPong=3]="pingPong",t[t.pingPongOnce=4]="pingPongOnce"}(LoopMode||(LoopMode={})),function(t){t[t.none=0]="none",t[t.running=1]="running",t[t.paused=2]="paused",t[t.completed=3]="completed"}(State||(State={}));var PointSectors,Mover=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.onAddedToEntity=function(){this._triggerHelper=new ColliderTriggerHelper(this.entity)},e.prototype.calculateMovement=function(t){var e=new CollisionResult;if(!this.entity.getComponent(Collider)||!this._triggerHelper)return null;for(var n=this.entity.getComponents(Collider),i=0;i<n.length;i++){var r=n[i];if(!r.isTrigger){var o=r.bounds;o.x+=t.x,o.y+=t.y;var s=Physics.boxcastBroadphaseExcludingSelf(r,o,r.collidesWithLayers);o=s.bounds;for(var a=s.tempHashSet,c=0;c<a.length;c++){var h=a[c];if(!h.isTrigger){var u=r.collidesWith(h,t);u&&(t=Vector2.subtract(t,u.minimumTranslationVector),u.collider&&(e=u))}}}}return ListPool.free(n),{collisionResult:e,motion:t}},e.prototype.applyMovement=function(t){this.entity.position=Vector2.add(this.entity.position,t),this._triggerHelper&&this._triggerHelper.update()},e.prototype.move=function(t){var e=this.calculateMovement(t),n=e.collisionResult;return t=e.motion,this.applyMovement(t),n},e}(Component),ProjectileMover=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e._tempTriggerList=[],e}return __extends(e,t),e.prototype.onAddedToEntity=function(){this._collider=this.entity.getComponent(Collider),this._collider||console.warn("ProjectileMover has no Collider. ProjectilMover requires a Collider!")},e.prototype.move=function(t){if(!this._collider)return!1;var e=!1;this.entity.position=Vector2.add(this.entity.position,t);for(var n=Physics.boxcastBroadphase(this._collider.bounds,this._collider.collidesWithLayers),i=0;i<n.colliders.length;i++){var r=n.colliders[i];this._collider.overlaps(r)&&r.enabled&&(e=!0,this.notifyTriggerListeners(this._collider,r))}return e},e.prototype.notifyTriggerListeners=function(t,e){e.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var n=0;n<this._tempTriggerList.length;n++)this._tempTriggerList[n].onTriggerEnter(t,e);this._tempTriggerList.length=0,this.entity.getComponents("ITriggerListener",this._tempTriggerList);for(n=0;n<this._tempTriggerList.length;n++)this._tempTriggerList[n].onTriggerEnter(e,t);this._tempTriggerList.length=0},e}(Component),Collider=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.physicsLayer=1,e.registeredPhysicsBounds=new Rectangle,e.shouldColliderScaleAndRotateWithTransform=!0,e.collidesWithLayers=Physics.allLayers,e}return __extends(e,t),Object.defineProperty(e.prototype,"bounds",{get:function(){var t=this.shape.bounds;return new Rectangle(this.entity.x,this.entity.y,t.width,t.height)},enumerable:!0,configurable:!0}),e.prototype.registerColliderWithPhysicsSystem=function(){this._isParentEntityAddedToScene&&!this._isColliderRegistered&&(Physics.addCollider(this),this._isColliderRegistered=!0)},e.prototype.unregisterColliderWithPhysicsSystem=function(){this._isParentEntityAddedToScene&&this._isColliderRegistered&&Physics.removeCollider(this),this._isColliderRegistered=!1},e.prototype.overlaps=function(t){return this.shape.overlaps(t.shape)},e.prototype.collidesWith=function(t,e){var n=this.entity.position;this.entity.position=Vector2.add(this.entity.position,e);var i=this.shape.collidesWithShape(t.shape);return i&&(i.collider=t),this.entity.position=n,i},e.prototype.onAddedToEntity=function(){if(this._colliderRequiresAutoSizing){this instanceof BoxCollider||this instanceof CircleCollider||console.error("Only box and circle colliders can be created automatically");var t=this.entity.getComponent(RenderableComponent);if(t){var e=t.bounds,n=e.width/this.entity.scale.x,i=e.height/this.entity.scale.y;if(this instanceof CircleCollider){this.radius=.5*Math.max(n,i)}else this.width=n,this.height=i;this.addChild(this.shape)}else console.warn("Collider has no shape and no RenderableComponent. Can't figure out how to size it.")}this._isParentEntityAddedToScene=!0,this.registerColliderWithPhysicsSystem()},e.prototype.onRemovedFromEntity=function(){this.unregisterColliderWithPhysicsSystem(),this._isParentEntityAddedToScene=!1,this.removeChild(this.shape)},e.prototype.onEnabled=function(){this.registerColliderWithPhysicsSystem()},e.prototype.onDisabled=function(){this.unregisterColliderWithPhysicsSystem()},e.prototype.onEntityTransformChanged=function(t){this._isColliderRegistered&&Physics.updateCollider(this)},e.prototype.update=function(){var t=this.entity.getComponent(RenderableComponent);t&&(this.$setX(t.x),this.$setY(t.y))},e}(Component),BoxCollider=function(t){function e(){var e=t.call(this)||this;return e.shape=new Box(1,1),e._colliderRequiresAutoSizing=!0,e}return __extends(e,t),Object.defineProperty(e.prototype,"width",{get:function(){return this.shape.width},set:function(t){this.setWidth(t)},enumerable:!0,configurable:!0}),e.prototype.setWidth=function(t){this._colliderRequiresAutoSizing=!1;var e=this.shape;return t!=e.width&&(e.updateBox(t,e.height),this.entity&&this._isParentEntityAddedToScene&&Physics.updateCollider(this)),this},Object.defineProperty(e.prototype,"height",{get:function(){return this.shape.height},set:function(t){this.setHeight(t)},enumerable:!0,configurable:!0}),e.prototype.setHeight=function(t){this._colliderRequiresAutoSizing=!1;var e=this.shape;t!=e.height&&(e.updateBox(e.width,t),this.entity&&this._isParentEntityAddedToScene&&Physics.updateCollider(this))},e.prototype.setSize=function(t,e){this._colliderRequiresAutoSizing=!1;var n=this.shape;return t==n.width&&e==n.height||(n.updateBox(t,e),this.entity&&this._isParentEntityAddedToScene&&Physics.updateCollider(this)),this},e}(Collider),CircleCollider=function(t){function e(e){var n=t.call(this)||this;return e&&(n._colliderRequiresAutoSizing=!0),n.shape=new Circle(e||1),n}return __extends(e,t),Object.defineProperty(e.prototype,"radius",{get:function(){return this.shape.radius},set:function(t){this.setRadius(t)},enumerable:!0,configurable:!0}),e.prototype.setRadius=function(t){this._colliderRequiresAutoSizing=!1;var e=this.shape;return t!=e.radius&&(e.radius=t,e._originalRadius=t,this.entity&&this._isParentEntityAddedToScene&&Physics.updateCollider(this)),this},e}(Collider),PolygonCollider=function(t){function e(e){var n=t.call(this)||this;return e[0]==e[e.length-1]&&e.splice(e.length-1,1),Polygon.recenterPolygonVerts(e),n.shape=new Polygon(e),n}return __extends(e,t),e}(Collider),EntitySystem=function(){function t(t){this._entities=[],this._matcher=t||Matcher.empty()}return Object.defineProperty(t.prototype,"matcher",{get:function(){return this._matcher},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"scene",{get:function(){return this._scene},set:function(t){this._scene=t,this._entities=[]},enumerable:!0,configurable:!0}),t.prototype.initialize=function(){},t.prototype.onChanged=function(t){var e=this._entities.contains(t),n=this._matcher.IsIntersted(t);n&&!e?this.add(t):!n&&e&&this.remove(t)},t.prototype.add=function(t){this._entities.push(t),this.onAdded(t)},t.prototype.onAdded=function(t){},t.prototype.remove=function(t){this._entities.remove(t),this.onRemoved(t)},t.prototype.onRemoved=function(t){},t.prototype.update=function(){this.begin(),this.process(this._entities)},t.prototype.lateUpdate=function(){this.lateProcess(this._entities),this.end()},t.prototype.begin=function(){},t.prototype.process=function(t){},t.prototype.lateProcess=function(t){},t.prototype.end=function(){},t}(),EntityProcessingSystem=function(t){function e(e){return t.call(this,e)||this}return __extends(e,t),e.prototype.lateProcessEntity=function(t){},e.prototype.process=function(t){var e=this;t.forEach(function(t){return e.processEntity(t)})},e.prototype.lateProcess=function(t){var e=this;t.forEach(function(t){return e.lateProcessEntity(t)})},e}(EntitySystem),PassiveSystem=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.onChanged=function(t){},e.prototype.process=function(t){this.begin(),this.end()},e}(EntitySystem),ProcessingSystem=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.onChanged=function(t){},e.prototype.process=function(t){this.begin(),this.processSystem(),this.end()},e}(EntitySystem),BitSet=function(){function t(e){void 0===e&&(e=64);var n=e>>6;0!=(e&t.LONG_MASK)&&n++,this._bits=new Array(n)}return t.prototype.and=function(t){for(var e,n=Math.min(this._bits.length,t._bits.length),i=0;i<n;++i)this._bits[i]&=t._bits[i];for(;e<this._bits.length;)this._bits[e++]=0},t.prototype.andNot=function(t){for(var e=Math.min(this._bits.length,t._bits.length);--e>=0;)this._bits[e]&=~t._bits[e]},t.prototype.cardinality=function(){for(var t=0,e=this._bits.length-1;e>=0;e--){var n=this._bits[e];if(0!=n)if(-1!=n){var i=((n=((n=(n>>1&0x5555555555555400)+(0x5555555555555400&n))>>2&0x3333333333333400)+(0x3333333333333400&n))>>32)+n;t+=((i=((i=(i>>4&252645135)+(252645135&i))>>8&16711935)+(16711935&i))>>16&65535)+(65535&i)}else t+=64}return t},t.prototype.clear=function(t){if(null!=t){var e=t>>6;this.ensure(e),this._bits[e]&=~(1<<t)}else for(var n=0;n<this._bits.length;n++)this._bits[n]=0},t.prototype.ensure=function(t){if(t>=this._bits.length){var e=new Number[t+1];e=this._bits.copyWithin(0,0,this._bits.length),this._bits=e}},t.prototype.get=function(t){var e=t>>6;return!(e>=this._bits.length)&&0!=(this._bits[e]&1<<t)},t.prototype.intersects=function(t){for(var e=Math.min(this._bits.length,t._bits.length);--e>=0;)if(0!=(this._bits[e]&t._bits[e]))return!0;return!1},t.prototype.isEmpty=function(){for(var t=this._bits.length-1;t>=0;t--)if(this._bits[t])return!1;return!0},t.prototype.nextSetBit=function(t){for(var e=t>>6,n=1<<t;e<this._bits.length;){var i=this._bits[e];do{if(0!=(i&n))return t;n<<=1,t++}while(0!=n);n=1,e++}return-1},t.prototype.set=function(t,e){if(void 0===e&&(e=!0),e){var n=t>>6;this.ensure(n),this._bits[n]|=1<<t}else this.clear(t)},t.LONG_MASK=63,t}(),ComponentList=function(){function t(t){this._components=[],this._componentsToAdd=[],this._componentsToRemove=[],this._tempBufferList=[],this._entity=t}return Object.defineProperty(t.prototype,"count",{get:function(){return this._components.length},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"buffer",{get:function(){return this._components},enumerable:!0,configurable:!0}),t.prototype.add=function(t){this._componentsToAdd.push(t)},t.prototype.remove=function(t){this._componentsToRemove.contains(t)&&console.warn("You are trying to remove a Component ("+t+") that you already removed"),this._componentsToAdd.contains(t)?this._componentsToAdd.remove(t):this._componentsToRemove.push(t)},t.prototype.removeAllComponents=function(){for(var t=0;t<this._components.length;t++)this.handleRemove(this._components[t]);this._components.length=0,this._componentsToAdd.length=0,this._componentsToRemove.length=0},t.prototype.deregisterAllComponents=function(){for(var t=0;t<this._components.length;t++){var e=this._components[t];e instanceof RenderableComponent&&this._entity.scene.renderableComponents.remove(e),this._entity.componentBits.set(ComponentTypeManager.getIndexFor(e),!1),this._entity.scene.entityProcessors.onComponentRemoved(this._entity)}},t.prototype.registerAllComponents=function(){for(var t=0;t<this._components.length;t++){var e=this._components[t];e instanceof RenderableComponent&&this._entity.scene.renderableComponents.add(e),this._entity.componentBits.set(ComponentTypeManager.getIndexFor(e)),this._entity.scene.entityProcessors.onComponentAdded(this._entity)}},t.prototype.updateLists=function(){if(this._componentsToRemove.length>0){for(var t=0;t<this._componentsToRemove.length;t++)this.handleRemove(this._componentsToRemove[t]),this._components.remove(this._componentsToRemove[t]);this._componentsToRemove.length=0}if(this._componentsToAdd.length>0){t=0;for(var e=this._componentsToAdd.length;t<e;t++){(n=this._componentsToAdd[t])instanceof RenderableComponent&&this._entity.scene.renderableComponents.add(n),this._entity.componentBits.set(ComponentTypeManager.getIndexFor(n)),this._entity.scene.entityProcessors.onComponentAdded(this._entity),this._components.push(n),this._tempBufferList.push(n)}this._componentsToAdd.length=0;for(t=0;t<this._tempBufferList.length;t++){var n;(n=this._tempBufferList[t]).onAddedToEntity(),n.enabled&&n.onEnabled()}this._tempBufferList.length=0}},t.prototype.onEntityTransformChanged=function(t){for(var e=0;e<this._components.length;e++)this._components[e].enabled&&this._components[e].onEntityTransformChanged(t);for(e=0;e<this._componentsToAdd.length;e++)this._componentsToAdd[e].enabled&&this._componentsToAdd[e].onEntityTransformChanged(t)},t.prototype.handleRemove=function(t){t instanceof RenderableComponent&&this._entity.scene.renderableComponents.remove(t),this._entity.componentBits.set(ComponentTypeManager.getIndexFor(t),!1),this._entity.scene.entityProcessors.onComponentRemoved(this._entity),t.onRemovedFromEntity(),t.entity=null},t.prototype.getComponent=function(t,e){for(var n=0;n<this._components.length;n++){if((i=this._components[n])instanceof t)return i}if(!e)for(n=0;n<this._componentsToAdd.length;n++){var i;if((i=this._componentsToAdd[n])instanceof t)return i}return null},t.prototype.getComponents=function(t,e){e||(e=[]);for(var n=0;n<this._components.length;n++){var i=this._components[n];"string"==typeof t?egret.is(i,t)&&e.push(i):i instanceof t&&e.push(i)}for(n=0;n<this._componentsToAdd.length;n++){i=this._componentsToAdd[n];"string"==typeof t?egret.is(i,t)&&e.push(i):i instanceof t&&e.push(i)}return e},t.prototype.update=function(){this.updateLists();for(var t=0;t<this._components.length;t++){var e=this._components[t],n=void 0;e instanceof Component&&(n=e),e.enabled&&n.enabled&&(1==n.updateInterval||Time.frameCount%n.updateInterval==0)&&e.update()}},t}(),ComponentTypeManager=function(){function t(){}return t.add=function(t){this._componentTypesMask.has(t)||(this._componentTypesMask[t]=this._componentTypesMask.size)},t.getIndexFor=function(t){var e=-1;return this._componentTypesMask.has(t)||(this.add(t),e=this._componentTypesMask.get(t)),e},t._componentTypesMask=new Map,t}(),EntityList=function(){function t(t){this._entitiesToRemove=[],this._entitiesToAdded=[],this._tempEntityList=[],this._entities=[],this._entityDict=new Map,this._unsortedTags=[],this.scene=t}return Object.defineProperty(t.prototype,"count",{get:function(){return this._entities.length},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"buffer",{get:function(){return this._entities},enumerable:!0,configurable:!0}),t.prototype.add=function(t){-1==this._entitiesToAdded.indexOf(t)&&this._entitiesToAdded.push(t)},t.prototype.remove=function(t){this._entitiesToAdded.contains(t)?this._entitiesToAdded.remove(t):this._entitiesToRemove.contains(t)||this._entitiesToRemove.push(t)},t.prototype.findEntity=function(t){for(var e=0;e<this._entities.length;e++)if(this._entities[e].name==t)return this._entities[e];return this._entitiesToAdded.firstOrDefault(function(e){return e.name==t})},t.prototype.getTagList=function(t){var e=this._entityDict.get(t);return e||(e=[],this._entityDict.set(t,e)),this._entityDict.get(t)},t.prototype.addToTagList=function(t){var e=this.getTagList(t.tag);e.contains(t)||(e.push(t),this._unsortedTags.push(t.tag))},t.prototype.removeFromTagList=function(t){var e=this._entityDict.get(t.tag);e&&e.remove(t)},t.prototype.update=function(){for(var t=0;t<this._entities.length;t++){var e=this._entities[t];e.enabled&&e.update()}},t.prototype.removeAllEntities=function(){this._entitiesToAdded.length=0,this.updateLists();for(var t=0;t<this._entities.length;t++)this._entities[t]._isDestoryed=!0,this._entities[t].onRemovedFromScene(),this._entities[t].scene=null;this._entities.length=0,this._entityDict.clear()},t.prototype.updateLists=function(){var t=this;if(this._entitiesToRemove.length>0){var e=this._entitiesToRemove;this._entitiesToRemove=this._tempEntityList,this._tempEntityList=e,this._tempEntityList.forEach(function(e){t._entities.remove(e),e.scene=null,t.scene.entityProcessors.onEntityRemoved(e)}),this._tempEntityList.length=0}if(this._entitiesToAdded.length>0){e=this._entitiesToAdded;this._entitiesToAdded=this._tempEntityList,this._tempEntityList=e,this._tempEntityList.forEach(function(e){t._entities.contains(e)||(t._entities.push(e),e.scene=t.scene,t.scene.entityProcessors.onEntityAdded(e))}),this._tempEntityList.forEach(function(t){return t.onAddedToScene()}),this._tempEntityList.length=0}this._unsortedTags.length>0&&(this._unsortedTags.forEach(function(e){t._entityDict.get(e).sort()}),this._unsortedTags.length=0)},t}(),EntityProcessorList=function(){function t(){this._processors=[]}return t.prototype.add=function(t){this._processors.push(t)},t.prototype.remove=function(t){this._processors.remove(t)},t.prototype.onComponentAdded=function(t){this.notifyEntityChanged(t)},t.prototype.onComponentRemoved=function(t){this.notifyEntityChanged(t)},t.prototype.onEntityAdded=function(t){this.notifyEntityChanged(t)},t.prototype.onEntityRemoved=function(t){this.removeFromProcessors(t)},t.prototype.notifyEntityChanged=function(t){for(var e=0;e<this._processors.length;e++)this._processors[e].onChanged(t)},t.prototype.removeFromProcessors=function(t){for(var e=0;e<this._processors.length;e++)this._processors[e].remove(t)},t.prototype.begin=function(){},t.prototype.update=function(){for(var t=0;t<this._processors.length;t++)this._processors[t].update()},t.prototype.lateUpdate=function(){for(var t=0;t<this._processors.length;t++)this._processors[t].lateUpdate()},t.prototype.end=function(){},t.prototype.getProcessor=function(){for(var t=0;t<this._processors.length;t++){var e=this._processors[t];if(e instanceof EntitySystem)return e}return null},t}(),Matcher=function(){function t(){this.allSet=new BitSet,this.exclusionSet=new BitSet,this.oneSet=new BitSet}return t.empty=function(){return new t},t.prototype.getAllSet=function(){return this.allSet},t.prototype.getExclusionSet=function(){return this.exclusionSet},t.prototype.getOneSet=function(){return this.oneSet},t.prototype.IsIntersted=function(t){if(!this.allSet.isEmpty())for(var e=this.allSet.nextSetBit(0);e>=0;e=this.allSet.nextSetBit(e+1))if(!t.componentBits.get(e))return!1;return!(!this.exclusionSet.isEmpty()&&this.exclusionSet.intersects(t.componentBits))&&!(!this.oneSet.isEmpty()&&!this.oneSet.intersects(t.componentBits))},t.prototype.all=function(){for(var t=this,e=[],n=0;n<arguments.length;n++)e[n]=arguments[n];return e.forEach(function(e){t.allSet.set(ComponentTypeManager.getIndexFor(e))}),this},t.prototype.exclude=function(){for(var t=this,e=[],n=0;n<arguments.length;n++)e[n]=arguments[n];return e.forEach(function(e){t.exclusionSet.set(ComponentTypeManager.getIndexFor(e))}),this},t.prototype.one=function(){for(var t=this,e=[],n=0;n<arguments.length;n++)e[n]=arguments[n];return e.forEach(function(e){t.oneSet.set(ComponentTypeManager.getIndexFor(e))}),this},t}(),ObjectUtils=function(){function t(){}return t.clone=function(t,e){void 0===e&&(e=null);e=e||{};for(var n in t)"object"==typeof t[n]?(e[n]=t[n]instanceof Array?[]:{},this.clone(t[n],e[n])):e[n]=t[n];return e},t}(),RenderableComponentList=function(){function t(){this._components=[]}return Object.defineProperty(t.prototype,"count",{get:function(){return this._components.length},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"buffer",{get:function(){return this._components},enumerable:!0,configurable:!0}),t.prototype.add=function(t){this._components.push(t)},t.prototype.remove=function(t){this._components.remove(t)},t.prototype.updateList=function(){},t}(),StringUtils=function(){function t(){}return t.matchChineseWord=function(t){return t.match(/[\u4E00-\u9FA5]+/gim)},t.lTrim=function(t){for(var e=0;this.isWhiteSpace(t.charAt(e));)e++;return t.slice(e,t.length)},t.rTrim=function(t){for(var e=t.length-1;this.isWhiteSpace(t.charAt(e));)e--;return t.slice(0,e+1)},t.trim=function(t){return null==t?null:this.rTrim(this.lTrim(t))},t.isWhiteSpace=function(t){return" "==t||"\t"==t||"\r"==t||"\n"==t},t.replaceMatch=function(t,e,n,i){void 0===i&&(i=!1);for(var r=t.length,o="",s=!1,a=1==i?e.toLowerCase():e,c=0;c<r;c++)s=!1,t.charAt(c)==a.charAt(0)&&t.substr(c,a.length)==a&&(s=!0),s?(o+=n,c=c+a.length-1):o+=t.charAt(c);return o},t.htmlSpecialChars=function(t,e){void 0===e&&(e=!1);for(var n=this.specialSigns.length,i=0;i<n;i+=2){var r=void 0,o=void 0;if(r=this.specialSigns[i],o=this.specialSigns[i+1],e){var s=r;r=o,o=s}t=this.replaceMatch(t,r,o)}return t},t.zfill=function(t,e){if(void 0===e&&(e=2),!t)return t;e=Math.floor(e);var n=t.length;if(n>=e)return t;var i=!1;"-"==t.substr(0,1)&&(i=!0,t=t.substr(1));for(var r=e-n,o=0;o<r;o++)t="0"+t;return i&&(t="-"+t),t},t.reverse=function(t){return t.length>1?this.reverse(t.substring(1))+t.substring(0,1):t},t.cutOff=function(t,e,n,i){void 0===i&&(i=!0),e=Math.floor(e),n=Math.floor(n);var r=t.length;e>r&&(e=r);var o,s=e,a=e+n;return i?o=t.substring(0,s)+t.substr(a,r):(a=(s=r-1-e-n)+n,o=t.substring(0,s+1)+t.substr(a+1,r)),o},t.strReplace=function(t,e){for(var n=0,i=e.length;n<i;n++)null!=e[n]&&""!=e[n]||(e[n]="无"),t=t.replace("{"+n+"}",e[n]);return t},t.specialSigns=["&","&amp;","<","&lt;",">","&gt;",'"',"&quot;","'","&apos;","®","&reg;","©","&copy;","™","&trade;"],t}(),TextureUtils=function(){function t(){}return t.convertImageToCanvas=function(t,e){this.sharedCanvas||(this.sharedCanvas=egret.sys.createCanvas(),this.sharedContext=this.sharedCanvas.getContext("2d"));var n=t.$getTextureWidth(),i=t.$getTextureHeight();e||((e=egret.$TempRectangle).x=0,e.y=0,e.width=n,e.height=i),e.x=Math.min(e.x,n-1),e.y=Math.min(e.y,i-1),e.width=Math.min(e.width,n-e.x),e.height=Math.min(e.height,i-e.y);var r=Math.floor(e.width),o=Math.floor(e.height),s=this.sharedCanvas;if(s.style.width=r+"px",s.style.height=o+"px",this.sharedCanvas.width=r,this.sharedCanvas.height=o,"webgl"==egret.Capabilities.renderMode){var a=void 0;t.$renderBuffer?a=t:(egret.sys.systemRenderer.renderClear&&egret.sys.systemRenderer.renderClear(),(a=new egret.RenderTexture).drawToTexture(new egret.Bitmap(t)));for(var c=a.$renderBuffer.getPixels(e.x,e.y,r,o),h=0,u=0,l=0;l<c.length;l+=4)this.sharedContext.fillStyle="rgba("+c[l]+","+c[l+1]+","+c[l+2]+","+c[l+3]/255+")",this.sharedContext.fillRect(h,u,1,1),++h==r&&(h=0,u++);return t.$renderBuffer||a.dispose(),s}var p=t,d=Math.round(p.$offsetX),f=Math.round(p.$offsetY),g=p.$bitmapWidth,m=p.$bitmapHeight,y=SceneManager.stage.textureScaleFactor;return this.sharedContext.drawImage(p.$bitmapData.source,p.$bitmapX+e.x/y,p.$bitmapY+e.y/y,g*e.width/n,m*e.height/i,d,f,e.width,e.height),s},t.toDataURL=function(t,e,n,i){try{return this.convertImageToCanvas(e,n).toDataURL(t,i)}catch(t){egret.$error(1033)}return null},t.eliFoTevas=function(t,e,n,i,r){var o=this.convertImageToCanvas(e,i).toTempFilePathSync({fileType:t.indexOf("png")>=0?"png":"jpg"});return wx.getFileSystemManager().saveFile({tempFilePath:o,filePath:wx.env.USER_DATA_PATH+"/"+n,success:function(t){}}),o},t.getPixel32=function(t,e,n){return egret.$warn(1041,"getPixel32","getPixels"),t.getPixels(e,n)},t.getPixels=function(t,e,n,i,r){if(void 0===i&&(i=1),void 0===r&&(r=1),"webgl"==egret.Capabilities.renderMode){var o=void 0;return t.$renderBuffer?o=t:(o=new egret.RenderTexture).drawToTexture(new egret.Bitmap(t)),o.$renderBuffer.getPixels(e,n,i,r)}try{this.convertImageToCanvas(t);return this.sharedContext.getImageData(e,n,i,r).data}catch(t){egret.$error(1039)}},t}(),Time=function(){function t(){}return t.update=function(t){var e=(t-this._lastTime)/1e3;this.deltaTime=e*this.timeScale,this.unscaledDeltaTime=e,this._timeSinceSceneLoad+=e,this.frameCount++,this._lastTime=t},t.sceneChanged=function(){this._timeSinceSceneLoad=0},t.checkEvery=function(t){return this._timeSinceSceneLoad/t>(this._timeSinceSceneLoad-this.deltaTime)/t},t.deltaTime=0,t.timeScale=1,t.frameCount=0,t._lastTime=0,t}(),TimeUtils=function(){function t(){}return t.monthId=function(t){void 0===t&&(t=null);var e=(t=t||new Date).getFullYear(),n=t.getMonth()+1;return parseInt(e+(n<10?"0":"")+n)},t.dateId=function(t){void 0===t&&(t=null);var e=(t=t||new Date).getMonth()+1,n=e<10?"0":"",i=t.getDate(),r=i<10?"0":"";return parseInt(t.getFullYear()+n+e+r+i)},t.weekId=function(t,e){void 0===t&&(t=null),void 0===e&&(e=!0),t=t||new Date;var n=new Date;n.setTime(t.getTime()),n.setDate(1),n.setMonth(0);var i=n.getFullYear(),r=n.getDay();0==r&&(r=7);var o=!1;r<=4?(o=r>1,n.setDate(n.getDate()-(r-1))):n.setDate(n.getDate()+7-r+1);var s=this.diffDay(t,n,!1);if(s<0)return n.setDate(1),n.setMonth(0),n.setDate(n.getDate()-1),this.weekId(n,!1);var a=s/7,c=Math.floor(a)+1;if(53==c){n.setTime(t.getTime()),n.setDate(n.getDate()-1);var h=n.getDay();if(0==h&&(h=7),e&&(!o||h<4))return n.setFullYear(n.getFullYear()+1),n.setDate(1),n.setMonth(0),this.weekId(n,!1)}return parseInt(i+"00"+(c>9?"":"0")+c)},t.diffDay=function(t,e,n){void 0===n&&(n=!1);var i=(t.getTime()-e.getTime())/864e5;return n?Math.ceil(i):Math.floor(i)},t.getFirstDayOfWeek=function(t){var e=(t=t||new Date).getDay()||7;return new Date(t.getFullYear(),t.getMonth(),t.getDate()+1-e,0,0,0,0)},t.getFirstOfDay=function(t){return(t=t||new Date).setHours(0,0,0,0),t},t.getNextFirstOfDay=function(t){return new Date(this.getFirstOfDay(t).getTime()+864e5)},t.formatDate=function(t){var e=t.getFullYear(),n=t.getMonth()+1;n=n<10?"0"+n:n;var i=t.getDate();return e+"-"+n+"-"+(i=i<10?"0"+i:i)},t.formatDateTime=function(t){var e=t.getFullYear(),n=t.getMonth()+1;n=n<10?"0"+n:n;var i=t.getDate();i=i<10?"0"+i:i;var r=t.getHours(),o=t.getMinutes();o=o<10?"0"+o:o;var s=t.getSeconds();return e+"-"+n+"-"+i+" "+r+":"+o+":"+(s=s<10?"0"+s:s)},t.parseDate=function(t){var e=Date.parse(t);return isNaN(e)?new Date:new Date(Date.parse(t.replace(/-/g,"/")))},t.secondToTime=function(t,e,n){void 0===t&&(t=0),void 0===e&&(e=":"),void 0===n&&(n=!0);var i=Math.floor(t/3600),r=Math.floor(t%3600/60),o=Math.floor(t%3600%60),s=i.toString(),a=r.toString(),c=o.toString();return i<10&&(s="0"+s),r<10&&(a="0"+a),o<10&&(c="0"+c),n?s+e+a+e+c:a+e+c},t.timeToMillisecond=function(t,e){void 0===e&&(e=":");for(var n=t.split(e),i=0,r=n.length,o=0;o<r;o++){i+=n[o]*Math.pow(60,r-1-o)}return(i*=1e3).toString()},t}(),GraphicsCapabilities=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.initialize=function(t){this.platformInitialize(t)},e.prototype.platformInitialize=function(t){this.isMobile=!0;var e=wx.getSystemInfoSync(),n=e.system.toLowerCase();n.indexOf("ios")>-1?this.os="iOS":n.indexOf("android")>-1&&(this.os="Android");var i=e.language;i=i.indexOf("zh")>-1?"zh-CN":"en-US",this.language=i},e}(egret.Capabilities),GraphicsDevice=function(){return function(){this.graphicsCapabilities=new GraphicsCapabilities,this.graphicsCapabilities.initialize(this)}}(),Viewport=function(){function t(t,e,n,i){this._x=t,this._y=e,this._width=n,this._height=i,this._minDepth=0,this._maxDepth=1}return Object.defineProperty(t.prototype,"aspectRatio",{get:function(){return 0!=this._height&&0!=this._width?this._width/this._height:0},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"bounds",{get:function(){return new Rectangle(this._x,this._y,this._width,this._height)},set:function(t){this._x=t.x,this._y=t.y,this._width=t.width,this._height=t.height},enumerable:!0,configurable:!0}),t}(),GaussianBlurEffect=function(t){function e(){return t.call(this,PostProcessor.default_vert,e.blur_frag,{screenWidth:SceneManager.stage.stageWidth,screenHeight:SceneManager.stage.stageHeight})||this}return __extends(e,t),e.blur_frag="precision mediump float;\nuniform sampler2D uSampler;\nuniform float screenWidth;\nuniform float screenHeight;\nfloat normpdf(in float x, in float sigma)\n{\nreturn 0.39894*exp(-0.5*x*x/(sigma*sigma))/sigma;\n}\nvoid main()\n{\nvec3 c = texture2D(uSampler, gl_FragCoord.xy / vec2(screenWidth, screenHeight).xy).rgb;\nconst int mSize = 11;\nconst int kSize = (mSize - 1)/2;\nfloat kernel[mSize];\nvec3 final_colour = vec3(0.0);\nfloat sigma = 7.0;\nfloat z = 0.0;\nfor (int j = 0; j <= kSize; ++j)\n{\nkernel[kSize+j] = kernel[kSize-j] = normpdf(float(j),sigma);\n}\nfor (int j = 0; j < mSize; ++j)\n{\nz += kernel[j];\n}\nfor (int i = -kSize; i <= kSize; ++i)\n{\nfor (int j = -kSize; j <= kSize; ++j)\n{\nfinal_colour += kernel[kSize+j]*kernel[kSize+i]*texture2D(uSampler, (gl_FragCoord.xy+vec2(float(i),float(j))) / vec2(screenWidth, screenHeight).xy).rgb;\n}\n}\ngl_FragColor = vec4(final_colour/(z*z), 1.0);\n}",e}(egret.CustomFilter),PolygonLightEffect=function(t){function e(){return t.call(this,e.vertSrc,e.fragmentSrc)||this}return __extends(e,t),e.vertSrc="attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n}",e.fragmentSrc="precision lowp float;\nvarying vec2 vTextureCoord;\nuniform sampler2D uSampler;\n#define SAMPLE_COUNT 15\nuniform vec2 _sampleOffsets[SAMPLE_COUNT];\nuniform float _sampleWeights[SAMPLE_COUNT];\nvoid main(void) {\nvec4 c = vec4(0, 0, 0, 0);\nfor( int i = 0; i < SAMPLE_COUNT; i++ )\n   c += texture2D( uSampler, vTextureCoord + _sampleOffsets[i] ) * _sampleWeights[i];\ngl_FragColor = c;\n}",e}(egret.CustomFilter),PostProcessor=function(){function t(t){void 0===t&&(t=null),this.enabled=!0,this.effect=t}return t.prototype.onAddedToScene=function(t){this.scene=t,this.shape=new egret.Shape,this.shape.graphics.beginFill(16777215,1),this.shape.graphics.drawRect(0,0,SceneManager.stage.stageWidth,SceneManager.stage.stageHeight),this.shape.graphics.endFill(),t.addChild(this.shape)},t.prototype.process=function(){this.drawFullscreenQuad()},t.prototype.onSceneBackBufferSizeChanged=function(t, e){},t.prototype.drawFullscreenQuad=function(){this.scene.filters=[this.effect]},t.prototype.unload=function(){this.effect&&(this.effect=null),this.scene.removeChild(this.shape),this.scene=null},t.default_vert="attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec2 aColor;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\ngl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\nvTextureCoord = aTextureCoord;\nvColor = vec4(aColor.x, aColor.x, aColor.x, aColor.x);\n}",t}(),GaussianBlurPostProcessor=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.onAddedToScene=function(e){t.prototype.onAddedToScene.call(this,e),this.effect=new GaussianBlurEffect},e}(PostProcessor),Renderer=function(){function t(){}return t.prototype.onAddedToScene=function(t){},t.prototype.beginRender=function(t){},t.prototype.unload=function(){},t.prototype.renderAfterStateCheck=function(t,e){t.render(e)},t}(),DefaultRenderer=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.render=function(t){var e=this.camera?this.camera:t.camera;this.beginRender(e);for(var n=0;n<t.renderableComponents.count;n++){var i=t.renderableComponents.buffer[n];i.enabled&&i.isVisibleFromCamera(e)&&this.renderAfterStateCheck(i,e)}},e}(Renderer),ScreenSpaceRenderer=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.render=function(t){},e}(Renderer),PolyLight=function(t){function e(e,n,i){var r=t.call(this)||this;return r._indices=[],r.radius=e,r.power=i,r.color=n,r.computeTriangleIndices(),r}return __extends(e,t),Object.defineProperty(e.prototype,"radius",{get:function(){return this._radius},set:function(t){this.setRadius(t)},enumerable:!0,configurable:!0}),e.prototype.computeTriangleIndices=function(t){void 0===t&&(t=20),this._indices.length=0;for(var e=0;e<t;e+=2)this._indices.push(0),this._indices.push(e+2),this._indices.push(e+1)},e.prototype.setRadius=function(t){t!=this._radius&&(this._radius=t,this._areBoundsDirty=!0)},e.prototype.render=function(t){},e.prototype.reset=function(){},e}(RenderableComponent),SceneTransition=function(){function t(t){this.sceneLoadAction=t,this.loadsNewScene=null!=t}return Object.defineProperty(t.prototype,"hasPreviousSceneRender",{get:function(){return!!this._hasPreviousSceneRender||(this._hasPreviousSceneRender=!0,!1)},enumerable:!0,configurable:!0}),t.prototype.preRender=function(){},t.prototype.render=function(){},t.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(t){switch(t.label){case 0:return[4,this.loadNextScene()];case 1:return t.sent(),this.transitionComplete(),[2]}})})},t.prototype.transitionComplete=function(){SceneManager.sceneTransition=null,this.onTransitionCompleted&&this.onTransitionCompleted()},t.prototype.loadNextScene=function(){return __awaiter(this,void 0,void 0,function(){var t;return __generator(this,function(e){switch(e.label){case 0:return this.onScreenObscured&&this.onScreenObscured(),this.loadsNewScene||(this.isNewSceneLoaded=!0),t=SceneManager,[4,this.sceneLoadAction()];case 1:return t.scene=e.sent(),this.isNewSceneLoaded=!0,[2]}})})},t.prototype.tickEffectProgressProperty=function(t,e,n,i){return void 0===i&&(i=!1),new Promise(function(r){var o=i?1:0,s=i?0:1;egret.Tween.get(t.uniforms).set({_progress:o}).to({_progress:s},1e3*e,n).call(function(){r()})})},t}(),FadeTransition=function(t){function e(e){var n=t.call(this,e)||this;return n.fadeToColor=0,n.fadeOutDuration=.4,n.fadeEaseType=egret.Ease.quadInOut,n.delayBeforeFadeInDuration=.1,n._alpha=0,n._mask=new egret.Shape,n}return __extends(e,t),e.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){var t=this;return __generator(this,function(e){return this._mask.graphics.beginFill(this.fadeToColor,1),this._mask.graphics.drawRect(0,0,SceneManager.stage.stageWidth,SceneManager.stage.stageHeight),this._mask.graphics.endFill(),SceneManager.stage.addChild(this._mask),egret.Tween.get(this).to({_alpha:1},1e3*this.fadeOutDuration,this.fadeEaseType).call(function(){return __awaiter(t,void 0,void 0,function(){return __generator(this,function(t){switch(t.label){case 0:return[4,this.loadNextScene()];case 1:return t.sent(),[2]}})})}).wait(this.delayBeforeFadeInDuration).call(function(){egret.Tween.get(t).to({_alpha:0},1e3*t.fadeOutDuration,t.fadeEaseType).call(function(){t.transitionComplete(),SceneManager.stage.removeChild(t._mask)})}),[2]})})},e.prototype.render=function(){this._mask.graphics.clear(),this._mask.graphics.beginFill(this.fadeToColor,this._alpha),this._mask.graphics.drawRect(0,0,SceneManager.stage.stageWidth,SceneManager.stage.stageHeight),this._mask.graphics.endFill()},e}(SceneTransition),WindTransition=function(t){function e(e){var n=t.call(this,e)||this;n.duration=1,n.easeType=egret.Ease.quadOut;return n._windEffect=new egret.CustomFilter("attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n}","precision lowp float;\nvarying vec2 vTextureCoord;\nuniform sampler2D uSampler;\nuniform float _progress;\nuniform float _size;\nuniform float _windSegments;\nvoid main(void) {\nvec2 co = floor(vec2(0.0, vTextureCoord.y * _windSegments));\nfloat x = sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453;\nfloat r = x - floor(x);\nfloat m = smoothstep(0.0, -_size, vTextureCoord.x * (1.0 - _size) + _size * r - (_progress * (1.0 + _size)));\nvec4 fg = texture2D(uSampler, vTextureCoord);\ngl_FragColor = mix(fg, vec4(0, 0, 0, 0), m);\n}",{_progress:0,_size:.3,_windSegments:100}),n._mask=new egret.Shape,n._mask.graphics.beginFill(16777215,1),n._mask.graphics.drawRect(0,0,SceneManager.stage.stageWidth,SceneManager.stage.stageHeight),n._mask.graphics.endFill(),n._mask.filters=[n._windEffect],SceneManager.stage.addChild(n._mask),n}return __extends(e,t),Object.defineProperty(e.prototype,"windSegments",{set:function(t){this._windEffect.uniforms._windSegments=t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"size",{set:function(t){this._windEffect.uniforms._size=t},enumerable:!0,configurable:!0}),e.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(t){switch(t.label){case 0:return this.loadNextScene(),[4,this.tickEffectProgressProperty(this._windEffect,this.duration,this.easeType)];case 1:return t.sent(),this.transitionComplete(),SceneManager.stage.removeChild(this._mask),[2]}})})},e}(SceneTransition),Bezier=function(){function t(){}return t.getPoint=function(t,e,n,i){var r=1-(i=MathHelper.clamp01(i));return Vector2.add(Vector2.add(Vector2.multiply(new Vector2(r*r),t),Vector2.multiply(new Vector2(2*r*i),e)),Vector2.multiply(new Vector2(i*i),n))},t.getFirstDerivative=function(t,e,n,i){return Vector2.add(Vector2.multiply(new Vector2(2*(1-i)),Vector2.subtract(e,t)),Vector2.multiply(new Vector2(2*i),Vector2.subtract(n,e)))},t.getFirstDerivativeThree=function(t,e,n,i,r){var o=1-(r=MathHelper.clamp01(r));return Vector2.add(Vector2.add(Vector2.multiply(new Vector2(3*o*o),Vector2.subtract(e,t)),Vector2.multiply(new Vector2(6*o*r),Vector2.subtract(n,e))),Vector2.multiply(new Vector2(3*r*r),Vector2.subtract(i,n)))},t.getPointThree=function(t,e,n,i,r){var o=1-(r=MathHelper.clamp01(r));return Vector2.add(Vector2.add(Vector2.add(Vector2.multiply(new Vector2(o*o*o),t),Vector2.multiply(new Vector2(3*o*o*r),e)),Vector2.multiply(new Vector2(3*o*r*r),n)),Vector2.multiply(new Vector2(r*r*r),i))},t.getOptimizedDrawingPoints=function(t,e,n,i,r){void 0===r&&(r=1);var o=ListPool.obtain();return o.push(t),this.recursiveGetOptimizedDrawingPoints(t,e,n,i,o,r),o.push(i),o},t.recursiveGetOptimizedDrawingPoints=function(t,e,n,i,r,o){var s=Vector2.divide(Vector2.add(t,e),new Vector2(2)),a=Vector2.divide(Vector2.add(e,n),new Vector2(2)),c=Vector2.divide(Vector2.add(n,i),new Vector2(2)),h=Vector2.divide(Vector2.add(s,a),new Vector2(2)),u=Vector2.divide(Vector2.add(a,c),new Vector2(2)),l=Vector2.divide(Vector2.add(h,u),new Vector2(2)),p=Vector2.subtract(i,t),d=Math.abs((e.x,i.x*p.y-(e.y-i.y)*p.x)),f=Math.abs((n.x-i.x)*p.y-(n.y-i.y)*p.x);(d+f)*(d+f)<o*(p.x*p.x+p.y*p.y)?r.push(l):(this.recursiveGetOptimizedDrawingPoints(t,s,h,l,r,o),this.recursiveGetOptimizedDrawingPoints(l,u,c,i,r,o))},t}(),Flags=function(){function t(){}return t.isFlagSet=function(t,e){return 0!=(t&e)},t.isUnshiftedFlagSet=function(t,e){return 0!=(t&(e=1<<e))},t.setFlagExclusive=function(t,e){return 1<<e},t.setFlag=function(t,e){return t|1<<e},t.unsetFlag=function(t,e){return t&~(e=1<<e)},t.invertFlags=function(t){return~t},t}(),MathHelper=function(){function t(){}return t.toDegrees=function(t){return 57.29577951308232*t},t.toRadians=function(t){return.017453292519943295*t},t.map=function(t,e,n,i,r){return i+(t-e)*(r-i)/(n-e)},t.lerp=function(t,e,n){return t+(e-t)*n},t.clamp=function(t,e,n){return t<e?e:t>n?n:t},t.pointOnCirlce=function(e,n,i){var r=t.toRadians(i);return new Vector2(Math.cos(r)*r+e.x,Math.sin(r)*r+e.y)},t.isEven=function(t){return t%2==0},t.clamp01=function(t){return t<0?0:t>1?1:t},t.angleBetweenVectors=function(t,e){return Math.atan2(e.y-t.y,e.x-t.x)},t.Epsilon=1e-5,t.Rad2Deg=57.29578,t.Deg2Rad=.0174532924,t}(),Matrix2D=function(){function t(t,e,n,i,r,o){this.m11=0,this.m12=0,this.m21=0,this.m22=0,this.m31=0,this.m32=0,this.m11=t||1,this.m12=e||0,this.m21=n||0,this.m22=i||1,this.m31=r||0,this.m32=o||0}return Object.defineProperty(t,"identity",{get:function(){return t._identity},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"translation",{get:function(){return new Vector2(this.m31,this.m32)},set:function(t){this.m31=t.x,this.m32=t.y},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"rotation",{get:function(){return Math.atan2(this.m21,this.m11)},set:function(t){var e=Math.cos(t),n=Math.sin(t);this.m11=e,this.m12=n,this.m21=-n,this.m22=e},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"rotationDegrees",{get:function(){return MathHelper.toDegrees(this.rotation)},set:function(t){this.rotation=MathHelper.toRadians(t)},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"scale",{get:function(){return new Vector2(this.m11,this.m22)},set:function(t){this.m11=t.x,this.m12=t.y},enumerable:!0,configurable:!0}),t.add=function(t,e){return t.m11+=e.m11,t.m12+=e.m12,t.m21+=e.m21,t.m22+=e.m22,t.m31+=e.m31,t.m32+=e.m32,t},t.divide=function(t,e){return t.m11/=e.m11,t.m12/=e.m12,t.m21/=e.m21,t.m22/=e.m22,t.m31/=e.m31,t.m32/=e.m32,t},t.multiply=function(e,n){var i=new t,r=e.m11*n.m11+e.m12*n.m21,o=e.m11*n.m12+e.m12*n.m22,s=e.m21*n.m11+e.m22*n.m21,a=e.m21*n.m12+e.m22*n.m22,c=e.m31*n.m11+e.m32*n.m21+n.m31,h=e.m31*n.m12+e.m32*n.m22+n.m32;return i.m11=r,i.m12=o,i.m21=s,i.m22=a,i.m31=c,i.m32=h,i},t.multiplyTranslation=function(e,n,i){var r=t.createTranslation(n,i);return t.multiply(e,r)},t.prototype.determinant=function(){return this.m11*this.m22-this.m12*this.m21},t.invert=function(e,n){void 0===n&&(n=new t);var i=1/e.determinant();return n.m11=e.m22*i,n.m12=-e.m12*i,n.m21=-e.m21*i,n.m22=e.m11*i,n.m31=(e.m32*e.m21-e.m31*e.m22)*i,n.m32=-(e.m32*e.m11-e.m31*e.m12)*i,n},t.createTranslation=function(e,n){var i=new t;return i.m11=1,i.m12=0,i.m21=0,i.m22=1,i.m31=e,i.m32=n,i},t.createTranslationVector=function(t){return this.createTranslation(t.x,t.y)},t.createRotation=function(e,n){n=new t;var i=Math.cos(e),r=Math.sin(e);return n.m11=i,n.m12=r,n.m21=-r,n.m22=i,n},t.createScale=function(e,n,i){return void 0===i&&(i=new t),i.m11=e,i.m12=0,i.m21=0,i.m22=n,i.m31=0,i.m32=0,i},t.prototype.toEgretMatrix=function(){return new egret.Matrix(this.m11,this.m12,this.m21,this.m22,this.m31,this.m32)},t._identity=new t(1,0,0,1,0,0),t}(),Rectangle=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),Object.defineProperty(e.prototype,"max",{get:function(){return new Vector2(this.right,this.bottom)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"center",{get:function(){return new Vector2(this.x+this.width/2,this.y+this.height/2)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"location",{get:function(){return new Vector2(this.x,this.y)},set:function(t){this.x=t.x,this.y=t.y},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"size",{get:function(){return new Vector2(this.width,this.height)},set:function(t){this.width=t.x,this.height=t.y},enumerable:!0,configurable:!0}),e.prototype.intersects=function(t){return t.left<this.right&&this.left<t.right&&t.top<this.bottom&&this.top<t.bottom},e.prototype.containsRect=function(t){return this.x<=t.x&&t.x<this.x+this.width&&this.y<=t.y&&t.y<this.y+this.height},e.prototype.getHalfSize=function(){return new Vector2(.5*this.width,.5*this.height)},e.fromMinMax=function(t,n,i,r){return new e(t,n,i-t,r-n)},e.prototype.getClosestPointOnRectangleBorderToPoint=function(t){var e=Vector2.zero,n=new Vector2;if(n.x=MathHelper.clamp(t.x,this.left,this.right),n.y=MathHelper.clamp(t.y,this.top,this.bottom),this.contains(n.x,n.y)){var i=n.x-this.left,r=this.right-n.x,o=n.y-this.top,s=this.bottom-n.y,a=Math.min(i,r,o,s);a==o?(n.y=this.top,e.y=-1):a==s?(n.y=this.bottom,e.y=1):a==i?(n.x=this.left,e.x=-1):(n.x=this.right,e.x=1)}else n.x==this.left&&(e.x=-1),n.x==this.right&&(e.x=1),n.y==this.top&&(e.y=-1),n.y==this.bottom&&(e.y=1);return{res:n,edgeNormal:e}},e.prototype.getClosestPointOnBoundsToOrigin=function(){var t=this.max,e=Math.abs(this.location.x),n=new Vector2(this.location.x,0);return Math.abs(t.x)<e&&(e=Math.abs(t.x),n.x=t.x,n.y=0),Math.abs(t.y)<e&&(e=Math.abs(t.y),n.x=0,n.y=t.y),Math.abs(this.location.y)<e&&(e=Math.abs(this.location.y),n.x=0,n.y=this.location.y),n},e.prototype.setEgretRect=function(t){return this.x=t.x,this.y=t.y,this.width=t.width,this.height=t.height,this},e.rectEncompassingPoints=function(t){for(var e=Number.POSITIVE_INFINITY,n=Number.POSITIVE_INFINITY,i=Number.NEGATIVE_INFINITY,r=Number.NEGATIVE_INFINITY,o=0;o<t.length;o++){var s=t[o];s.x<e&&(e=s.x),s.x>i&&(i=s.x),s.y<n&&(n=s.y),s.y>r&&(r=s.y)}return this.fromMinMax(e,n,i,r)},e}(egret.Rectangle),Vector3=function(){return function(t,e,n){this.x=t,this.y=e,this.z=n}}(),ColliderTriggerHelper=function(){function t(t){this._activeTriggerIntersections=[],this._previousTriggerIntersections=[],this._tempTriggerList=[],this._entity=t}return t.prototype.update=function(){for(var t=this._entity.getComponents(Collider),e=0;e<t.length;e++){var n=t[e],i=Physics.boxcastBroadphase(n.bounds,n.collidesWithLayers);n.bounds=i.rect;for(var r=i.colliders,o=function(t){var e=r[t];if(!n.isTrigger&&!e.isTrigger)return"continue";if(n.overlaps(e)){var i=new Pair(n,e);-1==s._activeTriggerIntersections.findIndex(function(t){return t.first==i.first&&t.second==i.second})&&-1==s._previousTriggerIntersections.findIndex(function(t){return t.first==i.first&&t.second==i.second})&&s.notifyTriggerListeners(i,!0),s._activeTriggerIntersections.contains(i)||s._activeTriggerIntersections.push(i)}},s=this,a=0;a<r.length;a++)o(a)}ListPool.free(t),this.checkForExitedColliders()},t.prototype.checkForExitedColliders=function(){for(var t=this,e=function(e){var i=n._previousTriggerIntersections.findIndex(function(n){return n.first==t._activeTriggerIntersections[e].first&&n.second==t._activeTriggerIntersections[e].second});-1!=i&&n._previousTriggerIntersections.removeAt(i)},n=this,i=0;i<this._activeTriggerIntersections.length;i++)e(i);for(i=0;i<this._previousTriggerIntersections.length;i++)this.notifyTriggerListeners(this._previousTriggerIntersections[i],!1);this._previousTriggerIntersections.length=0;for(i=0;i<this._activeTriggerIntersections.length;i++)this._previousTriggerIntersections.contains(this._activeTriggerIntersections[i])||this._previousTriggerIntersections.push(this._activeTriggerIntersections[i]);this._activeTriggerIntersections.length=0},t.prototype.notifyTriggerListeners=function(t,e){t.first.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var n=0;n<this._tempTriggerList.length;n++)if(e?this._tempTriggerList[n].onTriggerEnter(t.second,t.first):this._tempTriggerList[n].onTriggerExit(t.second,t.first),this._tempTriggerList.length=0,t.second.entity){t.second.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var i=0;i<this._tempTriggerList.length;i++)e?this._tempTriggerList[i].onTriggerEnter(t.first,t.second):this._tempTriggerList[i].onTriggerExit(t.first,t.second);this._tempTriggerList.length=0}},t}();!function(t){t[t.center=0]="center",t[t.top=1]="top",t[t.bottom=2]="bottom",t[t.topLeft=9]="topLeft",t[t.topRight=5]="topRight",t[t.left=8]="left",t[t.right=4]="right",t[t.bottomLeft=10]="bottomLeft",t[t.bottomRight=6]="bottomRight"}(PointSectors||(PointSectors={}));var Alignment,stopwatch,Collisions=function(){function t(){}return t.isLineToLine=function(t,e,n,i){var r=Vector2.subtract(e,t),o=Vector2.subtract(i,n),s=r.x*o.y-r.y*o.x;if(0==s)return!1;var a=Vector2.subtract(n,t),c=(a.x*o.y-a.y*o.x)/s;if(c<0||c>1)return!1;var h=(a.x*r.y-a.y*r.x)/s;return!(h<0||h>1)},t.lineToLineIntersection=function(t,e,n,i){var r=new Vector2(0,0),o=Vector2.subtract(e,t),s=Vector2.subtract(i,n),a=o.x*s.y-o.y*s.x;if(0==a)return r;var c=Vector2.subtract(n,t),h=(c.x*s.y-c.y*s.x)/a;if(h<0||h>1)return r;var u=(c.x*o.y-c.y*o.x)/a;return u<0||u>1?r:r=Vector2.add(t,new Vector2(h*o.x,h*o.y))},t.closestPointOnLine=function(t,e,n){var i=Vector2.subtract(e,t),r=Vector2.subtract(n,t),o=Vector2.dot(r,i)/Vector2.dot(i,i);return o=MathHelper.clamp(o,0,1),Vector2.add(t,new Vector2(i.x*o,i.y*o))},t.isCircleToCircle=function(t,e,n,i){return Vector2.distanceSquared(t,n)<(e+i)*(e+i)},t.isCircleToLine=function(t,e,n,i){return Vector2.distanceSquared(t,this.closestPointOnLine(n,i,t))<e*e},t.isCircleToPoint=function(t,e,n){return Vector2.distanceSquared(t,n)<e*e},t.isRectToCircle=function(t,e,n){var i=.5*t.width,r=.5*t.height,o=Math.max(0,Math.max(e.x-t.x)-i),s=Math.max(0,Math.max(e.y-t.y)-r);return o*o+s*s<n*n},t.isRectToLine=function(t,e,n){var i=this.getSector(t.x,t.y,t.width,t.height,e),r=this.getSector(t.x,t.y,t.width,t.height,n);if(i==PointSectors.center||r==PointSectors.center)return!0;if(0!=(i&r))return!1;var o=i|r,s=void 0,a=void 0;return!(0==(o&PointSectors.top)||(s=new Vector2(t.x,t.y),a=new Vector2(t.x+t.width,t.y),!this.isLineToLine(s,a,e,n)))||(!(0==(o&PointSectors.bottom)||(s=new Vector2(t.x,t.y+t.height),a=new Vector2(t.x+t.width,t.y+t.height),!this.isLineToLine(s,a,e,n)))||(!(0==(o&PointSectors.left)||(s=new Vector2(t.x,t.y),a=new Vector2(t.x,t.y+t.height),!this.isLineToLine(s,a,e,n)))||!(0==(o&PointSectors.right)||(s=new Vector2(t.x+t.width,t.y),a=new Vector2(t.x+t.width,t.y+t.height),!this.isLineToLine(s,a,e,n)))))},t.isRectToPoint=function(t,e,n,i,r){return r.x>=t&&r.y>=e&&r.x<t+n&&r.y<e+i},t.getSector=function(t,e,n,i,r){var o=PointSectors.center;return r.x<t?o|=PointSectors.left:r.x>=t+n&&(o|=PointSectors.right),r.y<e?o|=PointSectors.top:r.y>=e+i&&(o|=PointSectors.bottom),o},t}(),Physics=function(){function t(){}return t.reset=function(){this._spatialHash=new SpatialHash(this.spatialHashCellSize)},t.clear=function(){this._spatialHash.clear()},t.overlapCircleAll=function(t,e,n,i){return void 0===i&&(i=-1),this._spatialHash.overlapCircle(t,e,n,i)},t.boxcastBroadphase=function(t,e){void 0===e&&(e=this.allLayers);var n=this._spatialHash.aabbBroadphase(t,null,e);return{colliders:n.tempHashSet,rect:n.bounds}},t.boxcastBroadphaseExcludingSelf=function(t,e,n){return void 0===n&&(n=this.allLayers),this._spatialHash.aabbBroadphase(e,t,n)},t.addCollider=function(e){t._spatialHash.register(e)},t.removeCollider=function(e){t._spatialHash.remove(e)},t.updateCollider=function(t){this._spatialHash.remove(t),this._spatialHash.register(t)},t.debugDraw=function(t){this._spatialHash.debugDraw(t,2)},t.spatialHashCellSize=100,t.allLayers=-1,t}(),Shape=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e}(egret.DisplayObject),Polygon=function(t){function e(e,n){var i=t.call(this)||this;return i._areEdgeNormalsDirty=!0,i.center=new Vector2,i.setPoints(e),i.isBox=n,i}return __extends(e,t),Object.defineProperty(e.prototype,"position",{get:function(){return new Vector2(this.parent.x,this.parent.y)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"bounds",{get:function(){return new Rectangle(this.x,this.y,this.width,this.height)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"edgeNormals",{get:function(){return this._areEdgeNormalsDirty&&this.buildEdgeNormals(),this._edgeNormals},enumerable:!0,configurable:!0}),e.prototype.buildEdgeNormals=function(){var t,e=this.isBox?2:this.points.length;null!=this._edgeNormals&&this._edgeNormals.length==e||(this._edgeNormals=new Array(e));for(var n=0;n<e;n++){var i=this.points[n];t=n+1>=this.points.length?this.points[0]:this.points[n+1];var r=Vector2Ext.perpendicular(i,t);r=Vector2.normalize(r),this._edgeNormals[n]=r}},e.prototype.setPoints=function(t){this.points=t,this.recalculateCenterAndEdgeNormals(),this._originalPoints=[];for(var e=0;e<this.points.length;e++)this._originalPoints.push(this.points[e])},e.prototype.collidesWithShape=function(t){var n=new CollisionResult;if(t instanceof e)return ShapeCollisions.polygonToPolygon(this,t);if(t instanceof Circle)return(n=ShapeCollisions.circleToPolygon(t,this))?(n.invertResult(),n):null;throw new Error("overlaps of Polygon to "+t+" are not supported")},e.prototype.recalculateCenterAndEdgeNormals=function(){this._polygonCenter=e.findPolygonCenter(this.points),this._areEdgeNormalsDirty=!0},e.prototype.overlaps=function(t){var n;if(t instanceof e)return ShapeCollisions.polygonToPolygon(this,t);if(t instanceof Circle)return!!(n=ShapeCollisions.circleToPolygon(t,this))&&(n.invertResult(),!0);throw new Error("overlaps of Pologon to "+t+" are not supported")},e.findPolygonCenter=function(t){for(var e=0,n=0,i=0;i<t.length;i++)e+=t[i].x,n+=t[i].y;return new Vector2(e/t.length,n/t.length)},e.recenterPolygonVerts=function(t){for(var e=this.findPolygonCenter(t),n=0;n<t.length;n++)t[n]=Vector2.subtract(t[n],e)},e.getClosestPointOnPolygonToPoint=function(t,e){for(var n,i=Number.MAX_VALUE,r=new Vector2(0,0),o=new Vector2(0,0),s=0;s<t.length;s++){var a=s+1;a==t.length&&(a=0);var c=ShapeCollisions.closestPointOnLine(t[s],t[a],e);if((n=Vector2.distanceSquared(e,c))<i){i=n,o=c;var h=Vector2.subtract(t[a],t[s]);r.x=-h.y,r.y=h.x}}return{closestPoint:o,distanceSquared:i,edgeNormal:r=Vector2.normalize(r)}},e.prototype.pointCollidesWithShape=function(t){return ShapeCollisions.pointToPoly(t,this)},e.prototype.containsPoint=function(t){t=Vector2.subtract(t,this.position);for(var e=!1,n=0,i=this.points.length-1;n<this.points.length;i=n++)this.points[n].y>t.y!=this.points[i].y>t.y&&t.x<(this.points[i].x-this.points[n].x)*(t.y-this.points[n].y)/(this.points[i].y-this.points[n].y)+this.points[n].x&&(e=!e);return e},e.buildSymmertricalPolygon=function(t,e){for(var n=new Array(t),i=0;i<t;i++){var r=2*Math.PI*(i/t);n[i]=new Vector2(Math.cos(r),Math.sin(r)*e)}return n},e}(Shape),Box=function(t){function e(n,i){var r=t.call(this,e.buildBox(n,i),!0)||this;return r.width=n,r.height=i,r}return __extends(e,t),e.buildBox=function(t,e){var n=t/2,i=e/2,r=new Array(4);return r[0]=new Vector2(-n,-i),r[1]=new Vector2(n,-i),r[2]=new Vector2(n,i),r[3]=new Vector2(-n,i),r},e.prototype.overlaps=function(n){return n instanceof e?this.bounds.intersects(n.bounds):n instanceof Circle?Collisions.isRectToCircle(this.bounds,n.position,n.radius):t.prototype.overlaps.call(this,n)},e.prototype.collidesWithShape=function(n){return n instanceof e?ShapeCollisions.boxToBox(this,n):t.prototype.collidesWithShape.call(this,n)},e.prototype.updateBox=function(t,e){this.width=t,this.height=e;var n=t/2,i=e/2;this.points[0]=new Vector2(-n,-i),this.points[1]=new Vector2(n,-i),this.points[2]=new Vector2(n,i),this.points[3]=new Vector2(-n,i);for(var r=0;r<this.points.length;r++)this._originalPoints[r]=this.points[r]},e.prototype.containsPoint=function(t){return this.bounds.contains(t.x,t.y)},e}(Polygon),Circle=function(t){function e(e){var n=t.call(this)||this;return n.center=new Vector2,n.radius=e,n._originalRadius=e,n}return __extends(e,t),Object.defineProperty(e.prototype,"position",{get:function(){return new Vector2(this.parent.x,this.parent.y)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"bounds",{get:function(){return(new Rectangle).setEgretRect(this.getBounds())},enumerable:!0,configurable:!0}),e.prototype.pointCollidesWithShape=function(t){return ShapeCollisions.pointToCircle(t,this)},e.prototype.collidesWithShape=function(t){if(t instanceof Box)return ShapeCollisions.circleToBox(this,t);if(t instanceof e)return ShapeCollisions.circleToCircle(this,t);if(t instanceof Polygon)return ShapeCollisions.circleToPolygon(this,t);throw new Error("Collisions of Circle to "+t+" are not supported")},e.prototype.overlaps=function(t){if(t instanceof Box)return Collisions.isRectToCircle(t.bounds,this.position,this.radius);if(t instanceof e)return Collisions.isCircleToCircle(this.position,this.radius,t.position,t.radius);if(t instanceof Polygon)return ShapeCollisions.circleToPolygon(this,t);throw new Error("overlaps of circle to "+t+" are not supported")},e}(Shape),CollisionResult=function(){function t(){this.minimumTranslationVector=Vector2.zero,this.normal=Vector2.zero,this.point=Vector2.zero}return t.prototype.invertResult=function(){this.minimumTranslationVector=Vector2.negate(this.minimumTranslationVector),this.normal=Vector2.negate(this.normal)},t}(),ShapeCollisions=function(){function t(){}return t.polygonToPolygon=function(t,e){for(var n,i=new CollisionResult,r=!0,o=t.edgeNormals,s=e.edgeNormals,a=Number.POSITIVE_INFINITY,c=new Vector2,h=Vector2.subtract(t.position,e.position),u=0;u<o.length+s.length;u++){n=u<o.length?o[u]:s[u-o.length];var l=0,p=0,d=0,f=0,g=0,m=this.getInterval(n,t,l,d);l=m.min,p=m.max;var y=this.getInterval(n,e,p,f);p=y.min,f=y.max;var _=Vector2.dot(h,n);if(l+=_,d+=_,(g=this.intervalDistance(l,d,p,f))>0&&(r=!1),!r)return null;(g=Math.abs(g))<a&&(a=g,c=n,Vector2.dot(c,h)<0&&(c=new Vector2(-c)))}return i.normal=c,i.minimumTranslationVector=Vector2.multiply(new Vector2(-c.x,-c.y),new Vector2(a)),i},t.intervalDistance=function(t,e,n,i){return t<n?n-e:t-n},t.getInterval=function(t,e,n,i){var r=Vector2.dot(e.points[0],t);n=i=r;for(var o=1;o<e.points.length;o++)(r=Vector2.dot(e.points[o],t))<n?n=r:r>i&&(i=r);return{min:n,max:i}},t.circleToPolygon=function(t,e){var n=new CollisionResult,i=Vector2.subtract(t.position,e.position),r=Polygon.getClosestPointOnPolygonToPoint(e.points,i),o=r.closestPoint,s=r.distanceSquared;n.normal=r.edgeNormal;var a,c=e.containsPoint(t.position);if(s>t.radius*t.radius&&!c)return null;if(c)a=Vector2.multiply(n.normal,new Vector2(Math.sqrt(s)-t.radius));else if(0==s)a=Vector2.multiply(n.normal,new Vector2(t.radius));else{var h=Math.sqrt(s);a=Vector2.multiply(new Vector2(-Vector2.subtract(i,o)),new Vector2((t.radius-s)/h))}return n.minimumTranslationVector=a,n.point=Vector2.add(o,e.position),n},t.circleToBox=function(t,e){var n=new CollisionResult,i=e.bounds.getClosestPointOnRectangleBorderToPoint(t.position).res;if(e.containsPoint(t.position)){n.point=i;var r=Vector2.add(i,Vector2.subtract(n.normal,new Vector2(t.radius)));return n.minimumTranslationVector=Vector2.subtract(t.position,r),n}var o=Vector2.distanceSquared(i,t.position);if(0==o)n.minimumTranslationVector=Vector2.multiply(n.normal,new Vector2(t.radius));else if(o<=t.radius*t.radius){n.normal=Vector2.subtract(t.position,i);var s=n.normal.length()-t.radius;return n.normal=Vector2Ext.normalize(n.normal),n.minimumTranslationVector=Vector2.multiply(new Vector2(s),n.normal),n}return null},t.pointToCircle=function(t,e){var n=new CollisionResult,i=Vector2.distanceSquared(t,e.position),r=1+e.radius;if(i<r*r){n.normal=Vector2.normalize(Vector2.subtract(t,e.position));var o=r-Math.sqrt(i);return n.minimumTranslationVector=Vector2.multiply(new Vector2(-o,-o),n.normal),n.point=Vector2.add(e.position,Vector2.multiply(n.normal,new Vector2(e.radius,e.radius))),n}return null},t.closestPointOnLine=function(t,e,n){var i=Vector2.subtract(e,t),r=Vector2.subtract(n,t),o=Vector2.dot(r,i)/Vector2.dot(i,i);return o=MathHelper.clamp(o,0,1),Vector2.add(t,Vector2.multiply(i,new Vector2(o,o)))},t.pointToPoly=function(t,e){var n=new CollisionResult;if(e.containsPoint(t)){var i,r=Polygon.getClosestPointOnPolygonToPoint(e.points,Vector2.subtract(t,e.position)),o=r.closestPoint;return i=r.distanceSquared,n.normal=r.edgeNormal,n.minimumTranslationVector=Vector2.multiply(n.normal,new Vector2(Math.sqrt(i),Math.sqrt(i))),n.point=Vector2.add(o,e.position),n}return null},t.circleToCircle=function(t,e){var n=new CollisionResult,i=Vector2.distanceSquared(t.position,e.position),r=t.radius+e.radius;if(i<r*r){n.normal=Vector2.normalize(Vector2.subtract(t.position,e.position));var o=r-Math.sqrt(i);return n.minimumTranslationVector=Vector2.multiply(new Vector2(-o),n.normal),n.point=Vector2.add(e.position,Vector2.multiply(n.normal,new Vector2(e.radius))),n}return null},t.boxToBox=function(t,e){var n=new CollisionResult,i=this.minkowskiDifference(t,e);return i.contains(0,0)?(n.minimumTranslationVector=i.getClosestPointOnBoundsToOrigin(),0==n.minimumTranslationVector.x&&0==n.minimumTranslationVector.y?null:(n.normal=new Vector2(-n.minimumTranslationVector.x,-n.minimumTranslationVector.y),n.normal.normalize(),n)):null},t.minkowskiDifference=function(t,e){var n=Vector2.subtract(t.position,Vector2.add(t.bounds.location,Vector2.divide(t.bounds.size,new Vector2(2)))),i=Vector2.subtract(Vector2.add(t.bounds.location,n),e.bounds.max),r=Vector2.add(t.bounds.size,e.bounds.size);return new Rectangle(i.x,i.y,r.x,r.y)},t}(),SpatialHash=function(){function t(t){void 0===t&&(t=100),this.gridBounds=new Rectangle,this._overlapTestCircle=new Circle(0),this._tempHashSet=[],this._cellDict=new NumberDictionary,this._cellSize=t,this._inverseCellSize=1/this._cellSize,this._raycastParser=new RaycastResultParser}return t.prototype.remove=function(t){for(var e=t.registeredPhysicsBounds,n=this.cellCoords(e.x,e.y),i=this.cellCoords(e.right,e.bottom),r=n.x;r<=i.x;r++)for(var o=n.y;o<=i.y;o++){var s=this.cellAtPosition(r,o);s?s.remove(t):console.error("removing Collider ["+t+"] from a cell that it is not present in")}},t.prototype.register=function(t){var e=t.bounds;t.registeredPhysicsBounds=e;var n=this.cellCoords(e.x,e.y),i=this.cellCoords(e.right,e.bottom);this.gridBounds.contains(n.x,n.y)||(this.gridBounds=RectangleExt.union(this.gridBounds,n)),this.gridBounds.contains(i.x,i.y)||(this.gridBounds=RectangleExt.union(this.gridBounds,i));for(var r=n.x;r<=i.x;r++)for(var o=n.y;o<=i.y;o++){var s=this.cellAtPosition(r,o,!0);-1==s.indexOf(t)&&s.push(t)}},t.prototype.clear=function(){this._cellDict.clear()},t.prototype.overlapCircle=function(t,e,n,i){var r=new Rectangle(t.x-e,t.y-e,2*e,2*e);this._overlapTestCircle.radius=e;var o=0,s=this.aabbBroadphase(r,null,i);r=s.bounds;for(var a=s.tempHashSet,c=0;c<a.length;c++){var h=a[c];if(h instanceof BoxCollider)n[o]=h,o++;else if(h instanceof CircleCollider)h.shape.overlaps(this._overlapTestCircle)&&(n[o]=h,o++);else{if(!(h instanceof PolygonCollider))throw new Error("overlapCircle against this collider type is not implemented!");h.shape.overlaps(this._overlapTestCircle)&&(n[o]=h,o++)}if(o==n.length)return o}return o},t.prototype.aabbBroadphase=function(t,e,n){this._tempHashSet.length=0;for(var i=this.cellCoords(t.x,t.y),r=this.cellCoords(t.right,t.bottom),o=i.x;o<=r.x;o++)for(var s=i.y;s<=r.y;s++){var a=this.cellAtPosition(o,s);if(a)for(var c=0;c<a.length;c++){var h=a[c];h!=e&&Flags.isFlagSet(n,h.physicsLayer)&&(t.intersects(h.bounds)&&-1==this._tempHashSet.indexOf(h)&&this._tempHashSet.push(h))}}return{tempHashSet:this._tempHashSet,bounds:t}},t.prototype.cellAtPosition=function(t,e,n){void 0===n&&(n=!1);var i=this._cellDict.tryGetValue(t,e);return i||n&&(i=[],this._cellDict.add(t,e,i)),i},t.prototype.cellCoords=function(t,e){return new Vector2(Math.floor(t*this._inverseCellSize),Math.floor(e*this._inverseCellSize))},t.prototype.debugDraw=function(t,e){void 0===e&&(e=1);for(var n=this.gridBounds.x;n<=this.gridBounds.right;n++)for(var i=this.gridBounds.y;i<=this.gridBounds.bottom;i++){var r=this.cellAtPosition(n,i);r&&r.length>0&&this.debugDrawCellDetails(n,i,r.length,t,e)}},t.prototype.debugDrawCellDetails=function(t,e,n,i,r){void 0===i&&(i=.5),void 0===r&&(r=1)},t}(),RaycastResultParser=function(){return function(){}}(),NumberDictionary=function(){function t(){this._store=new Map}return t.prototype.getKey=function(t,e){return Long.fromNumber(t).shiftLeft(32).or(Long.fromNumber(e,!1)).toString()},t.prototype.add=function(t,e,n){this._store.set(this.getKey(t,e),n)},t.prototype.remove=function(t){this._store.forEach(function(e){e.contains(t)&&e.remove(t)})},t.prototype.tryGetValue=function(t,e){return this._store.get(this.getKey(t,e))},t.prototype.clear=function(){this._store.clear()},t}(),ArrayUtils=function(){function t(){}return t.bubbleSort=function(t){for(var e=!1,n=0;n<t.length;n++){e=!1;for(var i=t.length-1;i>n;i--)if(t[i]<t[i-1]){var r=t[i];t[i]=t[i-1],t[i-1]=r,e=!0}if(!e)break}},t.insertionSort=function(t){for(var e=t.length,n=1;n<e;n++){for(var i=t[n],r=n;r>0&&t[r-1]>i;r--)t[r]=t[r-1];t[r]=i}},t.binarySearch=function(t,e){for(var n=0,i=t.length,r=n+i>>1;n<i;)e<=t[r]?i=r:e>=t[r]&&(n=r+1),r=n+i>>1;return t[n]==e?n:-1},t.findElementIndex=function(t,e){for(var n=t.length,i=0;i<n;++i)if(t[i]==e)return i;return null},t.getMaxElementIndex=function(t){for(var e=0,n=t.length,i=1;i<n;i++)t[i]>t[e]&&(e=i);return e},t.getMinElementIndex=function(t){for(var e=0,n=t.length,i=1;i<n;i++)t[i]<t[e]&&(e=i);return e},t.getUniqueAry=function(t){for(var e=[],n=[],i=t.length,r=0;r<i;++r){var o=t[r];-1==e.indexOf(o)&&e.push(o)}for(r=(i=e.length)-1;r>=0;--r)n.unshift(e[r]);return n},t.getDifferAry=function(t,e){t=this.getUniqueAry(t),e=this.getUniqueAry(e);for(var n=t.concat(e),i=new Object,r=[],o=n.length,s=0;s<o;++s)i[n[s]]?i[n[s]]instanceof Object&&i[n[s]].count++:(i[n[s]]=new Object,i[n[s]].count=0,i[n[s]].key=n[s],i[n[s]].count++);for(var a in i)2!=i[a].count&&r.unshift(i[a].key);return r},t.swap=function(t,e,n){var i=t[e];t[e]=t[n],t[n]=i},t.clearList=function(t){if(t)for(var e=t.length-1;e>=0;e-=1)t.splice(e,1)},t.cloneList=function(t){return t?t.slice(0,t.length):null},t.equals=function(t,e){if(t==e)return!0;var n=t.length;if(n!=e.length)return!1;for(;n--;)if(t[n]!=e[n])return!1;return!0},t.insert=function(t,e,n){if(!t)return null;var i=t.length;if(e>i&&(e=i),e<0&&(e=0),e==i)t.push(n);else if(0==e)t.unshift(n);else{for(var r=i-1;r>=e;r-=1)t[r+1]=t[r];t[e]=n}return n},t}(),Base64Utils=function(){function t(){}return t._utf8_encode=function(t){t=t.replace(/\r\n/g,"\n");for(var e="",n=0;n<t.length;n++){var i=t.charCodeAt(n);i<128?e+=String.fromCharCode(i):i>127&&i<2048?(e+=String.fromCharCode(i>>6|192),e+=String.fromCharCode(63&i|128)):(e+=String.fromCharCode(i>>12|224),e+=String.fromCharCode(i>>6&63|128),e+=String.fromCharCode(63&i|128))}return e},t.decode=function(t,e){void 0===e&&(e=!0);var n,i,r,o,s,a,c="",h=0;for(t=(t=this.getConfKey(t)).replace(/[^A-Za-z0-9\+\/\=]/g,"");h<t.length;)n=this._keyAll.indexOf(t.charAt(h++))<<2|(o=this._keyAll.indexOf(t.charAt(h++)))>>4,i=(15&o)<<4|(s=this._keyAll.indexOf(t.charAt(h++)))>>2,r=(3&s)<<6|(a=this._keyAll.indexOf(t.charAt(h++))),c+=String.fromCharCode(n),64!=s&&(0==i?e&&(c+=String.fromCharCode(i)):c+=String.fromCharCode(i)),64!=a&&(0==r?e&&(c+=String.fromCharCode(r)):c+=String.fromCharCode(r));return c=this._utf8_decode(c)},t._utf8_decode=function(t){for(var e="",n=0,i=0,r=0,o=0;n<t.length;)(i=t.charCodeAt(n))<128?(e+=String.fromCharCode(i),n++):i>191&&i<224?(r=t.charCodeAt(n+1),e+=String.fromCharCode((31&i)<<6|63&r),n+=2):(r=t.charCodeAt(n+1),o=t.charCodeAt(n+2),e+=String.fromCharCode((15&i)<<12|(63&r)<<6|63&o),n+=3);return e},t.getConfKey=function(t){return t.slice(1,t.length)},t._keyNum="0123456789+/",t._keyStr="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",t._keyAll=t._keyNum+t._keyStr,t.encode=function(t){var e,n,i,r,o,s,a,c="",h=0;for(t=this._utf8_encode(t);h<t.length;)r=(e=t.charCodeAt(h++))>>2,o=(3&e)<<4|(n=t.charCodeAt(h++))>>4,s=(15&n)<<2|(i=t.charCodeAt(h++))>>6,a=63&i,isNaN(n)?s=a=64:isNaN(i)&&(a=64),c=c+this._keyAll.charAt(r)+this._keyAll.charAt(o)+this._keyAll.charAt(s)+this._keyAll.charAt(a);return this._keyStr.charAt(Math.floor(Math.random()*this._keyStr.length))+c},t}(),ContentManager=function(){function t(){this.loadedAssets=new Map}return t.prototype.loadRes=function(t,e){var n=this;return void 0===e&&(e=!0),new Promise(function(i,r){var o=n.loadedAssets.get(t);o?i(o):e?RES.getResAsync(t).then(function(e){n.loadedAssets.set(t,e),i(e)}).catch(function(e){console.error("资源加载错误:",t,e),r(e)}):RES.getResByUrl(t).then(function(e){n.loadedAssets.set(t,e),i(e)}).catch(function(e){console.error("资源加载错误:",t,e),r(e)})})},t.prototype.dispose=function(){this.loadedAssets.forEach(function(t){t.dispose()}),this.loadedAssets.clear()},t}(),DrawUtils=function(){function t(){}return t.drawLine=function(t,e,n,i,r){void 0===r&&(r=1),this.drawLineAngle(t,e,MathHelper.angleBetweenVectors(e,n),Vector2.distance(e,n),i,r)},t.drawLineAngle=function(t,e,n,i,r,o){void 0===o&&(o=1),t.graphics.beginFill(r),t.graphics.drawRect(e.x,e.y,1,1),t.graphics.endFill(),t.scaleX=i,t.scaleY=o,t.$anchorOffsetX=0,t.$anchorOffsetY=0,t.rotation=n},t.drawHollowRect=function(t,e,n,i){void 0===i&&(i=1),this.drawHollowRectR(t,e.x,e.y,e.width,e.height,n,i)},t.drawHollowRectR=function(t,e,n,i,r,o,s){void 0===s&&(s=1);var a=new Vector2(e,n).round(),c=new Vector2(e+i,n).round(),h=new Vector2(e+i,n+r).round(),u=new Vector2(e,n+r).round();this.drawLine(t,a,c,o,s),this.drawLine(t,c,h,o,s),this.drawLine(t,h,u,o,s),this.drawLine(t,u,a,o,s)},t.drawPixel=function(t,e,n,i){void 0===i&&(i=1);var r=new Rectangle(e.x,e.y,i,i);1!=i&&(r.x-=.5*i,r.y-=.5*i),t.graphics.beginFill(n),t.graphics.drawRect(r.x,r.y,r.width,r.height),t.graphics.endFill()},t}(),Emitter=function(){function t(){this._messageTable=new Map}return t.prototype.addObserver=function(t,e,n){var i=this._messageTable.get(t);i||(i=[],this._messageTable.set(t,i)),i.contains(e)&&console.warn("您试图添加相同的观察者两次"),i.push(new FuncPack(e,n))},t.prototype.removeObserver=function(t,e){var n=this._messageTable.get(t),i=n.findIndex(function(t){return t.func==e});-1!=i&&n.removeAt(i)},t.prototype.emit=function(t,e){var n=this._messageTable.get(t);if(n)for(var i=n.length-1;i>=0;i--)n[i].func.call(n[i].context,e)},t}(),FuncPack=function(){return function(t,e){this.func=t,this.context=e}}(),GlobalManager=function(){function t(){}return Object.defineProperty(t.prototype,"enabled",{get:function(){return this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),t.prototype.setEnabled=function(t){this._enabled!=t&&(this._enabled=t,this._enabled?this.onEnabled():this.onDisabled())},t.prototype.onEnabled=function(){},t.prototype.onDisabled=function(){},t.prototype.update=function(){},t.registerGlobalManager=function(t){this.globalManagers.push(t),t.enabled=!0},t.unregisterGlobalManager=function(t){this.globalManagers.remove(t),t.enabled=!1},t.getGlobalManager=function(t){for(var e=0;e<this.globalManagers.length;e++)if(this.globalManagers[e]instanceof t)return this.globalManagers[e];return null},t.globalManagers=[],t}(),TouchState=function(){function t(){this.x=0,this.y=0,this.touchPoint=-1,this.touchDown=!1}return Object.defineProperty(t.prototype,"position",{get:function(){return new Vector2(this.x,this.y)},enumerable:!0,configurable:!0}),t.prototype.reset=function(){this.x=0,this.y=0,this.touchDown=!1,this.touchPoint=-1},t}(),Input=function(){function t(){}return Object.defineProperty(t,"touchPosition",{get:function(){return this._gameTouchs[0]?this._gameTouchs[0].position:Vector2.zero},enumerable:!0,configurable:!0}),Object.defineProperty(t,"maxSupportedTouch",{get:function(){return this._stage.maxTouches},set:function(t){this._stage.maxTouches=t,this.initTouchCache()},enumerable:!0,configurable:!0}),Object.defineProperty(t,"resolutionScale",{get:function(){return this._resolutionScale},enumerable:!0,configurable:!0}),Object.defineProperty(t,"totalTouchCount",{get:function(){return this._totalTouchCount},enumerable:!0,configurable:!0}),Object.defineProperty(t,"gameTouchs",{get:function(){return this._gameTouchs},enumerable:!0,configurable:!0}),Object.defineProperty(t,"touchPositionDelta",{get:function(){var t=Vector2.subtract(this.touchPosition,this._previousTouchState.position);return t.length()>0&&this.setpreviousTouchState(this._gameTouchs[0]),t},enumerable:!0,configurable:!0}),t.initialize=function(t){this._init||(this._init=!0,this._stage=t,this._stage.addEventListener(egret.TouchEvent.TOUCH_BEGIN,this.touchBegin,this),this._stage.addEventListener(egret.TouchEvent.TOUCH_MOVE,this.touchMove,this),this._stage.addEventListener(egret.TouchEvent.TOUCH_END,this.touchEnd,this),this._stage.addEventListener(egret.TouchEvent.TOUCH_CANCEL,this.touchEnd,this),this._stage.addEventListener(egret.TouchEvent.TOUCH_RELEASE_OUTSIDE,this.touchEnd,this),this.initTouchCache())},t.initTouchCache=function(){this._totalTouchCount=0,this._touchIndex=0,this._gameTouchs.length=0;for(var t=0;t<this.maxSupportedTouch;t++)this._gameTouchs.push(new TouchState)},t.touchBegin=function(t){this._touchIndex<this.maxSupportedTouch&&(this._gameTouchs[this._touchIndex].touchPoint=t.touchPointID,this._gameTouchs[this._touchIndex].touchDown=t.touchDown,this._gameTouchs[this._touchIndex].x=t.stageX,this._gameTouchs[this._touchIndex].y=t.stageY,0==this._touchIndex&&this.setpreviousTouchState(this._gameTouchs[0]),this._touchIndex++,this._totalTouchCount++)},t.touchMove=function(t){t.touchPointID==this._gameTouchs[0].touchPoint&&this.setpreviousTouchState(this._gameTouchs[0]);var e=this._gameTouchs.findIndex(function(e){return e.touchPoint==t.touchPointID});if(-1!=e){var n=this._gameTouchs[e];n.x=t.stageX,n.y=t.stageY}},t.touchEnd=function(t){var e=this._gameTouchs.findIndex(function(e){return e.touchPoint==t.touchPointID});-1!=e&&(this._gameTouchs[e].reset(),0==e&&this._previousTouchState.reset(),this._totalTouchCount--,0==this.totalTouchCount&&(this._touchIndex=0))},t.setpreviousTouchState=function(t){this._previousTouchState=new TouchState,this._previousTouchState.x=t.position.x,this._previousTouchState.y=t.position.y,this._previousTouchState.touchPoint=t.touchPoint,this._previousTouchState.touchDown=t.touchDown},t.scaledPosition=function(t){var e=new Vector2(t.x-this._resolutionOffset.x,t.y-this._resolutionOffset.y);return Vector2.multiply(e,this.resolutionScale)},t._init=!1,t._previousTouchState=new TouchState,t._gameTouchs=[],t._resolutionOffset=new Vector2,t._resolutionScale=Vector2.one,t._touchIndex=0,t._totalTouchCount=0,t}(),KeyboardUtils=function(){function t(){}return t.init=function(){this.keyDownDict={},this.keyUpDict={},document.addEventListener("keydown",this.onKeyDonwHander),document.addEventListener("keyup",this.onKeyUpHander)},t.onKeyDonwHander=function(t){if(this.keyDownDict){var e=this.keyCodeToString(t.keyCode),n=this.keyDownDict[e];if(n){var i=n.fun,r=n.thisObj,o=n.args;i.apply(r,o)}}},t.onKeyUpHander=function(t){if(this.keyUpDict){var e=this.keyCodeToString(t.keyCode),n=this.keyUpDict[e];if(n){var i=n.fun,r=n.thisObj,o=n.args;i.apply(r,o)}}},t.registerKey=function(t,e,n,i){void 0===i&&(i=0);for(var r=[],o=4;o<arguments.length;o++)r[o-4]=arguments[o];(i?this.keyUpDict:this.keyDownDict)[t]={fun:e,args:r,thisObj:n}},t.unregisterKey=function(t,e){void 0===e&&(e=0),delete(e?this.keyUpDict:this.keyDownDict)[t]},t.keyCodeToString=function(t){switch(t){case 8:return this.BACK_SPACE;case 9:return this.TAB;case 13:return this.ENTER;case 16:return this.SHIFT;case 17:return this.CTRL;case 19:return this.PAUSE_BREAK;case 20:return this.CAPS_LOCK;case 27:return this.ESC;case 32:return this.SPACE;case 33:return this.PAGE_UP;case 34:return this.PAGE_DOWN;case 35:return this.END;case 36:return this.HOME;case 37:return this.LEFT;case 38:return this.UP;case 39:return this.RIGHT;case 40:return this.DOWN;case 45:return this.INSERT;case 46:return this.DELETE;case 91:return this.WINDOWS;case 112:return this.F1;case 113:return this.F2;case 114:return this.F3;case 115:return this.F4;case 116:return this.F5;case 117:return this.F6;case 118:return this.F7;case 119:return this.F8;case 120:return this.F9;case 122:return this.F11;case 123:return this.F12;case 144:return this.NUM_LOCK;case 145:return this.SCROLL_LOCK;default:return String.fromCharCode(t)}},t.destroy=function(){this.keyDownDict=null,this.keyUpDict=null,document.removeEventListener("keydown",this.onKeyDonwHander),document.removeEventListener("keyup",this.onKeyUpHander)},t.TYPE_KEY_DOWN=0,t.TYPE_KEY_UP=1,t.A="A",t.B="B",t.C="C",t.D="D",t.E="E",t.F="F",t.G="G",t.H="H",t.I="I",t.J="J",t.K="K",t.L="L",t.M="M",t.N="N",t.O="O",t.P="P",t.Q="Q",t.R="R",t.S="S",t.T="T",t.U="U",t.V="V",t.W="W",t.X="X",t.Y="Y",t.Z="Z",t.ESC="Esc",t.F1="F1",t.F2="F2",t.F3="F3",t.F4="F4",t.F5="F5",t.F6="F6",t.F7="F7",t.F8="F8",t.F9="F9",t.F10="F10",t.F11="F11",t.F12="F12",t.NUM_1="1",t.NUM_2="2",t.NUM_3="3",t.NUM_4="4",t.NUM_5="5",t.NUM_6="6",t.NUM_7="7",t.NUM_8="8",t.NUM_9="9",t.NUM_0="0",t.TAB="Tab",t.CTRL="Ctrl",t.ALT="Alt",t.SHIFT="Shift",t.CAPS_LOCK="Caps Lock",t.ENTER="Enter",t.SPACE="Space",t.BACK_SPACE="Back Space",t.INSERT="Insert",t.DELETE="Page Down",t.HOME="Home",t.END="Page Down",t.PAGE_UP="Page Up",t.PAGE_DOWN="Page Down",t.LEFT="Left",t.RIGHT="Right",t.UP="Up",t.DOWN="Down",t.PAUSE_BREAK="Pause Break",t.NUM_LOCK="Num Lock",t.SCROLL_LOCK="Scroll Lock",t.WINDOWS="Windows",t}(),ListPool=function(){function t(){}return t.warmCache=function(t){if((t-=this._objectQueue.length)>0)for(var e=0;e<t;e++)this._objectQueue.unshift([])},t.trimCache=function(t){for(;t>this._objectQueue.length;)this._objectQueue.shift()},t.clearCache=function(){this._objectQueue.length=0},t.obtain=function(){return this._objectQueue.length>0?this._objectQueue.shift():[]},t.free=function(t){this._objectQueue.unshift(t),t.length=0},t._objectQueue=[],t}(),THREAD_ID=Math.floor(1e3*Math.random())+"-"+Date.now(),setItem=egret.localStorage.setItem.bind(localStorage),getItem=egret.localStorage.getItem.bind(localStorage),removeItem=egret.localStorage.removeItem.bind(localStorage),nextTick=function(t){setTimeout(t,0)},LockUtils=function(){function t(t){this._keyX="mutex_key_"+t+"_X",this._keyY="mutex_key_"+t+"_Y"}return t.prototype.lock=function(){var t=this;return new Promise(function(e,n){var i=function(){setItem(t._keyX,THREAD_ID),null===!getItem(t._keyY)&&nextTick(i),setItem(t._keyY,THREAD_ID),getItem(t._keyX)!==THREAD_ID?setTimeout(function(){getItem(t._keyY)===THREAD_ID?(e(),removeItem(t._keyY)):nextTick(i)},10):(e(),removeItem(t._keyY))};i()})},t}(),Pair=function(){function t(t,e){this.first=t,this.second=e}return t.prototype.clear=function(){this.first=this.second=null},t.prototype.equals=function(t){return this.first==t.first&&this.second==t.second},t}(),RandomUtils=function(){function t(){}return t.randrange=function(t,e,n){if(void 0===n&&(n=1),0==n)throw new Error("step 不能为 0");var i=e-t;if(0==i)throw new Error("没有可用的范围("+t+","+e+")");i<0&&(i=t-e);var r=Math.floor((i+n-1)/n);return Math.floor(this.random()*r)*n+Math.min(t,e)},t.randint=function(t,e){return(t=Math.floor(t))>(e=Math.floor(e))?t++:e++,this.randrange(t,e)},t.randnum=function(t,e){return this.random()*(e-t)+t},t.shuffle=function(t){return t.sort(this._randomCompare),t},t._randomCompare=function(t,e){return this.random()>.5?1:-1},t.choice=function(t){if(!t.hasOwnProperty("length"))throw new Error("无法对此对象执行此操作");var e=Math.floor(this.random()*t.length);return t instanceof String?String(t).charAt(e):t[e]},t.sample=function(t,e){var n=t.length;if(e<=0||n<e)throw new Error("采样数量不够");for(var i=[],r=[],o=0;o<e;o++){for(var s=Math.floor(this.random()*n);r.indexOf(s)>=0;)s=Math.floor(this.random()*n);i.push(t[s]),r.push(s)}return i},t.random=function(){return Math.random()},t.boolean=function(t){return void 0===t&&(t=.5),this.random()<t},t}(),RectangleExt=function(){function t(){}return t.union=function(t,e){var n=new Rectangle(e.x,e.y,0,0),i=new Rectangle;return i.x=Math.min(t.x,n.x),i.y=Math.min(t.y,n.y),i.width=Math.max(t.right,n.right)-i.x,i.height=Math.max(t.bottom,i.bottom)-i.y,i},t}(),Triangulator=function(){function t(){this.triangleIndices=[],this._triPrev=new Array(12),this._triNext=new Array(12)}return t.prototype.triangulate=function(e,n){void 0===n&&(n=!0);var i=e.length;this.initialize(i);for(var r=0,o=0;i>3&&r<500;){r++;var s=!0,a=e[this._triPrev[o]],c=e[o],h=e[this._triNext[o]];if(Vector2Ext.isTriangleCCW(a,c,h)){var u=this._triNext[this._triNext[o]];do{if(t.testPointTriangle(e[u],a,c,h)){s=!1;break}u=this._triNext[u]}while(u!=this._triPrev[o])}else s=!1;s?(this.triangleIndices.push(this._triPrev[o]),this.triangleIndices.push(o),this.triangleIndices.push(this._triNext[o]),this._triNext[this._triPrev[o]]=this._triNext[o],this._triPrev[this._triNext[o]]=this._triPrev[o],i--,o=this._triPrev[o]):o=this._triNext[o]}this.triangleIndices.push(this._triPrev[o]),this.triangleIndices.push(o),this.triangleIndices.push(this._triNext[o]),n||this.triangleIndices.reverse()},t.prototype.initialize=function(t){this.triangleIndices.length=0,this._triNext.length<t&&(this._triNext.reverse(),this._triNext=new Array(Math.max(2*this._triNext.length,t))),this._triPrev.length<t&&(this._triPrev.reverse(),this._triPrev=new Array(Math.max(2*this._triPrev.length,t)));for(var e=0;e<t;e++)this._triPrev[e]=e-1,this._triNext[e]=e+1;this._triPrev[0]=t-1,this._triNext[t-1]=0},t.testPointTriangle=function(t,e,n,i){return!(Vector2Ext.cross(Vector2.subtract(t,e),Vector2.subtract(n,e))<0)&&(!(Vector2Ext.cross(Vector2.subtract(t,n),Vector2.subtract(i,n))<0)&&!(Vector2Ext.cross(Vector2.subtract(t,i),Vector2.subtract(e,i))<0))},t}(),Vector2Ext=function(){function t(){}return t.isTriangleCCW=function(t,e,n){return this.cross(Vector2.subtract(e,t),Vector2.subtract(n,e))<0},t.cross=function(t,e){return t.y*e.x-t.x*e.y},t.perpendicular=function(t,e){return new Vector2(-1*(e.y-t.y),e.x-t.x)},t.normalize=function(t){var e=Math.sqrt(t.x*t.x+t.y*t.y);return e>MathHelper.Epsilon?t=Vector2.divide(t,new Vector2(e)):t.x=t.y=0,t},t.transformA=function(t,e,n,i,r,o){for(var s=0;s<o;s++){var a=t[e+s],c=i[r+s];c.x=a.x*n.m11+a.y*n.m21+n.m31,c.y=a.x*n.m12+a.y*n.m22+n.m32,i[r+s]=c}},t.transformR=function(t,e){var n=t.x*e.m11+t.y*e.m21+e.m31,i=t.x*e.m12+t.y*e.m22+e.m32;return new Vector2(n,i)},t.transform=function(t,e,n){this.transformA(t,0,e,n,0,t.length)},t.round=function(t){return new Vector2(Math.round(t.x),Math.round(t.y))},t}(),WebGLUtils=function(){function t(){}return t.getContext=function(){return document.getElementsByTagName("canvas")[0].getContext("2d")},t}(),Layout=function(){function t(){this.clientArea=new Rectangle(0,0,SceneManager.stage.stageWidth,SceneManager.stage.stageHeight),this.safeArea=this.clientArea}return t.prototype.place=function(t,e,n,i){var r=new Rectangle(0,0,t.x,t.y);return 0!=(i&Alignment.left)?r.x=this.clientArea.x+this.clientArea.width*e:0!=(i&Alignment.right)?r.x=this.clientArea.x+this.clientArea.width*(1-e)-r.width:0!=(i&Alignment.horizontalCenter)&&(r.x=this.clientArea.x+(this.clientArea.width-r.width)/2+e*this.clientArea.width),0!=(i&Alignment.top)?r.y=this.clientArea.y+this.clientArea.height*n:0!=(i&Alignment.bottom)?r.y=this.clientArea.y+this.clientArea.height*(1-n)-r.height:0!=(i&Alignment.verticalCenter)&&(r.y=this.clientArea.y+(this.clientArea.height-r.height)/2+n*this.clientArea.height),r.left<this.safeArea.left&&(r.x=this.safeArea.left),r.right>this.safeArea.right&&(r.x=this.safeArea.right-r.width),r.top<this.safeArea.top&&(r.y=this.safeArea.top),r.bottom>this.safeArea.bottom&&(r.y=this.safeArea.bottom-r.height),r},t}();!function(t){t[t.none=0]="none",t[t.left=1]="left",t[t.right=2]="right",t[t.horizontalCenter=4]="horizontalCenter",t[t.top=8]="top",t[t.bottom=16]="bottom",t[t.verticalCenter=32]="verticalCenter",t[t.topLeft=9]="topLeft",t[t.topRight=10]="topRight",t[t.topCenter=12]="topCenter",t[t.bottomLeft=17]="bottomLeft",t[t.bottomRight=18]="bottomRight",t[t.bottomCenter=20]="bottomCenter",t[t.centerLeft=33]="centerLeft",t[t.centerRight=34]="centerRight",t[t.center=36]="center"}(Alignment||(Alignment={})),function(t){var e,n=function(){function t(t){void 0===t&&(t=i),this.getSystemTime=t,this._stopDuration=0,this._completeSlices=[]}return t.prototype.getState=function(){return void 0===this._startSystemTime?e.IDLE:void 0===this._stopSystemTime?e.RUNNING:e.STOPPED},t.prototype.isIdle=function(){return this.getState()===e.IDLE},t.prototype.isRunning=function(){return this.getState()===e.RUNNING},t.prototype.isStopped=function(){return this.getState()===e.STOPPED},t.prototype.slice=function(){return this.recordPendingSlice()},t.prototype.getCompletedSlices=function(){return Array.from(this._completeSlices)},t.prototype.getCompletedAndPendingSlices=function(){return this._completeSlices.concat([this.getPendingSlice()])},t.prototype.getPendingSlice=function(){return this.calculatePendingSlice()},t.prototype.getTime=function(){return this.caculateStopwatchTime()},t.prototype.calculatePendingSlice=function(t){return void 0===this._pendingSliceStartStopwatchTime?Object.freeze({startTime:0,endTime:0,duration:0}):(void 0===t&&(t=this.getTime()),Object.freeze({startTime:this._pendingSliceStartStopwatchTime,endTime:t,duration:t-this._pendingSliceStartStopwatchTime}))},t.prototype.caculateStopwatchTime=function(t){return void 0===this._startSystemTime?0:(void 0===t&&(t=this.getSystemTimeOfCurrentStopwatchTime()),t-this._startSystemTime-this._stopDuration)},t.prototype.getSystemTimeOfCurrentStopwatchTime=function(){return void 0===this._stopSystemTime?this.getSystemTime():this._stopSystemTime},t.prototype.reset=function(){this._startSystemTime=this._pendingSliceStartStopwatchTime=this._stopSystemTime=void 0,this._stopDuration=0,this._completeSlices=[]},t.prototype.start=function(t){if(void 0===t&&(t=!1),t&&this.reset(),void 0!==this._stopSystemTime){var e=(n=this.getSystemTime())-this._stopSystemTime;this._stopDuration+=e,this._stopSystemTime=void 0}else if(void 0===this._startSystemTime){var n=this.getSystemTime();this._startSystemTime=n,this._pendingSliceStartStopwatchTime=0}},t.prototype.stop=function(t){if(void 0===t&&(t=!1),void 0===this._startSystemTime)return 0;var e=this.getSystemTimeOfCurrentStopwatchTime();return t&&this.recordPendingSlice(this.caculateStopwatchTime(e)),this._stopSystemTime=e,this.getTime()},t.prototype.recordPendingSlice=function(t){if(void 0!==this._pendingSliceStartStopwatchTime){void 0===t&&(t=this.getTime());var e=this.calculatePendingSlice(t);return this._pendingSliceStartStopwatchTime=e.endTime,this._completeSlices.push(e),e}return this.calculatePendingSlice()},t}();t.Stopwatch=n,function(t){t.IDLE="IDLE",t.RUNNING="RUNNING",t.STOPPED="STOPPED"}(e||(e={})),t.setDefaultSystemTimeGetter=function(t){void 0===t&&(t=Date.now),i=t};var i=Date.now}(stopwatch||(stopwatch={}));var TimeRuler=function(){function t(){this._frameKey="frame",this._logKey="log",this.markers=[],this.stopwacth=new stopwatch.Stopwatch,this._markerNameToIdMap=new Map,this.showLog=!1,t.Instance=this,this._logs=new Array(2);for(var e=0;e<this._logs.length;++e)this._logs[e]=new FrameLog;this.sampleFrames=this.targetSampleFrames=1,this.width=.8*SceneManager.stage.stageWidth,this.onGraphicsDeviceReset()}return t.prototype.onGraphicsDeviceReset=function(){var e=new Layout;this._position=e.place(new Vector2(this.width,t.barHeight),0,.01,Alignment.bottomCenter).location},t.prototype.startFrame=function(){var e=this;new LockUtils(this._frameKey).lock().then(function(){e._updateCount=parseInt(egret.localStorage.getItem(e._frameKey),10),isNaN(e._updateCount)&&(e._updateCount=0);var n=e._updateCount;if(n+=1,egret.localStorage.setItem(e._frameKey,n.toString()),!(e.enabled&&1<n&&n<t.maxSampleFrames)){e._prevLog=e._logs[1&e.frameCount++],e._curLog=e._logs[1&e.frameCount];for(var i=e.stopwacth.getTime(),r=0;r<e._prevLog.bars.length;++r){for(var o=e._prevLog.bars[r],s=e._curLog.bars[r],a=0;a<o.nestCount;++a){var c=o.markerNests[a];o.markers[c].endTime=i,s.markerNests[a]=a,s.markers[a].markerId=o.markers[c].markerId,s.markers[a].beginTime=0,s.markers[a].endTime=-1,s.markers[a].color=o.markers[c].color}for(c=0;c<o.markCount;++c){var h=o.markers[c].endTime-o.markers[c].beginTime,u=o.markers[c].markerId,l=e.markers[u];l.logs[r].color=o.markers[c].color,l.logs[r].initialized?(l.logs[r].min=Math.min(l.logs[r].min,h),l.logs[r].max=Math.min(l.logs[r].max,h),l.logs[r].avg+=h,l.logs[r].avg*=.5,l.logs[r].samples++>=t.logSnapDuration&&(l.logs[r].snapMin=l.logs[r].min,l.logs[r].snapMax=l.logs[r].max,l.logs[r].snapAvg=l.logs[r].avg,l.logs[r].samples=0)):(l.logs[r].min=h,l.logs[r].max=h,l.logs[r].avg=h,l.logs[r].initialized=!0)}s.markCount=o.nestCount,s.nestCount=o.nestCount}e.stopwacth.reset(),e.stopwacth.start()}})},t.prototype.beginMark=function(e,n,i){var r=this;void 0===i&&(i=0),new LockUtils(this._frameKey).lock().then(function(){if(i<0||i>=t.maxBars)throw new Error("barIndex argument out of range");var o=r._curLog.bars[i];if(o.markCount>=t.maxSamples)throw new Error("exceeded sample count. either set larger number to timeruler.maxsaple or lower sample count");if(o.nestCount>=t.maxNestCall)throw new Error("exceeded nest count. either set larger number to timeruler.maxnestcall or lower nest calls");var s=r._markerNameToIdMap.get(e);isNaN(s)&&(s=r.markers.length,r._markerNameToIdMap.set(e,s)),o.markerNests[o.nestCount++]=o.markCount,o.markers[o.markCount].markerId=s,o.markers[o.markCount].color=n,o.markers[o.markCount].beginTime=r.stopwacth.getTime(),o.markers[o.markCount].endTime=-1})},t.prototype.endMark=function(e,n){var i=this;void 0===n&&(n=0),new LockUtils(this._frameKey).lock().then(function(){if(n<0||n>=t.maxBars)throw new Error("barIndex argument out of range");var r=i._curLog.bars[n];if(r.nestCount<=0)throw new Error("call beginMark method before calling endMark method");var o=i._markerNameToIdMap.get(e);if(isNaN(o))throw new Error("Marker "+e+" is not registered. Make sure you specifed same name as you used for beginMark method");var s=r.markerNests[--r.nestCount];if(r.markers[s].markerId!=o)throw new Error("Incorrect call order of beginMark/endMark method. beginMark(A), beginMark(B), endMark(B), endMark(A) But you can't called it like beginMark(A), beginMark(B), endMark(A), endMark(B).");r.markers[s].endTime=i.stopwacth.getTime()})},t.prototype.getAverageTime=function(e,n){if(e<0||e>=t.maxBars)throw new Error("barIndex argument out of range");var i=0,r=this._markerNameToIdMap.get(n);return r&&(i=this.markers[r].logs[e].avg),i},t.prototype.resetLog=function(){var t=this;new LockUtils(this._logKey).lock().then(function(){var e=parseInt(egret.localStorage.getItem(t._logKey),10);e+=1,egret.localStorage.setItem(t._logKey,e.toString()),t.markers.forEach(function(t){for(var e=0;e<t.logs.length;++e)t.logs[e].initialized=!1,t.logs[e].snapMin=0,t.logs[e].snapMax=0,t.logs[e].snapAvg=0,t.logs[e].min=0,t.logs[e].max=0,t.logs[e].avg=0,t.logs[e].samples=0})})},t.prototype.render=function(e,n){if(void 0===e&&(e=this._position),void 0===n&&(n=this.width),egret.localStorage.setItem(this._frameKey,"0"),this.showLog){var i=0,r=0;this._prevLog.bars.forEach(function(e){e.markCount>0&&(i+=t.barHeight+2*t.barPadding,r=Math.max(r,e.markers[e.markCount-1].endTime))});var o=this.sampleFrames*(1/60*1e3);this._frameAdjust=r>o?Math.max(0,this._frameAdjust)+1:Math.min(0,this._frameAdjust)-1,Math.max(this._frameAdjust)>t.autoAdjustDelay&&(this.sampleFrames=Math.min(t.maxSampleFrames,this.sampleFrames),this.sampleFrames=Math.max(this.targetSampleFrames,r/(1/60*1e3)+1),this._frameAdjust=0);e.y,t.barHeight}},t.maxBars=8,t.maxSamples=256,t.maxNestCall=32,t.barHeight=8,t.maxSampleFrames=4,t.logSnapDuration=120,t.barPadding=2,t.autoAdjustDelay=30,t}(),FrameLog=function(){return function(){this.bars=new Array(TimeRuler.maxBars),this.bars.fill(new MarkerCollection,0,TimeRuler.maxBars)}}(),MarkerCollection=function(){return function(){this.markers=new Array(TimeRuler.maxSamples),this.markCount=0,this.markerNests=new Array(TimeRuler.maxNestCall),this.nestCount=0,this.markers.fill(new Marker,0,TimeRuler.maxSamples),this.markerNests.fill(0,0,TimeRuler.maxNestCall)}}(),Marker=function(){return function(){this.markerId=0,this.beginTime=0,this.endTime=0,this.color=0}}(),MarkerInfo=function(){return function(t){this.logs=new Array(TimeRuler.maxBars),this.name=t,this.logs.fill(new MarkerLog,0,TimeRuler.maxBars)}}(),MarkerLog=function(){return function(){this.snapMin=0,this.snapMax=0,this.snapAvg=0,this.min=0,this.max=0,this.avg=0,this.samples=0,this.color=0,this.initialized=!1}}();
\ No newline at end of file
+window.framework={},window.__extends=this&&this.__extends||function(){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n])};return function(e,n){function i(){this.constructor=e}t(e,n),e.prototype=null===n?Object.create(n):(i.prototype=n.prototype,new i)}}();var transform,__awaiter=this&&this.__awaiter||function(t,e,n,i){return new(n||(n=Promise))(function(r,o){function s(t){try{c(i.next(t))}catch(t){o(t)}}function a(t){try{c(i.throw(t))}catch(t){o(t)}}function c(t){t.done?r(t.value):new n(function(e){e(t.value)}).then(s,a)}c((i=i.apply(t,e||[])).next())})},__generator=this&&this.__generator||function(t,e){var n,i,r,o,s={label:0,sent:function(){if(1&r[0])throw r[1];return r[1]},trys:[],ops:[]};return o={next:a(0),throw:a(1),return:a(2)},"function"==typeof Symbol&&(o[Symbol.iterator]=function(){return this}),o;function a(o){return function(a){return function(o){if(n)throw new TypeError("Generator is already executing.");for(;s;)try{if(n=1,i&&(r=2&o[0]?i.return:o[0]?i.throw||((r=i.return)&&r.call(i),0):i.next)&&!(r=r.call(i,o[1])).done)return r;switch(i=0,r&&(o=[2&o[0],r.value]),o[0]){case 0:case 1:r=o;break;case 4:return s.label++,{value:o[1],done:!1};case 5:s.label++,i=o[1],o=[0];continue;case 7:o=s.ops.pop(),s.trys.pop();continue;default:if(!(r=(r=s.trys).length>0&&r[r.length-1])&&(6===o[0]||2===o[0])){s=0;continue}if(3===o[0]&&(!r||o[1]>r[0]&&o[1]<r[3])){s.label=o[1];break}if(6===o[0]&&s.label<r[1]){s.label=r[1],r=o;break}if(r&&s.label<r[2]){s.label=r[2],s.ops.push(o);break}r[2]&&s.ops.pop(),s.trys.pop();continue}o=e.call(t,s)}catch(t){o=[6,t],i=0}finally{n=r=0}if(5&o[0])throw o[1];return{value:o[0]?o[1]:void 0,done:!0}}([o,a])}}};Array.prototype.findIndex=function(t){return function(t,e){for(var n=0,i=t.length;n<i;n++)if(e.call(arguments[2],t[n],n,t))return n;return-1}(this,t)},Array.prototype.any=function(t){return function(t,e){return t.findIndex(e)>-1}(this,t)},Array.prototype.firstOrDefault=function(t){return function(t,e){var n=t.findIndex(e);return-1==n?null:t[n]}(this,t)},Array.prototype.find=function(t){return function(t,e){return t.firstOrDefault(e)}(this,t)},Array.prototype.where=function(t){return function(t,e){if("function"==typeof t.reduce)return t.reduce(function(n,i,r){return e.call(arguments[2],i,r,t)&&n.push(i),n},[]);for(var n=[],i=0,r=t.length;i<r;i++){var o=t[i];e.call(arguments[2],o,i,t)&&n.push(o)}return n}(this,t)},Array.prototype.count=function(t){return function(t,e){return t.where(e).length}(this,t)},Array.prototype.findAll=function(t){return function(t,e){return t.where(e)}(this,t)},Array.prototype.contains=function(t){return function(t,e){for(var n=0,i=t.length;n<i;n++)if(t[n]==e)return!0;return!1}(this,t)},Array.prototype.removeAll=function(t){!function(t,e){var n;do{(n=t.findIndex(e))>=0&&t.splice(n,1)}while(n>=0)}(this,t)},Array.prototype.remove=function(t){return function(t,e){var n=t.findIndex(function(t){return t===e});return n>=0&&(t.splice(n,1),!0)}(this,t)},Array.prototype.removeAt=function(t){return function(t,e){t.splice(e,1)}(this,t)},Array.prototype.removeRange=function(t,e){return function(t,e,n){t.splice(e,n)}(this,t,e)},Array.prototype.select=function(t){return function(t,e){if("function"==typeof t.reduce)return t.reduce(function(n,i,r){return n.push(e.call(arguments[2],i,r,t)),n},[]);for(var n=[],i=0,r=t.length;i<r;i++)n.push(e.call(arguments[2],t[i],i,t));return n}(this,t)},Array.prototype.orderBy=function(t,e){return function(t,e,n){return t.sort(function(t,i){var r=e(t),o=e(i);return n?n(r,o):r>o?1:-1}),t}(this,t,e)},Array.prototype.orderByDescending=function(t,e){return function(t,e,n){return t.sort(function(t,i){var r=e(t),o=e(i);return n?-n(r,o):r<o?1:-1}),t}(this,t,e)},Array.prototype.groupBy=function(t){return function(t,e){if("function"==typeof t.reduce){var n=[];return t.reduce(function(i,r,o){var s=JSON.stringify(e.call(arguments[1],r,o,t)),a=n.findIndex(function(t){return t===s});return a<0&&(a=n.push(s)-1),i[a]||(i[a]=[]),i[a].push(r),i},[])}for(var i=[],r=[],o=function(n,o){var a=JSON.stringify(e.call(s[1],t[n],n,t)),c=r.findIndex(function(t){return t===a});c<0&&(c=r.push(a)-1),i[c]||(i[c]=[]),i[c].push(t[n])},s=arguments,a=0,c=t.length;a<c;a++)o(a);return i}(this,t)},Array.prototype.sum=function(t){return function(t,e){for(var n,i=0,r=t.length;i<r;i++)0==i?n=e?e.call(arguments[2],t[i],i,t):t[i]:n+=e?e.call(arguments[2],t[i],i,t):t[i];return n}(this,t)},function(t){var e=function(){return function(){this.priority=0,this.insertionIndex=0,this.queueIndex=0}}();t.PriorityQueueNode=e}(es||(es={})),function(t){var e=function(){function e(){}return e.search=function(e,i,r){var o=this,s=!1,a=new Map;a.set(i,i);var c=new Map,h=new t.PriorityQueue(1e3);h.enqueue(new n(i),0),c.set(i,0);for(var u=function(){var t=h.dequeue();if(JSON.stringify(t.data)==JSON.stringify(r))return s=!0,"break";e.getNeighbors(t.data).forEach(function(i){var s=c.get(t.data)+e.cost(t.data,i);if(!o.hasKey(c,i)||s<c.get(i)){c.set(i,s);var u=s+e.heuristic(i,r);h.enqueue(new n(i),u),a.set(i,t.data)}})};h.count>0;){if("break"===u())break}return s?this.recontructPath(a,i,r):null},e.hasKey=function(t,e){for(var n,i=t.keys();!(n=i.next()).done;)if(JSON.stringify(n.value)==JSON.stringify(e))return!0;return!1},e.getKey=function(t,e){for(var n,i,r=t.keys(),o=t.values();n=r.next(),i=o.next(),!n.done;)if(JSON.stringify(n.value)==JSON.stringify(e))return i.value;return null},e.recontructPath=function(t,e,n){var i=[],r=n;for(i.push(n);r!=e;)r=this.getKey(t,r),i.push(r);return i.reverse(),i},e}();t.AStarPathfinder=e;var n=function(t){function e(e){var n=t.call(this)||this;return n.data=e,n}return __extends(e,t),e}(t.PriorityQueueNode);t.AStarNode=n}(es||(es={})),function(t){var e=function(){function e(e,n){this.dirs=[new t.Vector2(1,0),new t.Vector2(0,-1),new t.Vector2(-1,0),new t.Vector2(0,1)],this.walls=[],this.weightedNodes=[],this.defaultWeight=1,this.weightedNodeWeight=5,this._neighbors=new Array(4),this._width=e,this._height=n}return e.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._height},e.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},e.prototype.search=function(e,n){return t.AStarPathfinder.search(this,e,n)},e.prototype.getNeighbors=function(e){var n=this;return this._neighbors.length=0,this.dirs.forEach(function(i){var r=new t.Vector2(e.x+i.x,e.y+i.y);n.isNodeInBounds(r)&&n.isNodePassable(r)&&n._neighbors.push(r)}),this._neighbors},e.prototype.cost=function(t,e){return this.weightedNodes.find(function(t){return JSON.stringify(t)==JSON.stringify(e)})?this.weightedNodeWeight:this.defaultWeight},e.prototype.heuristic=function(t,e){return Math.abs(t.x-e.x)+Math.abs(t.y-e.y)},e}();t.AstarGridGraph=e}(es||(es={})),function(t){var e=function(){function t(t){this._numNodes=0,this._nodes=new Array(t+1),this._numNodesEverEnqueued=0}return t.prototype.clear=function(){this._nodes.splice(1,this._numNodes),this._numNodes=0},Object.defineProperty(t.prototype,"count",{get:function(){return this._numNodes},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"maxSize",{get:function(){return this._nodes.length-1},enumerable:!0,configurable:!0}),t.prototype.contains=function(t){return t?t.queueIndex<0||t.queueIndex>=this._nodes.length?(console.error("node.QueueIndex has been corrupted. Did you change it manually? Or add this node to another queue?"),!1):this._nodes[t.queueIndex]==t:(console.error("node cannot be null"),!1)},t.prototype.enqueue=function(t,e){t.priority=e,this._numNodes++,this._nodes[this._numNodes]=t,t.queueIndex=this._numNodes,t.insertionIndex=this._numNodesEverEnqueued++,this.cascadeUp(this._nodes[this._numNodes])},t.prototype.dequeue=function(){var t=this._nodes[1];return this.remove(t),t},t.prototype.remove=function(t){if(t.queueIndex==this._numNodes)return this._nodes[this._numNodes]=null,void this._numNodes--;var e=this._nodes[this._numNodes];this.swap(t,e),delete this._nodes[this._numNodes],this._numNodes--,this.onNodeUpdated(e)},t.prototype.isValidQueue=function(){for(var t=1;t<this._nodes.length;t++)if(this._nodes[t]){var e=2*t;if(e<this._nodes.length&&this._nodes[e]&&this.hasHigherPriority(this._nodes[e],this._nodes[t]))return!1;var n=e+1;if(n<this._nodes.length&&this._nodes[n]&&this.hasHigherPriority(this._nodes[n],this._nodes[t]))return!1}return!0},t.prototype.onNodeUpdated=function(t){var e=Math.floor(t.queueIndex/2),n=this._nodes[e];e>0&&this.hasHigherPriority(t,n)?this.cascadeUp(t):this.cascadeDown(t)},t.prototype.cascadeDown=function(t){for(var e,n=t.queueIndex;;){e=t;var i=2*n;if(i>this._numNodes){t.queueIndex=n,this._nodes[n]=t;break}var r=this._nodes[i];this.hasHigherPriority(r,e)&&(e=r);var o=i+1;if(o<=this._numNodes){var s=this._nodes[o];this.hasHigherPriority(s,e)&&(e=s)}if(e==t){t.queueIndex=n,this._nodes[n]=t;break}this._nodes[n]=e;var a=e.queueIndex;e.queueIndex=n,n=a}},t.prototype.cascadeUp=function(t){for(var e=Math.floor(t.queueIndex/2);e>=1;){var n=this._nodes[e];if(this.hasHigherPriority(n,t))break;this.swap(t,n),e=Math.floor(t.queueIndex/2)}},t.prototype.swap=function(t,e){this._nodes[t.queueIndex]=e,this._nodes[e.queueIndex]=t;var n=t.queueIndex;t.queueIndex=e.queueIndex,e.queueIndex=n},t.prototype.hasHigherPriority=function(t,e){return t.priority<e.priority||t.priority==e.priority&&t.insertionIndex<e.insertionIndex},t}();t.PriorityQueue=e}(es||(es={})),function(t){var e=function(){function e(){}return e.search=function(e,n,i){var r=this,o=!1,s=[];s.unshift(n);var a=new Map;a.set(n,n);for(var c=function(){var t=s.shift();if(JSON.stringify(t)==JSON.stringify(i))return o=!0,"break";e.getNeighbors(t).forEach(function(e){r.hasKey(a,e)||(s.unshift(e),a.set(e,t))})};s.length>0;){if("break"===c())break}return o?t.AStarPathfinder.recontructPath(a,n,i):null},e.hasKey=function(t,e){for(var n,i=t.keys();!(n=i.next()).done;)if(JSON.stringify(n.value)==JSON.stringify(e))return!0;return!1},e}();t.BreadthFirstPathfinder=e}(es||(es={})),function(t){var e=function(){function t(){this.edges=new Map}return t.prototype.addEdgesForNode=function(t,e){return this.edges.set(t,e),this},t.prototype.getNeighbors=function(t){return this.edges.get(t)},t}();t.UnweightedGraph=e}(es||(es={})),function(t){var e=function(){function e(t,e){this.x=0,this.y=0,this.x=t||0,this.y=e||this.x}return Object.defineProperty(e,"zero",{get:function(){return e.zeroVector2},enumerable:!0,configurable:!0}),Object.defineProperty(e,"one",{get:function(){return e.unitVector2},enumerable:!0,configurable:!0}),Object.defineProperty(e,"unitX",{get:function(){return e.unitXVector},enumerable:!0,configurable:!0}),Object.defineProperty(e,"unitY",{get:function(){return e.unitYVector},enumerable:!0,configurable:!0}),e.add=function(t,n){var i=new e(0,0);return i.x=t.x+n.x,i.y=t.y+n.y,i},e.divide=function(t,n){var i=new e(0,0);return i.x=t.x/n.x,i.y=t.y/n.y,i},e.multiply=function(t,n){var i=new e(0,0);return i.x=t.x*n.x,i.y=t.y*n.y,i},e.subtract=function(t,n){var i=new e(0,0);return i.x=t.x-n.x,i.y=t.y-n.y,i},e.prototype.normalize=function(){var t=1/Math.sqrt(this.x*this.x+this.y*this.y);this.x*=t,this.y*=t},e.prototype.length=function(){return Math.sqrt(this.x*this.x+this.y*this.y)},e.prototype.round=function(){return new e(Math.round(this.x),Math.round(this.y))},e.normalize=function(t){var e=1/Math.sqrt(t.x*t.x+t.y*t.y);return t.x*=e,t.y*=e,t},e.dot=function(t,e){return t.x*e.x+t.y*e.y},e.distanceSquared=function(t,e){var n=t.x-e.x,i=t.y-e.y;return n*n+i*i},e.clamp=function(n,i,r){return new e(t.MathHelper.clamp(n.x,i.x,r.x),t.MathHelper.clamp(n.y,i.y,r.y))},e.lerp=function(n,i,r){return new e(t.MathHelper.lerp(n.x,i.x,r),t.MathHelper.lerp(n.y,i.y,r))},e.transform=function(t,n){return new e(t.x*n.m11+t.y*n.m21,t.x*n.m12+t.y*n.m22)},e.distance=function(t,e){var n=t.x-e.x,i=t.y-e.y;return Math.sqrt(n*n+i*i)},e.negate=function(t){var n=new e;return n.x=-t.x,n.y=-t.y,n},e.unitYVector=new e(0,1),e.unitXVector=new e(1,0),e.unitVector2=new e(1,1),e.zeroVector2=new e(0,0),e}();t.Vector2=e}(es||(es={})),function(t){var e=function(){function e(t,n,i){void 0===i&&(i=!1),this.walls=[],this._neighbors=new Array(4),this._width=t,this._hegiht=n,this._dirs=i?e.COMPASS_DIRS:e.CARDINAL_DIRS}return e.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._hegiht},e.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},e.prototype.getNeighbors=function(e){var n=this;return this._neighbors.length=0,this._dirs.forEach(function(i){var r=new t.Vector2(e.x+i.x,e.y+i.y);n.isNodeInBounds(r)&&n.isNodePassable(r)&&n._neighbors.push(r)}),this._neighbors},e.prototype.search=function(e,n){return t.BreadthFirstPathfinder.search(this,e,n)},e.CARDINAL_DIRS=[new t.Vector2(1,0),new t.Vector2(0,-1),new t.Vector2(-1,0),new t.Vector2(0,-1)],e.COMPASS_DIRS=[new t.Vector2(1,0),new t.Vector2(1,-1),new t.Vector2(0,-1),new t.Vector2(-1,-1),new t.Vector2(-1,0),new t.Vector2(-1,1),new t.Vector2(0,1),new t.Vector2(1,1)],e}();t.UnweightedGridGraph=e}(es||(es={})),function(t){var e=function(){function e(t,n,i){void 0===i&&(i=!1),this.walls=[],this.weightedNodes=[],this.defaultWeight=1,this.weightedNodeWeight=5,this._neighbors=new Array(4),this._width=t,this._height=n,this._dirs=i?e.COMPASS_DIRS:e.CARDINAL_DIRS}return e.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._height},e.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},e.prototype.search=function(e,n){return t.WeightedPathfinder.search(this,e,n)},e.prototype.getNeighbors=function(e){var n=this;return this._neighbors.length=0,this._dirs.forEach(function(i){var r=new t.Vector2(e.x+i.x,e.y+i.y);n.isNodeInBounds(r)&&n.isNodePassable(r)&&n._neighbors.push(r)}),this._neighbors},e.prototype.cost=function(t,e){return this.weightedNodes.find(function(t){return JSON.stringify(t)==JSON.stringify(e)})?this.weightedNodeWeight:this.defaultWeight},e.CARDINAL_DIRS=[new t.Vector2(1,0),new t.Vector2(0,-1),new t.Vector2(-1,0),new t.Vector2(0,1)],e.COMPASS_DIRS=[new t.Vector2(1,0),new t.Vector2(1,-1),new t.Vector2(0,-1),new t.Vector2(-1,-1),new t.Vector2(-1,0),new t.Vector2(-1,1),new t.Vector2(0,1),new t.Vector2(1,1)],e}();t.WeightedGridGraph=e}(es||(es={})),function(t){var e=function(t){function e(e){var n=t.call(this)||this;return n.data=e,n}return __extends(e,t),e}(t.PriorityQueueNode);t.WeightedNode=e;var n=function(){function n(){}return n.search=function(n,i,r){var o=this,s=!1,a=new Map;a.set(i,i);var c=new Map,h=new t.PriorityQueue(1e3);h.enqueue(new e(i),0),c.set(i,0);for(var u=function(){var t=h.dequeue();if(JSON.stringify(t.data)==JSON.stringify(r))return s=!0,"break";n.getNeighbors(t.data).forEach(function(i){var r=c.get(t.data)+n.cost(t.data,i);if(!o.hasKey(c,i)||r<c.get(i)){c.set(i,r);var s=r;h.enqueue(new e(i),s),a.set(i,t.data)}})};h.count>0;){if("break"===u())break}return s?this.recontructPath(a,i,r):null},n.hasKey=function(t,e){for(var n,i=t.keys();!(n=i.next()).done;)if(JSON.stringify(n.value)==JSON.stringify(e))return!0;return!1},n.getKey=function(t,e){for(var n,i,r=t.keys(),o=t.values();n=r.next(),i=o.next(),!n.done;)if(JSON.stringify(n.value)==JSON.stringify(e))return i.value;return null},n.recontructPath=function(t,e,n){var i=[],r=n;for(i.push(n);r!=e;)r=this.getKey(t,r),i.push(r);return i.reverse(),i},n}();t.WeightedPathfinder=n}(es||(es={})),function(t){var e=function(){function e(){}return e.drawHollowRect=function(e,n,i){void 0===i&&(i=0),this._debugDrawItems.push(new t.DebugDrawItem(e,n,i))},e.render=function(){if(this._debugDrawItems.length>0){var e=new egret.Shape;t.SceneManager.scene&&t.SceneManager.scene.addChild(e);for(var n=this._debugDrawItems.length-1;n>=0;n--){this._debugDrawItems[n].draw(e)&&this._debugDrawItems.removeAt(n)}}},e._debugDrawItems=[],e}();t.Debug=e}(es||(es={})),function(t){var e=function(){function t(){}return t.verletParticle=14431326,t.verletConstraintEdge=4406838,t}();t.DebugDefaults=e}(es||(es={})),function(t){var e;!function(t){t[t.line=0]="line",t[t.hollowRectangle=1]="hollowRectangle",t[t.pixel=2]="pixel",t[t.text=3]="text"}(e=t.DebugDrawType||(t.DebugDrawType={}));var n=function(){function n(t,n,i){this.rectangle=t,this.color=n,this.duration=i,this.drawType=e.hollowRectangle}return n.prototype.draw=function(n){switch(this.drawType){case e.line:t.DrawUtils.drawLine(n,this.start,this.end,this.color);break;case e.hollowRectangle:t.DrawUtils.drawHollowRect(n,this.rectangle,this.color);break;case e.pixel:t.DrawUtils.drawPixel(n,new t.Vector2(this.x,this.y),this.color,this.size);break;case e.text:}return this.duration-=t.Time.deltaTime,this.duration<0},n}();t.DebugDrawItem=n}(es||(es={})),function(t){var e=function(){function t(){this.updateInterval=1,this._enabled=!0,this._updateOrder=0}return Object.defineProperty(t.prototype,"transform",{get:function(){return this.entity.transform},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"enabled",{get:function(){return this.entity?this.entity.enabled&&this._enabled:this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"updateOrder",{get:function(){return this._updateOrder},set:function(t){this.setUpdateOrder(t)},enumerable:!0,configurable:!0}),t.prototype.initialize=function(){},t.prototype.onAddedToEntity=function(){},t.prototype.onRemovedFromEntity=function(){},t.prototype.onEntityTransformChanged=function(t){},t.prototype.debugRender=function(){},t.prototype.onEnabled=function(){},t.prototype.onDisabled=function(){},t.prototype.update=function(){},t.prototype.setEnabled=function(t){return this._enabled!=t&&(this._enabled=t,this._enabled?this.onEnabled():this.onDisabled()),this},t.prototype.setUpdateOrder=function(t){return this._updateOrder!=t&&(this._updateOrder=t),this},t.prototype.clone=function(){var t=ObjectUtils.clone(this);return t.entity=null,t},t}();t.Component=e}(es||(es={})),function(t){!function(t){t[t.SceneChanged=0]="SceneChanged"}(t.CoreEvents||(t.CoreEvents={}))}(es||(es={})),function(t){var e=function(){function e(n){this.updateInterval=1,this._tag=0,this._enabled=!0,this._updateOrder=0,this.components=new t.ComponentList(this),this.transform=new t.Transform(this),this.name=n,this.id=e._idGenerator++,this.componentBits=new t.BitSet}return Object.defineProperty(e.prototype,"tag",{get:function(){return this._tag},set:function(t){this.setTag(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"enabled",{get:function(){return this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"updateOrder",{get:function(){return this._updateOrder},set:function(t){this.setUpdateOrder(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isDestroyed",{get:function(){return this._isDestroyed},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"parent",{get:function(){return this.transform.parent},set:function(t){this.transform.setParent(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"childCount",{get:function(){return this.transform.childCount},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"position",{get:function(){return this.transform.position},set:function(t){this.transform.setPosition(t.x,t.y)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"rotation",{get:function(){return this.transform.rotation},set:function(t){this.transform.setRotation(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"scale",{get:function(){return this.transform.scale},set:function(t){this.transform.setScale(t)},enumerable:!0,configurable:!0}),e.prototype.onTransformChanged=function(t){this.components.onEntityTransformChanged(t)},e.prototype.setTag=function(t){return this._tag!=t&&(this.scene&&this.scene.entities.removeFromTagList(this),this._tag=t,this.scene&&this.scene.entities.addToTagList(this)),this},e.prototype.setEnabled=function(t){return this._enabled!=t&&(this._enabled=t,this._enabled?this.components.onEntityEnabled():this.components.onEntityDisabled()),this},e.prototype.setUpdateOrder=function(t){if(this._updateOrder!=t)return this._updateOrder=t,this.scene,this},e.prototype.destroy=function(){this._isDestroyed=!0,this.scene.entities.remove(this),this.transform.parent=null;for(var t=this.transform.childCount-1;t>=0;t--){this.transform.getChild(t).entity.destroy()}},e.prototype.detachFromScene=function(){this.scene.entities.remove(this),this.components.deregisterAllComponents();for(var t=0;t<this.transform.childCount;t++)this.transform.getChild(t).entity.detachFromScene()},e.prototype.attachToScene=function(t){this.scene=t,t.entities.add(this),this.components.registerAllComponents();for(var e=0;e<this.transform.childCount;e++)this.transform.getChild(e).entity.attachToScene(t)},e.prototype.clone=function(n){void 0===n&&(n=new t.Vector2);var i=new e(this.name+"(clone)");return i.copyFrom(this),i.transform.position=n,i},e.prototype.copyFrom=function(t){this.tag=t.tag,this.updateInterval=t.updateInterval,this.updateOrder=t.updateOrder,this.enabled=t.enabled,this.transform.scale=t.transform.scale,this.transform.rotation=t.transform.rotation;for(var e=0;e<t.components.count;e++)this.addComponent(t.components.buffer[e].clone());for(e=0;e<t.components._componentsToAdd.length;e++)this.addComponent(t.components._componentsToAdd[e].clone());for(e=0;e<t.transform.childCount;e++){var n=t.transform.getChild(e).entity,i=n.clone();i.transform.copyFrom(n.transform),i.transform.parent=this.transform}},e.prototype.onAddedToScene=function(){},e.prototype.onRemovedFromScene=function(){this._isDestroyed&&this.components.removeAllComponents()},e.prototype.update=function(){this.components.update()},e.prototype.addComponent=function(t){return t.entity=this,this.components.add(t),t.initialize(),t},e.prototype.getComponent=function(t){return this.components.getComponent(t,!1)},e.prototype.hasComponent=function(t){return null!=this.components.getComponent(t,!1)},e.prototype.getOrCreateComponent=function(t){var e=this.components.getComponent(t,!0);return e||(e=this.addComponent(t)),e},e.prototype.getComponents=function(t,e){return this.components.getComponents(t,e)},e.prototype.removeComponent=function(t){this.components.remove(t)},e.prototype.removeComponentForType=function(t){var e=this.getComponent(t);return!!e&&(this.removeComponent(e),!0)},e.prototype.removeAllComponents=function(){for(var t=0;t<this.components.count;t++)this.removeComponent(this.components.buffer[t])},e.prototype.toString=function(){return"[Entity: name: "+this.name+", tag: "+this.tag+", enabled: "+this.enabled+", depth: "+this.updateOrder+"]"},e}();t.Entity=e}(es||(es={})),function(t){var e=function(e){function n(){var n=e.call(this)||this;return n.enablePostProcessing=!0,n._renderers=[],n._postProcessors=[],n.entities=new t.EntityList(n),n.renderableComponents=new t.RenderableComponentList,n.content=new t.ContentManager,n.entityProcessors=new t.EntityProcessorList,n.width=t.SceneManager.stage.stageWidth,n.height=t.SceneManager.stage.stageHeight,n.initialize(),n}return __extends(n,e),n.createWithDefaultRenderer=function(){var e=new n;return e.addRenderer(new t.DefaultRenderer),e},n.prototype.initialize=function(){},n.prototype.onStart=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(t){return[2]})})},n.prototype.unload=function(){},n.prototype.onActive=function(){},n.prototype.onDeactive=function(){},n.prototype.begin=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(e){return t.SceneManager.sceneTransition?t.SceneManager.stage.addChildAt(this,t.SceneManager.stage.numChildren-1):t.SceneManager.stage.addChild(this),0==this._renderers.length&&(this.addRenderer(new t.DefaultRenderer),console.warn("场景开始时没有渲染器 自动添加DefaultRenderer以保证能够正常渲染")),this.camera=this.createEntity("camera").getOrCreateComponent(new t.Camera),t.Physics.reset(),this.entityProcessors&&this.entityProcessors.begin(),this.addEventListener(egret.Event.ACTIVATE,this.onActive,this),this.addEventListener(egret.Event.DEACTIVATE,this.onDeactive,this),this.camera.onSceneSizeChanged(this.stage.stageWidth,this.stage.stageHeight),this._didSceneBegin=!0,this.onStart(),[2]})})},n.prototype.end=function(){this._didSceneBegin=!1,this.removeEventListener(egret.Event.DEACTIVATE,this.onDeactive,this),this.removeEventListener(egret.Event.ACTIVATE,this.onActive,this);for(var t=0;t<this._renderers.length;t++)this._renderers[t].unload();for(t=0;t<this._postProcessors.length;t++)this._postProcessors[t].unload();this.entities.removeAllEntities(),this.removeChildren(),this.camera=null,this.content.dispose(),this.entityProcessors&&this.entityProcessors.end(),this.parent&&this.parent.removeChild(this),this.unload()},n.prototype.update=function(){this.entities.updateLists(),this.entityProcessors&&this.entityProcessors.update(),this.entities.update(),this.entityProcessors&&this.entityProcessors.lateUpdate(),this.renderableComponents.updateList()},n.prototype.render=function(){if(0!=this._renderers.length)for(var t=0;t<this._renderers.length;t++)this._renderers[t].render(this);else console.error("there are no renderers in the scene!")},n.prototype.postRender=function(){if(this.enablePostProcessing)for(var t=0;t<this._postProcessors.length;t++)this._postProcessors[t].enabled&&this._postProcessors[t].process()},n.prototype.addRenderer=function(t){return this._renderers.push(t),this._renderers.sort(),t.onAddedToScene(this),t},n.prototype.getRenderer=function(t){for(var e=0;e<this._renderers.length;e++)if(this._renderers[e]instanceof t)return this._renderers[e];return null},n.prototype.removeRenderer=function(t){this._renderers.contains(t)&&(this._renderers.remove(t),t.unload())},n.prototype.addPostProcessor=function(t){return this._postProcessors.push(t),this._postProcessors.sort(),t.onAddedToScene(this),this._didSceneBegin&&t.onSceneBackBufferSizeChanged(this.stage.stageWidth,this.stage.stageHeight),t},n.prototype.getPostProcessor=function(t){for(var e=0;e<this._postProcessors.length;e++)if(this._postProcessors[e]instanceof t)return this._postProcessors[e];return null},n.prototype.removePostProcessor=function(t){this._postProcessors.contains(t)&&(this._postProcessors.remove(t),t.unload())},n.prototype.createEntity=function(e){var n=new t.Entity(e);return this.addEntity(n)},n.prototype.addEntity=function(t){this.entities.buffer.contains(t)&&console.warn("You are attempting to add the same entity to a scene twice: "+t),this.entities.add(t),t.scene=this;for(var e=0;e<t.transform.childCount;e++)this.addEntity(t.transform.getChild(e).entity);return t},n.prototype.destroyAllEntities=function(){for(var t=0;t<this.entities.count;t++)this.entities.buffer[t].destroy()},n.prototype.findEntity=function(t){return this.entities.findEntity(t)},n.prototype.findEntitiesWithTag=function(t){return this.entities.entitiesWithTag(t)},n.prototype.entitiesOfType=function(t){return this.entities.entitiesOfType(t)},n.prototype.findComponentOfType=function(t){return this.entities.findComponentOfType(t)},n.prototype.findComponentsOfType=function(t){return this.entities.findComponentsOfType(t)},n.prototype.addEntityProcessor=function(t){return t.scene=this,this.entityProcessors.add(t),t},n.prototype.removeEntityProcessor=function(t){this.entityProcessors.remove(t)},n.prototype.getEntityProcessor=function(){return this.entityProcessors.getProcessor()},n}(egret.DisplayObjectContainer);t.Scene=e}(es||(es={})),function(t){var e=function(){function e(n){n.addEventListener(egret.Event.ENTER_FRAME,e.update,this),e._instnace=this,e.emitter=new t.Emitter,e.content=new t.ContentManager,e.stage=n,e.initialize(n),e.timerRuler=new t.TimeRuler}return Object.defineProperty(e,"Instance",{get:function(){return this._instnace},enumerable:!0,configurable:!0}),Object.defineProperty(e,"scene",{get:function(){return this._scene},set:function(t){if(!t)throw new Error("场景不能为空");null==this._scene?(this._scene=t,this._scene.begin(),e.Instance.onSceneChanged()):this._nextScene=t,this.registerActiveSceneChanged(this._scene,this._nextScene)},enumerable:!0,configurable:!0}),e.initialize=function(e){t.Input.initialize(e)},e.update=function(){if(e.startDebugUpdate(),t.Time.update(egret.getTimer()),e._scene){for(var n=t.GlobalManager.globalManagers.length-1;n>=0;n--)t.GlobalManager.globalManagers[n].enabled&&t.GlobalManager.globalManagers[n].update();e.sceneTransition&&(!e.sceneTransition||e.sceneTransition.loadsNewScene&&!e.sceneTransition.isNewSceneLoaded)||e._scene.update(),e._nextScene&&(e._scene.end(),e._scene=e._nextScene,e._nextScene=null,e._instnace.onSceneChanged(),e._scene.begin())}e.endDebugUpdate(),e.render()},e.render=function(){this.sceneTransition?(this.sceneTransition.preRender(),this._scene&&!this.sceneTransition.hasPreviousSceneRender?(this._scene.render(),this._scene.postRender(),this.sceneTransition.onBeginTransition()):this.sceneTransition&&(this._scene&&this.sceneTransition.isNewSceneLoaded&&(this._scene.render(),this._scene.postRender()),this.sceneTransition.render())):this._scene&&(this._scene.render(),t.Debug.render(),this._scene.postRender())},e.startSceneTransition=function(t){if(!this.sceneTransition)return this.sceneTransition=t,t;console.warn("在前一个场景完成之前，不能开始一个新的场景转换。")},e.registerActiveSceneChanged=function(t,e){this.activeSceneChanged&&this.activeSceneChanged(t,e)},e.prototype.onSceneChanged=function(){e.emitter.emit(t.CoreEvents.SceneChanged),t.Time.sceneChanged()},e.startDebugUpdate=function(){t.TimeRuler.Instance.startFrame(),t.TimeRuler.Instance.beginMark("update",65280)},e.endDebugUpdate=function(){t.TimeRuler.Instance.endMark("update")},e}();t.SceneManager=e}(es||(es={})),function(t){!function(t){t[t.position=0]="position",t[t.scale=1]="scale",t[t.rotation=2]="rotation"}(t.Component||(t.Component={}))}(transform||(transform={})),function(t){var e;!function(t){t[t.clean=0]="clean",t[t.positionDirty=1]="positionDirty",t[t.scaleDirty=2]="scaleDirty",t[t.rotationDirty=3]="rotationDirty"}(e=t.DirtyType||(t.DirtyType={}));var n=function(){function n(e){this.entity=e,this.scale=t.Vector2.one,this._children=[]}return Object.defineProperty(n.prototype,"parent",{get:function(){return this._parent},set:function(t){this.setParent(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"childCount",{get:function(){return this._children.length},enumerable:!0,configurable:!0}),n.prototype.getChild=function(t){return this._children[t]},n.prototype.setParent=function(t){return this._parent==t?this:(this._parent||(this._parent._children.remove(this),this._parent._children.push(this)),this._parent=t,this.setDirty(e.positionDirty),this)},n.prototype.setPosition=function(n,i){return this.position=new t.Vector2(n,i),this.setDirty(e.positionDirty),this},n.prototype.setRotation=function(t){return this.rotation=t,this.setDirty(e.rotationDirty),this},n.prototype.setScale=function(t){return this.scale=t,this.setDirty(e.scaleDirty),this},n.prototype.lookAt=function(e){var n=this.position.x>e.x?-1:1,i=t.Vector2.normalize(t.Vector2.subtract(this.position,e));this.rotation=n*Math.acos(t.Vector2.dot(i,t.Vector2.unitY))},n.prototype.roundPosition=function(){this.position=this.position.round()},n.prototype.setDirty=function(e){if(0==(this.hierarchyDirty&e)){switch(this.hierarchyDirty|=e,e){case t.DirtyType.positionDirty:this.entity.onTransformChanged(transform.Component.position);break;case t.DirtyType.rotationDirty:this.entity.onTransformChanged(transform.Component.rotation);break;case t.DirtyType.scaleDirty:this.entity.onTransformChanged(transform.Component.scale)}this._children||(this._children=[]);for(var n=0;n<this._children.length;n++)this._children[n].setDirty(e)}},n.prototype.copyFrom=function(t){this.position=t.position,this.rotation=t.rotation,this.scale=t.scale,this.setDirty(e.positionDirty),this.setDirty(e.rotationDirty),this.setDirty(e.scaleDirty)},n}();t.Transform=n}(es||(es={})),function(t){var e;!function(t){t[t.lockOn=0]="lockOn",t[t.cameraWindow=1]="cameraWindow"}(e=t.CameraStyle||(t.CameraStyle={}));var n=function(n){function i(i,r){void 0===i&&(i=null),void 0===r&&(r=e.lockOn);var o=n.call(this)||this;return o._minimumZoom=.3,o._maximumZoom=3,o._origin=t.Vector2.zero,o.followLerp=.1,o.deadzone=new t.Rectangle,o.focusOffset=new t.Vector2,o.mapLockEnabled=!1,o.mapSize=new t.Vector2,o._desiredPositionDelta=new t.Vector2,o._worldSpaceDeadZone=new t.Rectangle,o._targetEntity=i,o._cameraStyle=r,o.setZoom(0),o}return __extends(i,n),Object.defineProperty(i.prototype,"position",{get:function(){return this.entity.transform.position},set:function(t){this.entity.transform.position=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"rotation",{get:function(){return this.entity.transform.rotation},set:function(t){this.entity.transform.rotation=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"zoom",{get:function(){return 0==this._zoom?1:this._zoom<1?t.MathHelper.map(this._zoom,this._minimumZoom,1,-1,0):t.MathHelper.map(this._zoom,1,this._maximumZoom,0,1)},set:function(t){this.setZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"minimumZoom",{get:function(){return this._minimumZoom},set:function(t){this.setMinimumZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"maximumZoom",{get:function(){return this._maximumZoom},set:function(t){this.setMaximumZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"bounds",{get:function(){return new t.Rectangle(0,0,t.SceneManager.stage.stageWidth,t.SceneManager.stage.stageHeight)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"origin",{get:function(){return this._origin},set:function(t){this._origin!=t&&(this._origin=t)},enumerable:!0,configurable:!0}),i.prototype.onSceneSizeChanged=function(e,n){var i=this._origin;this.origin=new t.Vector2(e/2,n/2),this.entity.transform.position=t.Vector2.add(this.entity.transform.position,t.Vector2.subtract(this._origin,i))},i.prototype.setPosition=function(t){return this.entity.transform.setPosition(t.x,t.y),this},i.prototype.setRotation=function(t){return this.entity.transform.setRotation(t),this},i.prototype.setZoom=function(e){var n=t.MathHelper.clamp(e,-1,1);return this._zoom=0==n?1:n<0?t.MathHelper.map(n,-1,0,this._minimumZoom,1):t.MathHelper.map(n,0,1,1,this._maximumZoom),t.SceneManager.scene.scaleX=this._zoom,t.SceneManager.scene.scaleY=this._zoom,this},i.prototype.setMinimumZoom=function(t){return this._zoom<t&&(this._zoom=this.minimumZoom),this._minimumZoom=t,this},i.prototype.setMaximumZoom=function(t){if(!(t<=0))return this._zoom>t&&(this._zoom=t),this._maximumZoom=t,this;console.error("maximumZoom must be greater than zero")},i.prototype.zoomIn=function(t){this.zoom+=t},i.prototype.zoomOut=function(t){this.zoom-=t},i.prototype.onAddedToEntity=function(){this.follow(this._targetEntity,this._cameraStyle)},i.prototype.update=function(){var e=t.Vector2.multiply(new t.Vector2(this.bounds.width,this.bounds.height),new t.Vector2(.5));this._worldSpaceDeadZone.x=this.position.x-e.x*t.SceneManager.scene.scaleX+this.deadzone.x+this.focusOffset.x,this._worldSpaceDeadZone.y=this.position.y-e.y*t.SceneManager.scene.scaleY+this.deadzone.y+this.focusOffset.y,this._worldSpaceDeadZone.width=this.deadzone.width,this._worldSpaceDeadZone.height=this.deadzone.height,this._targetEntity&&this.updateFollow(),this.position=t.Vector2.lerp(this.position,t.Vector2.add(this.position,this._desiredPositionDelta),this.followLerp),this.entity.transform.roundPosition(),this.mapLockEnabled&&(this.position=this.clampToMapSize(this.position),this.entity.transform.roundPosition())},i.prototype.clampToMapSize=function(e){var n=t.Vector2.multiply(new t.Vector2(this.bounds.width,this.bounds.height),new t.Vector2(.5)),i=new t.Vector2(this.mapSize.x-n.x,this.mapSize.y-n.y);return t.Vector2.clamp(e,n,i)},i.prototype.updateFollow=function(){if(this._desiredPositionDelta.x=this._desiredPositionDelta.y=0,this._cameraStyle==e.lockOn){var n=this._targetEntity.transform.position.x,i=this._targetEntity.transform.position.y;this._worldSpaceDeadZone.x>n?this._desiredPositionDelta.x=n-this._worldSpaceDeadZone.x:this._worldSpaceDeadZone.x<n&&(this._desiredPositionDelta.x=n-this._worldSpaceDeadZone.x),this._worldSpaceDeadZone.y<i?this._desiredPositionDelta.y=i-this._worldSpaceDeadZone.y:this._worldSpaceDeadZone.y>i&&(this._desiredPositionDelta.y=i-this._worldSpaceDeadZone.y)}else{if(!this._targetCollider&&(this._targetCollider=this._targetEntity.getComponent(t.Collider),!this._targetCollider))return;var r=this._targetEntity.getComponent(t.Collider).bounds;this._worldSpaceDeadZone.containsRect(r)||(this._worldSpaceDeadZone.left>r.left?this._desiredPositionDelta.x=r.left-this._worldSpaceDeadZone.left:this._worldSpaceDeadZone.right<r.right&&(this._desiredPositionDelta.x=r.right-this._worldSpaceDeadZone.right),this._worldSpaceDeadZone.bottom<r.bottom?this._desiredPositionDelta.y=r.bottom-this._worldSpaceDeadZone.bottom:this._worldSpaceDeadZone.top>r.top&&(this._desiredPositionDelta.y=r.top-this._worldSpaceDeadZone.top))}},i.prototype.follow=function(n,i){switch(void 0===i&&(i=e.cameraWindow),this._targetEntity=n,this._cameraStyle=i,this._cameraStyle){case e.cameraWindow:var r=this.bounds.width/6,o=this.bounds.height/3;this.deadzone=new t.Rectangle((this.bounds.width-r)/2,(this.bounds.height-o)/2,r,o);break;case e.lockOn:this.deadzone=new t.Rectangle(this.bounds.width/2,this.bounds.height/2,10,10)}},i.prototype.setCenteredDeadzone=function(e,n){this.deadzone=new t.Rectangle((this.bounds.width-e)/2,(this.bounds.height-n)/2,e,n)},i}(t.Component);t.Camera=n}(es||(es={})),function(t){var e=function(){function t(t){this._type=t,this._cache=[]}return t.prototype.obtain=function(){try{return this._cache.length>0?this._cache.shift():new this._type}catch(t){throw new Error(this._type+t)}},t.prototype.free=function(t){t.reset(),this._cache.push(t)},t}();t.ComponentPool=e}(es||(es={})),function(t){var e=function(){function t(){}return t.prototype.compare=function(t,e){return t.updateOrder-e.updateOrder},t}();t.IUpdatableComparer=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e}(t.Component);t.PooledComponent=e}(es||(es={})),function(t){var e=function(e){function n(){var n=null!==e&&e.apply(this,arguments)||this;return n.color=0,n._localOffset=t.Vector2.zero,n._renderLayer=0,n._bounds=new t.Rectangle,n._areBoundsDirty=!0,n}return __extends(n,e),Object.defineProperty(n.prototype,"width",{get:function(){return this.bounds.width},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"height",{get:function(){return this.bounds.height},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"bounds",{get:function(){return this._areBoundsDirty&&(this._bounds.calculateBounds(this.entity.transform.position,this._localOffset,t.Vector2.zero,this.entity.transform.scale,this.entity.transform.rotation,this.width,this.height),this._areBoundsDirty=!1),this._bounds},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"renderLayer",{get:function(){return this._renderLayer},set:function(t){},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"localOffset",{get:function(){return this._localOffset},set:function(t){this.setLocalOffset(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"isVisible",{get:function(){return this._isVisible},set:function(t){this._isVisible!=t&&(this._isVisible=t,this._isVisible?this.onBecameVisible():this.onBecameInvisible())},enumerable:!0,configurable:!0}),n.prototype.onEntityTransformChanged=function(t){this._areBoundsDirty=!0},n.prototype.onBecameVisible=function(){},n.prototype.onBecameInvisible=function(){},n.prototype.isVisibleFromCamera=function(t){return this.isVisible=t.bounds.intersects(this.bounds),this.isVisible},n.prototype.setRenderLayer=function(t){if(t!=this._renderLayer){var e=this._renderLayer;this._renderLayer=t,this.entity&&this.entity.scene&&this.entity.scene.renderableComponents.updateRenderableRenderLayer(this,e,this._renderLayer)}return this},n.prototype.setColor=function(t){return this.color=t,this},n.prototype.setLocalOffset=function(t){return this._localOffset!=t&&(this._localOffset=t),this},n.prototype.toString=function(){return"[RenderableComponent] "+this+", renderLayer: "+this.renderLayer},n}(t.Component);t.RenderableComponent=e}(es||(es={})),function(t){var e=function(t){function e(){var e=t.call(this)||this;return e._mesh=new egret.Mesh,e}return __extends(e,t),e.prototype.setTexture=function(t){return this._mesh.texture=t,this},e.prototype.reset=function(){},e.prototype.render=function(t){},e}(t.RenderableComponent);t.Mesh=e}(es||(es={})),function(t){var e=function(e){function n(n){void 0===n&&(n=null);var i=e.call(this)||this;return n instanceof t.Sprite?i.setSprite(n):n instanceof egret.Texture&&i.setSprite(new t.Sprite(n)),i}return __extends(n,e),Object.defineProperty(n.prototype,"bounds",{get:function(){if(this._areBoundsDirty)return this._sprite&&(this._bounds.calculateBounds(this.entity.transform.position,this._localOffset,this._origin,this.entity.transform.scale,this.entity.transform.rotation,this._sprite.sourceRect.width,this._sprite.sourceRect.height),this._areBoundsDirty=!1),this._bounds},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"origin",{get:function(){return this._origin},set:function(t){this.setOrigin(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"originNormalized",{get:function(){return new t.Vector2(this._origin.x/this.width*this.entity.transform.scale.x,this._origin.y/this.height*this.entity.transform.scale.y)},set:function(e){this.setOrigin(new t.Vector2(e.x*this.width/this.entity.transform.scale.x,e.y*this.height/this.entity.transform.scale.y))},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"sprite",{get:function(){return this._sprite},set:function(t){this.setSprite(t)},enumerable:!0,configurable:!0}),n.prototype.setSprite=function(t){return this._sprite=t,this._sprite&&(this._origin=this._sprite.origin),this},n.prototype.setOrigin=function(t){return this._origin!=t&&(this._origin=t,this._areBoundsDirty=!0),this},n.prototype.setOriginNormalized=function(e){return this.setOrigin(new t.Vector2(e.x*this.width/this.entity.transform.scale.x,e.y*this.height/this.entity.transform.scale.y)),this},n.prototype.render=function(t){},n}(t.RenderableComponent);t.SpriteRenderer=e}(es||(es={})),function(t){var e=function(t){function e(e){var n=t.call(this,e)||this;return n.leftTexture=new egret.Bitmap,n.rightTexture=new egret.Bitmap,n.leftTexture.texture=e.texture2D,n.rightTexture.texture=e.texture2D,n.setSprite(e),n.sourceRect=e.sourceRect,n}return __extends(e,t),Object.defineProperty(e.prototype,"scrollX",{get:function(){return this.sourceRect.x},set:function(t){this.sourceRect.x=t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"scrollY",{get:function(){return this.sourceRect.y},set:function(t){this.sourceRect.y=t},enumerable:!0,configurable:!0}),e.prototype.render=function(e){if(this.sprite){t.prototype.render.call(this,e);var n=new egret.RenderTexture,i=new egret.DisplayObjectContainer;i.removeChildren(),i.addChild(this.leftTexture),i.addChild(this.rightTexture),this.leftTexture.x=this.sourceRect.x,this.rightTexture.x=this.sourceRect.x-this.sourceRect.width,this.leftTexture.y=this.sourceRect.y,this.rightTexture.y=this.sourceRect.y,i.cacheAsBitmap=!0,n.drawToTexture(i,new egret.Rectangle(0,0,this.sourceRect.width,this.sourceRect.height))}},e}(t.SpriteRenderer);t.TiledSpriteRenderer=e}(es||(es={})),function(t){var e=function(e){function n(){var t=null!==e&&e.apply(this,arguments)||this;return t.scrollSpeedX=15,t.scroolSpeedY=0,t._scrollX=0,t._scrollY=0,t}return __extends(n,e),n.prototype.update=function(){this._scrollX+=this.scrollSpeedX*t.Time.deltaTime,this._scrollY+=this.scroolSpeedY*t.Time.deltaTime,this.sourceRect.x=this._scrollX,this.sourceRect.y=this._scrollY},n.prototype.render=function(t){if(this.sprite){e.prototype.render.call(this,t);var n=new egret.RenderTexture,i=new egret.DisplayObjectContainer;i.removeChildren(),i.addChild(this.leftTexture),i.addChild(this.rightTexture),this.leftTexture.x=this.sourceRect.x,this.rightTexture.x=this.sourceRect.x-this.sourceRect.width,this.leftTexture.y=this.sourceRect.y,this.rightTexture.y=this.sourceRect.y,i.cacheAsBitmap=!0,n.drawToTexture(i,new egret.Rectangle(0,0,this.sourceRect.width,this.sourceRect.height))}},n}(t.TiledSpriteRenderer);t.ScrollingSpriteRenderer=e}(es||(es={})),function(t){var e=function(){return function(e,n,i){void 0===n&&(n=new t.Rectangle(0,0,e.textureWidth,e.textureHeight)),void 0===i&&(i=n.getHalfSize()),this.uvs=new t.Rectangle,this.texture2D=e,this.sourceRect=n,this.center=new t.Vector2(.5*n.width,.5*n.height),this.origin=i;var r=1/e.textureWidth,o=1/e.textureHeight;this.uvs.x=n.x*r,this.uvs.y=n.y*o,this.uvs.width=n.width*r,this.uvs.height=n.height*o}}();t.Sprite=e}(es||(es={})),function(t){var e=function(){return function(t,e){this.sprites=t,this.frameRate=e}}();t.SpriteAnimation=e}(es||(es={})),function(t){var e,n;!function(t){t[t.loop=0]="loop",t[t.once=1]="once",t[t.clampForever=2]="clampForever",t[t.pingPong=3]="pingPong",t[t.pingPongOnce=4]="pingPongOnce"}(e=t.LoopMode||(t.LoopMode={})),function(t){t[t.none=0]="none",t[t.running=1]="running",t[t.paused=2]="paused",t[t.completed=3]="completed"}(n=t.State||(t.State={}));var i=function(i){function r(t){var e=i.call(this,t)||this;return e.speed=1,e.animationState=n.none,e._animations=new Map,e._elapsedTime=0,e}return __extends(r,i),Object.defineProperty(r.prototype,"isRunning",{get:function(){return this.animationState==n.running},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"animations",{get:function(){return this._animations},enumerable:!0,configurable:!0}),r.prototype.update=function(){if(this.animationState==n.running&&this.currentAnimation){var i=this.currentAnimation,r=1/(i.frameRate*this.speed),o=r*i.sprites.length;this._elapsedTime+=t.Time.deltaTime;var s=Math.abs(this._elapsedTime);if(this._loopMode==e.once&&s>o||this._loopMode==e.pingPongOnce&&s>2*o)return this.animationState=n.completed,this._elapsedTime=0,this.currentFrame=0,void(this.sprite=i.sprites[this.currentFrame]);var a=Math.floor(s/r),c=i.sprites.length;if(c>2&&(this._loopMode==e.pingPong||this._loopMode==e.pingPongOnce)){var h=c-1;this.currentFrame=h-Math.abs(h-a%(2*h))}else this.currentFrame=a%c;this.sprite=i.sprites[this.currentFrame]}},r.prototype.addAnimation=function(t,e){return!this.sprite&&e.sprites.length>0&&this.setSprite(e.sprites[0]),this._animations[t]=e,this},r.prototype.play=function(t,i){void 0===i&&(i=null),this.currentAnimation=this._animations[t],this.currentAnimationName=t,this.currentFrame=0,this.animationState=n.running,this.sprite=this.currentAnimation.sprites[0],this._elapsedTime=0,this._loopMode=i||e.loop},r.prototype.isAnimationActive=function(t){return this.currentAnimation&&this.currentAnimationName==t},r.prototype.pause=function(){this.animationState=n.paused},r.prototype.unPause=function(){this.animationState=n.running},r.prototype.stop=function(){this.currentAnimation=null,this.currentAnimationName=null,this.currentFrame=0,this.animationState=n.none},r}(t.SpriteRenderer);t.SpriteAnimator=i}(es||(es={})),function(t){var e=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return __extends(n,e),n.prototype.onAddedToEntity=function(){this._triggerHelper=new t.ColliderTriggerHelper(this.entity)},n.prototype.calculateMovement=function(e){var n=new t.CollisionResult;if(!this.entity.getComponent(t.Collider)||!this._triggerHelper)return null;for(var i=this.entity.getComponents(t.Collider),r=0;r<i.length;r++){var o=i[r];if(!o.isTrigger){var s=o.bounds;s.x+=e.x,s.y+=e.y;var a=t.Physics.boxcastBroadphaseExcludingSelf(o,s,o.collidesWithLayers);s=a.bounds;for(var c=a.tempHashSet,h=0;h<c.length;h++){var u=c[h];if(!u.isTrigger){var l=o.collidesWith(u,e);l&&(e=t.Vector2.subtract(e,l.minimumTranslationVector),l.collider&&(n=l))}}}}return t.ListPool.free(i),{collisionResult:n,motion:e}},n.prototype.applyMovement=function(e){this.entity.position=t.Vector2.add(this.entity.position,e),this._triggerHelper&&this._triggerHelper.update()},n.prototype.move=function(t){var e=this.calculateMovement(t),n=e.collisionResult;return t=e.motion,this.applyMovement(t),n},n}(t.Component);t.Mover=e}(es||(es={})),function(t){var e=function(e){function n(){var t=null!==e&&e.apply(this,arguments)||this;return t._tempTriggerList=[],t}return __extends(n,e),n.prototype.onAddedToEntity=function(){this._collider=this.entity.getComponent(t.Collider),this._collider||console.warn("ProjectileMover has no Collider. ProjectilMover requires a Collider!")},n.prototype.move=function(e){if(!this._collider)return!1;var n=!1;this.entity.position=t.Vector2.add(this.entity.position,e);for(var i=t.Physics.boxcastBroadphase(this._collider.bounds,this._collider.collidesWithLayers),r=0;r<i.colliders.length;r++){var o=i.colliders[r];this._collider.overlaps(o)&&o.enabled&&(n=!0,this.notifyTriggerListeners(this._collider,o))}return n},n.prototype.notifyTriggerListeners=function(t,e){e.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var n=0;n<this._tempTriggerList.length;n++)this._tempTriggerList[n].onTriggerEnter(t,e);this._tempTriggerList.length=0,this.entity.getComponents("ITriggerListener",this._tempTriggerList);for(n=0;n<this._tempTriggerList.length;n++)this._tempTriggerList[n].onTriggerEnter(e,t);this._tempTriggerList.length=0},n}(t.Component);t.ProjectileMover=e}(es||(es={})),function(t){var e=function(e){function n(){var n=null!==e&&e.apply(this,arguments)||this;return n.physicsLayer=1,n.collidesWithLayers=t.Physics.allLayers,n.shouldColliderScaleAndRotateWithTransform=!0,n.registeredPhysicsBounds=new t.Rectangle,n._localOffset=t.Vector2.zero,n}return __extends(n,e),Object.defineProperty(n.prototype,"localOffset",{get:function(){return this._localOffset},set:function(t){this.setLocalOffset(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"absolutePosition",{get:function(){return t.Vector2.add(this.entity.transform.position,this._localOffset)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"rotation",{get:function(){return this.shouldColliderScaleAndRotateWithTransform&&this.entity?this.entity.transform.rotation:0},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"bounds",{get:function(){return this.shape.recalculateBounds(this),this.shape.bounds},enumerable:!0,configurable:!0}),n.prototype.setLocalOffset=function(t){return this._localOffset!=t&&(this.unregisterColliderWithPhysicsSystem(),this._localOffset=t,this._localOffsetLength=this._localOffset.length(),this.registerColliderWithPhysicsSystem()),this},n.prototype.setShouldColliderScaleAndRotateWithTransform=function(t){return this.shouldColliderScaleAndRotateWithTransform=t,this},n.prototype.onAddedToEntity=function(){if(this._colliderRequiresAutoSizing){if(!(this instanceof t.BoxCollider||this instanceof t.CircleCollider))return void console.error("Only box and circle colliders can be created automatically");var e=this.entity.getComponent(t.RenderableComponent);if(e){var n=e.bounds,i=n.width/this.entity.scale.x,r=n.height/this.entity.scale.y;if(this instanceof t.CircleCollider){this.radius=.5*Math.max(i,r)}else this.width=i,this.height=r;this.localOffset=t.Vector2.subtract(n.center,this.entity.transform.position)}else console.warn("Collider has no shape and no RenderableComponent. Can't figure out how to size it.")}this._isParentEntityAddedToScene=!0,this.registerColliderWithPhysicsSystem()},n.prototype.onRemovedFromEntity=function(){this.unregisterColliderWithPhysicsSystem(),this._isParentEntityAddedToScene=!1},n.prototype.onEntityTransformChanged=function(e){this._isColliderRegistered&&t.Physics.updateCollider(this)},n.prototype.onEnabled=function(){this.registerColliderWithPhysicsSystem()},n.prototype.onDisabled=function(){this.unregisterColliderWithPhysicsSystem()},n.prototype.registerColliderWithPhysicsSystem=function(){this._isParentEntityAddedToScene&&!this._isColliderRegistered&&(t.Physics.addCollider(this),this._isColliderRegistered=!0)},n.prototype.unregisterColliderWithPhysicsSystem=function(){this._isParentEntityAddedToScene&&this._isColliderRegistered&&t.Physics.removeCollider(this),this._isColliderRegistered=!1},n.prototype.overlaps=function(t){return this.shape.overlaps(t.shape)},n.prototype.collidesWith=function(e,n){var i=this.entity.position;this.entity.position=t.Vector2.add(this.entity.position,n);var r=this.shape.collidesWithShape(e.shape);return r&&(r.collider=e),this.entity.position=i,r},n}(t.Component);t.Collider=e}(es||(es={})),function(t){var e=function(e){function n(){var n=e.call(this)||this;return n.shape=new t.Box(1,1),n._colliderRequiresAutoSizing=!0,n}return __extends(n,e),Object.defineProperty(n.prototype,"width",{get:function(){return this.shape.width},set:function(t){this.setWidth(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"height",{get:function(){return this.shape.height},set:function(t){this.setHeight(t)},enumerable:!0,configurable:!0}),n.prototype.setSize=function(e,n){this._colliderRequiresAutoSizing=!1;var i=this.shape;return e==i.width&&n==i.height||(i.updateBox(e,n),this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this)),this},n.prototype.setWidth=function(e){this._colliderRequiresAutoSizing=!1;var n=this.shape;return e!=n.width&&(n.updateBox(e,n.height),this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this)),this},n.prototype.setHeight=function(e){this._colliderRequiresAutoSizing=!1;var n=this.shape;e!=n.height&&(n.updateBox(n.width,e),this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this))},n.prototype.toString=function(){return"[BoxCollider: bounds: "+this.bounds+"]"},n}(t.Collider);t.BoxCollider=e}(es||(es={})),function(t){var e=function(e){function n(n){var i=e.call(this)||this;return n&&(i._colliderRequiresAutoSizing=!0),i.shape=new t.Circle(n||1),i}return __extends(n,e),Object.defineProperty(n.prototype,"radius",{get:function(){return this.shape.radius},set:function(t){this.setRadius(t)},enumerable:!0,configurable:!0}),n.prototype.setRadius=function(e){this._colliderRequiresAutoSizing=!1;var n=this.shape;return e!=n.radius&&(n.radius=e,n._originalRadius=e,this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this)),this},n.prototype.toString=function(){return"[CircleCollider: bounds: "+this.bounds+", radius: "+this.shape.radius+"]"},n}(t.Collider);t.CircleCollider=e}(es||(es={})),function(t){var e=function(e){function n(n){var i=e.call(this)||this;n[0]==n[n.length-1]&&n.splice(n.length-1,1);var r=t.Polygon.findPolygonCenter(n);return i.setLocalOffset(r),t.Polygon.recenterPolygonVerts(n),i.shape=new t.Polygon(n),i}return __extends(n,e),n}(t.Collider);t.PolygonCollider=e}(es||(es={})),function(t){var e=function(){function e(e){this._entities=[],this._matcher=e||t.Matcher.empty()}return Object.defineProperty(e.prototype,"matcher",{get:function(){return this._matcher},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"scene",{get:function(){return this._scene},set:function(t){this._scene=t,this._entities=[]},enumerable:!0,configurable:!0}),e.prototype.initialize=function(){},e.prototype.onChanged=function(t){var e=this._entities.contains(t),n=this._matcher.IsIntersted(t);n&&!e?this.add(t):!n&&e&&this.remove(t)},e.prototype.add=function(t){this._entities.push(t),this.onAdded(t)},e.prototype.onAdded=function(t){},e.prototype.remove=function(t){this._entities.remove(t),this.onRemoved(t)},e.prototype.onRemoved=function(t){},e.prototype.update=function(){this.begin(),this.process(this._entities)},e.prototype.lateUpdate=function(){this.lateProcess(this._entities),this.end()},e.prototype.begin=function(){},e.prototype.process=function(t){},e.prototype.lateProcess=function(t){},e.prototype.end=function(){},e}();t.EntitySystem=e}(es||(es={})),function(t){var e=function(t){function e(e){return t.call(this,e)||this}return __extends(e,t),e.prototype.lateProcessEntity=function(t){},e.prototype.process=function(t){var e=this;t.forEach(function(t){return e.processEntity(t)})},e.prototype.lateProcess=function(t){var e=this;t.forEach(function(t){return e.lateProcessEntity(t)})},e}(t.EntitySystem);t.EntityProcessingSystem=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.onChanged=function(t){},e.prototype.process=function(t){this.begin(),this.end()},e}(t.EntitySystem);t.PassiveSystem=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.onChanged=function(t){},e.prototype.process=function(t){this.begin(),this.processSystem(),this.end()},e}(t.EntitySystem);t.ProcessingSystem=e}(es||(es={})),function(t){var e=function(){function t(e){void 0===e&&(e=64);var n=e>>6;0!=(e&t.LONG_MASK)&&n++,this._bits=new Array(n)}return t.prototype.and=function(t){for(var e,n=Math.min(this._bits.length,t._bits.length),i=0;i<n;++i)this._bits[i]&=t._bits[i];for(;e<this._bits.length;)this._bits[e++]=0},t.prototype.andNot=function(t){for(var e=Math.min(this._bits.length,t._bits.length);--e>=0;)this._bits[e]&=~t._bits[e]},t.prototype.cardinality=function(){for(var t=0,e=this._bits.length-1;e>=0;e--){var n=this._bits[e];if(0!=n)if(-1!=n){var i=((n=((n=(n>>1&0x5555555555555400)+(0x5555555555555400&n))>>2&0x3333333333333400)+(0x3333333333333400&n))>>32)+n;t+=((i=((i=(i>>4&252645135)+(252645135&i))>>8&16711935)+(16711935&i))>>16&65535)+(65535&i)}else t+=64}return t},t.prototype.clear=function(t){if(null!=t){var e=t>>6;this.ensure(e),this._bits[e]&=~(1<<t)}else for(var n=0;n<this._bits.length;n++)this._bits[n]=0},t.prototype.ensure=function(t){if(t>=this._bits.length){var e=new Number[t+1];e=this._bits.copyWithin(0,0,this._bits.length),this._bits=e}},t.prototype.get=function(t){var e=t>>6;return!(e>=this._bits.length)&&0!=(this._bits[e]&1<<t)},t.prototype.intersects=function(t){for(var e=Math.min(this._bits.length,t._bits.length);--e>=0;)if(0!=(this._bits[e]&t._bits[e]))return!0;return!1},t.prototype.isEmpty=function(){for(var t=this._bits.length-1;t>=0;t--)if(this._bits[t])return!1;return!0},t.prototype.nextSetBit=function(t){for(var e=t>>6,n=1<<t;e<this._bits.length;){var i=this._bits[e];do{if(0!=(i&n))return t;n<<=1,t++}while(0!=n);n=1,e++}return-1},t.prototype.set=function(t,e){if(void 0===e&&(e=!0),e){var n=t>>6;this.ensure(n),this._bits[n]|=1<<t}else this.clear(t)},t.LONG_MASK=63,t}();t.BitSet=e}(es||(es={})),function(t){var e=function(){function e(t){this._components=[],this._componentsToAdd=[],this._componentsToRemove=[],this._tempBufferList=[],this._entity=t}return Object.defineProperty(e.prototype,"count",{get:function(){return this._components.length},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"buffer",{get:function(){return this._components},enumerable:!0,configurable:!0}),e.prototype.markEntityListUnsorted=function(){this._isComponentListUnsorted=!0},e.prototype.add=function(t){this._componentsToAdd.push(t)},e.prototype.remove=function(t){this._componentsToRemove.contains(t)&&console.warn("You are trying to remove a Component ("+t+") that you already removed"),this._componentsToAdd.contains(t)?this._componentsToAdd.remove(t):this._componentsToRemove.push(t)},e.prototype.removeAllComponents=function(){for(var t=0;t<this._components.length;t++)this.handleRemove(this._components[t]);this._components.length=0,this._componentsToAdd.length=0,this._componentsToRemove.length=0},e.prototype.deregisterAllComponents=function(){for(var e=0;e<this._components.length;e++){var n=this._components[e];n instanceof t.RenderableComponent&&this._entity.scene.renderableComponents.remove(n),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(n),!1),this._entity.scene.entityProcessors.onComponentRemoved(this._entity)}},e.prototype.registerAllComponents=function(){for(var e=0;e<this._components.length;e++){var n=this._components[e];n instanceof t.RenderableComponent&&this._entity.scene.renderableComponents.add(n),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(n)),this._entity.scene.entityProcessors.onComponentAdded(this._entity)}},e.prototype.updateLists=function(){if(this._componentsToRemove.length>0){for(var n=0;n<this._componentsToRemove.length;n++)this.handleRemove(this._componentsToRemove[n]),this._components.remove(this._componentsToRemove[n]);this._componentsToRemove.length=0}if(this._componentsToAdd.length>0){n=0;for(var i=this._componentsToAdd.length;n<i;n++){(r=this._componentsToAdd[n])instanceof t.RenderableComponent&&this._entity.scene.renderableComponents.add(r),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(r)),this._entity.scene.entityProcessors.onComponentAdded(this._entity),this._components.push(r),this._tempBufferList.push(r)}this._componentsToAdd.length=0,this._isComponentListUnsorted=!0;for(n=0;n<this._tempBufferList.length;n++){var r;(r=this._tempBufferList[n]).onAddedToEntity(),r.enabled&&r.onEnabled()}this._tempBufferList.length=0}this._isComponentListUnsorted&&(this._components.sort(e.compareUpdatableOrder.compare),this._isComponentListUnsorted=!1)},e.prototype.handleRemove=function(e){e instanceof t.RenderableComponent&&this._entity.scene.renderableComponents.remove(e),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(e),!1),this._entity.scene.entityProcessors.onComponentRemoved(this._entity),e.onRemovedFromEntity(),e.entity=null},e.prototype.getComponent=function(t,e){for(var n=0;n<this._components.length;n++){if((i=this._components[n])instanceof t)return i}if(!e)for(n=0;n<this._componentsToAdd.length;n++){var i;if((i=this._componentsToAdd[n])instanceof t)return i}return null},e.prototype.getComponents=function(t,e){e||(e=[]);for(var n=0;n<this._components.length;n++){var i=this._components[n];"string"==typeof t?egret.is(i,t)&&e.push(i):i instanceof t&&e.push(i)}for(n=0;n<this._componentsToAdd.length;n++){i=this._componentsToAdd[n];"string"==typeof t?egret.is(i,t)&&e.push(i):i instanceof t&&e.push(i)}return e},e.prototype.update=function(){this.updateLists();for(var e=0;e<this._components.length;e++){var n=this._components[e];!n.enabled||1!=n.updateInterval&&t.Time.frameCount%n.updateInterval!=0||n.update()}},e.prototype.onEntityTransformChanged=function(t){for(var e=0;e<this._components.length;e++)this._components[e].enabled&&this._components[e].onEntityTransformChanged(t);for(e=0;e<this._componentsToAdd.length;e++)this._componentsToAdd[e].enabled&&this._componentsToAdd[e].onEntityTransformChanged(t)},e.prototype.onEntityEnabled=function(){for(var t=0;t<this._components.length;t++)this._components[t].onEnabled()},e.prototype.onEntityDisabled=function(){for(var t=0;t<this._components.length;t++)this._components[t].onDisabled()},e.compareUpdatableOrder=new t.IUpdatableComparer,e}();t.ComponentList=e}(es||(es={})),function(t){var e=function(){function t(){}return t.add=function(t){this._componentTypesMask.has(t)||(this._componentTypesMask[t]=this._componentTypesMask.size)},t.getIndexFor=function(t){var e=-1;return this._componentTypesMask.has(t)||(this.add(t),e=this._componentTypesMask.get(t)),e},t._componentTypesMask=new Map,t}();t.ComponentTypeManager=e}(es||(es={})),function(t){var e=function(){function e(t){this._entitiesToRemove=[],this._entitiesToAdded=[],this._tempEntityList=[],this._entities=[],this._entityDict=new Map,this._unsortedTags=[],this.scene=t}return Object.defineProperty(e.prototype,"count",{get:function(){return this._entities.length},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"buffer",{get:function(){return this._entities},enumerable:!0,configurable:!0}),e.prototype.add=function(t){-1==this._entitiesToAdded.indexOf(t)&&this._entitiesToAdded.push(t)},e.prototype.remove=function(t){this._entitiesToAdded.contains(t)?this._entitiesToAdded.remove(t):this._entitiesToRemove.contains(t)||this._entitiesToRemove.push(t)},e.prototype.findEntity=function(t){for(var e=0;e<this._entities.length;e++)if(this._entities[e].name==t)return this._entities[e];return this._entitiesToAdded.firstOrDefault(function(e){return e.name==t})},e.prototype.entitiesWithTag=function(e){for(var n=this.getTagList(e),i=t.ListPool.obtain(),r=0;r<n.length;r++)i.push(n[r]);return i},e.prototype.entitiesOfType=function(e){for(var n=t.ListPool.obtain(),i=0;i<this._entities.length;i++)this._entities[i]instanceof e&&n.push(this._entities[i]);return this._entitiesToAdded.forEach(function(t){t instanceof e&&n.push(t)}),n},e.prototype.findComponentOfType=function(t){for(var e=0;e<this._entities.length;e++){if(this._entities[e].enabled)if(n=this._entities[e].getComponent(t))return n}for(e=0;e<this._entitiesToAdded.length;e++){var n,i=this._entitiesToAdded[e];if(i.enabled)if(n=i.getComponent(t))return n}return null},e.prototype.findComponentsOfType=function(e){for(var n=t.ListPool.obtain(),i=0;i<this._entities.length;i++)this._entities[i].enabled&&this._entities[i].getComponents(e,n);for(i=0;i<this._entitiesToAdded.length;i++){var r=this._entitiesToAdded[i];r.enabled&&r.getComponents(e,n)}return n},e.prototype.getTagList=function(t){var e=this._entityDict.get(t);return e||(e=[],this._entityDict.set(t,e)),this._entityDict.get(t)},e.prototype.addToTagList=function(t){var e=this.getTagList(t.tag);e.contains(t)||(e.push(t),this._unsortedTags.push(t.tag))},e.prototype.removeFromTagList=function(t){var e=this._entityDict.get(t.tag);e&&e.remove(t)},e.prototype.update=function(){for(var t=0;t<this._entities.length;t++){var e=this._entities[t];e.enabled&&e.update()}},e.prototype.removeAllEntities=function(){this._entitiesToAdded.length=0,this.updateLists();for(var t=0;t<this._entities.length;t++)this._entities[t]._isDestroyed=!0,this._entities[t].onRemovedFromScene(),this._entities[t].scene=null;this._entities.length=0,this._entityDict.clear()},e.prototype.updateLists=function(){var t=this;if(this._entitiesToRemove.length>0){var e=this._entitiesToRemove;this._entitiesToRemove=this._tempEntityList,this._tempEntityList=e,this._tempEntityList.forEach(function(e){t._entities.remove(e),e.scene=null,t.scene.entityProcessors.onEntityRemoved(e)}),this._tempEntityList.length=0}if(this._entitiesToAdded.length>0){e=this._entitiesToAdded;this._entitiesToAdded=this._tempEntityList,this._tempEntityList=e,this._tempEntityList.forEach(function(e){t._entities.contains(e)||(t._entities.push(e),e.scene=t.scene,t.scene.entityProcessors.onEntityAdded(e))}),this._tempEntityList.forEach(function(t){return t.onAddedToScene()}),this._tempEntityList.length=0}this._unsortedTags.length>0&&(this._unsortedTags.forEach(function(e){t._entityDict.get(e).sort()}),this._unsortedTags.length=0)},e}();t.EntityList=e}(es||(es={})),function(t){var e=function(){function e(){this._processors=[]}return e.prototype.add=function(t){this._processors.push(t)},e.prototype.remove=function(t){this._processors.remove(t)},e.prototype.onComponentAdded=function(t){this.notifyEntityChanged(t)},e.prototype.onComponentRemoved=function(t){this.notifyEntityChanged(t)},e.prototype.onEntityAdded=function(t){this.notifyEntityChanged(t)},e.prototype.onEntityRemoved=function(t){this.removeFromProcessors(t)},e.prototype.notifyEntityChanged=function(t){for(var e=0;e<this._processors.length;e++)this._processors[e].onChanged(t)},e.prototype.removeFromProcessors=function(t){for(var e=0;e<this._processors.length;e++)this._processors[e].remove(t)},e.prototype.begin=function(){},e.prototype.update=function(){for(var t=0;t<this._processors.length;t++)this._processors[t].update()},e.prototype.lateUpdate=function(){for(var t=0;t<this._processors.length;t++)this._processors[t].lateUpdate()},e.prototype.end=function(){},e.prototype.getProcessor=function(){for(var e=0;e<this._processors.length;e++){var n=this._processors[e];if(n instanceof t.EntitySystem)return n}return null},e}();t.EntityProcessorList=e}(es||(es={})),function(t){var e=function(){function e(){this.allSet=new t.BitSet,this.exclusionSet=new t.BitSet,this.oneSet=new t.BitSet}return e.empty=function(){return new e},e.prototype.getAllSet=function(){return this.allSet},e.prototype.getExclusionSet=function(){return this.exclusionSet},e.prototype.getOneSet=function(){return this.oneSet},e.prototype.IsIntersted=function(t){if(!this.allSet.isEmpty())for(var e=this.allSet.nextSetBit(0);e>=0;e=this.allSet.nextSetBit(e+1))if(!t.componentBits.get(e))return!1;return!(!this.exclusionSet.isEmpty()&&this.exclusionSet.intersects(t.componentBits))&&!(!this.oneSet.isEmpty()&&!this.oneSet.intersects(t.componentBits))},e.prototype.all=function(){for(var e=this,n=[],i=0;i<arguments.length;i++)n[i]=arguments[i];return n.forEach(function(n){e.allSet.set(t.ComponentTypeManager.getIndexFor(n))}),this},e.prototype.exclude=function(){for(var e=this,n=[],i=0;i<arguments.length;i++)n[i]=arguments[i];return n.forEach(function(n){e.exclusionSet.set(t.ComponentTypeManager.getIndexFor(n))}),this},e.prototype.one=function(){for(var e=this,n=[],i=0;i<arguments.length;i++)n[i]=arguments[i];return n.forEach(function(n){e.oneSet.set(t.ComponentTypeManager.getIndexFor(n))}),this},e}();t.Matcher=e}(es||(es={}));var ObjectUtils=function(){function t(){}return t.clone=function(t,e){void 0===e&&(e=null);e=e||{};for(var n in t)"object"==typeof t[n]?(e[n]=t[n]instanceof Array?[]:{},this.clone(t[n],e[n])):e[n]=t[n];return e},t}();!function(t){var e=function(){function t(){}return t.prototype.compare=function(t,e){return e.renderLayer-t.renderLayer},t}();t.RenderableComparer=e}(es||(es={})),function(t){var e=function(){function e(){this._components=[],this._componentsByRenderLayer=new Map,this._unsortedRenderLayers=[],this._componentsNeedSort=!0}return Object.defineProperty(e.prototype,"count",{get:function(){return this._components.length},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"buffer",{get:function(){return this._components},enumerable:!0,configurable:!0}),e.prototype.add=function(t){this._components.push(t),this.addToRenderLayerList(t,t.renderLayer)},e.prototype.remove=function(t){this._components.remove(t),this._componentsByRenderLayer.get(t.renderLayer).remove(t)},e.prototype.updateRenderableRenderLayer=function(t,e,n){this._componentsByRenderLayer.has(e)&&this._componentsByRenderLayer.get(e).contains(t)&&(this._componentsByRenderLayer.get(e).remove(t),this.addToRenderLayerList(t,n))},e.prototype.setRenderLayerNeedsComponentSort=function(t){this._unsortedRenderLayers.contains(t)||this._unsortedRenderLayers.push(t),this._componentsNeedSort=!0},e.prototype.setNeedsComponentSort=function(){this._componentsNeedSort=!0},e.prototype.addToRenderLayerList=function(t,e){var n=this.componentsWithRenderLayer(e);n.contains(t)?(n.push(t),this._unsortedRenderLayers.contains(e)||this._unsortedRenderLayers.push(e),this._componentsNeedSort=!0):console.warn("Component renderLayer list already contains this component")},e.prototype.componentsWithRenderLayer=function(t){return this._componentsByRenderLayer.get(t)||this._componentsByRenderLayer.set(t,[]),this._componentsByRenderLayer.get(t)},e.prototype.updateList=function(){if(this._componentsNeedSort&&(this._components.sort(e.compareUpdatableOrder.compare),this._componentsNeedSort=!1),this._unsortedRenderLayers.length>0){for(var t=0,n=this._unsortedRenderLayers.length;t<n;t++){var i=this._componentsByRenderLayer.get(this._unsortedRenderLayers[t]);i&&i.sort(e.compareUpdatableOrder.compare)}this._unsortedRenderLayers.length=0}},e.compareUpdatableOrder=new t.RenderableComparer,e}();t.RenderableComponentList=e}(es||(es={}));var StringUtils=function(){function t(){}return t.matchChineseWord=function(t){return t.match(/[\u4E00-\u9FA5]+/gim)},t.lTrim=function(t){for(var e=0;this.isWhiteSpace(t.charAt(e));)e++;return t.slice(e,t.length)},t.rTrim=function(t){for(var e=t.length-1;this.isWhiteSpace(t.charAt(e));)e--;return t.slice(0,e+1)},t.trim=function(t){return null==t?null:this.rTrim(this.lTrim(t))},t.isWhiteSpace=function(t){return" "==t||"\t"==t||"\r"==t||"\n"==t},t.replaceMatch=function(t,e,n,i){void 0===i&&(i=!1);for(var r=t.length,o="",s=!1,a=1==i?e.toLowerCase():e,c=0;c<r;c++)s=!1,t.charAt(c)==a.charAt(0)&&t.substr(c,a.length)==a&&(s=!0),s?(o+=n,c=c+a.length-1):o+=t.charAt(c);return o},t.htmlSpecialChars=function(t,e){void 0===e&&(e=!1);for(var n=this.specialSigns.length,i=0;i<n;i+=2){var r=void 0,o=void 0;if(r=this.specialSigns[i],o=this.specialSigns[i+1],e){var s=r;r=o,o=s}t=this.replaceMatch(t,r,o)}return t},t.zfill=function(t,e){if(void 0===e&&(e=2),!t)return t;e=Math.floor(e);var n=t.length;if(n>=e)return t;var i=!1;"-"==t.substr(0,1)&&(i=!0,t=t.substr(1));for(var r=e-n,o=0;o<r;o++)t="0"+t;return i&&(t="-"+t),t},t.reverse=function(t){return t.length>1?this.reverse(t.substring(1))+t.substring(0,1):t},t.cutOff=function(t,e,n,i){void 0===i&&(i=!0),e=Math.floor(e),n=Math.floor(n);var r=t.length;e>r&&(e=r);var o,s=e,a=e+n;return i?o=t.substring(0,s)+t.substr(a,r):(a=(s=r-1-e-n)+n,o=t.substring(0,s+1)+t.substr(a+1,r)),o},t.strReplace=function(t,e){for(var n=0,i=e.length;n<i;n++)null!=e[n]&&""!=e[n]||(e[n]="无"),t=t.replace("{"+n+"}",e[n]);return t},t.specialSigns=["&","&amp;","<","&lt;",">","&gt;",'"',"&quot;","'","&apos;","®","&reg;","©","&copy;","™","&trade;"],t}();!function(t){var e=function(){function e(){}return e.convertImageToCanvas=function(e,n){this.sharedCanvas||(this.sharedCanvas=egret.sys.createCanvas(),this.sharedContext=this.sharedCanvas.getContext("2d"));var i=e.$getTextureWidth(),r=e.$getTextureHeight();n||((n=egret.$TempRectangle).x=0,n.y=0,n.width=i,n.height=r),n.x=Math.min(n.x,i-1),n.y=Math.min(n.y,r-1),n.width=Math.min(n.width,i-n.x),n.height=Math.min(n.height,r-n.y);var o=Math.floor(n.width),s=Math.floor(n.height),a=this.sharedCanvas;if(a.style.width=o+"px",a.style.height=s+"px",this.sharedCanvas.width=o,this.sharedCanvas.height=s,"webgl"==egret.Capabilities.renderMode){var c=void 0;e.$renderBuffer?c=e:(egret.sys.systemRenderer.renderClear&&egret.sys.systemRenderer.renderClear(),(c=new egret.RenderTexture).drawToTexture(new egret.Bitmap(e)));for(var h=c.$renderBuffer.getPixels(n.x,n.y,o,s),u=0,l=0,p=0;p<h.length;p+=4)this.sharedContext.fillStyle="rgba("+h[p]+","+h[p+1]+","+h[p+2]+","+h[p+3]/255+")",this.sharedContext.fillRect(u,l,1,1),++u==o&&(u=0,l++);return e.$renderBuffer||c.dispose(),a}var d=e,f=Math.round(d.$offsetX),g=Math.round(d.$offsetY),m=d.$bitmapWidth,y=d.$bitmapHeight,_=t.SceneManager.stage.textureScaleFactor;return this.sharedContext.drawImage(d.$bitmapData.source,d.$bitmapX+n.x/_,d.$bitmapY+n.y/_,m*n.width/i,y*n.height/r,f,g,n.width,n.height),a},e.toDataURL=function(t,e,n,i){try{return this.convertImageToCanvas(e,n).toDataURL(t,i)}catch(t){egret.$error(1033)}return null},e.eliFoTevas=function(t,e,n,i,r){var o=this.convertImageToCanvas(e,i).toTempFilePathSync({fileType:t.indexOf("png")>=0?"png":"jpg"});return wx.getFileSystemManager().saveFile({tempFilePath:o,filePath:wx.env.USER_DATA_PATH+"/"+n,success:function(t){}}),o},e.getPixel32=function(t,e,n){return egret.$warn(1041,"getPixel32","getPixels"),t.getPixels(e,n)},e.getPixels=function(t,e,n,i,r){if(void 0===i&&(i=1),void 0===r&&(r=1),"webgl"==egret.Capabilities.renderMode){var o=void 0;return t.$renderBuffer?o=t:(o=new egret.RenderTexture).drawToTexture(new egret.Bitmap(t)),o.$renderBuffer.getPixels(e,n,i,r)}try{this.convertImageToCanvas(t);return this.sharedContext.getImageData(e,n,i,r).data}catch(t){egret.$error(1039)}},e}();t.TextureUtils=e}(es||(es={})),function(t){var e=function(){function t(){}return t.update=function(t){var e=(t-this._lastTime)/1e3;this.deltaTime=e*this.timeScale,this.unscaledDeltaTime=e,this._timeSinceSceneLoad+=e,this.frameCount++,this._lastTime=t},t.sceneChanged=function(){this._timeSinceSceneLoad=0},t.checkEvery=function(t){return this._timeSinceSceneLoad/t>(this._timeSinceSceneLoad-this.deltaTime)/t},t.deltaTime=0,t.timeScale=1,t.frameCount=0,t._lastTime=0,t}();t.Time=e}(es||(es={}));var TimeUtils=function(){function t(){}return t.monthId=function(t){void 0===t&&(t=null);var e=(t=t||new Date).getFullYear(),n=t.getMonth()+1;return parseInt(e+(n<10?"0":"")+n)},t.dateId=function(t){void 0===t&&(t=null);var e=(t=t||new Date).getMonth()+1,n=e<10?"0":"",i=t.getDate(),r=i<10?"0":"";return parseInt(t.getFullYear()+n+e+r+i)},t.weekId=function(t,e){void 0===t&&(t=null),void 0===e&&(e=!0),t=t||new Date;var n=new Date;n.setTime(t.getTime()),n.setDate(1),n.setMonth(0);var i=n.getFullYear(),r=n.getDay();0==r&&(r=7);var o=!1;r<=4?(o=r>1,n.setDate(n.getDate()-(r-1))):n.setDate(n.getDate()+7-r+1);var s=this.diffDay(t,n,!1);if(s<0)return n.setDate(1),n.setMonth(0),n.setDate(n.getDate()-1),this.weekId(n,!1);var a=s/7,c=Math.floor(a)+1;if(53==c){n.setTime(t.getTime()),n.setDate(n.getDate()-1);var h=n.getDay();if(0==h&&(h=7),e&&(!o||h<4))return n.setFullYear(n.getFullYear()+1),n.setDate(1),n.setMonth(0),this.weekId(n,!1)}return parseInt(i+"00"+(c>9?"":"0")+c)},t.diffDay=function(t,e,n){void 0===n&&(n=!1);var i=(t.getTime()-e.getTime())/864e5;return n?Math.ceil(i):Math.floor(i)},t.getFirstDayOfWeek=function(t){var e=(t=t||new Date).getDay()||7;return new Date(t.getFullYear(),t.getMonth(),t.getDate()+1-e,0,0,0,0)},t.getFirstOfDay=function(t){return(t=t||new Date).setHours(0,0,0,0),t},t.getNextFirstOfDay=function(t){return new Date(this.getFirstOfDay(t).getTime()+864e5)},t.formatDate=function(t){var e=t.getFullYear(),n=t.getMonth()+1;n=n<10?"0"+n:n;var i=t.getDate();return e+"-"+n+"-"+(i=i<10?"0"+i:i)},t.formatDateTime=function(t){var e=t.getFullYear(),n=t.getMonth()+1;n=n<10?"0"+n:n;var i=t.getDate();i=i<10?"0"+i:i;var r=t.getHours(),o=t.getMinutes();o=o<10?"0"+o:o;var s=t.getSeconds();return e+"-"+n+"-"+i+" "+r+":"+o+":"+(s=s<10?"0"+s:s)},t.parseDate=function(t){var e=Date.parse(t);return isNaN(e)?new Date:new Date(Date.parse(t.replace(/-/g,"/")))},t.secondToTime=function(t,e,n){void 0===t&&(t=0),void 0===e&&(e=":"),void 0===n&&(n=!0);var i=Math.floor(t/3600),r=Math.floor(t%3600/60),o=Math.floor(t%3600%60),s=i.toString(),a=r.toString(),c=o.toString();return i<10&&(s="0"+s),r<10&&(a="0"+a),o<10&&(c="0"+c),n?s+e+a+e+c:a+e+c},t.timeToMillisecond=function(t,e){void 0===e&&(e=":");for(var n=t.split(e),i=0,r=n.length,o=0;o<r;o++){i+=n[o]*Math.pow(60,r-1-o)}return(i*=1e3).toString()},t}();!function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.initialize=function(t){this.platformInitialize(t)},e.prototype.platformInitialize=function(t){this.isMobile=!0;var e=wx.getSystemInfoSync(),n=e.system.toLowerCase();n.indexOf("ios")>-1?this.os="iOS":n.indexOf("android")>-1&&(this.os="Android");var i=e.language;i=i.indexOf("zh")>-1?"zh-CN":"en-US",this.language=i},e}(egret.Capabilities);t.GraphicsCapabilities=e}(es||(es={})),function(t){var e=function(){return function(){this.graphicsCapabilities=new t.GraphicsCapabilities,this.graphicsCapabilities.initialize(this)}}();t.GraphicsDevice=e}(es||(es={})),function(t){var e=function(){function e(t,e,n,i){this._x=t,this._y=e,this._width=n,this._height=i,this._minDepth=0,this._maxDepth=1}return Object.defineProperty(e.prototype,"aspectRatio",{get:function(){return 0!=this._height&&0!=this._width?this._width/this._height:0},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"bounds",{get:function(){return new t.Rectangle(this._x,this._y,this._width,this._height)},set:function(t){this._x=t.x,this._y=t.y,this._width=t.width,this._height=t.height},enumerable:!0,configurable:!0}),e}();t.Viewport=e}(es||(es={})),function(t){var e=function(e){function n(){return e.call(this,t.PostProcessor.default_vert,n.blur_frag,{screenWidth:t.SceneManager.stage.stageWidth,screenHeight:t.SceneManager.stage.stageHeight})||this}return __extends(n,e),n.blur_frag="precision mediump float;\nuniform sampler2D uSampler;\nuniform float screenWidth;\nuniform float screenHeight;\nfloat normpdf(in float x, in float sigma)\n{\nreturn 0.39894*exp(-0.5*x*x/(sigma*sigma))/sigma;\n}\nvoid main()\n{\nvec3 c = texture2D(uSampler, gl_FragCoord.xy / vec2(screenWidth, screenHeight).xy).rgb;\nconst int mSize = 11;\nconst int kSize = (mSize - 1)/2;\nfloat kernel[mSize];\nvec3 final_colour = vec3(0.0);\nfloat sigma = 7.0;\nfloat z = 0.0;\nfor (int j = 0; j <= kSize; ++j)\n{\nkernel[kSize+j] = kernel[kSize-j] = normpdf(float(j),sigma);\n}\nfor (int j = 0; j < mSize; ++j)\n{\nz += kernel[j];\n}\nfor (int i = -kSize; i <= kSize; ++i)\n{\nfor (int j = -kSize; j <= kSize; ++j)\n{\nfinal_colour += kernel[kSize+j]*kernel[kSize+i]*texture2D(uSampler, (gl_FragCoord.xy+vec2(float(i),float(j))) / vec2(screenWidth, screenHeight).xy).rgb;\n}\n}\ngl_FragColor = vec4(final_colour/(z*z), 1.0);\n}",n}(egret.CustomFilter);t.GaussianBlurEffect=e}(es||(es={})),function(t){var e=function(t){function e(){return t.call(this,e.vertSrc,e.fragmentSrc)||this}return __extends(e,t),e.vertSrc="attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n}",e.fragmentSrc="precision lowp float;\nvarying vec2 vTextureCoord;\nuniform sampler2D uSampler;\n#define SAMPLE_COUNT 15\nuniform vec2 _sampleOffsets[SAMPLE_COUNT];\nuniform float _sampleWeights[SAMPLE_COUNT];\nvoid main(void) {\nvec4 c = vec4(0, 0, 0, 0);\nfor( int i = 0; i < SAMPLE_COUNT; i++ )\n   c += texture2D( uSampler, vTextureCoord + _sampleOffsets[i] ) * _sampleWeights[i];\ngl_FragColor = c;\n}",e}(egret.CustomFilter);t.PolygonLightEffect=e}(es||(es={})),function(t){var e=function(){function e(t){void 0===t&&(t=null),this.enabled=!0,this.effect=t}return e.prototype.onAddedToScene=function(e){this.scene=e,this.shape=new egret.Shape,this.shape.graphics.beginFill(16777215,1),this.shape.graphics.drawRect(0,0,t.SceneManager.stage.stageWidth,t.SceneManager.stage.stageHeight),this.shape.graphics.endFill(),e.addChild(this.shape)},e.prototype.process=function(){this.drawFullscreenQuad()},e.prototype.onSceneBackBufferSizeChanged=function(t,e){},e.prototype.drawFullscreenQuad=function(){this.scene.filters=[this.effect]},e.prototype.unload=function(){this.effect&&(this.effect=null),this.scene.removeChild(this.shape),this.scene=null},e.default_vert="attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec2 aColor;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\ngl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\nvTextureCoord = aTextureCoord;\nvColor = vec4(aColor.x, aColor.x, aColor.x, aColor.x);\n}",e}();t.PostProcessor=e}(es||(es={})),function(t){var e=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return __extends(n,e),n.prototype.onAddedToScene=function(n){e.prototype.onAddedToScene.call(this,n),this.effect=new t.GaussianBlurEffect},n}(t.PostProcessor);t.GaussianBlurPostProcessor=e}(es||(es={})),function(t){var e=function(){function t(){}return t.prototype.onAddedToScene=function(t){},t.prototype.beginRender=function(t){},t.prototype.unload=function(){},t.prototype.renderAfterStateCheck=function(t,e){t.render(e)},t}();t.Renderer=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.render=function(t){var e=this.camera?this.camera:t.camera;this.beginRender(e);for(var n=0;n<t.renderableComponents.count;n++){var i=t.renderableComponents.buffer[n];i.enabled&&i.isVisibleFromCamera(e)&&this.renderAfterStateCheck(i,e)}},e}(t.Renderer);t.DefaultRenderer=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.render=function(t){},e}(t.Renderer);t.ScreenSpaceRenderer=e}(es||(es={})),function(t){var e=function(t){function e(e,n,i){var r=t.call(this)||this;return r._indices=[],r.radius=e,r.power=i,r.color=n,r.computeTriangleIndices(),r}return __extends(e,t),Object.defineProperty(e.prototype,"radius",{get:function(){return this._radius},set:function(t){this.setRadius(t)},enumerable:!0,configurable:!0}),e.prototype.computeTriangleIndices=function(t){void 0===t&&(t=20),this._indices.length=0;for(var e=0;e<t;e+=2)this._indices.push(0),this._indices.push(e+2),this._indices.push(e+1)},e.prototype.setRadius=function(t){t!=this._radius&&(this._radius=t,this._areBoundsDirty=!0)},e.prototype.render=function(t){},e.prototype.reset=function(){},e}(t.RenderableComponent);t.PolyLight=e}(es||(es={})),function(t){var e=function(){function e(t){this.sceneLoadAction=t,this.loadsNewScene=null!=t}return Object.defineProperty(e.prototype,"hasPreviousSceneRender",{get:function(){return!!this._hasPreviousSceneRender||(this._hasPreviousSceneRender=!0,!1)},enumerable:!0,configurable:!0}),e.prototype.preRender=function(){},e.prototype.render=function(){},e.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(t){switch(t.label){case 0:return[4,this.loadNextScene()];case 1:return t.sent(),this.transitionComplete(),[2]}})})},e.prototype.transitionComplete=function(){t.SceneManager.sceneTransition=null,this.onTransitionCompleted&&this.onTransitionCompleted()},e.prototype.loadNextScene=function(){return __awaiter(this,void 0,void 0,function(){var e;return __generator(this,function(n){switch(n.label){case 0:return this.onScreenObscured&&this.onScreenObscured(),this.loadsNewScene||(this.isNewSceneLoaded=!0),e=t.SceneManager,[4,this.sceneLoadAction()];case 1:return e.scene=n.sent(),this.isNewSceneLoaded=!0,[2]}})})},e.prototype.tickEffectProgressProperty=function(t,e,n,i){return void 0===i&&(i=!1),new Promise(function(r){var o=i?1:0,s=i?0:1;egret.Tween.get(t.uniforms).set({_progress:o}).to({_progress:s},1e3*e,n).call(function(){r()})})},e}();t.SceneTransition=e}(es||(es={})),function(t){var e=function(e){function n(t){var n=e.call(this,t)||this;return n.fadeToColor=0,n.fadeOutDuration=.4,n.fadeEaseType=egret.Ease.quadInOut,n.delayBeforeFadeInDuration=.1,n._alpha=0,n._mask=new egret.Shape,n}return __extends(n,e),n.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){var e=this;return __generator(this,function(n){return this._mask.graphics.beginFill(this.fadeToColor,1),this._mask.graphics.drawRect(0,0,t.SceneManager.stage.stageWidth,t.SceneManager.stage.stageHeight),this._mask.graphics.endFill(),t.SceneManager.stage.addChild(this._mask),egret.Tween.get(this).to({_alpha:1},1e3*this.fadeOutDuration,this.fadeEaseType).call(function(){return __awaiter(e,void 0,void 0,function(){return __generator(this,function(t){switch(t.label){case 0:return[4,this.loadNextScene()];case 1:return t.sent(),[2]}})})}).wait(this.delayBeforeFadeInDuration).call(function(){egret.Tween.get(e).to({_alpha:0},1e3*e.fadeOutDuration,e.fadeEaseType).call(function(){e.transitionComplete(),t.SceneManager.stage.removeChild(e._mask)})}),[2]})})},n.prototype.render=function(){this._mask.graphics.clear(),this._mask.graphics.beginFill(this.fadeToColor,this._alpha),this._mask.graphics.drawRect(0,0,t.SceneManager.stage.stageWidth,t.SceneManager.stage.stageHeight),this._mask.graphics.endFill()},n}(t.SceneTransition);t.FadeTransition=e}(es||(es={})),function(t){var e=function(e){function n(n){var i=e.call(this,n)||this;i.duration=1,i.easeType=egret.Ease.quadOut;return i._windEffect=new egret.CustomFilter("attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n}","precision lowp float;\nvarying vec2 vTextureCoord;\nuniform sampler2D uSampler;\nuniform float _progress;\nuniform float _size;\nuniform float _windSegments;\nvoid main(void) {\nvec2 co = floor(vec2(0.0, vTextureCoord.y * _windSegments));\nfloat x = sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453;\nfloat r = x - floor(x);\nfloat m = smoothstep(0.0, -_size, vTextureCoord.x * (1.0 - _size) + _size * r - (_progress * (1.0 + _size)));\nvec4 fg = texture2D(uSampler, vTextureCoord);\ngl_FragColor = mix(fg, vec4(0, 0, 0, 0), m);\n}",{_progress:0,_size:.3,_windSegments:100}),i._mask=new egret.Shape,i._mask.graphics.beginFill(16777215,1),i._mask.graphics.drawRect(0,0,t.SceneManager.stage.stageWidth,t.SceneManager.stage.stageHeight),i._mask.graphics.endFill(),i._mask.filters=[i._windEffect],t.SceneManager.stage.addChild(i._mask),i}return __extends(n,e),Object.defineProperty(n.prototype,"windSegments",{set:function(t){this._windEffect.uniforms._windSegments=t},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"size",{set:function(t){this._windEffect.uniforms._size=t},enumerable:!0,configurable:!0}),n.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(e){switch(e.label){case 0:return this.loadNextScene(),[4,this.tickEffectProgressProperty(this._windEffect,this.duration,this.easeType)];case 1:return e.sent(),this.transitionComplete(),t.SceneManager.stage.removeChild(this._mask),[2]}})})},n}(t.SceneTransition);t.WindTransition=e}(es||(es={})),function(t){var e=function(){function e(){}return e.getPoint=function(e,n,i,r){var o=1-(r=t.MathHelper.clamp01(r));return t.Vector2.add(t.Vector2.add(t.Vector2.multiply(new t.Vector2(o*o),e),t.Vector2.multiply(new t.Vector2(2*o*r),n)),t.Vector2.multiply(new t.Vector2(r*r),i))},e.getFirstDerivative=function(e,n,i,r){return t.Vector2.add(t.Vector2.multiply(new t.Vector2(2*(1-r)),t.Vector2.subtract(n,e)),t.Vector2.multiply(new t.Vector2(2*r),t.Vector2.subtract(i,n)))},e.getFirstDerivativeThree=function(e,n,i,r,o){var s=1-(o=t.MathHelper.clamp01(o));return t.Vector2.add(t.Vector2.add(t.Vector2.multiply(new t.Vector2(3*s*s),t.Vector2.subtract(n,e)),t.Vector2.multiply(new t.Vector2(6*s*o),t.Vector2.subtract(i,n))),t.Vector2.multiply(new t.Vector2(3*o*o),t.Vector2.subtract(r,i)))},e.getPointThree=function(e,n,i,r,o){var s=1-(o=t.MathHelper.clamp01(o));return t.Vector2.add(t.Vector2.add(t.Vector2.add(t.Vector2.multiply(new t.Vector2(s*s*s),e),t.Vector2.multiply(new t.Vector2(3*s*s*o),n)),t.Vector2.multiply(new t.Vector2(3*s*o*o),i)),t.Vector2.multiply(new t.Vector2(o*o*o),r))},e.getOptimizedDrawingPoints=function(e,n,i,r,o){void 0===o&&(o=1);var s=t.ListPool.obtain();return s.push(e),this.recursiveGetOptimizedDrawingPoints(e,n,i,r,s,o),s.push(r),s},e.recursiveGetOptimizedDrawingPoints=function(e,n,i,r,o,s){var a=t.Vector2.divide(t.Vector2.add(e,n),new t.Vector2(2)),c=t.Vector2.divide(t.Vector2.add(n,i),new t.Vector2(2)),h=t.Vector2.divide(t.Vector2.add(i,r),new t.Vector2(2)),u=t.Vector2.divide(t.Vector2.add(a,c),new t.Vector2(2)),l=t.Vector2.divide(t.Vector2.add(c,h),new t.Vector2(2)),p=t.Vector2.divide(t.Vector2.add(u,l),new t.Vector2(2)),d=t.Vector2.subtract(r,e),f=Math.abs((n.x,r.x*d.y-(n.y-r.y)*d.x)),g=Math.abs((i.x-r.x)*d.y-(i.y-r.y)*d.x);(f+g)*(f+g)<s*(d.x*d.x+d.y*d.y)?o.push(p):(this.recursiveGetOptimizedDrawingPoints(e,a,u,p,o,s),this.recursiveGetOptimizedDrawingPoints(p,l,h,r,o,s))},e}();t.Bezier=e}(es||(es={})),function(t){var e=function(){function t(){}return t.isFlagSet=function(t,e){return 0!=(t&e)},t.isUnshiftedFlagSet=function(t,e){return 0!=(t&(e=1<<e))},t.setFlagExclusive=function(t,e){return 1<<e},t.setFlag=function(t,e){return t|1<<e},t.unsetFlag=function(t,e){return t&~(e=1<<e)},t.invertFlags=function(t){return~t},t}();t.Flags=e}(es||(es={})),function(t){var e=function(){function e(){}return e.toDegrees=function(t){return 57.29577951308232*t},e.toRadians=function(t){return.017453292519943295*t},e.map=function(t,e,n,i,r){return i+(t-e)*(r-i)/(n-e)},e.lerp=function(t,e,n){return t+(e-t)*n},e.clamp=function(t,e,n){return t<e?e:t>n?n:t},e.pointOnCirlce=function(n,i,r){var o=e.toRadians(r);return new t.Vector2(Math.cos(o)*o+n.x,Math.sin(o)*o+n.y)},e.isEven=function(t){return t%2==0},e.clamp01=function(t){return t<0?0:t>1?1:t},e.angleBetweenVectors=function(t,e){return Math.atan2(e.y-t.y,e.x-t.x)},e.Epsilon=1e-5,e.Rad2Deg=57.29578,e.Deg2Rad=.0174532924,e}();t.MathHelper=e}(es||(es={})),function(t){var e=function(){function e(t,e,n,i,r,o){this.m11=0,this.m12=0,this.m21=0,this.m22=0,this.m31=0,this.m32=0,this.m11=t||1,this.m12=e||0,this.m21=n||0,this.m22=i||1,this.m31=r||0,this.m32=o||0}return Object.defineProperty(e,"identity",{get:function(){return e._identity},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"translation",{get:function(){return new t.Vector2(this.m31,this.m32)},set:function(t){this.m31=t.x,this.m32=t.y},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"rotation",{get:function(){return Math.atan2(this.m21,this.m11)},set:function(t){var e=Math.cos(t),n=Math.sin(t);this.m11=e,this.m12=n,this.m21=-n,this.m22=e},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"rotationDegrees",{get:function(){return t.MathHelper.toDegrees(this.rotation)},set:function(e){this.rotation=t.MathHelper.toRadians(e)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"scale",{get:function(){return new t.Vector2(this.m11,this.m22)},set:function(t){this.m11=t.x,this.m12=t.y},enumerable:!0,configurable:!0}),e.add=function(t,e){return t.m11+=e.m11,t.m12+=e.m12,t.m21+=e.m21,t.m22+=e.m22,t.m31+=e.m31,t.m32+=e.m32,t},e.divide=function(t,e){return t.m11/=e.m11,t.m12/=e.m12,t.m21/=e.m21,t.m22/=e.m22,t.m31/=e.m31,t.m32/=e.m32,t},e.multiply=function(t,n){var i=new e,r=t.m11*n.m11+t.m12*n.m21,o=t.m11*n.m12+t.m12*n.m22,s=t.m21*n.m11+t.m22*n.m21,a=t.m21*n.m12+t.m22*n.m22,c=t.m31*n.m11+t.m32*n.m21+n.m31,h=t.m31*n.m12+t.m32*n.m22+n.m32;return i.m11=r,i.m12=o,i.m21=s,i.m22=a,i.m31=c,i.m32=h,i},e.multiplyTranslation=function(t,n,i){var r=e.createTranslation(n,i);return e.multiply(t,r)},e.prototype.determinant=function(){return this.m11*this.m22-this.m12*this.m21},e.invert=function(t,n){void 0===n&&(n=new e);var i=1/t.determinant();return n.m11=t.m22*i,n.m12=-t.m12*i,n.m21=-t.m21*i,n.m22=t.m11*i,n.m31=(t.m32*t.m21-t.m31*t.m22)*i,n.m32=-(t.m32*t.m11-t.m31*t.m12)*i,n},e.createTranslation=function(t,n){var i=new e;return i.m11=1,i.m12=0,i.m21=0,i.m22=1,i.m31=t,i.m32=n,i},e.createTranslationVector=function(t){return this.createTranslation(t.x,t.y)},e.createRotation=function(t,n){n=new e;var i=Math.cos(t),r=Math.sin(t);return n.m11=i,n.m12=r,n.m21=-r,n.m22=i,n},e.createScale=function(t,n,i){return void 0===i&&(i=new e),i.m11=t,i.m12=0,i.m21=0,i.m22=n,i.m31=0,i.m32=0,i},e.prototype.toEgretMatrix=function(){return new egret.Matrix(this.m11,this.m12,this.m21,this.m22,this.m31,this.m32)},e._identity=new e(1,0,0,1,0,0),e}();t.Matrix2D=e}(es||(es={})),function(t){var e=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return __extends(n,e),Object.defineProperty(n.prototype,"max",{get:function(){return new t.Vector2(this.right,this.bottom)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"center",{get:function(){return new t.Vector2(this.x+this.width/2,this.y+this.height/2)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"location",{get:function(){return new t.Vector2(this.x,this.y)},set:function(t){this.x=t.x,this.y=t.y},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"size",{get:function(){return new t.Vector2(this.width,this.height)},set:function(t){this.width=t.x,this.height=t.y},enumerable:!0,configurable:!0}),n.prototype.intersects=function(t){return t.left<this.right&&this.left<t.right&&t.top<this.bottom&&this.top<t.bottom},n.prototype.containsRect=function(t){return this.x<=t.x&&t.x<this.x+this.width&&this.y<=t.y&&t.y<this.y+this.height},n.prototype.getHalfSize=function(){return new t.Vector2(.5*this.width,.5*this.height)},n.fromMinMax=function(t,e,i,r){return new n(t,e,i-t,r-e)},n.prototype.getClosestPointOnRectangleBorderToPoint=function(e){var n=t.Vector2.zero,i=new t.Vector2;if(i.x=t.MathHelper.clamp(e.x,this.left,this.right),i.y=t.MathHelper.clamp(e.y,this.top,this.bottom),this.contains(i.x,i.y)){var r=i.x-this.left,o=this.right-i.x,s=i.y-this.top,a=this.bottom-i.y,c=Math.min(r,o,s,a);c==s?(i.y=this.top,n.y=-1):c==a?(i.y=this.bottom,n.y=1):c==r?(i.x=this.left,n.x=-1):(i.x=this.right,n.x=1)}else i.x==this.left&&(n.x=-1),i.x==this.right&&(n.x=1),i.y==this.top&&(n.y=-1),i.y==this.bottom&&(n.y=1);return{res:i,edgeNormal:n}},n.prototype.getClosestPointOnBoundsToOrigin=function(){var e=this.max,n=Math.abs(this.location.x),i=new t.Vector2(this.location.x,0);return Math.abs(e.x)<n&&(n=Math.abs(e.x),i.x=e.x,i.y=0),Math.abs(e.y)<n&&(n=Math.abs(e.y),i.x=0,i.y=e.y),Math.abs(this.location.y)<n&&(n=Math.abs(this.location.y),i.x=0,i.y=this.location.y),i},n.prototype.calculateBounds=function(t,e,n,i,r,o,s){this.x=t.x+e.x-n.x*i.x,this.y=t.y+e.y-n.y*i.y,this.width=o*i.x,this.height=s*i.y},n.prototype.setEgretRect=function(t){return this.x=t.x,this.y=t.y,this.width=t.width,this.height=t.height,this},n.rectEncompassingPoints=function(t){for(var e=Number.POSITIVE_INFINITY,n=Number.POSITIVE_INFINITY,i=Number.NEGATIVE_INFINITY,r=Number.NEGATIVE_INFINITY,o=0;o<t.length;o++){var s=t[o];s.x<e&&(e=s.x),s.x>i&&(i=s.x),s.y<n&&(n=s.y),s.y>r&&(r=s.y)}return this.fromMinMax(e,n,i,r)},n}(egret.Rectangle);t.Rectangle=e}(es||(es={})),function(t){var e=function(){return function(t,e,n){this.x=t,this.y=e,this.z=n}}();t.Vector3=e}(es||(es={})),function(t){var e=function(){function e(t){this._activeTriggerIntersections=[],this._previousTriggerIntersections=[],this._tempTriggerList=[],this._entity=t}return e.prototype.update=function(){for(var e=this._entity.getComponents(t.Collider),n=0;n<e.length;n++){var i=e[n],r=t.Physics.boxcastBroadphase(i.bounds,i.collidesWithLayers);i.bounds=r.rect;for(var o=r.colliders,s=function(e){var n=o[e];if(!i.isTrigger&&!n.isTrigger)return"continue";if(i.overlaps(n)){var r=new t.Pair(i,n);-1==a._activeTriggerIntersections.findIndex(function(t){return t.first==r.first&&t.second==r.second})&&-1==a._previousTriggerIntersections.findIndex(function(t){return t.first==r.first&&t.second==r.second})&&a.notifyTriggerListeners(r,!0),a._activeTriggerIntersections.contains(r)||a._activeTriggerIntersections.push(r)}},a=this,c=0;c<o.length;c++)s(c)}t.ListPool.free(e),this.checkForExitedColliders()},e.prototype.checkForExitedColliders=function(){for(var t=this,e=function(e){var i=n._previousTriggerIntersections.findIndex(function(n){return n.first==t._activeTriggerIntersections[e].first&&n.second==t._activeTriggerIntersections[e].second});-1!=i&&n._previousTriggerIntersections.removeAt(i)},n=this,i=0;i<this._activeTriggerIntersections.length;i++)e(i);for(i=0;i<this._previousTriggerIntersections.length;i++)this.notifyTriggerListeners(this._previousTriggerIntersections[i],!1);this._previousTriggerIntersections.length=0;for(i=0;i<this._activeTriggerIntersections.length;i++)this._previousTriggerIntersections.contains(this._activeTriggerIntersections[i])||this._previousTriggerIntersections.push(this._activeTriggerIntersections[i]);this._activeTriggerIntersections.length=0},e.prototype.notifyTriggerListeners=function(t,e){t.first.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var n=0;n<this._tempTriggerList.length;n++)if(e?this._tempTriggerList[n].onTriggerEnter(t.second,t.first):this._tempTriggerList[n].onTriggerExit(t.second,t.first),this._tempTriggerList.length=0,t.second.entity){t.second.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var i=0;i<this._tempTriggerList.length;i++)e?this._tempTriggerList[i].onTriggerEnter(t.first,t.second):this._tempTriggerList[i].onTriggerExit(t.first,t.second);this._tempTriggerList.length=0}},e}();t.ColliderTriggerHelper=e}(es||(es={})),function(t){var e;!function(t){t[t.center=0]="center",t[t.top=1]="top",t[t.bottom=2]="bottom",t[t.topLeft=9]="topLeft",t[t.topRight=5]="topRight",t[t.left=8]="left",t[t.right=4]="right",t[t.bottomLeft=10]="bottomLeft",t[t.bottomRight=6]="bottomRight"}(e=t.PointSectors||(t.PointSectors={}));var n=function(){function n(){}return n.isLineToLine=function(e,n,i,r){var o=t.Vector2.subtract(n,e),s=t.Vector2.subtract(r,i),a=o.x*s.y-o.y*s.x;if(0==a)return!1;var c=t.Vector2.subtract(i,e),h=(c.x*s.y-c.y*s.x)/a;if(h<0||h>1)return!1;var u=(c.x*o.y-c.y*o.x)/a;return!(u<0||u>1)},n.lineToLineIntersection=function(e,n,i,r){var o=new t.Vector2(0,0),s=t.Vector2.subtract(n,e),a=t.Vector2.subtract(r,i),c=s.x*a.y-s.y*a.x;if(0==c)return o;var h=t.Vector2.subtract(i,e),u=(h.x*a.y-h.y*a.x)/c;if(u<0||u>1)return o;var l=(h.x*s.y-h.y*s.x)/c;return l<0||l>1?o:o=t.Vector2.add(e,new t.Vector2(u*s.x,u*s.y))},n.closestPointOnLine=function(e,n,i){var r=t.Vector2.subtract(n,e),o=t.Vector2.subtract(i,e),s=t.Vector2.dot(o,r)/t.Vector2.dot(r,r);return s=t.MathHelper.clamp(s,0,1),t.Vector2.add(e,new t.Vector2(r.x*s,r.y*s))},n.isCircleToCircle=function(e,n,i,r){return t.Vector2.distanceSquared(e,i)<(n+r)*(n+r)},n.isCircleToLine=function(e,n,i,r){return t.Vector2.distanceSquared(e,this.closestPointOnLine(i,r,e))<n*n},n.isCircleToPoint=function(e,n,i){return t.Vector2.distanceSquared(e,i)<n*n},n.isRectToCircle=function(t,e,n){var i=.5*t.width,r=.5*t.height,o=Math.max(0,Math.max(e.x-t.x)-i),s=Math.max(0,Math.max(e.y-t.y)-r);return o*o+s*s<n*n},n.isRectToLine=function(n,i,r){var o=this.getSector(n.x,n.y,n.width,n.height,i),s=this.getSector(n.x,n.y,n.width,n.height,r);if(o==e.center||s==e.center)return!0;if(0!=(o&s))return!1;var a=o|s,c=void 0,h=void 0;return!(0==(a&e.top)||(c=new t.Vector2(n.x,n.y),h=new t.Vector2(n.x+n.width,n.y),!this.isLineToLine(c,h,i,r)))||(!(0==(a&e.bottom)||(c=new t.Vector2(n.x,n.y+n.height),h=new t.Vector2(n.x+n.width,n.y+n.height),!this.isLineToLine(c,h,i,r)))||(!(0==(a&e.left)||(c=new t.Vector2(n.x,n.y),h=new t.Vector2(n.x,n.y+n.height),!this.isLineToLine(c,h,i,r)))||!(0==(a&e.right)||(c=new t.Vector2(n.x+n.width,n.y),h=new t.Vector2(n.x+n.width,n.y+n.height),!this.isLineToLine(c,h,i,r)))))},n.isRectToPoint=function(t,e,n,i,r){return r.x>=t&&r.y>=e&&r.x<t+n&&r.y<e+i},n.getSector=function(t,n,i,r,o){var s=e.center;return o.x<t?s|=e.left:o.x>=t+i&&(s|=e.right),o.y<n?s|=e.top:o.y>=n+r&&(s|=e.bottom),s},n}();t.Collisions=n}(es||(es={})),function(t){var e=function(){function e(){}return e.reset=function(){this._spatialHash=new t.SpatialHash(this.spatialHashCellSize)},e.clear=function(){this._spatialHash.clear()},e.overlapCircleAll=function(t,e,n,i){return void 0===i&&(i=-1),this._spatialHash.overlapCircle(t,e,n,i)},e.boxcastBroadphase=function(t,e){void 0===e&&(e=this.allLayers);var n=this._spatialHash.aabbBroadphase(t,null,e);return{colliders:n.tempHashSet,rect:n.bounds}},e.boxcastBroadphaseExcludingSelf=function(t,e,n){return void 0===n&&(n=this.allLayers),this._spatialHash.aabbBroadphase(e,t,n)},e.addCollider=function(t){e._spatialHash.register(t)},e.removeCollider=function(t){e._spatialHash.remove(t)},e.updateCollider=function(t){this._spatialHash.remove(t),this._spatialHash.register(t)},e.debugDraw=function(t){this._spatialHash.debugDraw(t,2)},e.spatialHashCellSize=100,e.allLayers=-1,e}();t.Physics=e}(es||(es={})),function(t){var e=function(){return function(){}}();t.Shape=e}(es||(es={})),function(t){var e=function(e){function n(t,n){var i=e.call(this)||this;return i._areEdgeNormalsDirty=!0,i.isUnrotated=!0,i.setPoints(t),i.isBox=n,i}return __extends(n,e),Object.defineProperty(n.prototype,"edgeNormals",{get:function(){return this._areEdgeNormalsDirty&&this.buildEdgeNormals(),this._edgeNormals},enumerable:!0,configurable:!0}),n.prototype.setPoints=function(t){this.points=t,this.recalculateCenterAndEdgeNormals(),this._originalPoints=[];for(var e=0;e<this.points.length;e++)this._originalPoints.push(this.points[e])},n.prototype.recalculateCenterAndEdgeNormals=function(){this._polygonCenter=n.findPolygonCenter(this.points),this._areEdgeNormalsDirty=!0},n.prototype.buildEdgeNormals=function(){var e,n=this.isBox?2:this.points.length;null!=this._edgeNormals&&this._edgeNormals.length==n||(this._edgeNormals=new Array(n));for(var i=0;i<n;i++){var r=this.points[i];e=i+1>=this.points.length?this.points[0]:this.points[i+1];var o=t.Vector2Ext.perpendicular(r,e);o=t.Vector2.normalize(o),this._edgeNormals[i]=o}},n.buildSymmetricalPolygon=function(e,n){for(var i=new Array(e),r=0;r<e;r++){var o=2*Math.PI*(r/e);i[r]=new t.Vector2(Math.cos(o),Math.sin(o)*n)}return i},n.recenterPolygonVerts=function(e){for(var n=this.findPolygonCenter(e),i=0;i<e.length;i++)e[i]=t.Vector2.subtract(e[i],n)},n.findPolygonCenter=function(e){for(var n=0,i=0,r=0;r<e.length;r++)n+=e[r].x,i+=e[r].y;return new t.Vector2(n/e.length,i/e.length)},n.getClosestPointOnPolygonToPoint=function(e,n){for(var i,r=Number.MAX_VALUE,o=new t.Vector2(0,0),s=new t.Vector2(0,0),a=0;a<e.length;a++){var c=a+1;c==e.length&&(c=0);var h=t.ShapeCollisions.closestPointOnLine(e[a],e[c],n);if((i=t.Vector2.distanceSquared(n,h))<r){r=i,s=h;var u=t.Vector2.subtract(e[c],e[a]);o.x=-u.y,o.y=u.x}}return{closestPoint:s,distanceSquared:r,edgeNormal:o=t.Vector2.normalize(o)}},n.prototype.recalculateBounds=function(e){this.center=e.localOffset,e.shouldColliderScaleAndRotateWithTransform&&(this.isUnrotated=0==e.entity.transform.rotation),this.position=t.Vector2.add(e.entity.transform.position,this.center),this.bounds=t.Rectangle.rectEncompassingPoints(this.points),this.bounds.location=t.Vector2.add(this.bounds.location,this.position)},n.prototype.overlaps=function(e){var i;if(e instanceof n)return t.ShapeCollisions.polygonToPolygon(this,e);if(e instanceof t.Circle)return!!(i=t.ShapeCollisions.circleToPolygon(e,this))&&(i.invertResult(),!0);throw new Error("overlaps of Pologon to "+e+" are not supported")},n.prototype.collidesWithShape=function(e){var i=new t.CollisionResult;if(e instanceof n)return t.ShapeCollisions.polygonToPolygon(this,e);if(e instanceof t.Circle)return(i=t.ShapeCollisions.circleToPolygon(e,this))?(i.invertResult(),i):null;throw new Error("overlaps of Polygon to "+e+" are not supported")},n.prototype.containsPoint=function(e){e=t.Vector2.subtract(e,this.position);for(var n=!1,i=0,r=this.points.length-1;i<this.points.length;r=i++)this.points[i].y>e.y!=this.points[r].y>e.y&&e.x<(this.points[r].x-this.points[i].x)*(e.y-this.points[i].y)/(this.points[r].y-this.points[i].y)+this.points[i].x&&(n=!n);return n},n.prototype.pointCollidesWithShape=function(e){return t.ShapeCollisions.pointToPoly(e,this)},n}(t.Shape);t.Polygon=e}(es||(es={})),function(t){var e=function(e){function n(t,i){var r=e.call(this,n.buildBox(t,i),!0)||this;return r.width=t,r.height=i,r}return __extends(n,e),n.buildBox=function(e,n){var i=e/2,r=n/2,o=new Array(4);return o[0]=new t.Vector2(-i,-r),o[1]=new t.Vector2(i,-r),o[2]=new t.Vector2(i,r),o[3]=new t.Vector2(-i,r),o},n.prototype.updateBox=function(e,n){this.width=e,this.height=n;var i=e/2,r=n/2;this.points[0]=new t.Vector2(-i,-r),this.points[1]=new t.Vector2(i,-r),this.points[2]=new t.Vector2(i,r),this.points[3]=new t.Vector2(-i,r);for(var o=0;o<this.points.length;o++)this._originalPoints[o]=this.points[o]},n.prototype.overlaps=function(i){if(this.isUnrotated){if(i instanceof n)return this.bounds.intersects(i.bounds);if(i instanceof t.Circle)return t.Collisions.isRectToCircle(this.bounds,i.position,i.radius)}return e.prototype.overlaps.call(this,i)},n.prototype.collidesWithShape=function(i){return i instanceof n&&i.isUnrotated?t.ShapeCollisions.boxToBox(this,i):e.prototype.collidesWithShape.call(this,i)},n.prototype.containsPoint=function(t){return this.isUnrotated?this.bounds.contains(t.x,t.y):e.prototype.containsPoint.call(this,t)},n}(t.Polygon);t.Box=e}(es||(es={})),function(t){var e=function(e){function n(t){var n=e.call(this)||this;return n.radius=t,n._originalRadius=t,n}return __extends(n,e),n.prototype.recalculateBounds=function(e){if(this.center=e.localOffset,e.shouldColliderScaleAndRotateWithTransform){var n=e.entity.transform.scale,i=1==n.x&&1==n.y,r=Math.max(n.x,n.y);if(this.radius=this._originalRadius*r,0!=e.entity.transform.rotation){var o=Math.atan2(e.localOffset.y,e.localOffset.x)*t.MathHelper.Rad2Deg,s=i?e._localOffsetLength:t.Vector2.multiply(e.localOffset,e.entity.transform.scale).length();this.center=t.MathHelper.pointOnCirlce(t.Vector2.zero,s,e.entity.transform.rotation+o)}}this.position=t.Vector2.add(e.transform.position,this.center),this.bounds=new t.Rectangle(this.position.x-this.radius,this.position.y-this.radius,2*this.radius,2*this.radius)},n.prototype.overlaps=function(e){if(e instanceof t.Box&&e.isUnrotated)return t.Collisions.isRectToCircle(e.bounds,this.position,this.radius);if(e instanceof n)return t.Collisions.isCircleToCircle(this.position,this.radius,e.position,e.radius);if(e instanceof t.Polygon)return t.ShapeCollisions.circleToPolygon(this,e);throw new Error("overlaps of circle to "+e+" are not supported")},n.prototype.collidesWithShape=function(e){if(e instanceof t.Box&&e.isUnrotated)return t.ShapeCollisions.circleToBox(this,e);if(e instanceof n)return t.ShapeCollisions.circleToCircle(this,e);if(e instanceof t.Polygon)return t.ShapeCollisions.circleToPolygon(this,e);throw new Error("Collisions of Circle to "+e+" are not supported")},n.prototype.pointCollidesWithShape=function(e){return t.ShapeCollisions.pointToCircle(e,this)},n}(t.Shape);t.Circle=e}(es||(es={})),function(t){var e=function(){function e(){this.minimumTranslationVector=t.Vector2.zero,this.normal=t.Vector2.zero,this.point=t.Vector2.zero}return e.prototype.invertResult=function(){this.minimumTranslationVector=t.Vector2.negate(this.minimumTranslationVector),this.normal=t.Vector2.negate(this.normal)},e}();t.CollisionResult=e}(es||(es={})),function(t){var e=function(){function e(){}return e.polygonToPolygon=function(e,n){for(var i,r=new t.CollisionResult,o=!0,s=e.edgeNormals,a=n.edgeNormals,c=Number.POSITIVE_INFINITY,h=new t.Vector2,u=t.Vector2.subtract(e.position,n.position),l=0;l<s.length+a.length;l++){i=l<s.length?s[l]:a[l-s.length];var p=0,d=0,f=0,g=0,m=0,y=this.getInterval(i,e,p,f);p=y.min,d=y.max;var _=this.getInterval(i,n,d,g);d=_.min,g=_.max;var v=t.Vector2.dot(u,i);if(p+=v,f+=v,(m=this.intervalDistance(p,f,d,g))>0&&(o=!1),!o)return null;(m=Math.abs(m))<c&&(c=m,h=i,t.Vector2.dot(h,u)<0&&(h=new t.Vector2(-h)))}return r.normal=h,r.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(-h.x,-h.y),new t.Vector2(c)),r},e.intervalDistance=function(t,e,n,i){return t<n?n-e:t-n},e.getInterval=function(e,n,i,r){var o=t.Vector2.dot(n.points[0],e);i=r=o;for(var s=1;s<n.points.length;s++)(o=t.Vector2.dot(n.points[s],e))<i?i=o:o>r&&(r=o);return{min:i,max:r}},e.circleToPolygon=function(e,n){var i=new t.CollisionResult,r=t.Vector2.subtract(e.position,n.position),o=t.Polygon.getClosestPointOnPolygonToPoint(n.points,r),s=o.closestPoint,a=o.distanceSquared;i.normal=o.edgeNormal;var c,h=n.containsPoint(e.position);if(a>e.radius*e.radius&&!h)return null;if(h)c=t.Vector2.multiply(i.normal,new t.Vector2(Math.sqrt(a)-e.radius));else if(0==a)c=t.Vector2.multiply(i.normal,new t.Vector2(e.radius));else{var u=Math.sqrt(a);c=t.Vector2.multiply(new t.Vector2(-t.Vector2.subtract(r,s)),new t.Vector2((e.radius-a)/u))}return i.minimumTranslationVector=c,i.point=t.Vector2.add(s,n.position),i},e.circleToBox=function(e,n){var i=new t.CollisionResult,r=n.bounds.getClosestPointOnRectangleBorderToPoint(e.position).res;if(n.containsPoint(e.position)){i.point=r;var o=t.Vector2.add(r,t.Vector2.subtract(i.normal,new t.Vector2(e.radius)));return i.minimumTranslationVector=t.Vector2.subtract(e.position,o),i}var s=t.Vector2.distanceSquared(r,e.position);if(0==s)i.minimumTranslationVector=t.Vector2.multiply(i.normal,new t.Vector2(e.radius));else if(s<=e.radius*e.radius){i.normal=t.Vector2.subtract(e.position,r);var a=i.normal.length()-e.radius;return i.normal=t.Vector2Ext.normalize(i.normal),i.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(a),i.normal),i}return null},e.pointToCircle=function(e,n){var i=new t.CollisionResult,r=t.Vector2.distanceSquared(e,n.position),o=1+n.radius;if(r<o*o){i.normal=t.Vector2.normalize(t.Vector2.subtract(e,n.position));var s=o-Math.sqrt(r);return i.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(-s,-s),i.normal),i.point=t.Vector2.add(n.position,t.Vector2.multiply(i.normal,new t.Vector2(n.radius,n.radius))),i}return null},e.closestPointOnLine=function(e,n,i){var r=t.Vector2.subtract(n,e),o=t.Vector2.subtract(i,e),s=t.Vector2.dot(o,r)/t.Vector2.dot(r,r);return s=t.MathHelper.clamp(s,0,1),t.Vector2.add(e,t.Vector2.multiply(r,new t.Vector2(s,s)))},e.pointToPoly=function(e,n){var i=new t.CollisionResult;if(n.containsPoint(e)){var r,o=t.Polygon.getClosestPointOnPolygonToPoint(n.points,t.Vector2.subtract(e,n.position)),s=o.closestPoint;return r=o.distanceSquared,i.normal=o.edgeNormal,i.minimumTranslationVector=t.Vector2.multiply(i.normal,new t.Vector2(Math.sqrt(r),Math.sqrt(r))),i.point=t.Vector2.add(s,n.position),i}return null},e.circleToCircle=function(e,n){var i=new t.CollisionResult,r=t.Vector2.distanceSquared(e.position,n.position),o=e.radius+n.radius;if(r<o*o){i.normal=t.Vector2.normalize(t.Vector2.subtract(e.position,n.position));var s=o-Math.sqrt(r);return i.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(-s),i.normal),i.point=t.Vector2.add(n.position,t.Vector2.multiply(i.normal,new t.Vector2(n.radius))),i}return null},e.boxToBox=function(e,n){var i=new t.CollisionResult,r=this.minkowskiDifference(e,n);return r.contains(0,0)?(i.minimumTranslationVector=r.getClosestPointOnBoundsToOrigin(),0==i.minimumTranslationVector.x&&0==i.minimumTranslationVector.y?null:(i.normal=new t.Vector2(-i.minimumTranslationVector.x,-i.minimumTranslationVector.y),i.normal.normalize(),i)):null},e.minkowskiDifference=function(e,n){var i=t.Vector2.subtract(e.position,t.Vector2.add(e.bounds.location,t.Vector2.divide(e.bounds.size,new t.Vector2(2)))),r=t.Vector2.subtract(t.Vector2.add(e.bounds.location,i),n.bounds.max),o=t.Vector2.add(e.bounds.size,n.bounds.size);return new t.Rectangle(r.x,r.y,o.x,o.y)},e}();t.ShapeCollisions=e}(es||(es={})),function(t){var e=function(){function e(e){void 0===e&&(e=100),this.gridBounds=new t.Rectangle,this._overlapTestCircle=new t.Circle(0),this._cellDict=new n,this._tempHashSet=[],this._cellSize=e,this._inverseCellSize=1/this._cellSize,this._raycastParser=new i}return e.prototype.cellCoords=function(e,n){return new t.Vector2(Math.floor(e*this._inverseCellSize),Math.floor(n*this._inverseCellSize))},e.prototype.cellAtPosition=function(t,e,n){void 0===n&&(n=!1);var i=this._cellDict.tryGetValue(t,e);return i||n&&(i=[],this._cellDict.add(t,e,i)),i},e.prototype.register=function(e){var n=e.bounds;e.registeredPhysicsBounds=n;var i=this.cellCoords(n.x,n.y),r=this.cellCoords(n.right,n.bottom);this.gridBounds.contains(i.x,i.y)||(this.gridBounds=t.RectangleExt.union(this.gridBounds,i)),this.gridBounds.contains(r.x,r.y)||(this.gridBounds=t.RectangleExt.union(this.gridBounds,r));for(var o=i.x;o<=r.x;o++)for(var s=i.y;s<=r.y;s++){var a=this.cellAtPosition(o,s,!0);-1==a.indexOf(e)&&a.push(e)}},e.prototype.remove=function(t){for(var e=t.registeredPhysicsBounds,n=this.cellCoords(e.x,e.y),i=this.cellCoords(e.right,e.bottom),r=n.x;r<=i.x;r++)for(var o=n.y;o<=i.y;o++){var s=this.cellAtPosition(r,o);s?s.remove(t):console.error("removing Collider ["+t+"] from a cell that it is not present in")}},e.prototype.removeWithBruteForce=function(t){this._cellDict.remove(t)},e.prototype.clear=function(){this._cellDict.clear()},e.prototype.debugDraw=function(t,e){void 0===e&&(e=1);for(var n=this.gridBounds.x;n<=this.gridBounds.right;n++)for(var i=this.gridBounds.y;i<=this.gridBounds.bottom;i++){var r=this.cellAtPosition(n,i);r&&r.length>0&&this.debugDrawCellDetails(n,i,r.length,t,e)}},e.prototype.debugDrawCellDetails=function(t,e,n,i,r){void 0===i&&(i=.5),void 0===r&&(r=1)},e.prototype.aabbBroadphase=function(e,n,i){this._tempHashSet.length=0;for(var r=this.cellCoords(e.x,e.y),o=this.cellCoords(e.right,e.bottom),s=r.x;s<=o.x;s++)for(var a=r.y;a<=o.y;a++){var c=this.cellAtPosition(s,a);if(c)for(var h=0;h<c.length;h++){var u=c[h];u!=n&&t.Flags.isFlagSet(i,u.physicsLayer)&&(e.intersects(u.bounds)&&-1==this._tempHashSet.indexOf(u)&&this._tempHashSet.push(u))}}return{tempHashSet:this._tempHashSet,bounds:e}},e.prototype.overlapCircle=function(e,n,i,r){var o=new t.Rectangle(e.x-n,e.y-n,2*n,2*n);this._overlapTestCircle.radius=n,this._overlapTestCircle.position=e;var s=0,a=this.aabbBroadphase(o,null,r);o=a.bounds;for(var c=a.tempHashSet,h=0;h<c.length;h++){var u=c[h];if(u instanceof t.BoxCollider)i[s]=u,s++;else if(u instanceof t.CircleCollider)u.shape.overlaps(this._overlapTestCircle)&&(i[s]=u,s++);else{if(!(u instanceof t.PolygonCollider))throw new Error("overlapCircle against this collider type is not implemented!");u.shape.overlaps(this._overlapTestCircle)&&(i[s]=u,s++)}if(s==i.length)return s}return s},e}();t.SpatialHash=e;var n=function(){function t(){this._store=new Map}return t.prototype.getKey=function(t,e){return Long.fromNumber(t).shiftLeft(32).or(Long.fromNumber(e,!1)).toString()},t.prototype.add=function(t,e,n){this._store.set(this.getKey(t,e),n)},t.prototype.remove=function(t){this._store.forEach(function(e){e.contains(t)&&e.remove(t)})},t.prototype.tryGetValue=function(t,e){return this._store.get(this.getKey(t,e))},t.prototype.clear=function(){this._store.clear()},t}();t.NumberDictionary=n;var i=function(){return function(){}}();t.RaycastResultParser=i}(es||(es={}));var ArrayUtils=function(){function t(){}return t.bubbleSort=function(t){for(var e=!1,n=0;n<t.length;n++){e=!1;for(var i=t.length-1;i>n;i--)if(t[i]<t[i-1]){var r=t[i];t[i]=t[i-1],t[i-1]=r,e=!0}if(!e)break}},t.insertionSort=function(t){for(var e=t.length,n=1;n<e;n++){for(var i=t[n],r=n;r>0&&t[r-1]>i;r--)t[r]=t[r-1];t[r]=i}},t.binarySearch=function(t,e){for(var n=0,i=t.length,r=n+i>>1;n<i;)e<=t[r]?i=r:e>=t[r]&&(n=r+1),r=n+i>>1;return t[n]==e?n:-1},t.findElementIndex=function(t,e){for(var n=t.length,i=0;i<n;++i)if(t[i]==e)return i;return null},t.getMaxElementIndex=function(t){for(var e=0,n=t.length,i=1;i<n;i++)t[i]>t[e]&&(e=i);return e},t.getMinElementIndex=function(t){for(var e=0,n=t.length,i=1;i<n;i++)t[i]<t[e]&&(e=i);return e},t.getUniqueAry=function(t){for(var e=[],n=[],i=t.length,r=0;r<i;++r){var o=t[r];-1==e.indexOf(o)&&e.push(o)}for(r=(i=e.length)-1;r>=0;--r)n.unshift(e[r]);return n},t.getDifferAry=function(t,e){t=this.getUniqueAry(t),e=this.getUniqueAry(e);for(var n=t.concat(e),i=new Object,r=[],o=n.length,s=0;s<o;++s)i[n[s]]?i[n[s]]instanceof Object&&i[n[s]].count++:(i[n[s]]=new Object,i[n[s]].count=0,i[n[s]].key=n[s],i[n[s]].count++);for(var a in i)2!=i[a].count&&r.unshift(i[a].key);return r},t.swap=function(t,e,n){var i=t[e];t[e]=t[n],t[n]=i},t.clearList=function(t){if(t)for(var e=t.length-1;e>=0;e-=1)t.splice(e,1)},t.cloneList=function(t){return t?t.slice(0,t.length):null},t.equals=function(t,e){if(t==e)return!0;var n=t.length;if(n!=e.length)return!1;for(;n--;)if(t[n]!=e[n])return!1;return!0},t.insert=function(t,e,n){if(!t)return null;var i=t.length;if(e>i&&(e=i),e<0&&(e=0),e==i)t.push(n);else if(0==e)t.unshift(n);else{for(var r=i-1;r>=e;r-=1)t[r+1]=t[r];t[e]=n}return n},t}(),Base64Utils=function(){function t(){}return t._utf8_encode=function(t){t=t.replace(/\r\n/g,"\n");for(var e="",n=0;n<t.length;n++){var i=t.charCodeAt(n);i<128?e+=String.fromCharCode(i):i>127&&i<2048?(e+=String.fromCharCode(i>>6|192),e+=String.fromCharCode(63&i|128)):(e+=String.fromCharCode(i>>12|224),e+=String.fromCharCode(i>>6&63|128),e+=String.fromCharCode(63&i|128))}return e},t.decode=function(t,e){void 0===e&&(e=!0);var n,i,r,o,s,a,c="",h=0;for(t=(t=this.getConfKey(t)).replace(/[^A-Za-z0-9\+\/\=]/g,"");h<t.length;)n=this._keyAll.indexOf(t.charAt(h++))<<2|(o=this._keyAll.indexOf(t.charAt(h++)))>>4,i=(15&o)<<4|(s=this._keyAll.indexOf(t.charAt(h++)))>>2,r=(3&s)<<6|(a=this._keyAll.indexOf(t.charAt(h++))),c+=String.fromCharCode(n),64!=s&&(0==i?e&&(c+=String.fromCharCode(i)):c+=String.fromCharCode(i)),64!=a&&(0==r?e&&(c+=String.fromCharCode(r)):c+=String.fromCharCode(r));return c=this._utf8_decode(c)},t._utf8_decode=function(t){for(var e="",n=0,i=0,r=0,o=0;n<t.length;)(i=t.charCodeAt(n))<128?(e+=String.fromCharCode(i),n++):i>191&&i<224?(r=t.charCodeAt(n+1),e+=String.fromCharCode((31&i)<<6|63&r),n+=2):(r=t.charCodeAt(n+1),o=t.charCodeAt(n+2),e+=String.fromCharCode((15&i)<<12|(63&r)<<6|63&o),n+=3);return e},t.getConfKey=function(t){return t.slice(1,t.length)},t._keyNum="0123456789+/",t._keyStr="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",t._keyAll=t._keyNum+t._keyStr,t.encode=function(t){var e,n,i,r,o,s,a,c="",h=0;for(t=this._utf8_encode(t);h<t.length;)r=(e=t.charCodeAt(h++))>>2,o=(3&e)<<4|(n=t.charCodeAt(h++))>>4,s=(15&n)<<2|(i=t.charCodeAt(h++))>>6,a=63&i,isNaN(n)?s=a=64:isNaN(i)&&(a=64),c=c+this._keyAll.charAt(r)+this._keyAll.charAt(o)+this._keyAll.charAt(s)+this._keyAll.charAt(a);return this._keyStr.charAt(Math.floor(Math.random()*this._keyStr.length))+c},t}();!function(t){var e=function(){function t(){this.loadedAssets=new Map}return t.prototype.loadRes=function(t,e){var n=this;return void 0===e&&(e=!0),new Promise(function(i,r){var o=n.loadedAssets.get(t);o?i(o):e?RES.getResAsync(t).then(function(e){n.loadedAssets.set(t,e),i(e)}).catch(function(e){console.error("资源加载错误:",t,e),r(e)}):RES.getResByUrl(t).then(function(e){n.loadedAssets.set(t,e),i(e)}).catch(function(e){console.error("资源加载错误:",t,e),r(e)})})},t.prototype.dispose=function(){this.loadedAssets.forEach(function(t){t.dispose()}),this.loadedAssets.clear()},t}();t.ContentManager=e}(es||(es={})),function(t){var e=function(){function e(){}return e.drawLine=function(e,n,i,r,o){void 0===o&&(o=1),this.drawLineAngle(e,n,t.MathHelper.angleBetweenVectors(n,i),t.Vector2.distance(n,i),r,o)},e.drawLineAngle=function(t,e,n,i,r,o){void 0===o&&(o=1),t.graphics.beginFill(r),t.graphics.drawRect(e.x,e.y,1,1),t.graphics.endFill(),t.scaleX=i,t.scaleY=o,t.$anchorOffsetX=0,t.$anchorOffsetY=0,t.rotation=n},e.drawHollowRect=function(t,e,n,i){void 0===i&&(i=1),this.drawHollowRectR(t,e.x,e.y,e.width,e.height,n,i)},e.drawHollowRectR=function(e,n,i,r,o,s,a){void 0===a&&(a=1);var c=new t.Vector2(n,i).round(),h=new t.Vector2(n+r,i).round(),u=new t.Vector2(n+r,i+o).round(),l=new t.Vector2(n,i+o).round();this.drawLine(e,c,h,s,a),this.drawLine(e,h,u,s,a),this.drawLine(e,u,l,s,a),this.drawLine(e,l,c,s,a)},e.drawPixel=function(e,n,i,r){void 0===r&&(r=1);var o=new t.Rectangle(n.x,n.y,r,r);1!=r&&(o.x-=.5*r,o.y-=.5*r),e.graphics.beginFill(i),e.graphics.drawRect(o.x,o.y,o.width,o.height),e.graphics.endFill()},e.getColorMatrix=function(t){var e=[1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0];return e[0]=Math.floor(t/256/256)/255,e[6]=Math.floor(t/256%256)/255,e[12]=t%256/255,new egret.ColorMatrixFilter(e)},e}();t.DrawUtils=e}(es||(es={})),function(t){var e=function(){return function(t,e){this.func=t,this.context=e}}();t.FuncPack=e;var n=function(){function t(){this._messageTable=new Map}return t.prototype.addObserver=function(t,n,i){var r=this._messageTable.get(t);r||(r=[],this._messageTable.set(t,r)),r.contains(n)&&console.warn("您试图添加相同的观察者两次"),r.push(new e(n,i))},t.prototype.removeObserver=function(t,e){var n=this._messageTable.get(t),i=n.findIndex(function(t){return t.func==e});-1!=i&&n.removeAt(i)},t.prototype.emit=function(t,e){var n=this._messageTable.get(t);if(n)for(var i=n.length-1;i>=0;i--)n[i].func.call(n[i].context,e)},t}();t.Emitter=n}(es||(es={})),function(t){var e=function(){function t(){}return Object.defineProperty(t.prototype,"enabled",{get:function(){return this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),t.prototype.setEnabled=function(t){this._enabled!=t&&(this._enabled=t,this._enabled?this.onEnabled():this.onDisabled())},t.prototype.onEnabled=function(){},t.prototype.onDisabled=function(){},t.prototype.update=function(){},t.registerGlobalManager=function(t){this.globalManagers.push(t),t.enabled=!0},t.unregisterGlobalManager=function(t){this.globalManagers.remove(t),t.enabled=!1},t.getGlobalManager=function(t){for(var e=0;e<this.globalManagers.length;e++)if(this.globalManagers[e]instanceof t)return this.globalManagers[e];return null},t.globalManagers=[],t}();t.GlobalManager=e}(es||(es={})),function(t){var e=function(){function e(){this.x=0,this.y=0,this.touchPoint=-1,this.touchDown=!1}return Object.defineProperty(e.prototype,"position",{get:function(){return new t.Vector2(this.x,this.y)},enumerable:!0,configurable:!0}),e.prototype.reset=function(){this.x=0,this.y=0,this.touchDown=!1,this.touchPoint=-1},e}();t.TouchState=e;var n=function(){function n(){}return Object.defineProperty(n,"touchPosition",{get:function(){return this._gameTouchs[0]?this._gameTouchs[0].position:t.Vector2.zero},enumerable:!0,configurable:!0}),Object.defineProperty(n,"maxSupportedTouch",{get:function(){return this._stage.maxTouches},set:function(t){this._stage.maxTouches=t,this.initTouchCache()},enumerable:!0,configurable:!0}),Object.defineProperty(n,"resolutionScale",{get:function(){return this._resolutionScale},enumerable:!0,configurable:!0}),Object.defineProperty(n,"totalTouchCount",{get:function(){return this._totalTouchCount},enumerable:!0,configurable:!0}),Object.defineProperty(n,"gameTouchs",{get:function(){return this._gameTouchs},enumerable:!0,configurable:!0}),Object.defineProperty(n,"touchPositionDelta",{get:function(){var e=t.Vector2.subtract(this.touchPosition,this._previousTouchState.position);return e.length()>0&&this.setpreviousTouchState(this._gameTouchs[0]),e},enumerable:!0,configurable:!0}),n.initialize=function(t){this._init||(this._init=!0,this._stage=t,this._stage.addEventListener(egret.TouchEvent.TOUCH_BEGIN,this.touchBegin,this),this._stage.addEventListener(egret.TouchEvent.TOUCH_MOVE,this.touchMove,this),this._stage.addEventListener(egret.TouchEvent.TOUCH_END,this.touchEnd,this),this._stage.addEventListener(egret.TouchEvent.TOUCH_CANCEL,this.touchEnd,this),this._stage.addEventListener(egret.TouchEvent.TOUCH_RELEASE_OUTSIDE,this.touchEnd,this),this.initTouchCache())},n.initTouchCache=function(){this._totalTouchCount=0,this._touchIndex=0,this._gameTouchs.length=0;for(var t=0;t<this.maxSupportedTouch;t++)this._gameTouchs.push(new e)},n.touchBegin=function(t){this._touchIndex<this.maxSupportedTouch&&(this._gameTouchs[this._touchIndex].touchPoint=t.touchPointID,this._gameTouchs[this._touchIndex].touchDown=t.touchDown,this._gameTouchs[this._touchIndex].x=t.stageX,this._gameTouchs[this._touchIndex].y=t.stageY,0==this._touchIndex&&this.setpreviousTouchState(this._gameTouchs[0]),this._touchIndex++,this._totalTouchCount++)},n.touchMove=function(t){t.touchPointID==this._gameTouchs[0].touchPoint&&this.setpreviousTouchState(this._gameTouchs[0]);var e=this._gameTouchs.findIndex(function(e){return e.touchPoint==t.touchPointID});if(-1!=e){var n=this._gameTouchs[e];n.x=t.stageX,n.y=t.stageY}},n.touchEnd=function(t){var e=this._gameTouchs.findIndex(function(e){return e.touchPoint==t.touchPointID});-1!=e&&(this._gameTouchs[e].reset(),0==e&&this._previousTouchState.reset(),this._totalTouchCount--,0==this.totalTouchCount&&(this._touchIndex=0))},n.setpreviousTouchState=function(t){this._previousTouchState=new e,this._previousTouchState.x=t.position.x,this._previousTouchState.y=t.position.y,this._previousTouchState.touchPoint=t.touchPoint,this._previousTouchState.touchDown=t.touchDown},n.scaledPosition=function(e){var n=new t.Vector2(e.x-this._resolutionOffset.x,e.y-this._resolutionOffset.y);return t.Vector2.multiply(n,this.resolutionScale)},n._init=!1,n._previousTouchState=new e,n._gameTouchs=[],n._resolutionOffset=new t.Vector2,n._resolutionScale=t.Vector2.one,n._touchIndex=0,n._totalTouchCount=0,n}();t.Input=n}(es||(es={}));var KeyboardUtils=function(){function t(){}return t.init=function(){this.keyDownDict={},this.keyUpDict={},document.addEventListener("keydown",this.onKeyDonwHander),document.addEventListener("keyup",this.onKeyUpHander)},t.onKeyDonwHander=function(t){if(this.keyDownDict){var e=this.keyCodeToString(t.keyCode),n=this.keyDownDict[e];if(n){var i=n.fun,r=n.thisObj,o=n.args;i.apply(r,o)}}},t.onKeyUpHander=function(t){if(this.keyUpDict){var e=this.keyCodeToString(t.keyCode),n=this.keyUpDict[e];if(n){var i=n.fun,r=n.thisObj,o=n.args;i.apply(r,o)}}},t.registerKey=function(t,e,n,i){void 0===i&&(i=0);for(var r=[],o=4;o<arguments.length;o++)r[o-4]=arguments[o];(i?this.keyUpDict:this.keyDownDict)[t]={fun:e,args:r,thisObj:n}},t.unregisterKey=function(t,e){void 0===e&&(e=0),delete(e?this.keyUpDict:this.keyDownDict)[t]},t.keyCodeToString=function(t){switch(t){case 8:return this.BACK_SPACE;case 9:return this.TAB;case 13:return this.ENTER;case 16:return this.SHIFT;case 17:return this.CTRL;case 19:return this.PAUSE_BREAK;case 20:return this.CAPS_LOCK;case 27:return this.ESC;case 32:return this.SPACE;case 33:return this.PAGE_UP;case 34:return this.PAGE_DOWN;case 35:return this.END;case 36:return this.HOME;case 37:return this.LEFT;case 38:return this.UP;case 39:return this.RIGHT;case 40:return this.DOWN;case 45:return this.INSERT;case 46:return this.DELETE;case 91:return this.WINDOWS;case 112:return this.F1;case 113:return this.F2;case 114:return this.F3;case 115:return this.F4;case 116:return this.F5;case 117:return this.F6;case 118:return this.F7;case 119:return this.F8;case 120:return this.F9;case 122:return this.F11;case 123:return this.F12;case 144:return this.NUM_LOCK;case 145:return this.SCROLL_LOCK;default:return String.fromCharCode(t)}},t.destroy=function(){this.keyDownDict=null,this.keyUpDict=null,document.removeEventListener("keydown",this.onKeyDonwHander),document.removeEventListener("keyup",this.onKeyUpHander)},t.TYPE_KEY_DOWN=0,t.TYPE_KEY_UP=1,t.A="A",t.B="B",t.C="C",t.D="D",t.E="E",t.F="F",t.G="G",t.H="H",t.I="I",t.J="J",t.K="K",t.L="L",t.M="M",t.N="N",t.O="O",t.P="P",t.Q="Q",t.R="R",t.S="S",t.T="T",t.U="U",t.V="V",t.W="W",t.X="X",t.Y="Y",t.Z="Z",t.ESC="Esc",t.F1="F1",t.F2="F2",t.F3="F3",t.F4="F4",t.F5="F5",t.F6="F6",t.F7="F7",t.F8="F8",t.F9="F9",t.F10="F10",t.F11="F11",t.F12="F12",t.NUM_1="1",t.NUM_2="2",t.NUM_3="3",t.NUM_4="4",t.NUM_5="5",t.NUM_6="6",t.NUM_7="7",t.NUM_8="8",t.NUM_9="9",t.NUM_0="0",t.TAB="Tab",t.CTRL="Ctrl",t.ALT="Alt",t.SHIFT="Shift",t.CAPS_LOCK="Caps Lock",t.ENTER="Enter",t.SPACE="Space",t.BACK_SPACE="Back Space",t.INSERT="Insert",t.DELETE="Page Down",t.HOME="Home",t.END="Page Down",t.PAGE_UP="Page Up",t.PAGE_DOWN="Page Down",t.LEFT="Left",t.RIGHT="Right",t.UP="Up",t.DOWN="Down",t.PAUSE_BREAK="Pause Break",t.NUM_LOCK="Num Lock",t.SCROLL_LOCK="Scroll Lock",t.WINDOWS="Windows",t}();!function(t){var e=function(){function t(){}return t.warmCache=function(t){if((t-=this._objectQueue.length)>0)for(var e=0;e<t;e++)this._objectQueue.unshift([])},t.trimCache=function(t){for(;t>this._objectQueue.length;)this._objectQueue.shift()},t.clearCache=function(){this._objectQueue.length=0},t.obtain=function(){return this._objectQueue.length>0?this._objectQueue.shift():[]},t.free=function(t){this._objectQueue.unshift(t),t.length=0},t._objectQueue=[],t}();t.ListPool=e}(es||(es={}));var THREAD_ID=Math.floor(1e3*Math.random())+"-"+Date.now(),setItem=egret.localStorage.setItem.bind(localStorage),getItem=egret.localStorage.getItem.bind(localStorage),removeItem=egret.localStorage.removeItem.bind(localStorage),nextTick=function(t){setTimeout(t,0)},LockUtils=function(){function t(t){this._keyX="mutex_key_"+t+"_X",this._keyY="mutex_key_"+t+"_Y"}return t.prototype.lock=function(){var t=this;return new Promise(function(e,n){var i=function(){setItem(t._keyX,THREAD_ID),null===!getItem(t._keyY)&&nextTick(i),setItem(t._keyY,THREAD_ID),getItem(t._keyX)!==THREAD_ID?setTimeout(function(){getItem(t._keyY)===THREAD_ID?(e(),removeItem(t._keyY)):nextTick(i)},10):(e(),removeItem(t._keyY))};i()})},t}();!function(t){var e=function(){function t(t,e){this.first=t,this.second=e}return t.prototype.clear=function(){this.first=this.second=null},t.prototype.equals=function(t){return this.first==t.first&&this.second==t.second},t}();t.Pair=e}(es||(es={}));var RandomUtils=function(){function t(){}return t.randrange=function(t,e,n){if(void 0===n&&(n=1),0==n)throw new Error("step 不能为 0");var i=e-t;if(0==i)throw new Error("没有可用的范围("+t+","+e+")");i<0&&(i=t-e);var r=Math.floor((i+n-1)/n);return Math.floor(this.random()*r)*n+Math.min(t,e)},t.randint=function(t,e){return(t=Math.floor(t))>(e=Math.floor(e))?t++:e++,this.randrange(t,e)},t.randnum=function(t,e){return this.random()*(e-t)+t},t.shuffle=function(t){return t.sort(this._randomCompare),t},t._randomCompare=function(t,e){return this.random()>.5?1:-1},t.choice=function(t){if(!t.hasOwnProperty("length"))throw new Error("无法对此对象执行此操作");var e=Math.floor(this.random()*t.length);return t instanceof String?String(t).charAt(e):t[e]},t.sample=function(t,e){var n=t.length;if(e<=0||n<e)throw new Error("采样数量不够");for(var i=[],r=[],o=0;o<e;o++){for(var s=Math.floor(this.random()*n);r.indexOf(s)>=0;)s=Math.floor(this.random()*n);i.push(t[s]),r.push(s)}return i},t.random=function(){return Math.random()},t.boolean=function(t){return void 0===t&&(t=.5),this.random()<t},t}();!function(t){var e=function(){function e(){}return e.union=function(e,n){var i=new t.Rectangle(n.x,n.y,0,0),r=new t.Rectangle;return r.x=Math.min(e.x,i.x),r.y=Math.min(e.y,i.y),r.width=Math.max(e.right,i.right)-r.x,r.height=Math.max(e.bottom,r.bottom)-r.y,r},e}();t.RectangleExt=e}(es||(es={})),function(t){var e=function(){function e(){this.triangleIndices=[],this._triPrev=new Array(12),this._triNext=new Array(12)}return e.prototype.triangulate=function(n,i){void 0===i&&(i=!0);var r=n.length;this.initialize(r);for(var o=0,s=0;r>3&&o<500;){o++;var a=!0,c=n[this._triPrev[s]],h=n[s],u=n[this._triNext[s]];if(t.Vector2Ext.isTriangleCCW(c,h,u)){var l=this._triNext[this._triNext[s]];do{if(e.testPointTriangle(n[l],c,h,u)){a=!1;break}l=this._triNext[l]}while(l!=this._triPrev[s])}else a=!1;a?(this.triangleIndices.push(this._triPrev[s]),this.triangleIndices.push(s),this.triangleIndices.push(this._triNext[s]),this._triNext[this._triPrev[s]]=this._triNext[s],this._triPrev[this._triNext[s]]=this._triPrev[s],r--,s=this._triPrev[s]):s=this._triNext[s]}this.triangleIndices.push(this._triPrev[s]),this.triangleIndices.push(s),this.triangleIndices.push(this._triNext[s]),i||this.triangleIndices.reverse()},e.prototype.initialize=function(t){this.triangleIndices.length=0,this._triNext.length<t&&(this._triNext.reverse(),this._triNext=new Array(Math.max(2*this._triNext.length,t))),this._triPrev.length<t&&(this._triPrev.reverse(),this._triPrev=new Array(Math.max(2*this._triPrev.length,t)));for(var e=0;e<t;e++)this._triPrev[e]=e-1,this._triNext[e]=e+1;this._triPrev[0]=t-1,this._triNext[t-1]=0},e.testPointTriangle=function(e,n,i,r){return!(t.Vector2Ext.cross(t.Vector2.subtract(e,n),t.Vector2.subtract(i,n))<0)&&(!(t.Vector2Ext.cross(t.Vector2.subtract(e,i),t.Vector2.subtract(r,i))<0)&&!(t.Vector2Ext.cross(t.Vector2.subtract(e,r),t.Vector2.subtract(n,r))<0))},e}();t.Triangulator=e}(es||(es={})),function(t){var e=function(){function e(){}return e.isTriangleCCW=function(e,n,i){return this.cross(t.Vector2.subtract(n,e),t.Vector2.subtract(i,n))<0},e.cross=function(t,e){return t.y*e.x-t.x*e.y},e.perpendicular=function(e,n){return new t.Vector2(-1*(n.y-e.y),n.x-e.x)},e.normalize=function(e){var n=Math.sqrt(e.x*e.x+e.y*e.y);return n>t.MathHelper.Epsilon?e=t.Vector2.divide(e,new t.Vector2(n)):e.x=e.y=0,e},e.transformA=function(t,e,n,i,r,o){for(var s=0;s<o;s++){var a=t[e+s],c=i[r+s];c.x=a.x*n.m11+a.y*n.m21+n.m31,c.y=a.x*n.m12+a.y*n.m22+n.m32,i[r+s]=c}},e.transformR=function(e,n){var i=e.x*n.m11+e.y*n.m21+n.m31,r=e.x*n.m12+e.y*n.m22+n.m32;return new t.Vector2(i,r)},e.transform=function(t,e,n){this.transformA(t,0,e,n,0,t.length)},e.round=function(e){return new t.Vector2(Math.round(e.x),Math.round(e.y))},e}();t.Vector2Ext=e}(es||(es={}));var stopwatch,es,WebGLUtils=function(){function t(){}return t.getContext=function(){return document.getElementsByTagName("canvas")[0].getContext("2d")},t}();!function(t){var e,n=function(){function n(){this.clientArea=new t.Rectangle(0,0,t.SceneManager.stage.stageWidth,t.SceneManager.stage.stageHeight),this.safeArea=this.clientArea}return n.prototype.place=function(n,i,r,o){var s=new t.Rectangle(0,0,n.x,n.y);return 0!=(o&e.left)?s.x=this.clientArea.x+this.clientArea.width*i:0!=(o&e.right)?s.x=this.clientArea.x+this.clientArea.width*(1-i)-s.width:0!=(o&e.horizontalCenter)&&(s.x=this.clientArea.x+(this.clientArea.width-s.width)/2+i*this.clientArea.width),0!=(o&e.top)?s.y=this.clientArea.y+this.clientArea.height*r:0!=(o&e.bottom)?s.y=this.clientArea.y+this.clientArea.height*(1-r)-s.height:0!=(o&e.verticalCenter)&&(s.y=this.clientArea.y+(this.clientArea.height-s.height)/2+r*this.clientArea.height),s.left<this.safeArea.left&&(s.x=this.safeArea.left),s.right>this.safeArea.right&&(s.x=this.safeArea.right-s.width),s.top<this.safeArea.top&&(s.y=this.safeArea.top),s.bottom>this.safeArea.bottom&&(s.y=this.safeArea.bottom-s.height),s},n}();t.Layout=n,function(t){t[t.none=0]="none",t[t.left=1]="left",t[t.right=2]="right",t[t.horizontalCenter=4]="horizontalCenter",t[t.top=8]="top",t[t.bottom=16]="bottom",t[t.verticalCenter=32]="verticalCenter",t[t.topLeft=9]="topLeft",t[t.topRight=10]="topRight",t[t.topCenter=12]="topCenter",t[t.bottomLeft=17]="bottomLeft",t[t.bottomRight=18]="bottomRight",t[t.bottomCenter=20]="bottomCenter",t[t.centerLeft=33]="centerLeft",t[t.centerRight=34]="centerRight",t[t.center=36]="center"}(e=t.Alignment||(t.Alignment={}))}(es||(es={})),function(t){var e,n=function(){function t(t){void 0===t&&(t=i),this.getSystemTime=t,this._stopDuration=0,this._completeSlices=[]}return t.prototype.getState=function(){return void 0===this._startSystemTime?e.IDLE:void 0===this._stopSystemTime?e.RUNNING:e.STOPPED},t.prototype.isIdle=function(){return this.getState()===e.IDLE},t.prototype.isRunning=function(){return this.getState()===e.RUNNING},t.prototype.isStopped=function(){return this.getState()===e.STOPPED},t.prototype.slice=function(){return this.recordPendingSlice()},t.prototype.getCompletedSlices=function(){return Array.from(this._completeSlices)},t.prototype.getCompletedAndPendingSlices=function(){return this._completeSlices.concat([this.getPendingSlice()])},t.prototype.getPendingSlice=function(){return this.calculatePendingSlice()},t.prototype.getTime=function(){return this.caculateStopwatchTime()},t.prototype.calculatePendingSlice=function(t){return void 0===this._pendingSliceStartStopwatchTime?Object.freeze({startTime:0,endTime:0,duration:0}):(void 0===t&&(t=this.getTime()),Object.freeze({startTime:this._pendingSliceStartStopwatchTime,endTime:t,duration:t-this._pendingSliceStartStopwatchTime}))},t.prototype.caculateStopwatchTime=function(t){return void 0===this._startSystemTime?0:(void 0===t&&(t=this.getSystemTimeOfCurrentStopwatchTime()),t-this._startSystemTime-this._stopDuration)},t.prototype.getSystemTimeOfCurrentStopwatchTime=function(){return void 0===this._stopSystemTime?this.getSystemTime():this._stopSystemTime},t.prototype.reset=function(){this._startSystemTime=this._pendingSliceStartStopwatchTime=this._stopSystemTime=void 0,this._stopDuration=0,this._completeSlices=[]},t.prototype.start=function(t){if(void 0===t&&(t=!1),t&&this.reset(),void 0!==this._stopSystemTime){var e=(n=this.getSystemTime())-this._stopSystemTime;this._stopDuration+=e,this._stopSystemTime=void 0}else if(void 0===this._startSystemTime){var n=this.getSystemTime();this._startSystemTime=n,this._pendingSliceStartStopwatchTime=0}},t.prototype.stop=function(t){if(void 0===t&&(t=!1),void 0===this._startSystemTime)return 0;var e=this.getSystemTimeOfCurrentStopwatchTime();return t&&this.recordPendingSlice(this.caculateStopwatchTime(e)),this._stopSystemTime=e,this.getTime()},t.prototype.recordPendingSlice=function(t){if(void 0!==this._pendingSliceStartStopwatchTime){void 0===t&&(t=this.getTime());var e=this.calculatePendingSlice(t);return this._pendingSliceStartStopwatchTime=e.endTime,this._completeSlices.push(e),e}return this.calculatePendingSlice()},t}();t.Stopwatch=n,function(t){t.IDLE="IDLE",t.RUNNING="RUNNING",t.STOPPED="STOPPED"}(e||(e={})),t.setDefaultSystemTimeGetter=function(t){void 0===t&&(t=Date.now),i=t};var i=Date.now}(stopwatch||(stopwatch={})),function(t){var e=function(){function e(){this._frameKey="frame",this._logKey="log",this.markers=[],this.stopwacth=new stopwatch.Stopwatch,this._markerNameToIdMap=new Map,this.showLog=!1,e.Instance=this,this._logs=new Array(2);for(var i=0;i<this._logs.length;++i)this._logs[i]=new n;this.sampleFrames=this.targetSampleFrames=1,this.width=.8*t.SceneManager.stage.stageWidth,this.onGraphicsDeviceReset()}return e.prototype.onGraphicsDeviceReset=function(){var n=new t.Layout;this._position=n.place(new t.Vector2(this.width,e.barHeight),0,.01,t.Alignment.bottomCenter).location},e.prototype.startFrame=function(){var t=this;new LockUtils(this._frameKey).lock().then(function(){t._updateCount=parseInt(egret.localStorage.getItem(t._frameKey),10),isNaN(t._updateCount)&&(t._updateCount=0);var n=t._updateCount;if(n+=1,egret.localStorage.setItem(t._frameKey,n.toString()),!(t.enabled&&1<n&&n<e.maxSampleFrames)){t._prevLog=t._logs[1&t.frameCount++],t._curLog=t._logs[1&t.frameCount];for(var i=t.stopwacth.getTime(),r=0;r<t._prevLog.bars.length;++r){for(var o=t._prevLog.bars[r],s=t._curLog.bars[r],a=0;a<o.nestCount;++a){var c=o.markerNests[a];o.markers[c].endTime=i,s.markerNests[a]=a,s.markers[a].markerId=o.markers[c].markerId,s.markers[a].beginTime=0,s.markers[a].endTime=-1,s.markers[a].color=o.markers[c].color}for(c=0;c<o.markCount;++c){var h=o.markers[c].endTime-o.markers[c].beginTime,u=o.markers[c].markerId,l=t.markers[u];l.logs[r].color=o.markers[c].color,l.logs[r].initialized?(l.logs[r].min=Math.min(l.logs[r].min,h),l.logs[r].max=Math.min(l.logs[r].max,h),l.logs[r].avg+=h,l.logs[r].avg*=.5,l.logs[r].samples++>=e.logSnapDuration&&(l.logs[r].snapMin=l.logs[r].min,l.logs[r].snapMax=l.logs[r].max,l.logs[r].snapAvg=l.logs[r].avg,l.logs[r].samples=0)):(l.logs[r].min=h,l.logs[r].max=h,l.logs[r].avg=h,l.logs[r].initialized=!0)}s.markCount=o.nestCount,s.nestCount=o.nestCount}t.stopwacth.reset(),t.stopwacth.start()}})},e.prototype.beginMark=function(t,n,i){var r=this;void 0===i&&(i=0),new LockUtils(this._frameKey).lock().then(function(){if(i<0||i>=e.maxBars)throw new Error("barIndex argument out of range");var o=r._curLog.bars[i];if(o.markCount>=e.maxSamples)throw new Error("exceeded sample count. either set larger number to timeruler.maxsaple or lower sample count");if(o.nestCount>=e.maxNestCall)throw new Error("exceeded nest count. either set larger number to timeruler.maxnestcall or lower nest calls");var s=r._markerNameToIdMap.get(t);isNaN(s)&&(s=r.markers.length,r._markerNameToIdMap.set(t,s)),o.markerNests[o.nestCount++]=o.markCount,o.markers[o.markCount].markerId=s,o.markers[o.markCount].color=n,o.markers[o.markCount].beginTime=r.stopwacth.getTime(),o.markers[o.markCount].endTime=-1})},e.prototype.endMark=function(t,n){var i=this;void 0===n&&(n=0),new LockUtils(this._frameKey).lock().then(function(){if(n<0||n>=e.maxBars)throw new Error("barIndex argument out of range");var r=i._curLog.bars[n];if(r.nestCount<=0)throw new Error("call beginMark method before calling endMark method");var o=i._markerNameToIdMap.get(t);if(isNaN(o))throw new Error("Marker "+t+" is not registered. Make sure you specifed same name as you used for beginMark method");var s=r.markerNests[--r.nestCount];if(r.markers[s].markerId!=o)throw new Error("Incorrect call order of beginMark/endMark method. beginMark(A), beginMark(B), endMark(B), endMark(A) But you can't called it like beginMark(A), beginMark(B), endMark(A), endMark(B).");r.markers[s].endTime=i.stopwacth.getTime()})},e.prototype.getAverageTime=function(t,n){if(t<0||t>=e.maxBars)throw new Error("barIndex argument out of range");var i=0,r=this._markerNameToIdMap.get(n);return r&&(i=this.markers[r].logs[t].avg),i},e.prototype.resetLog=function(){var t=this;new LockUtils(this._logKey).lock().then(function(){var e=parseInt(egret.localStorage.getItem(t._logKey),10);e+=1,egret.localStorage.setItem(t._logKey,e.toString()),t.markers.forEach(function(t){for(var e=0;e<t.logs.length;++e)t.logs[e].initialized=!1,t.logs[e].snapMin=0,t.logs[e].snapMax=0,t.logs[e].snapAvg=0,t.logs[e].min=0,t.logs[e].max=0,t.logs[e].avg=0,t.logs[e].samples=0})})},e.prototype.render=function(t,n){if(void 0===t&&(t=this._position),void 0===n&&(n=this.width),egret.localStorage.setItem(this._frameKey,"0"),this.showLog){var i=0,r=0;this._prevLog.bars.forEach(function(t){t.markCount>0&&(i+=e.barHeight+2*e.barPadding,r=Math.max(r,t.markers[t.markCount-1].endTime))});var o=this.sampleFrames*(1/60*1e3);this._frameAdjust=r>o?Math.max(0,this._frameAdjust)+1:Math.min(0,this._frameAdjust)-1,Math.max(this._frameAdjust)>e.autoAdjustDelay&&(this.sampleFrames=Math.min(e.maxSampleFrames,this.sampleFrames),this.sampleFrames=Math.max(this.targetSampleFrames,r/(1/60*1e3)+1),this._frameAdjust=0);t.y,e.barHeight}},e.maxBars=8,e.maxSamples=256,e.maxNestCall=32,e.barHeight=8,e.maxSampleFrames=4,e.logSnapDuration=120,e.barPadding=2,e.autoAdjustDelay=30,e}();t.TimeRuler=e;var n=function(){return function(){this.bars=new Array(e.maxBars),this.bars.fill(new i,0,e.maxBars)}}();t.FrameLog=n;var i=function(){return function(){this.markers=new Array(e.maxSamples),this.markCount=0,this.markerNests=new Array(e.maxNestCall),this.nestCount=0,this.markers.fill(new r,0,e.maxSamples),this.markerNests.fill(0,0,e.maxNestCall)}}();t.MarkerCollection=i;var r=function(){return function(){this.markerId=0,this.beginTime=0,this.endTime=0,this.color=0}}();t.Marker=r;var o=function(){return function(t){this.logs=new Array(e.maxBars),this.name=t,this.logs.fill(new s,0,e.maxBars)}}();t.MarkerInfo=o;var s=function(){return function(){this.snapMin=0,this.snapMax=0,this.snapAvg=0,this.min=0,this.max=0,this.avg=0,this.samples=0,this.color=0,this.initialized=!1}}();t.MarkerLog=s}(es||(es={}));
\ No newline at end of file
diff --git a/source/bin/framework.d.ts b/source/bin/framework.d.ts
index 9ab1a179..6c72ef06 100644
--- a/source/bin/framework.d.ts
+++ b/source/bin/framework.d.ts
@@ -17,648 +17,842 @@ declare interface Array<T> {
     groupBy(keySelector: Function): Array<T>;
     sum(selector: any): any;
 }
-declare class PriorityQueueNode {
-    priority: number;
-    insertionIndex: number;
-    queueIndex: number;
+declare module es {
+    class PriorityQueueNode {
+        priority: number;
+        insertionIndex: number;
+        queueIndex: number;
+    }
 }
-declare class AStarPathfinder {
-    static search<T>(graph: IAstarGraph<T>, start: T, goal: T): T[];
-    private static hasKey;
-    private static getKey;
-    static recontructPath<T>(cameFrom: Map<T, T>, start: T, goal: T): T[];
+declare module es {
+    class AStarPathfinder {
+        static search<T>(graph: IAstarGraph<T>, start: T, goal: T): T[];
+        private static hasKey;
+        private static getKey;
+        static recontructPath<T>(cameFrom: Map<T, T>, start: T, goal: T): T[];
+    }
+    class AStarNode<T> extends PriorityQueueNode {
+        data: T;
+        constructor(data: T);
+    }
 }
-declare class AStarNode<T> extends PriorityQueueNode {
-    data: T;
-    constructor(data: T);
+declare module es {
+    class AstarGridGraph implements IAstarGraph<Vector2> {
+        dirs: Vector2[];
+        walls: Vector2[];
+        weightedNodes: Vector2[];
+        defaultWeight: number;
+        weightedNodeWeight: number;
+        private _width;
+        private _height;
+        private _neighbors;
+        constructor(width: number, height: number);
+        isNodeInBounds(node: Vector2): boolean;
+        isNodePassable(node: Vector2): boolean;
+        search(start: Vector2, goal: Vector2): Vector2[];
+        getNeighbors(node: Vector2): Vector2[];
+        cost(from: Vector2, to: Vector2): number;
+        heuristic(node: Vector2, goal: Vector2): number;
+    }
 }
-declare class AstarGridGraph implements IAstarGraph<Vector2> {
-    dirs: Vector2[];
-    walls: Vector2[];
-    weightedNodes: Vector2[];
-    defaultWeight: number;
-    weightedNodeWeight: number;
-    private _width;
-    private _height;
-    private _neighbors;
-    constructor(width: number, height: number);
-    isNodeInBounds(node: Vector2): boolean;
-    isNodePassable(node: Vector2): boolean;
-    search(start: Vector2, goal: Vector2): Vector2[];
-    getNeighbors(node: Vector2): Vector2[];
-    cost(from: Vector2, to: Vector2): number;
-    heuristic(node: Vector2, goal: Vector2): number;
+declare module es {
+    interface IAstarGraph<T> {
+        getNeighbors(node: T): Array<T>;
+        cost(from: T, to: T): number;
+        heuristic(node: T, goal: T): any;
+    }
 }
-interface IAstarGraph<T> {
-    getNeighbors(node: T): Array<T>;
-    cost(from: T, to: T): number;
-    heuristic(node: T, goal: T): any;
+declare module es {
+    class PriorityQueue<T extends PriorityQueueNode> {
+        private _numNodes;
+        private _nodes;
+        private _numNodesEverEnqueued;
+        constructor(maxNodes: number);
+        clear(): void;
+        readonly count: number;
+        readonly maxSize: number;
+        contains(node: T): boolean;
+        enqueue(node: T, priority: number): void;
+        dequeue(): T;
+        remove(node: T): void;
+        isValidQueue(): boolean;
+        private onNodeUpdated;
+        private cascadeDown;
+        private cascadeUp;
+        private swap;
+        private hasHigherPriority;
+    }
 }
-declare class PriorityQueue<T extends PriorityQueueNode> {
-    private _numNodes;
-    private _nodes;
-    private _numNodesEverEnqueued;
-    constructor(maxNodes: number);
-    clear(): void;
-    readonly count: number;
-    readonly maxSize: number;
-    contains(node: T): boolean;
-    enqueue(node: T, priority: number): void;
-    dequeue(): T;
-    remove(node: T): void;
-    isValidQueue(): boolean;
-    private onNodeUpdated;
-    private cascadeDown;
-    private cascadeUp;
-    private swap;
-    private hasHigherPriority;
+declare module es {
+    class BreadthFirstPathfinder {
+        static search<T>(graph: IUnweightedGraph<T>, start: T, goal: T): T[];
+        private static hasKey;
+    }
 }
-declare class BreadthFirstPathfinder {
-    static search<T>(graph: IUnweightedGraph<T>, start: T, goal: T): T[];
-    private static hasKey;
+declare module es {
+    interface IUnweightedGraph<T> {
+        getNeighbors(node: T): T[];
+    }
 }
-interface IUnweightedGraph<T> {
-    getNeighbors(node: T): T[];
+declare module es {
+    class UnweightedGraph<T> implements IUnweightedGraph<T> {
+        edges: Map<T, T[]>;
+        addEdgesForNode(node: T, edges: T[]): this;
+        getNeighbors(node: T): T[];
+    }
 }
-declare class UnweightedGraph<T> implements IUnweightedGraph<T> {
-    edges: Map<T, T[]>;
-    addEdgesForNode(node: T, edges: T[]): this;
-    getNeighbors(node: T): T[];
+declare module es {
+    class Vector2 {
+        x: number;
+        y: number;
+        private static readonly unitYVector;
+        private static readonly unitXVector;
+        private static readonly unitVector2;
+        private static readonly zeroVector2;
+        static readonly zero: Vector2;
+        static readonly one: Vector2;
+        static readonly unitX: Vector2;
+        static readonly unitY: Vector2;
+        constructor(x?: number, y?: number);
+        static add(value1: Vector2, value2: Vector2): Vector2;
+        static divide(value1: Vector2, value2: Vector2): Vector2;
+        static multiply(value1: Vector2, value2: Vector2): Vector2;
+        static subtract(value1: Vector2, value2: Vector2): Vector2;
+        normalize(): void;
+        length(): number;
+        round(): Vector2;
+        static normalize(value: Vector2): Vector2;
+        static dot(value1: Vector2, value2: Vector2): number;
+        static distanceSquared(value1: Vector2, value2: Vector2): number;
+        static clamp(value1: Vector2, min: Vector2, max: Vector2): Vector2;
+        static lerp(value1: Vector2, value2: Vector2, amount: number): Vector2;
+        static transform(position: Vector2, matrix: Matrix2D): Vector2;
+        static distance(value1: Vector2, value2: Vector2): number;
+        static negate(value: Vector2): Vector2;
+    }
 }
-declare class Vector2 {
-    x: number;
-    y: number;
-    private static readonly unitYVector;
-    private static readonly unitXVector;
-    private static readonly unitVector2;
-    private static readonly zeroVector2;
-    static readonly zero: Vector2;
-    static readonly one: Vector2;
-    static readonly unitX: Vector2;
-    static readonly unitY: Vector2;
-    constructor(x?: number, y?: number);
-    static add(value1: Vector2, value2: Vector2): Vector2;
-    static divide(value1: Vector2, value2: Vector2): Vector2;
-    static multiply(value1: Vector2, value2: Vector2): Vector2;
-    static subtract(value1: Vector2, value2: Vector2): Vector2;
-    normalize(): void;
-    length(): number;
-    round(): Vector2;
-    static normalize(value: Vector2): Vector2;
-    static dot(value1: Vector2, value2: Vector2): number;
-    static distanceSquared(value1: Vector2, value2: Vector2): number;
-    static clamp(value1: Vector2, min: Vector2, max: Vector2): Vector2;
-    static lerp(value1: Vector2, value2: Vector2, amount: number): Vector2;
-    static transform(position: Vector2, matrix: Matrix2D): Vector2;
-    static distance(value1: Vector2, value2: Vector2): number;
-    static negate(value: Vector2): Vector2;
+declare module es {
+    class UnweightedGridGraph implements IUnweightedGraph<Vector2> {
+        private static readonly CARDINAL_DIRS;
+        private static readonly COMPASS_DIRS;
+        walls: Vector2[];
+        private _width;
+        private _hegiht;
+        private _dirs;
+        private _neighbors;
+        constructor(width: number, height: number, allowDiagonalSearch?: boolean);
+        isNodeInBounds(node: Vector2): boolean;
+        isNodePassable(node: Vector2): boolean;
+        getNeighbors(node: Vector2): Vector2[];
+        search(start: Vector2, goal: Vector2): Vector2[];
+    }
 }
-declare class UnweightedGridGraph implements IUnweightedGraph<Vector2> {
-    private static readonly CARDINAL_DIRS;
-    private static readonly COMPASS_DIRS;
-    walls: Vector2[];
-    private _width;
-    private _hegiht;
-    private _dirs;
-    private _neighbors;
-    constructor(width: number, height: number, allowDiagonalSearch?: boolean);
-    isNodeInBounds(node: Vector2): boolean;
-    isNodePassable(node: Vector2): boolean;
-    getNeighbors(node: Vector2): Vector2[];
-    search(start: Vector2, goal: Vector2): Vector2[];
+declare module es {
+    interface IWeightedGraph<T> {
+        getNeighbors(node: T): T[];
+        cost(from: T, to: T): number;
+    }
 }
-interface IWeightedGraph<T> {
-    getNeighbors(node: T): T[];
-    cost(from: T, to: T): number;
+declare module es {
+    class WeightedGridGraph implements IWeightedGraph<Vector2> {
+        static readonly CARDINAL_DIRS: Vector2[];
+        private static readonly COMPASS_DIRS;
+        walls: Vector2[];
+        weightedNodes: Vector2[];
+        defaultWeight: number;
+        weightedNodeWeight: number;
+        private _width;
+        private _height;
+        private _dirs;
+        private _neighbors;
+        constructor(width: number, height: number, allowDiagonalSearch?: boolean);
+        isNodeInBounds(node: Vector2): boolean;
+        isNodePassable(node: Vector2): boolean;
+        search(start: Vector2, goal: Vector2): Vector2[];
+        getNeighbors(node: Vector2): Vector2[];
+        cost(from: Vector2, to: Vector2): number;
+    }
 }
-declare class WeightedGridGraph implements IWeightedGraph<Vector2> {
-    static readonly CARDINAL_DIRS: Vector2[];
-    private static readonly COMPASS_DIRS;
-    walls: Vector2[];
-    weightedNodes: Vector2[];
-    defaultWeight: number;
-    weightedNodeWeight: number;
-    private _width;
-    private _height;
-    private _dirs;
-    private _neighbors;
-    constructor(width: number, height: number, allowDiagonalSearch?: boolean);
-    isNodeInBounds(node: Vector2): boolean;
-    isNodePassable(node: Vector2): boolean;
-    search(start: Vector2, goal: Vector2): Vector2[];
-    getNeighbors(node: Vector2): Vector2[];
-    cost(from: Vector2, to: Vector2): number;
+declare module es {
+    class WeightedNode<T> extends PriorityQueueNode {
+        data: T;
+        constructor(data: T);
+    }
+    class WeightedPathfinder {
+        static search<T>(graph: IWeightedGraph<T>, start: T, goal: T): T[];
+        private static hasKey;
+        private static getKey;
+        static recontructPath<T>(cameFrom: Map<T, T>, start: T, goal: T): T[];
+    }
 }
-declare class WeightedNode<T> extends PriorityQueueNode {
-    data: T;
-    constructor(data: T);
+declare module es {
+    class Debug {
+        private static _debugDrawItems;
+        static drawHollowRect(rectanle: Rectangle, color: number, duration?: number): void;
+        static render(): void;
+    }
 }
-declare class WeightedPathfinder {
-    static search<T>(graph: IWeightedGraph<T>, start: T, goal: T): T[];
-    private static hasKey;
-    private static getKey;
-    static recontructPath<T>(cameFrom: Map<T, T>, start: T, goal: T): T[];
+declare module es {
+    class DebugDefaults {
+        static verletParticle: number;
+        static verletConstraintEdge: number;
+    }
 }
-declare class Debug {
-    private static _debugDrawItems;
-    static drawHollowRect(rectanle: Rectangle, color: number, duration?: number): void;
-    static render(): void;
+declare module es {
+    enum DebugDrawType {
+        line = 0,
+        hollowRectangle = 1,
+        pixel = 2,
+        text = 3
+    }
+    class DebugDrawItem {
+        rectangle: Rectangle;
+        color: number;
+        duration: number;
+        drawType: DebugDrawType;
+        text: string;
+        start: Vector2;
+        end: Vector2;
+        x: number;
+        y: number;
+        size: number;
+        constructor(rectangle: Rectangle, color: number, duration: number);
+        draw(shape: egret.Shape): boolean;
+    }
 }
-declare class DebugDefaults {
-    static verletParticle: number;
-    static verletConstraintEdge: number;
+declare module es {
+    abstract class Component {
+        entity: Entity;
+        readonly transform: Transform;
+        enabled: boolean;
+        updateOrder: number;
+        updateInterval: number;
+        private _enabled;
+        private _updateOrder;
+        initialize(): void;
+        onAddedToEntity(): void;
+        onRemovedFromEntity(): void;
+        onEntityTransformChanged(comp: transform.Component): void;
+        debugRender(): void;
+        onEnabled(): void;
+        onDisabled(): void;
+        update(): void;
+        setEnabled(isEnabled: boolean): this;
+        setUpdateOrder(updateOrder: number): this;
+        clone(): Component;
+    }
 }
-declare enum DebugDrawType {
-    line = 0,
-    hollowRectangle = 1,
-    pixel = 2,
-    text = 3
+declare module es {
+    enum CoreEvents {
+        SceneChanged = 0
+    }
 }
-declare class DebugDrawItem {
-    rectangle: Rectangle;
-    color: number;
-    duration: number;
-    drawType: DebugDrawType;
-    text: string;
-    start: Vector2;
-    end: Vector2;
-    x: number;
-    y: number;
-    size: number;
-    constructor(rectangle: Rectangle, color: number, duration: number);
-    draw(shape: egret.Shape): boolean;
+declare module es {
+    class Entity {
+        static _idGenerator: number;
+        scene: Scene;
+        name: string;
+        readonly id: number;
+        readonly transform: Transform;
+        readonly components: ComponentList;
+        tag: number;
+        updateInterval: number;
+        enabled: boolean;
+        updateOrder: number;
+        _isDestroyed: boolean;
+        readonly isDestroyed: boolean;
+        componentBits: BitSet;
+        private _tag;
+        private _enabled;
+        private _updateOrder;
+        parent: Transform;
+        readonly childCount: number;
+        position: Vector2;
+        rotation: number;
+        scale: Vector2;
+        constructor(name: string);
+        onTransformChanged(comp: transform.Component): void;
+        setTag(tag: number): Entity;
+        setEnabled(isEnabled: boolean): this;
+        setUpdateOrder(updateOrder: number): this;
+        destroy(): void;
+        detachFromScene(): void;
+        attachToScene(newScene: Scene): void;
+        clone(position?: Vector2): Entity;
+        protected copyFrom(entity: Entity): void;
+        onAddedToScene(): void;
+        onRemovedFromScene(): void;
+        update(): void;
+        addComponent<T extends Component>(component: T): T;
+        getComponent<T extends Component>(type: any): T;
+        hasComponent<T extends Component>(type: any): boolean;
+        getOrCreateComponent<T extends Component>(type: T): T;
+        getComponents(typeName: string | any, componentList?: any): any;
+        removeComponent(component: Component): void;
+        removeComponentForType<T extends Component>(type: any): boolean;
+        removeAllComponents(): void;
+        toString(): string;
+    }
 }
-declare abstract class Component extends egret.DisplayObjectContainer {
-    entity: Entity;
-    private _enabled;
-    updateInterval: number;
-    userData: any;
-    private _updateOrder;
-    enabled: boolean;
-    readonly localPosition: Vector2;
-    setEnabled(isEnabled: boolean): this;
-    updateOrder: number;
-    setUpdateOrder(updateOrder: number): this;
-    initialize(): void;
-    onAddedToEntity(): void;
-    onRemovedFromEntity(): void;
-    onEnabled(): void;
-    onDisabled(): void;
-    debugRender(): void;
-    update(): void;
-    onEntityTransformChanged(comp: TransformComponent): void;
-    registerComponent(): void;
-    deregisterComponent(): void;
+declare module es {
+    class Scene extends egret.DisplayObjectContainer {
+        camera: Camera;
+        readonly content: ContentManager;
+        enablePostProcessing: boolean;
+        readonly entities: EntityList;
+        readonly renderableComponents: RenderableComponentList;
+        readonly entityProcessors: EntityProcessorList;
+        _renderers: Renderer[];
+        readonly _postProcessors: PostProcessor[];
+        _didSceneBegin: any;
+        static createWithDefaultRenderer(): Scene;
+        constructor();
+        initialize(): void;
+        onStart(): Promise<void>;
+        unload(): void;
+        onActive(): void;
+        onDeactive(): void;
+        begin(): Promise<void>;
+        end(): void;
+        update(): void;
+        render(): void;
+        postRender(): void;
+        addRenderer<T extends Renderer>(renderer: T): T;
+        getRenderer<T extends Renderer>(type: any): T;
+        removeRenderer(renderer: Renderer): void;
+        addPostProcessor<T extends PostProcessor>(postProcessor: T): T;
+        getPostProcessor<T extends PostProcessor>(type: any): T;
+        removePostProcessor(postProcessor: PostProcessor): void;
+        createEntity(name: string): Entity;
+        addEntity(entity: Entity): Entity;
+        destroyAllEntities(): void;
+        findEntity(name: string): Entity;
+        findEntitiesWithTag(tag: number): Entity[];
+        entitiesOfType<T extends Entity>(type: any): T[];
+        findComponentOfType<T extends Component>(type: any): T;
+        findComponentsOfType<T extends Component>(type: any): T[];
+        addEntityProcessor(processor: EntitySystem): EntitySystem;
+        removeEntityProcessor(processor: EntitySystem): void;
+        getEntityProcessor<T extends EntitySystem>(): T;
+    }
 }
-declare enum CoreEvents {
-    SceneChanged = 0
+declare module es {
+    class SceneManager {
+        private static _scene;
+        private static _nextScene;
+        static sceneTransition: SceneTransition;
+        static stage: egret.Stage;
+        static activeSceneChanged: Function;
+        static emitter: Emitter<CoreEvents>;
+        static content: ContentManager;
+        private static _instnace;
+        private static timerRuler;
+        static readonly Instance: SceneManager;
+        constructor(stage: egret.Stage);
+        static scene: Scene;
+        static initialize(stage: egret.Stage): void;
+        static update(): void;
+        static render(): void;
+        static startSceneTransition<T extends SceneTransition>(sceneTransition: T): T;
+        static registerActiveSceneChanged(current: Scene, next: Scene): void;
+        onSceneChanged(): void;
+        private static startDebugUpdate;
+        private static endDebugUpdate;
+    }
 }
-declare class Entity extends egret.DisplayObjectContainer {
-    private static _idGenerator;
-    name: string;
-    readonly id: number;
-    scene: Scene;
-    readonly components: ComponentList;
-    private _updateOrder;
-    private _enabled;
-    _isDestoryed: boolean;
-    private _tag;
-    componentBits: BitSet;
-    readonly isDestoryed: boolean;
-    position: Vector2;
-    scale: Vector2;
-    rotation: number;
-    enabled: boolean;
-    setEnabled(isEnabled: boolean): this;
-    tag: number;
-    readonly stage: egret.Stage;
-    constructor(name: string);
-    private onAddToStage;
-    updateOrder: number;
-    roundPosition(): void;
-    setUpdateOrder(updateOrder: number): this;
-    setTag(tag: number): Entity;
-    attachToScene(newScene: Scene): void;
-    detachFromScene(): void;
-    addComponent<T extends Component>(component: T): T;
-    hasComponent<T extends Component>(type: any): boolean;
-    getOrCreateComponent<T extends Component>(type: T): T;
-    getComponent<T extends Component>(type: any): T;
-    getComponents(typeName: string | any, componentList?: any): any;
-    onEntityTransformChanged(comp: TransformComponent): void;
-    removeComponentForType<T extends Component>(type: any): boolean;
-    removeComponent(component: Component): void;
-    removeAllComponents(): void;
-    update(): void;
-    onAddedToScene(): void;
-    onRemovedFromScene(): void;
-    destroy(): void;
+declare module transform {
+    enum Component {
+        position = 0,
+        scale = 1,
+        rotation = 2
+    }
 }
-declare enum TransformComponent {
-    rotation = 0,
-    scale = 1,
-    position = 2
+declare module es {
+    enum DirtyType {
+        clean = 0,
+        positionDirty = 1,
+        scaleDirty = 2,
+        rotationDirty = 3
+    }
+    class Transform {
+        readonly entity: Entity;
+        parent: Transform;
+        readonly childCount: number;
+        position: Vector2;
+        rotation: number;
+        scale: Vector2;
+        _parent: Transform;
+        hierarchyDirty: DirtyType;
+        _children: Transform[];
+        constructor(entity: Entity);
+        getChild(index: number): Transform;
+        setParent(parent: Transform): Transform;
+        setPosition(x: number, y: number): Transform;
+        setRotation(degrees: number): Transform;
+        setScale(scale: Vector2): Transform;
+        lookAt(pos: Vector2): void;
+        roundPosition(): void;
+        setDirty(dirtyFlagType: DirtyType): void;
+        copyFrom(transform: Transform): void;
+    }
 }
-declare class Scene extends egret.DisplayObjectContainer {
-    camera: Camera;
-    readonly entities: EntityList;
-    readonly renderableComponents: RenderableComponentList;
-    readonly content: ContentManager;
-    enablePostProcessing: boolean;
-    private _renderers;
-    private _postProcessors;
-    private _didSceneBegin;
-    readonly entityProcessors: EntityProcessorList;
-    constructor();
-    createEntity(name: string): Entity;
-    addEntity(entity: Entity): Entity;
-    destroyAllEntities(): void;
-    findEntity(name: string): Entity;
-    addEntityProcessor(processor: EntitySystem): EntitySystem;
-    removeEntityProcessor(processor: EntitySystem): void;
-    getEntityProcessor<T extends EntitySystem>(): T;
-    addRenderer<T extends Renderer>(renderer: T): T;
-    getRenderer<T extends Renderer>(type: any): T;
-    removeRenderer(renderer: Renderer): void;
-    begin(): void;
-    end(): void;
-    protected onStart(): Promise<void>;
-    protected onActive(): void;
-    protected onDeactive(): void;
-    protected unload(): void;
-    update(): void;
-    postRender(): void;
-    render(): void;
-    addPostProcessor<T extends PostProcessor>(postProcessor: T): T;
+declare module es {
+    enum CameraStyle {
+        lockOn = 0,
+        cameraWindow = 1
+    }
+    class Camera extends Component {
+        position: Vector2;
+        rotation: number;
+        zoom: number;
+        minimumZoom: number;
+        maximumZoom: number;
+        readonly bounds: Rectangle;
+        origin: Vector2;
+        private _zoom;
+        private _minimumZoom;
+        private _maximumZoom;
+        private _origin;
+        followLerp: number;
+        deadzone: Rectangle;
+        focusOffset: Vector2;
+        mapLockEnabled: boolean;
+        mapSize: Vector2;
+        _targetEntity: Entity;
+        _targetCollider: Collider;
+        _desiredPositionDelta: Vector2;
+        _cameraStyle: CameraStyle;
+        _worldSpaceDeadZone: Rectangle;
+        constructor(targetEntity?: Entity, cameraStyle?: CameraStyle);
+        onSceneSizeChanged(newWidth: number, newHeight: number): void;
+        setPosition(position: Vector2): this;
+        setRotation(rotation: number): Camera;
+        setZoom(zoom: number): Camera;
+        setMinimumZoom(minZoom: number): Camera;
+        setMaximumZoom(maxZoom: number): Camera;
+        zoomIn(deltaZoom: number): void;
+        zoomOut(deltaZoom: number): void;
+        onAddedToEntity(): void;
+        update(): void;
+        clampToMapSize(position: Vector2): Vector2;
+        updateFollow(): void;
+        follow(targetEntity: Entity, cameraStyle?: CameraStyle): void;
+        setCenteredDeadzone(width: number, height: number): void;
+    }
 }
-declare class SceneManager {
-    private static _scene;
-    private static _nextScene;
-    static sceneTransition: SceneTransition;
-    static stage: egret.Stage;
-    static activeSceneChanged: Function;
-    static emitter: Emitter<CoreEvents>;
-    static content: ContentManager;
-    private static _instnace;
-    private static timerRuler;
-    static readonly Instance: SceneManager;
-    constructor(stage: egret.Stage);
-    static scene: Scene;
-    static initialize(stage: egret.Stage): void;
-    static update(): void;
-    static render(): void;
-    static startSceneTransition<T extends SceneTransition>(sceneTransition: T): T;
-    static registerActiveSceneChanged(current: Scene, next: Scene): void;
-    onSceneChanged(): void;
-    private static startDebugUpdate;
-    private static endDebugUpdate;
+declare module es {
+    class ComponentPool<T extends PooledComponent> {
+        private _cache;
+        private _type;
+        constructor(typeClass: any);
+        obtain(): T;
+        free(component: T): void;
+    }
 }
-declare class Camera extends Component {
-    private _zoom;
-    private _origin;
-    private _minimumZoom;
-    private _maximumZoom;
-    private _position;
-    followLerp: number;
-    deadzone: Rectangle;
-    focusOffset: Vector2;
-    mapLockEnabled: boolean;
-    mapSize: Vector2;
-    targetEntity: Entity;
-    private _worldSpaceDeadZone;
-    private _desiredPositionDelta;
-    private _targetCollider;
-    cameraStyle: CameraStyle;
-    zoom: number;
-    minimumZoom: number;
-    maximumZoom: number;
-    origin: Vector2;
-    position: Vector2;
-    x: number;
-    y: number;
-    constructor();
-    onSceneSizeChanged(newWidth: number, newHeight: number): void;
-    setMinimumZoom(minZoom: number): Camera;
-    setMaximumZoom(maxZoom: number): Camera;
-    setZoom(zoom: number): Camera;
-    setRotation(rotation: number): Camera;
-    setPosition(position: Vector2): this;
-    follow(targetEntity: Entity, cameraStyle?: CameraStyle): void;
-    update(): void;
-    private clampToMapSize;
-    private updateFollow;
+declare module es {
+    class IUpdatableComparer {
+        compare(a: Component, b: Component): number;
+    }
 }
-declare enum CameraStyle {
-    lockOn = 0,
-    cameraWindow = 1
+declare module es {
+    abstract class PooledComponent extends Component {
+        abstract reset(): any;
+    }
 }
-declare class ComponentPool<T extends PooledComponent> {
-    private _cache;
-    private _type;
-    constructor(typeClass: any);
-    obtain(): T;
-    free(component: T): void;
+declare module es {
+    abstract class RenderableComponent extends Component implements IRenderable {
+        readonly width: number;
+        readonly height: number;
+        readonly bounds: Rectangle;
+        renderLayer: number;
+        color: number;
+        localOffset: Vector2;
+        isVisible: boolean;
+        protected _localOffset: Vector2;
+        protected _renderLayer: number;
+        protected _bounds: Rectangle;
+        private _isVisible;
+        protected _areBoundsDirty: boolean;
+        onEntityTransformChanged(comp: transform.Component): void;
+        abstract render(camera: Camera): any;
+        protected onBecameVisible(): void;
+        protected onBecameInvisible(): void;
+        isVisibleFromCamera(camera: Camera): boolean;
+        setRenderLayer(renderLayer: number): RenderableComponent;
+        setColor(color: number): RenderableComponent;
+        setLocalOffset(offset: Vector2): RenderableComponent;
+        toString(): string;
+    }
 }
-declare abstract class PooledComponent extends Component {
-    abstract reset(): any;
+declare module es {
+    class Mesh extends RenderableComponent {
+        private _mesh;
+        constructor();
+        setTexture(texture: egret.Texture): Mesh;
+        reset(): void;
+        render(camera: es.Camera): void;
+    }
 }
-declare abstract class RenderableComponent extends PooledComponent implements IRenderable {
-    private _isVisible;
-    protected _areBoundsDirty: boolean;
-    protected _bounds: Rectangle;
-    protected _localOffset: Vector2;
-    color: number;
-    readonly width: number;
-    readonly height: number;
-    isVisible: boolean;
-    readonly bounds: Rectangle;
-    protected getWidth(): number;
-    protected getHeight(): number;
-    protected onBecameVisible(): void;
-    protected onBecameInvisible(): void;
-    abstract render(camera: Camera): any;
-    isVisibleFromCamera(camera: Camera): boolean;
+declare module es {
+    class SpriteRenderer extends RenderableComponent {
+        readonly bounds: Rectangle;
+        origin: Vector2;
+        originNormalized: Vector2;
+        sprite: Sprite;
+        protected _origin: Vector2;
+        protected _sprite: Sprite;
+        constructor(sprite?: Sprite | egret.Texture);
+        setSprite(sprite: Sprite): SpriteRenderer;
+        setOrigin(origin: Vector2): SpriteRenderer;
+        setOriginNormalized(value: Vector2): SpriteRenderer;
+        render(camera: Camera): void;
+    }
 }
-declare class Mesh extends RenderableComponent {
-    private _mesh;
-    constructor();
-    setTexture(texture: egret.Texture): Mesh;
-    onAddedToEntity(): void;
-    onRemovedFromEntity(): void;
-    render(camera: Camera): void;
-    reset(): void;
+declare module es {
+    class TiledSpriteRenderer extends SpriteRenderer {
+        protected sourceRect: Rectangle;
+        protected leftTexture: egret.Bitmap;
+        protected rightTexture: egret.Bitmap;
+        scrollX: number;
+        scrollY: number;
+        constructor(sprite: Sprite);
+        render(camera: es.Camera): void;
+    }
 }
-declare class SpriteRenderer extends RenderableComponent {
-    private _sprite;
-    protected bitmap: egret.Bitmap;
-    sprite: Sprite;
-    setSprite(sprite: Sprite): SpriteRenderer;
-    setColor(color: number): SpriteRenderer;
-    isVisibleFromCamera(camera: Camera): boolean;
-    render(camera: Camera): void;
-    onRemovedFromEntity(): void;
-    reset(): void;
+declare module es {
+    class ScrollingSpriteRenderer extends TiledSpriteRenderer {
+        scrollSpeedX: number;
+        scroolSpeedY: number;
+        private _scrollX;
+        private _scrollY;
+        update(): void;
+        render(camera: Camera): void;
+    }
 }
-declare class TiledSpriteRenderer extends SpriteRenderer {
-    protected sourceRect: Rectangle;
-    protected leftTexture: egret.Bitmap;
-    protected rightTexture: egret.Bitmap;
-    scrollX: number;
-    scrollY: number;
-    constructor(sprite: Sprite);
-    render(camera: Camera): void;
+declare module es {
+    class Sprite {
+        texture2D: egret.Texture;
+        readonly sourceRect: Rectangle;
+        readonly center: Vector2;
+        origin: Vector2;
+        readonly uvs: Rectangle;
+        constructor(texture: egret.Texture, sourceRect?: Rectangle, origin?: Vector2);
+    }
 }
-declare class ScrollingSpriteRenderer extends TiledSpriteRenderer {
-    scrollSpeedX: number;
-    scroolSpeedY: number;
-    private _scrollX;
-    private _scrollY;
-    update(): void;
-    render(camera: Camera): void;
+declare module es {
+    class SpriteAnimation {
+        readonly sprites: Sprite[];
+        readonly frameRate: number;
+        constructor(sprites: Sprite[], frameRate: number);
+    }
 }
-declare class Sprite {
-    texture2D: egret.Texture;
-    readonly sourceRect: Rectangle;
-    readonly center: Vector2;
-    origin: Vector2;
-    readonly uvs: Rectangle;
-    constructor(texture: egret.Texture, sourceRect?: Rectangle, origin?: Vector2);
+declare module es {
+    enum LoopMode {
+        loop = 0,
+        once = 1,
+        clampForever = 2,
+        pingPong = 3,
+        pingPongOnce = 4
+    }
+    enum State {
+        none = 0,
+        running = 1,
+        paused = 2,
+        completed = 3
+    }
+    class SpriteAnimator extends SpriteRenderer {
+        onAnimationCompletedEvent: (string: any) => {};
+        speed: number;
+        animationState: State;
+        currentAnimation: SpriteAnimation;
+        currentAnimationName: string;
+        currentFrame: number;
+        readonly isRunning: boolean;
+        readonly animations: Map<string, SpriteAnimation>;
+        private _animations;
+        _elapsedTime: number;
+        _loopMode: LoopMode;
+        constructor(sprite?: Sprite);
+        update(): void;
+        addAnimation(name: string, animation: SpriteAnimation): SpriteAnimator;
+        play(name: string, loopMode?: LoopMode): void;
+        isAnimationActive(name: string): boolean;
+        pause(): void;
+        unPause(): void;
+        stop(): void;
+    }
 }
-declare class SpriteAnimation {
-    readonly sprites: Sprite[];
-    readonly frameRate: number;
-    constructor(sprites: Sprite[], frameRate: number);
+declare module es {
+    interface ITriggerListener {
+        onTriggerEnter(other: Collider, local: Collider): any;
+        onTriggerExit(other: Collider, local: Collider): any;
+    }
 }
-declare class SpriteAnimator extends SpriteRenderer {
-    onAnimationCompletedEvent: Function;
-    speed: number;
-    animationState: State;
-    currentAnimation: SpriteAnimation;
-    currentAnimationName: string;
-    currentFrame: number;
-    readonly isRunning: boolean;
-    readonly animations: Map<string, SpriteAnimation>;
-    private _animations;
-    private _elapsedTime;
-    private _loopMode;
-    constructor(sprite?: Sprite);
-    addAnimation(name: string, animation: SpriteAnimation): SpriteAnimator;
-    play(name: string, loopMode?: LoopMode): void;
-    isAnimationActive(name: string): boolean;
-    pause(): void;
-    unPause(): void;
-    stop(): void;
-    update(): void;
+declare module es {
+    class Mover extends Component {
+        private _triggerHelper;
+        onAddedToEntity(): void;
+        calculateMovement(motion: Vector2): {
+            collisionResult: CollisionResult;
+            motion: Vector2;
+        };
+        applyMovement(motion: Vector2): void;
+        move(motion: Vector2): CollisionResult;
+    }
 }
-declare enum LoopMode {
-    loop = 0,
-    once = 1,
-    clampForever = 2,
-    pingPong = 3,
-    pingPongOnce = 4
+declare module es {
+    class ProjectileMover extends Component {
+        private _tempTriggerList;
+        private _collider;
+        onAddedToEntity(): void;
+        move(motion: Vector2): boolean;
+        private notifyTriggerListeners;
+    }
 }
-declare enum State {
-    none = 0,
-    running = 1,
-    paused = 2,
-    completed = 3
+declare module es {
+    abstract class Collider extends Component {
+        shape: Shape;
+        localOffset: Vector2;
+        readonly absolutePosition: Vector2;
+        readonly rotation: number;
+        isTrigger: boolean;
+        physicsLayer: number;
+        collidesWithLayers: number;
+        shouldColliderScaleAndRotateWithTransform: boolean;
+        readonly bounds: Rectangle;
+        registeredPhysicsBounds: Rectangle;
+        protected _colliderRequiresAutoSizing: any;
+        protected _localOffset: Vector2;
+        _localOffsetLength: number;
+        protected _isParentEntityAddedToScene: any;
+        protected _isColliderRegistered: any;
+        setLocalOffset(offset: Vector2): Collider;
+        setShouldColliderScaleAndRotateWithTransform(shouldColliderScaleAndRotationWithTransform: boolean): Collider;
+        onAddedToEntity(): void;
+        onRemovedFromEntity(): void;
+        onEntityTransformChanged(comp: transform.Component): void;
+        onEnabled(): void;
+        onDisabled(): void;
+        registerColliderWithPhysicsSystem(): void;
+        unregisterColliderWithPhysicsSystem(): void;
+        overlaps(other: Collider): any;
+        collidesWith(collider: Collider, motion: Vector2): CollisionResult;
+    }
 }
-interface ITriggerListener {
-    onTriggerEnter(other: Collider, local: Collider): any;
-    onTriggerExit(other: Collider, local: Collider): any;
+declare module es {
+    class BoxCollider extends Collider {
+        width: number;
+        height: number;
+        constructor();
+        setSize(width: number, height: number): this;
+        setWidth(width: number): BoxCollider;
+        setHeight(height: number): void;
+        toString(): string;
+    }
 }
-declare class Mover extends Component {
-    private _triggerHelper;
-    onAddedToEntity(): void;
-    calculateMovement(motion: Vector2): {
-        collisionResult: CollisionResult;
-        motion: Vector2;
-    };
-    applyMovement(motion: Vector2): void;
-    move(motion: Vector2): CollisionResult;
+declare module es {
+    class CircleCollider extends Collider {
+        radius: number;
+        constructor(radius?: number);
+        setRadius(radius: number): CircleCollider;
+        toString(): string;
+    }
 }
-declare class ProjectileMover extends Component {
-    private _tempTriggerList;
-    private _collider;
-    onAddedToEntity(): void;
-    move(motion: Vector2): boolean;
-    private notifyTriggerListeners;
+declare module es {
+    class PolygonCollider extends Collider {
+        constructor(points: Vector2[]);
+    }
 }
-declare abstract class Collider extends Component {
-    shape: Shape;
-    physicsLayer: number;
-    isTrigger: boolean;
-    registeredPhysicsBounds: Rectangle;
-    shouldColliderScaleAndRotateWithTransform: boolean;
-    collidesWithLayers: number;
-    protected _isParentEntityAddedToScene: any;
-    protected _colliderRequiresAutoSizing: any;
-    protected _isColliderRegistered: any;
-    readonly bounds: Rectangle;
-    registerColliderWithPhysicsSystem(): void;
-    unregisterColliderWithPhysicsSystem(): void;
-    overlaps(other: Collider): any;
-    collidesWith(collider: Collider, motion: Vector2): CollisionResult;
-    onAddedToEntity(): void;
-    onRemovedFromEntity(): void;
-    onEnabled(): void;
-    onDisabled(): void;
-    onEntityTransformChanged(comp: TransformComponent): void;
-    update(): void;
+declare module es {
+    class EntitySystem {
+        private _scene;
+        private _entities;
+        private _matcher;
+        readonly matcher: Matcher;
+        scene: Scene;
+        constructor(matcher?: Matcher);
+        initialize(): void;
+        onChanged(entity: Entity): void;
+        add(entity: Entity): void;
+        onAdded(entity: Entity): void;
+        remove(entity: Entity): void;
+        onRemoved(entity: Entity): void;
+        update(): void;
+        lateUpdate(): void;
+        protected begin(): void;
+        protected process(entities: Entity[]): void;
+        protected lateProcess(entities: Entity[]): void;
+        protected end(): void;
+    }
 }
-declare class BoxCollider extends Collider {
-    width: number;
-    setWidth(width: number): BoxCollider;
-    height: number;
-    setHeight(height: number): void;
-    constructor();
-    setSize(width: number, height: number): this;
+declare module es {
+    abstract class EntityProcessingSystem extends EntitySystem {
+        constructor(matcher: Matcher);
+        abstract processEntity(entity: Entity): any;
+        lateProcessEntity(entity: Entity): void;
+        protected process(entities: Entity[]): void;
+        protected lateProcess(entities: Entity[]): void;
+    }
 }
-declare class CircleCollider extends Collider {
-    radius: number;
-    constructor(radius?: number);
-    setRadius(radius: number): CircleCollider;
+declare module es {
+    abstract class PassiveSystem extends EntitySystem {
+        onChanged(entity: Entity): void;
+        protected process(entities: Entity[]): void;
+    }
 }
-declare class PolygonCollider extends Collider {
-    constructor(points: Vector2[]);
+declare module es {
+    abstract class ProcessingSystem extends EntitySystem {
+        onChanged(entity: Entity): void;
+        protected process(entities: Entity[]): void;
+        abstract processSystem(): any;
+    }
 }
-declare class EntitySystem {
-    private _scene;
-    private _entities;
-    private _matcher;
-    readonly matcher: Matcher;
-    scene: Scene;
-    constructor(matcher?: Matcher);
-    initialize(): void;
-    onChanged(entity: Entity): void;
-    add(entity: Entity): void;
-    onAdded(entity: Entity): void;
-    remove(entity: Entity): void;
-    onRemoved(entity: Entity): void;
-    update(): void;
-    lateUpdate(): void;
-    protected begin(): void;
-    protected process(entities: Entity[]): void;
-    protected lateProcess(entities: Entity[]): void;
-    protected end(): void;
+declare module es {
+    class BitSet {
+        private static LONG_MASK;
+        private _bits;
+        constructor(nbits?: number);
+        and(bs: BitSet): void;
+        andNot(bs: BitSet): void;
+        cardinality(): number;
+        clear(pos?: number): void;
+        private ensure;
+        get(pos: number): boolean;
+        intersects(set: BitSet): boolean;
+        isEmpty(): boolean;
+        nextSetBit(from: number): number;
+        set(pos: number, value?: boolean): void;
+    }
 }
-declare abstract class EntityProcessingSystem extends EntitySystem {
-    constructor(matcher: Matcher);
-    abstract processEntity(entity: Entity): any;
-    lateProcessEntity(entity: Entity): void;
-    protected process(entities: Entity[]): void;
-    protected lateProcess(entities: Entity[]): void;
+declare module es {
+    class ComponentList {
+        static compareUpdatableOrder: IUpdatableComparer;
+        _entity: Entity;
+        _components: Component[];
+        _componentsToAdd: Component[];
+        _componentsToRemove: Component[];
+        _tempBufferList: Component[];
+        _isComponentListUnsorted: boolean;
+        constructor(entity: Entity);
+        readonly count: number;
+        readonly buffer: Component[];
+        markEntityListUnsorted(): void;
+        add(component: Component): void;
+        remove(component: Component): void;
+        removeAllComponents(): void;
+        deregisterAllComponents(): void;
+        registerAllComponents(): void;
+        updateLists(): void;
+        handleRemove(component: Component): void;
+        getComponent<T extends Component>(type: any, onlyReturnInitializedComponents: boolean): T;
+        getComponents(typeName: string | any, components?: any): any;
+        update(): void;
+        onEntityTransformChanged(comp: transform.Component): void;
+        onEntityEnabled(): void;
+        onEntityDisabled(): void;
+    }
 }
-declare abstract class PassiveSystem extends EntitySystem {
-    onChanged(entity: Entity): void;
-    protected process(entities: Entity[]): void;
+declare module es {
+    class ComponentTypeManager {
+        private static _componentTypesMask;
+        static add(type: any): void;
+        static getIndexFor(type: any): number;
+    }
 }
-declare abstract class ProcessingSystem extends EntitySystem {
-    onChanged(entity: Entity): void;
-    protected process(entities: Entity[]): void;
-    abstract processSystem(): any;
+declare module es {
+    class EntityList {
+        scene: Scene;
+        private _entitiesToRemove;
+        private _entitiesToAdded;
+        private _tempEntityList;
+        private _entities;
+        private _entityDict;
+        private _unsortedTags;
+        constructor(scene: Scene);
+        readonly count: number;
+        readonly buffer: Entity[];
+        add(entity: Entity): void;
+        remove(entity: Entity): void;
+        findEntity(name: string): Entity;
+        entitiesWithTag(tag: number): Entity[];
+        entitiesOfType<T extends Entity>(type: any): T[];
+        findComponentOfType<T extends Component>(type: any): T;
+        findComponentsOfType<T extends Component>(type: any): T[];
+        getTagList(tag: number): Entity[];
+        addToTagList(entity: Entity): void;
+        removeFromTagList(entity: Entity): void;
+        update(): void;
+        removeAllEntities(): void;
+        updateLists(): void;
+    }
 }
-declare class BitSet {
-    private static LONG_MASK;
-    private _bits;
-    constructor(nbits?: number);
-    and(bs: BitSet): void;
-    andNot(bs: BitSet): void;
-    cardinality(): number;
-    clear(pos?: number): void;
-    private ensure;
-    get(pos: number): boolean;
-    intersects(set: BitSet): boolean;
-    isEmpty(): boolean;
-    nextSetBit(from: number): number;
-    set(pos: number, value?: boolean): void;
+declare module es {
+    class EntityProcessorList {
+        private _processors;
+        add(processor: EntitySystem): void;
+        remove(processor: EntitySystem): void;
+        onComponentAdded(entity: Entity): void;
+        onComponentRemoved(entity: Entity): void;
+        onEntityAdded(entity: Entity): void;
+        onEntityRemoved(entity: Entity): void;
+        protected notifyEntityChanged(entity: Entity): void;
+        protected removeFromProcessors(entity: Entity): void;
+        begin(): void;
+        update(): void;
+        lateUpdate(): void;
+        end(): void;
+        getProcessor<T extends EntitySystem>(): T;
+    }
 }
-declare class ComponentList {
-    private _entity;
-    private _components;
-    private _componentsToAdd;
-    private _componentsToRemove;
-    private _tempBufferList;
-    constructor(entity: Entity);
-    readonly count: number;
-    readonly buffer: Component[];
-    add(component: Component): void;
-    remove(component: Component): void;
-    removeAllComponents(): void;
-    deregisterAllComponents(): void;
-    registerAllComponents(): void;
-    updateLists(): void;
-    onEntityTransformChanged(comp: TransformComponent): void;
-    private handleRemove;
-    getComponent<T extends Component>(type: any, onlyReturnInitializedComponents: boolean): T;
-    getComponents(typeName: string | any, components?: any): any;
-    update(): void;
-}
-declare class ComponentTypeManager {
-    private static _componentTypesMask;
-    static add(type: any): void;
-    static getIndexFor(type: any): number;
-}
-declare class EntityList {
-    scene: Scene;
-    private _entitiesToRemove;
-    private _entitiesToAdded;
-    private _tempEntityList;
-    private _entities;
-    private _entityDict;
-    private _unsortedTags;
-    constructor(scene: Scene);
-    readonly count: number;
-    readonly buffer: Entity[];
-    add(entity: Entity): void;
-    remove(entity: Entity): void;
-    findEntity(name: string): Entity;
-    getTagList(tag: number): Entity[];
-    addToTagList(entity: Entity): void;
-    removeFromTagList(entity: Entity): void;
-    update(): void;
-    removeAllEntities(): void;
-    updateLists(): void;
-}
-declare class EntityProcessorList {
-    private _processors;
-    add(processor: EntitySystem): void;
-    remove(processor: EntitySystem): void;
-    onComponentAdded(entity: Entity): void;
-    onComponentRemoved(entity: Entity): void;
-    onEntityAdded(entity: Entity): void;
-    onEntityRemoved(entity: Entity): void;
-    protected notifyEntityChanged(entity: Entity): void;
-    protected removeFromProcessors(entity: Entity): void;
-    begin(): void;
-    update(): void;
-    lateUpdate(): void;
-    end(): void;
-    getProcessor<T extends EntitySystem>(): T;
-}
-declare class Matcher {
-    protected allSet: BitSet;
-    protected exclusionSet: BitSet;
-    protected oneSet: BitSet;
-    static empty(): Matcher;
-    getAllSet(): BitSet;
-    getExclusionSet(): BitSet;
-    getOneSet(): BitSet;
-    IsIntersted(e: Entity): boolean;
-    all(...types: any[]): Matcher;
-    exclude(...types: any[]): this;
-    one(...types: any[]): this;
+declare module es {
+    class Matcher {
+        protected allSet: BitSet;
+        protected exclusionSet: BitSet;
+        protected oneSet: BitSet;
+        static empty(): Matcher;
+        getAllSet(): BitSet;
+        getExclusionSet(): BitSet;
+        getOneSet(): BitSet;
+        IsIntersted(e: Entity): boolean;
+        all(...types: any[]): Matcher;
+        exclude(...types: any[]): this;
+        one(...types: any[]): this;
+    }
 }
 declare class ObjectUtils {
     static clone<T>(p: any, c?: T): T;
 }
-declare class RenderableComponentList {
-    private _components;
-    readonly count: number;
-    readonly buffer: IRenderable[];
-    add(component: IRenderable): void;
-    remove(component: IRenderable): void;
-    updateList(): void;
+declare module es {
+    interface IRenderable {
+        bounds: Rectangle;
+        enabled: boolean;
+        renderLayer: number;
+        isVisible: boolean;
+        isVisibleFromCamera(camera: Camera): any;
+        render(camera: Camera): any;
+    }
+    class RenderableComparer {
+        compare(self: IRenderable, other: IRenderable): number;
+    }
+}
+declare module es {
+    class RenderableComponentList {
+        static compareUpdatableOrder: RenderableComparer;
+        _components: IRenderable[];
+        _componentsByRenderLayer: Map<number, IRenderable[]>;
+        _unsortedRenderLayers: number[];
+        _componentsNeedSort: boolean;
+        readonly count: number;
+        readonly buffer: IRenderable[];
+        add(component: IRenderable): void;
+        remove(component: IRenderable): void;
+        updateRenderableRenderLayer(component: IRenderable, oldRenderLayer: number, newRenderLayer: number): void;
+        setRenderLayerNeedsComponentSort(renderLayer: number): void;
+        setNeedsComponentSort(): void;
+        addToRenderLayerList(component: IRenderable, renderLayer: number): void;
+        componentsWithRenderLayer(renderLayer: number): IRenderable[];
+        updateList(): void;
+    }
 }
 declare class StringUtils {
     static matchChineseWord(str: string): string[];
@@ -674,25 +868,29 @@ declare class StringUtils {
     static cutOff(str: string, start: number, len: number, order?: boolean): string;
     static strReplace(str: string, rStr: string[]): string;
 }
-declare class TextureUtils {
-    static sharedCanvas: HTMLCanvasElement;
-    static sharedContext: CanvasRenderingContext2D;
-    static convertImageToCanvas(texture: egret.Texture, rect?: egret.Rectangle): HTMLCanvasElement;
-    static toDataURL(type: string, texture: egret.Texture, rect?: egret.Rectangle, encoderOptions?: any): string;
-    static eliFoTevas(type: string, texture: egret.Texture, filePath: string, rect?: egret.Rectangle, encoderOptions?: any): void;
-    static getPixel32(texture: egret.Texture, x: number, y: number): number[];
-    static getPixels(texture: egret.Texture, x: number, y: number, width?: number, height?: number): number[];
+declare module es {
+    class TextureUtils {
+        static sharedCanvas: HTMLCanvasElement;
+        static sharedContext: CanvasRenderingContext2D;
+        static convertImageToCanvas(texture: egret.Texture, rect?: egret.Rectangle): HTMLCanvasElement;
+        static toDataURL(type: string, texture: egret.Texture, rect?: egret.Rectangle, encoderOptions?: any): string;
+        static eliFoTevas(type: string, texture: egret.Texture, filePath: string, rect?: egret.Rectangle, encoderOptions?: any): void;
+        static getPixel32(texture: egret.Texture, x: number, y: number): number[];
+        static getPixels(texture: egret.Texture, x: number, y: number, width?: number, height?: number): number[];
+    }
 }
-declare class Time {
-    static unscaledDeltaTime: any;
-    static deltaTime: number;
-    static timeScale: number;
-    static frameCount: number;
-    private static _lastTime;
-    static _timeSinceSceneLoad: any;
-    static update(currentTime: number): void;
-    static sceneChanged(): void;
-    static checkEvery(interval: number): boolean;
+declare module es {
+    class Time {
+        static unscaledDeltaTime: any;
+        static deltaTime: number;
+        static timeScale: number;
+        static frameCount: number;
+        private static _lastTime;
+        static _timeSinceSceneLoad: any;
+        static update(currentTime: number): void;
+        static sceneChanged(): void;
+        static checkEvery(interval: number): boolean;
+    }
 }
 declare class TimeUtils {
     static monthId(d?: Date): number;
@@ -708,362 +906,417 @@ declare class TimeUtils {
     static secondToTime(time?: number, partition?: string, showHour?: boolean): string;
     static timeToMillisecond(time: string, partition?: string): string;
 }
-declare class GraphicsCapabilities extends egret.Capabilities {
-    initialize(device: GraphicsDevice): void;
-    private platformInitialize;
+declare module es {
+    class GraphicsCapabilities extends egret.Capabilities {
+        initialize(device: GraphicsDevice): void;
+        private platformInitialize;
+    }
 }
-declare class GraphicsDevice {
-    private viewport;
-    graphicsCapabilities: GraphicsCapabilities;
-    constructor();
+declare module es {
+    class GraphicsDevice {
+        private viewport;
+        graphicsCapabilities: GraphicsCapabilities;
+        constructor();
+    }
 }
-declare class Viewport {
-    private _x;
-    private _y;
-    private _width;
-    private _height;
-    private _minDepth;
-    private _maxDepth;
-    readonly aspectRatio: number;
-    bounds: Rectangle;
-    constructor(x: number, y: number, width: number, height: number);
-}
-declare class GaussianBlurEffect extends egret.CustomFilter {
-    private static blur_frag;
-    constructor();
-}
-declare class PolygonLightEffect extends egret.CustomFilter {
-    private static vertSrc;
-    private static fragmentSrc;
-    constructor();
-}
-declare class PostProcessor {
-    enable: boolean;
-    effect: egret.Filter;
-    scene: Scene;
-    shape: egret.Shape;
-    static default_vert: string;
-    constructor(effect?: egret.Filter);
-    onAddedToScene(scene: Scene): void;
-    process(): void;
-    onSceneBackBufferSizeChanged(newWidth: number, newHeight: number): void;
-    protected drawFullscreenQuad(): void;
-    unload(): void;
-}
-declare class GaussianBlurPostProcessor extends PostProcessor {
-    onAddedToScene(scene: Scene): void;
-}
-declare abstract class Renderer {
-    camera: Camera;
-    onAddedToScene(scene: Scene): void;
-    protected beginRender(cam: Camera): void;
-    abstract render(scene: Scene): any;
-    unload(): void;
-    protected renderAfterStateCheck(renderable: IRenderable, cam: Camera): void;
-}
-declare class DefaultRenderer extends Renderer {
-    render(scene: Scene): void;
-}
-interface IRenderable {
-    bounds: Rectangle;
-    enabled: boolean;
-    isVisible: boolean;
-    isVisibleFromCamera(camera: Camera): any;
-    render(camera: Camera): any;
-}
-declare class ScreenSpaceRenderer extends Renderer {
-    render(scene: Scene): void;
-}
-declare class PolyLight extends RenderableComponent {
-    power: number;
-    protected _radius: number;
-    private _lightEffect;
-    private _indices;
-    radius: number;
-    constructor(radius: number, color: number, power: number);
-    private computeTriangleIndices;
-    setRadius(radius: number): void;
-    render(camera: Camera): void;
-    reset(): void;
-}
-declare abstract class SceneTransition {
-    private _hasPreviousSceneRender;
-    loadsNewScene: boolean;
-    isNewSceneLoaded: boolean;
-    protected sceneLoadAction: Function;
-    onScreenObscured: Function;
-    onTransitionCompleted: Function;
-    readonly hasPreviousSceneRender: boolean;
-    constructor(sceneLoadAction: Function);
-    preRender(): void;
-    render(): void;
-    onBeginTransition(): Promise<void>;
-    protected transitionComplete(): void;
-    protected loadNextScene(): Promise<void>;
-    tickEffectProgressProperty(filter: egret.CustomFilter, duration: number, easeType: Function, reverseDirection?: boolean): Promise<boolean>;
-}
-declare class FadeTransition extends SceneTransition {
-    fadeToColor: number;
-    fadeOutDuration: number;
-    fadeEaseType: Function;
-    delayBeforeFadeInDuration: number;
-    private _mask;
-    private _alpha;
-    constructor(sceneLoadAction: Function);
-    onBeginTransition(): Promise<void>;
-    render(): void;
-}
-declare class WindTransition extends SceneTransition {
-    private _mask;
-    private _windEffect;
-    duration: number;
-    windSegments: number;
-    size: number;
-    easeType: (t: number) => number;
-    constructor(sceneLoadAction: Function);
-    onBeginTransition(): Promise<void>;
-}
-declare class Bezier {
-    static getPoint(p0: Vector2, p1: Vector2, p2: Vector2, t: number): Vector2;
-    static getFirstDerivative(p0: Vector2, p1: Vector2, p2: Vector2, t: number): Vector2;
-    static getFirstDerivativeThree(start: Vector2, firstControlPoint: Vector2, secondControlPoint: Vector2, end: Vector2, t: number): Vector2;
-    static getPointThree(start: Vector2, firstControlPoint: Vector2, secondControlPoint: Vector2, end: Vector2, t: number): Vector2;
-    static getOptimizedDrawingPoints(start: Vector2, firstCtrlPoint: Vector2, secondCtrlPoint: Vector2, end: Vector2, distanceTolerance?: number): Vector2[];
-    private static recursiveGetOptimizedDrawingPoints;
-}
-declare class Flags {
-    static isFlagSet(self: number, flag: number): boolean;
-    static isUnshiftedFlagSet(self: number, flag: number): boolean;
-    static setFlagExclusive(self: number, flag: number): number;
-    static setFlag(self: number, flag: number): number;
-    static unsetFlag(self: number, flag: number): number;
-    static invertFlags(self: number): number;
-}
-declare class MathHelper {
-    static readonly Epsilon: number;
-    static readonly Rad2Deg: number;
-    static readonly Deg2Rad: number;
-    static toDegrees(radians: number): number;
-    static toRadians(degrees: number): number;
-    static map(value: number, leftMin: number, leftMax: number, rightMin: number, rightMax: number): number;
-    static lerp(value1: number, value2: number, amount: number): number;
-    static clamp(value: number, min: number, max: number): number;
-    static pointOnCirlce(circleCenter: Vector2, radius: number, angleInDegrees: number): Vector2;
-    static isEven(value: number): boolean;
-    static clamp01(value: number): number;
-    static angleBetweenVectors(from: Vector2, to: Vector2): number;
-}
-declare class Matrix2D {
-    m11: number;
-    m12: number;
-    m21: number;
-    m22: number;
-    m31: number;
-    m32: number;
-    private static _identity;
-    static readonly identity: Matrix2D;
-    constructor(m11?: number, m12?: number, m21?: number, m22?: number, m31?: number, m32?: number);
-    translation: Vector2;
-    rotation: number;
-    rotationDegrees: number;
-    scale: Vector2;
-    static add(matrix1: Matrix2D, matrix2: Matrix2D): Matrix2D;
-    static divide(matrix1: Matrix2D, matrix2: Matrix2D): Matrix2D;
-    static multiply(matrix1: Matrix2D, matrix2: Matrix2D): Matrix2D;
-    static multiplyTranslation(matrix: Matrix2D, x: number, y: number): Matrix2D;
-    determinant(): number;
-    static invert(matrix: Matrix2D, result?: Matrix2D): Matrix2D;
-    static createTranslation(xPosition: number, yPosition: number): Matrix2D;
-    static createTranslationVector(position: Vector2): Matrix2D;
-    static createRotation(radians: number, result?: Matrix2D): Matrix2D;
-    static createScale(xScale: number, yScale: number, result?: Matrix2D): Matrix2D;
-    toEgretMatrix(): egret.Matrix;
-}
-declare class Rectangle extends egret.Rectangle {
-    readonly max: Vector2;
-    readonly center: Vector2;
-    location: Vector2;
-    size: Vector2;
-    intersects(value: egret.Rectangle): boolean;
-    containsRect(value: Rectangle): boolean;
-    getHalfSize(): Vector2;
-    static fromMinMax(minX: number, minY: number, maxX: number, maxY: number): Rectangle;
-    getClosestPointOnRectangleBorderToPoint(point: Vector2): {
-        res: Vector2;
-        edgeNormal: Vector2;
-    };
-    getClosestPointOnBoundsToOrigin(): Vector2;
-    setEgretRect(rect: egret.Rectangle): Rectangle;
-    static rectEncompassingPoints(points: Vector2[]): Rectangle;
-}
-declare class Vector3 {
-    x: number;
-    y: number;
-    z: number;
-    constructor(x: number, y: number, z: number);
-}
-declare class ColliderTriggerHelper {
-    private _entity;
-    private _activeTriggerIntersections;
-    private _previousTriggerIntersections;
-    private _tempTriggerList;
-    constructor(entity: Entity);
-    update(): void;
-    private checkForExitedColliders;
-    private notifyTriggerListeners;
-}
-declare enum PointSectors {
-    center = 0,
-    top = 1,
-    bottom = 2,
-    topLeft = 9,
-    topRight = 5,
-    left = 8,
-    right = 4,
-    bottomLeft = 10,
-    bottomRight = 6
-}
-declare class Collisions {
-    static isLineToLine(a1: Vector2, a2: Vector2, b1: Vector2, b2: Vector2): boolean;
-    static lineToLineIntersection(a1: Vector2, a2: Vector2, b1: Vector2, b2: Vector2): Vector2;
-    static closestPointOnLine(lineA: Vector2, lineB: Vector2, closestTo: Vector2): Vector2;
-    static isCircleToCircle(circleCenter1: Vector2, circleRadius1: number, circleCenter2: Vector2, circleRadius2: number): boolean;
-    static isCircleToLine(circleCenter: Vector2, radius: number, lineFrom: Vector2, lineTo: Vector2): boolean;
-    static isCircleToPoint(circleCenter: Vector2, radius: number, point: Vector2): boolean;
-    static isRectToCircle(rect: egret.Rectangle, cPosition: Vector2, cRadius: number): boolean;
-    static isRectToLine(rect: Rectangle, lineFrom: Vector2, lineTo: Vector2): boolean;
-    static isRectToPoint(rX: number, rY: number, rW: number, rH: number, point: Vector2): boolean;
-    static getSector(rX: number, rY: number, rW: number, rH: number, point: Vector2): PointSectors;
-}
-declare class Physics {
-    private static _spatialHash;
-    static spatialHashCellSize: number;
-    static readonly allLayers: number;
-    static reset(): void;
-    static clear(): void;
-    static overlapCircleAll(center: Vector2, randius: number, results: any[], layerMask?: number): number;
-    static boxcastBroadphase(rect: Rectangle, layerMask?: number): {
-        colliders: Collider[];
-        rect: Rectangle;
-    };
-    static boxcastBroadphaseExcludingSelf(collider: Collider, rect: Rectangle, layerMask?: number): {
-        tempHashSet: Collider[];
+declare module es {
+    class Viewport {
+        private _x;
+        private _y;
+        private _width;
+        private _height;
+        private _minDepth;
+        private _maxDepth;
+        readonly aspectRatio: number;
         bounds: Rectangle;
-    };
-    static addCollider(collider: Collider): void;
-    static removeCollider(collider: Collider): void;
-    static updateCollider(collider: Collider): void;
-    static debugDraw(secondsToDisplay: any): void;
+        constructor(x: number, y: number, width: number, height: number);
+    }
 }
-declare abstract class Shape extends egret.DisplayObject {
-    abstract bounds: Rectangle;
-    abstract center: Vector2;
-    abstract position: Vector2;
-    abstract pointCollidesWithShape(point: Vector2): CollisionResult;
-    abstract overlaps(other: Shape): any;
-    abstract collidesWithShape(other: Shape): CollisionResult;
+declare module es {
+    class GaussianBlurEffect extends egret.CustomFilter {
+        private static blur_frag;
+        constructor();
+    }
 }
-declare class Polygon extends Shape {
-    points: Vector2[];
-    private _polygonCenter;
-    private _areEdgeNormalsDirty;
-    protected _originalPoints: Vector2[];
-    center: Vector2;
-    readonly position: Vector2;
-    readonly bounds: Rectangle;
-    _edgeNormals: Vector2[];
-    readonly edgeNormals: Vector2[];
-    isBox: boolean;
-    constructor(points: Vector2[], isBox?: boolean);
-    private buildEdgeNormals;
-    setPoints(points: Vector2[]): void;
-    collidesWithShape(other: Shape): any;
-    recalculateCenterAndEdgeNormals(): void;
-    overlaps(other: Shape): any;
-    static findPolygonCenter(points: Vector2[]): Vector2;
-    static recenterPolygonVerts(points: Vector2[]): void;
-    static getClosestPointOnPolygonToPoint(points: Vector2[], point: Vector2): {
-        closestPoint: any;
-        distanceSquared: any;
-        edgeNormal: any;
-    };
-    pointCollidesWithShape(point: Vector2): CollisionResult;
-    containsPoint(point: Vector2): boolean;
-    static buildSymmertricalPolygon(vertCount: number, radius: number): any[];
+declare module es {
+    class PolygonLightEffect extends egret.CustomFilter {
+        private static vertSrc;
+        private static fragmentSrc;
+        constructor();
+    }
 }
-declare class Box extends Polygon {
-    constructor(width: number, height: number);
-    private static buildBox;
-    overlaps(other: Shape): any;
-    collidesWithShape(other: Shape): any;
-    updateBox(width: number, height: number): void;
-    containsPoint(point: Vector2): boolean;
+declare module es {
+    class PostProcessor {
+        enabled: boolean;
+        effect: egret.Filter;
+        scene: Scene;
+        shape: egret.Shape;
+        static default_vert: string;
+        constructor(effect?: egret.Filter);
+        onAddedToScene(scene: Scene): void;
+        process(): void;
+        onSceneBackBufferSizeChanged(newWidth: number, newHeight: number): void;
+        protected drawFullscreenQuad(): void;
+        unload(): void;
+    }
 }
-declare class Circle extends Shape {
-    radius: number;
-    _originalRadius: number;
-    center: Vector2;
-    readonly position: Vector2;
-    readonly bounds: Rectangle;
-    constructor(radius: number);
-    pointCollidesWithShape(point: Vector2): CollisionResult;
-    collidesWithShape(other: Shape): CollisionResult;
-    overlaps(other: Shape): any;
+declare module es {
+    class GaussianBlurPostProcessor extends PostProcessor {
+        onAddedToScene(scene: Scene): void;
+    }
 }
-declare class CollisionResult {
-    collider: Collider;
-    minimumTranslationVector: Vector2;
-    normal: Vector2;
-    point: Vector2;
-    invertResult(): void;
+declare module es {
+    abstract class Renderer {
+        camera: Camera;
+        onAddedToScene(scene: Scene): void;
+        protected beginRender(cam: Camera): void;
+        abstract render(scene: Scene): any;
+        unload(): void;
+        protected renderAfterStateCheck(renderable: IRenderable, cam: Camera): void;
+    }
 }
-declare class ShapeCollisions {
-    static polygonToPolygon(first: Polygon, second: Polygon): CollisionResult;
-    static intervalDistance(minA: number, maxA: number, minB: number, maxB: any): number;
-    static getInterval(axis: Vector2, polygon: Polygon, min: number, max: number): {
-        min: number;
-        max: number;
-    };
-    static circleToPolygon(circle: Circle, polygon: Polygon): CollisionResult;
-    static circleToBox(circle: Circle, box: Box): CollisionResult;
-    static pointToCircle(point: Vector2, circle: Circle): CollisionResult;
-    static closestPointOnLine(lineA: Vector2, lineB: Vector2, closestTo: Vector2): Vector2;
-    static pointToPoly(point: Vector2, poly: Polygon): CollisionResult;
-    static circleToCircle(first: Circle, second: Circle): CollisionResult;
-    static boxToBox(first: Box, second: Box): CollisionResult;
-    private static minkowskiDifference;
+declare module es {
+    class DefaultRenderer extends Renderer {
+        render(scene: Scene): void;
+    }
 }
-declare class SpatialHash {
-    gridBounds: Rectangle;
-    private _raycastParser;
-    private _cellSize;
-    private _inverseCellSize;
-    private _overlapTestCircle;
-    private _tempHashSet;
-    private _cellDict;
-    constructor(cellSize?: number);
-    remove(collider: Collider): void;
-    register(collider: Collider): void;
-    clear(): void;
-    overlapCircle(circleCenter: Vector2, radius: number, results: Collider[], layerMask: any): number;
-    aabbBroadphase(bounds: Rectangle, excludeCollider: Collider, layerMask: number): {
-        tempHashSet: Collider[];
+declare module es {
+    class ScreenSpaceRenderer extends Renderer {
+        render(scene: Scene): void;
+    }
+}
+declare module es {
+    class PolyLight extends RenderableComponent {
+        power: number;
+        protected _radius: number;
+        private _lightEffect;
+        private _indices;
+        radius: number;
+        constructor(radius: number, color: number, power: number);
+        private computeTriangleIndices;
+        setRadius(radius: number): void;
+        render(camera: Camera): void;
+        reset(): void;
+    }
+}
+declare module es {
+    abstract class SceneTransition {
+        private _hasPreviousSceneRender;
+        loadsNewScene: boolean;
+        isNewSceneLoaded: boolean;
+        protected sceneLoadAction: Function;
+        onScreenObscured: Function;
+        onTransitionCompleted: Function;
+        readonly hasPreviousSceneRender: boolean;
+        constructor(sceneLoadAction: Function);
+        preRender(): void;
+        render(): void;
+        onBeginTransition(): Promise<void>;
+        protected transitionComplete(): void;
+        protected loadNextScene(): Promise<void>;
+        tickEffectProgressProperty(filter: egret.CustomFilter, duration: number, easeType: Function, reverseDirection?: boolean): Promise<boolean>;
+    }
+}
+declare module es {
+    class FadeTransition extends SceneTransition {
+        fadeToColor: number;
+        fadeOutDuration: number;
+        fadeEaseType: Function;
+        delayBeforeFadeInDuration: number;
+        private _mask;
+        private _alpha;
+        constructor(sceneLoadAction: Function);
+        onBeginTransition(): Promise<void>;
+        render(): void;
+    }
+}
+declare module es {
+    class WindTransition extends SceneTransition {
+        private _mask;
+        private _windEffect;
+        duration: number;
+        windSegments: number;
+        size: number;
+        easeType: (t: number) => number;
+        constructor(sceneLoadAction: Function);
+        onBeginTransition(): Promise<void>;
+    }
+}
+declare module es {
+    class Bezier {
+        static getPoint(p0: Vector2, p1: Vector2, p2: Vector2, t: number): Vector2;
+        static getFirstDerivative(p0: Vector2, p1: Vector2, p2: Vector2, t: number): Vector2;
+        static getFirstDerivativeThree(start: Vector2, firstControlPoint: Vector2, secondControlPoint: Vector2, end: Vector2, t: number): Vector2;
+        static getPointThree(start: Vector2, firstControlPoint: Vector2, secondControlPoint: Vector2, end: Vector2, t: number): Vector2;
+        static getOptimizedDrawingPoints(start: Vector2, firstCtrlPoint: Vector2, secondCtrlPoint: Vector2, end: Vector2, distanceTolerance?: number): Vector2[];
+        private static recursiveGetOptimizedDrawingPoints;
+    }
+}
+declare module es {
+    class Flags {
+        static isFlagSet(self: number, flag: number): boolean;
+        static isUnshiftedFlagSet(self: number, flag: number): boolean;
+        static setFlagExclusive(self: number, flag: number): number;
+        static setFlag(self: number, flag: number): number;
+        static unsetFlag(self: number, flag: number): number;
+        static invertFlags(self: number): number;
+    }
+}
+declare module es {
+    class MathHelper {
+        static readonly Epsilon: number;
+        static readonly Rad2Deg: number;
+        static readonly Deg2Rad: number;
+        static toDegrees(radians: number): number;
+        static toRadians(degrees: number): number;
+        static map(value: number, leftMin: number, leftMax: number, rightMin: number, rightMax: number): number;
+        static lerp(value1: number, value2: number, amount: number): number;
+        static clamp(value: number, min: number, max: number): number;
+        static pointOnCirlce(circleCenter: Vector2, radius: number, angleInDegrees: number): Vector2;
+        static isEven(value: number): boolean;
+        static clamp01(value: number): number;
+        static angleBetweenVectors(from: Vector2, to: Vector2): number;
+    }
+}
+declare module es {
+    class Matrix2D {
+        m11: number;
+        m12: number;
+        m21: number;
+        m22: number;
+        m31: number;
+        m32: number;
+        private static _identity;
+        static readonly identity: Matrix2D;
+        constructor(m11?: number, m12?: number, m21?: number, m22?: number, m31?: number, m32?: number);
+        translation: Vector2;
+        rotation: number;
+        rotationDegrees: number;
+        scale: Vector2;
+        static add(matrix1: Matrix2D, matrix2: Matrix2D): Matrix2D;
+        static divide(matrix1: Matrix2D, matrix2: Matrix2D): Matrix2D;
+        static multiply(matrix1: Matrix2D, matrix2: Matrix2D): Matrix2D;
+        static multiplyTranslation(matrix: Matrix2D, x: number, y: number): Matrix2D;
+        determinant(): number;
+        static invert(matrix: Matrix2D, result?: Matrix2D): Matrix2D;
+        static createTranslation(xPosition: number, yPosition: number): Matrix2D;
+        static createTranslationVector(position: Vector2): Matrix2D;
+        static createRotation(radians: number, result?: Matrix2D): Matrix2D;
+        static createScale(xScale: number, yScale: number, result?: Matrix2D): Matrix2D;
+        toEgretMatrix(): egret.Matrix;
+    }
+}
+declare module es {
+    class Rectangle extends egret.Rectangle {
+        readonly max: Vector2;
+        readonly center: Vector2;
+        location: Vector2;
+        size: Vector2;
+        intersects(value: egret.Rectangle): boolean;
+        containsRect(value: Rectangle): boolean;
+        getHalfSize(): Vector2;
+        static fromMinMax(minX: number, minY: number, maxX: number, maxY: number): Rectangle;
+        getClosestPointOnRectangleBorderToPoint(point: Vector2): {
+            res: Vector2;
+            edgeNormal: Vector2;
+        };
+        getClosestPointOnBoundsToOrigin(): Vector2;
+        calculateBounds(parentPosition: Vector2, position: Vector2, origin: Vector2, scale: Vector2, rotation: number, width: number, height: number): void;
+        setEgretRect(rect: egret.Rectangle): Rectangle;
+        static rectEncompassingPoints(points: Vector2[]): Rectangle;
+    }
+}
+declare module es {
+    class Vector3 {
+        x: number;
+        y: number;
+        z: number;
+        constructor(x: number, y: number, z: number);
+    }
+}
+declare module es {
+    class ColliderTriggerHelper {
+        private _entity;
+        private _activeTriggerIntersections;
+        private _previousTriggerIntersections;
+        private _tempTriggerList;
+        constructor(entity: Entity);
+        update(): void;
+        private checkForExitedColliders;
+        private notifyTriggerListeners;
+    }
+}
+declare module es {
+    enum PointSectors {
+        center = 0,
+        top = 1,
+        bottom = 2,
+        topLeft = 9,
+        topRight = 5,
+        left = 8,
+        right = 4,
+        bottomLeft = 10,
+        bottomRight = 6
+    }
+    class Collisions {
+        static isLineToLine(a1: Vector2, a2: Vector2, b1: Vector2, b2: Vector2): boolean;
+        static lineToLineIntersection(a1: Vector2, a2: Vector2, b1: Vector2, b2: Vector2): Vector2;
+        static closestPointOnLine(lineA: Vector2, lineB: Vector2, closestTo: Vector2): Vector2;
+        static isCircleToCircle(circleCenter1: Vector2, circleRadius1: number, circleCenter2: Vector2, circleRadius2: number): boolean;
+        static isCircleToLine(circleCenter: Vector2, radius: number, lineFrom: Vector2, lineTo: Vector2): boolean;
+        static isCircleToPoint(circleCenter: Vector2, radius: number, point: Vector2): boolean;
+        static isRectToCircle(rect: egret.Rectangle, cPosition: Vector2, cRadius: number): boolean;
+        static isRectToLine(rect: Rectangle, lineFrom: Vector2, lineTo: Vector2): boolean;
+        static isRectToPoint(rX: number, rY: number, rW: number, rH: number, point: Vector2): boolean;
+        static getSector(rX: number, rY: number, rW: number, rH: number, point: Vector2): PointSectors;
+    }
+}
+declare module es {
+    class Physics {
+        private static _spatialHash;
+        static spatialHashCellSize: number;
+        static readonly allLayers: number;
+        static reset(): void;
+        static clear(): void;
+        static overlapCircleAll(center: Vector2, randius: number, results: any[], layerMask?: number): number;
+        static boxcastBroadphase(rect: Rectangle, layerMask?: number): {
+            colliders: Collider[];
+            rect: Rectangle;
+        };
+        static boxcastBroadphaseExcludingSelf(collider: Collider, rect: Rectangle, layerMask?: number): {
+            tempHashSet: Collider[];
+            bounds: Rectangle;
+        };
+        static addCollider(collider: Collider): void;
+        static removeCollider(collider: Collider): void;
+        static updateCollider(collider: Collider): void;
+        static debugDraw(secondsToDisplay: any): void;
+    }
+}
+declare module es {
+    abstract class Shape {
+        position: Vector2;
+        center: Vector2;
         bounds: Rectangle;
-    };
-    private cellAtPosition;
-    private cellCoords;
-    debugDraw(secondsToDisplay: number, textScale?: number): void;
-    private debugDrawCellDetails;
+        abstract recalculateBounds(collider: Collider): any;
+        abstract pointCollidesWithShape(point: Vector2): CollisionResult;
+        abstract overlaps(other: Shape): any;
+        abstract collidesWithShape(other: Shape): CollisionResult;
+    }
 }
-declare class RaycastResultParser {
+declare module es {
+    class Polygon extends Shape {
+        points: Vector2[];
+        readonly edgeNormals: Vector2[];
+        _areEdgeNormalsDirty: boolean;
+        _edgeNormals: Vector2[];
+        _originalPoints: Vector2[];
+        _polygonCenter: Vector2;
+        isBox: boolean;
+        isUnrotated: boolean;
+        constructor(points: Vector2[], isBox?: boolean);
+        setPoints(points: Vector2[]): void;
+        recalculateCenterAndEdgeNormals(): void;
+        buildEdgeNormals(): void;
+        static buildSymmetricalPolygon(vertCount: number, radius: number): any[];
+        static recenterPolygonVerts(points: Vector2[]): void;
+        static findPolygonCenter(points: Vector2[]): Vector2;
+        static getClosestPointOnPolygonToPoint(points: Vector2[], point: Vector2): {
+            closestPoint: any;
+            distanceSquared: any;
+            edgeNormal: any;
+        };
+        recalculateBounds(collider: Collider): void;
+        overlaps(other: Shape): any;
+        collidesWithShape(other: Shape): any;
+        containsPoint(point: Vector2): boolean;
+        pointCollidesWithShape(point: Vector2): CollisionResult;
+    }
 }
-declare class NumberDictionary {
-    private _store;
-    private getKey;
-    add(x: number, y: number, list: Collider[]): void;
-    remove(obj: Collider): void;
-    tryGetValue(x: number, y: number): Collider[];
-    clear(): void;
+declare module es {
+    class Box extends Polygon {
+        width: number;
+        height: number;
+        constructor(width: number, height: number);
+        private static buildBox;
+        updateBox(width: number, height: number): void;
+        overlaps(other: Shape): any;
+        collidesWithShape(other: Shape): any;
+        containsPoint(point: Vector2): boolean;
+    }
+}
+declare module es {
+    class Circle extends Shape {
+        radius: number;
+        _originalRadius: number;
+        constructor(radius: number);
+        recalculateBounds(collider: es.Collider): void;
+        overlaps(other: Shape): any;
+        collidesWithShape(other: Shape): CollisionResult;
+        pointCollidesWithShape(point: Vector2): CollisionResult;
+    }
+}
+declare module es {
+    class CollisionResult {
+        collider: Collider;
+        minimumTranslationVector: Vector2;
+        normal: Vector2;
+        point: Vector2;
+        invertResult(): void;
+    }
+}
+declare module es {
+    class ShapeCollisions {
+        static polygonToPolygon(first: Polygon, second: Polygon): CollisionResult;
+        static intervalDistance(minA: number, maxA: number, minB: number, maxB: any): number;
+        static getInterval(axis: Vector2, polygon: Polygon, min: number, max: number): {
+            min: number;
+            max: number;
+        };
+        static circleToPolygon(circle: Circle, polygon: Polygon): CollisionResult;
+        static circleToBox(circle: Circle, box: Box): CollisionResult;
+        static pointToCircle(point: Vector2, circle: Circle): CollisionResult;
+        static closestPointOnLine(lineA: Vector2, lineB: Vector2, closestTo: Vector2): Vector2;
+        static pointToPoly(point: Vector2, poly: Polygon): CollisionResult;
+        static circleToCircle(first: Circle, second: Circle): CollisionResult;
+        static boxToBox(first: Box, second: Box): CollisionResult;
+        private static minkowskiDifference;
+    }
+}
+declare module es {
+    class SpatialHash {
+        gridBounds: Rectangle;
+        _raycastParser: RaycastResultParser;
+        _cellSize: number;
+        _inverseCellSize: number;
+        _overlapTestCircle: Circle;
+        _cellDict: NumberDictionary;
+        _tempHashSet: Collider[];
+        constructor(cellSize?: number);
+        private cellCoords;
+        private cellAtPosition;
+        register(collider: Collider): void;
+        remove(collider: Collider): void;
+        removeWithBruteForce(obj: Collider): void;
+        clear(): void;
+        debugDraw(secondsToDisplay: number, textScale?: number): void;
+        private debugDrawCellDetails;
+        aabbBroadphase(bounds: Rectangle, excludeCollider: Collider, layerMask: number): {
+            tempHashSet: Collider[];
+            bounds: Rectangle;
+        };
+        overlapCircle(circleCenter: Vector2, radius: number, results: Collider[], layerMask: any): number;
+    }
+    class NumberDictionary {
+        _store: Map<string, Collider[]>;
+        private getKey;
+        add(x: number, y: number, list: Collider[]): void;
+        remove(obj: Collider): void;
+        tryGetValue(x: number, y: number): Collider[];
+        clear(): void;
+    }
+    class RaycastResultParser {
+    }
 }
 declare class ArrayUtils {
     static bubbleSort(ary: number[]): void;
@@ -1090,72 +1343,83 @@ declare class Base64Utils {
     private static _utf8_decode;
     private static getConfKey;
 }
-declare class ContentManager {
-    protected loadedAssets: Map<string, any>;
-    loadRes(name: string, local?: boolean): Promise<any>;
-    dispose(): void;
+declare module es {
+    class ContentManager {
+        protected loadedAssets: Map<string, any>;
+        loadRes(name: string, local?: boolean): Promise<any>;
+        dispose(): void;
+    }
 }
-declare class DrawUtils {
-    static drawLine(shape: egret.Shape, start: Vector2, end: Vector2, color: number, thickness?: number): void;
-    static drawLineAngle(shape: egret.Shape, start: Vector2, radians: number, length: number, color: number, thickness?: number): void;
-    static drawHollowRect(shape: egret.Shape, rect: Rectangle, color: number, thickness?: number): void;
-    static drawHollowRectR(shape: egret.Shape, x: number, y: number, width: number, height: number, color: number, thickness?: number): void;
-    static drawPixel(shape: egret.Shape, position: Vector2, color: number, size?: number): void;
+declare module es {
+    class DrawUtils {
+        static drawLine(shape: egret.Shape, start: Vector2, end: Vector2, color: number, thickness?: number): void;
+        static drawLineAngle(shape: egret.Shape, start: Vector2, radians: number, length: number, color: number, thickness?: number): void;
+        static drawHollowRect(shape: egret.Shape, rect: Rectangle, color: number, thickness?: number): void;
+        static drawHollowRectR(shape: egret.Shape, x: number, y: number, width: number, height: number, color: number, thickness?: number): void;
+        static drawPixel(shape: egret.Shape, position: Vector2, color: number, size?: number): void;
+        static getColorMatrix(color: number): egret.ColorMatrixFilter;
+    }
 }
-declare class Emitter<T> {
-    private _messageTable;
-    constructor();
-    addObserver(eventType: T, handler: Function, context: any): void;
-    removeObserver(eventType: T, handler: Function): void;
-    emit(eventType: T, data?: any): void;
+declare module es {
+    class FuncPack {
+        func: Function;
+        context: any;
+        constructor(func: Function, context: any);
+    }
+    class Emitter<T> {
+        private _messageTable;
+        constructor();
+        addObserver(eventType: T, handler: Function, context: any): void;
+        removeObserver(eventType: T, handler: Function): void;
+        emit(eventType: T, data?: any): void;
+    }
 }
-declare class FuncPack {
-    func: Function;
-    context: any;
-    constructor(func: Function, context: any);
+declare module es {
+    class GlobalManager {
+        static globalManagers: GlobalManager[];
+        private _enabled;
+        enabled: boolean;
+        setEnabled(isEnabled: boolean): void;
+        onEnabled(): void;
+        onDisabled(): void;
+        update(): void;
+        static registerGlobalManager(manager: GlobalManager): void;
+        static unregisterGlobalManager(manager: GlobalManager): void;
+        static getGlobalManager<T extends GlobalManager>(type: any): T;
+    }
 }
-declare class GlobalManager {
-    static globalManagers: GlobalManager[];
-    private _enabled;
-    enabled: boolean;
-    setEnabled(isEnabled: boolean): void;
-    onEnabled(): void;
-    onDisabled(): void;
-    update(): void;
-    static registerGlobalManager(manager: GlobalManager): void;
-    static unregisterGlobalManager(manager: GlobalManager): void;
-    static getGlobalManager<T extends GlobalManager>(type: any): T;
-}
-declare class TouchState {
-    x: number;
-    y: number;
-    touchPoint: number;
-    touchDown: boolean;
-    readonly position: Vector2;
-    reset(): void;
-}
-declare class Input {
-    private static _init;
-    private static _stage;
-    private static _previousTouchState;
-    private static _gameTouchs;
-    private static _resolutionOffset;
-    private static _resolutionScale;
-    private static _touchIndex;
-    private static _totalTouchCount;
-    static readonly touchPosition: Vector2;
-    static maxSupportedTouch: number;
-    static readonly resolutionScale: Vector2;
-    static readonly totalTouchCount: number;
-    static readonly gameTouchs: TouchState[];
-    static readonly touchPositionDelta: Vector2;
-    static initialize(stage: egret.Stage): void;
-    private static initTouchCache;
-    private static touchBegin;
-    private static touchMove;
-    private static touchEnd;
-    private static setpreviousTouchState;
-    static scaledPosition(position: Vector2): Vector2;
+declare module es {
+    class TouchState {
+        x: number;
+        y: number;
+        touchPoint: number;
+        touchDown: boolean;
+        readonly position: Vector2;
+        reset(): void;
+    }
+    class Input {
+        private static _init;
+        private static _stage;
+        private static _previousTouchState;
+        private static _gameTouchs;
+        private static _resolutionOffset;
+        private static _resolutionScale;
+        private static _touchIndex;
+        private static _totalTouchCount;
+        static readonly touchPosition: Vector2;
+        static maxSupportedTouch: number;
+        static readonly resolutionScale: Vector2;
+        static readonly totalTouchCount: number;
+        static readonly gameTouchs: TouchState[];
+        static readonly touchPositionDelta: Vector2;
+        static initialize(stage: egret.Stage): void;
+        private static initTouchCache;
+        private static touchBegin;
+        private static touchMove;
+        private static touchEnd;
+        private static setpreviousTouchState;
+        static scaledPosition(position: Vector2): Vector2;
+    }
 }
 declare class KeyboardUtils {
     static TYPE_KEY_DOWN: number;
@@ -1241,13 +1505,15 @@ declare class KeyboardUtils {
     private static keyCodeToString;
     static destroy(): void;
 }
-declare class ListPool {
-    private static readonly _objectQueue;
-    static warmCache(cacheCount: number): void;
-    static trimCache(cacheCount: any): void;
-    static clearCache(): void;
-    static obtain<T>(): Array<T>;
-    static free<T>(obj: Array<T>): void;
+declare module es {
+    class ListPool {
+        private static readonly _objectQueue;
+        static warmCache(cacheCount: number): void;
+        static trimCache(cacheCount: any): void;
+        static clearCache(): void;
+        static obtain<T>(): T[];
+        static free<T>(obj: Array<T>): void;
+    }
 }
 declare const THREAD_ID: string;
 declare const setItem: any;
@@ -1260,12 +1526,14 @@ declare class LockUtils {
     constructor(key: any);
     lock(): Promise<{}>;
 }
-declare class Pair<T> {
-    first: T;
-    second: T;
-    constructor(first: T, second: T);
-    clear(): void;
-    equals(other: Pair<T>): boolean;
+declare module es {
+    class Pair<T> {
+        first: T;
+        second: T;
+        constructor(first: T, second: T);
+        clear(): void;
+        equals(other: Pair<T>): boolean;
+    }
 }
 declare class RandomUtils {
     static randrange(start: number, stop: number, step?: number): number;
@@ -1278,53 +1546,61 @@ declare class RandomUtils {
     static random(): number;
     static boolean(chance?: number): boolean;
 }
-declare class RectangleExt {
-    static union(first: Rectangle, point: Vector2): Rectangle;
+declare module es {
+    class RectangleExt {
+        static union(first: Rectangle, point: Vector2): Rectangle;
+    }
 }
-declare class Triangulator {
-    triangleIndices: number[];
-    private _triPrev;
-    private _triNext;
-    triangulate(points: Vector2[], arePointsCCW?: boolean): void;
-    private initialize;
-    static testPointTriangle(point: Vector2, a: Vector2, b: Vector2, c: Vector2): boolean;
+declare module es {
+    class Triangulator {
+        triangleIndices: number[];
+        private _triPrev;
+        private _triNext;
+        triangulate(points: Vector2[], arePointsCCW?: boolean): void;
+        private initialize;
+        static testPointTriangle(point: Vector2, a: Vector2, b: Vector2, c: Vector2): boolean;
+    }
 }
-declare class Vector2Ext {
-    static isTriangleCCW(a: Vector2, center: Vector2, c: Vector2): boolean;
-    static cross(u: Vector2, v: Vector2): number;
-    static perpendicular(first: Vector2, second: Vector2): Vector2;
-    static normalize(vec: Vector2): Vector2;
-    static transformA(sourceArray: Vector2[], sourceIndex: number, matrix: Matrix2D, destinationArray: Vector2[], destinationIndex: number, length: number): void;
-    static transformR(position: Vector2, matrix: Matrix2D): Vector2;
-    static transform(sourceArray: Vector2[], matrix: Matrix2D, destinationArray: Vector2[]): void;
-    static round(vec: Vector2): Vector2;
+declare module es {
+    class Vector2Ext {
+        static isTriangleCCW(a: Vector2, center: Vector2, c: Vector2): boolean;
+        static cross(u: Vector2, v: Vector2): number;
+        static perpendicular(first: Vector2, second: Vector2): Vector2;
+        static normalize(vec: Vector2): Vector2;
+        static transformA(sourceArray: Vector2[], sourceIndex: number, matrix: Matrix2D, destinationArray: Vector2[], destinationIndex: number, length: number): void;
+        static transformR(position: Vector2, matrix: Matrix2D): Vector2;
+        static transform(sourceArray: Vector2[], matrix: Matrix2D, destinationArray: Vector2[]): void;
+        static round(vec: Vector2): Vector2;
+    }
 }
 declare class WebGLUtils {
     static getContext(): CanvasRenderingContext2D;
 }
-declare class Layout {
-    clientArea: Rectangle;
-    safeArea: Rectangle;
-    constructor();
-    place(size: Vector2, horizontalMargin: number, verticalMargine: number, alignment: Alignment): Rectangle;
-}
-declare enum Alignment {
-    none = 0,
-    left = 1,
-    right = 2,
-    horizontalCenter = 4,
-    top = 8,
-    bottom = 16,
-    verticalCenter = 32,
-    topLeft = 9,
-    topRight = 10,
-    topCenter = 12,
-    bottomLeft = 17,
-    bottomRight = 18,
-    bottomCenter = 20,
-    centerLeft = 33,
-    centerRight = 34,
-    center = 36
+declare module es {
+    class Layout {
+        clientArea: Rectangle;
+        safeArea: Rectangle;
+        constructor();
+        place(size: Vector2, horizontalMargin: number, verticalMargine: number, alignment: Alignment): Rectangle;
+    }
+    enum Alignment {
+        none = 0,
+        left = 1,
+        right = 2,
+        horizontalCenter = 4,
+        top = 8,
+        bottom = 16,
+        verticalCenter = 32,
+        topLeft = 9,
+        topRight = 10,
+        topCenter = 12,
+        bottomLeft = 17,
+        bottomRight = 18,
+        bottomCenter = 20,
+        centerLeft = 33,
+        centerRight = 34,
+        center = 36
+    }
 }
 declare namespace stopwatch {
     class Stopwatch {
@@ -1365,72 +1641,74 @@ declare namespace stopwatch {
         readonly duration: number;
     }
 }
-declare class TimeRuler {
-    static readonly maxBars: number;
-    static readonly maxSamples: number;
-    static readonly maxNestCall: number;
-    static readonly barHeight: number;
-    static readonly maxSampleFrames: number;
-    static readonly logSnapDuration: number;
-    static readonly barPadding: number;
-    static readonly autoAdjustDelay: number;
-    static Instance: TimeRuler;
-    private _frameKey;
-    private _logKey;
-    private _logs;
-    private sampleFrames;
-    targetSampleFrames: number;
-    width: number;
-    enabled: true;
-    private _position;
-    private _prevLog;
-    private _curLog;
-    private frameCount;
-    private markers;
-    private stopwacth;
-    private _markerNameToIdMap;
-    private _updateCount;
-    showLog: boolean;
-    private _frameAdjust;
-    constructor();
-    private onGraphicsDeviceReset;
-    startFrame(): void;
-    beginMark(markerName: string, color: number, barIndex?: number): void;
-    endMark(markerName: string, barIndex?: number): void;
-    getAverageTime(barIndex: number, markerName: string): number;
-    resetLog(): void;
-    render(position?: Vector2, width?: number): void;
-}
-declare class FrameLog {
-    bars: MarkerCollection[];
-    constructor();
-}
-declare class MarkerCollection {
-    markers: Marker[];
-    markCount: number;
-    markerNests: number[];
-    nestCount: number;
-    constructor();
-}
-declare class Marker {
-    markerId: number;
-    beginTime: number;
-    endTime: number;
-    color: number;
-}
-declare class MarkerInfo {
-    name: string;
-    logs: MarkerLog[];
-    constructor(name: any);
-}
-declare class MarkerLog {
-    snapMin: number;
-    snapMax: number;
-    snapAvg: number;
-    min: number;
-    max: number;
-    avg: number;
-    samples: number;
-    color: number;
-    initialized: boolean;
+declare module es {
+    class TimeRuler {
+        static readonly maxBars: number;
+        static readonly maxSamples: number;
+        static readonly maxNestCall: number;
+        static readonly barHeight: number;
+        static readonly maxSampleFrames: number;
+        static readonly logSnapDuration: number;
+        static readonly barPadding: number;
+        static readonly autoAdjustDelay: number;
+        static Instance: TimeRuler;
+        private _frameKey;
+        private _logKey;
+        private _logs;
+        private sampleFrames;
+        targetSampleFrames: number;
+        width: number;
+        enabled: true;
+        private _position;
+        private _prevLog;
+        private _curLog;
+        private frameCount;
+        private markers;
+        private stopwacth;
+        private _markerNameToIdMap;
+        private _updateCount;
+        showLog: boolean;
+        private _frameAdjust;
+        constructor();
+        private onGraphicsDeviceReset;
+        startFrame(): void;
+        beginMark(markerName: string, color: number, barIndex?: number): void;
+        endMark(markerName: string, barIndex?: number): void;
+        getAverageTime(barIndex: number, markerName: string): number;
+        resetLog(): void;
+        render(position?: Vector2, width?: number): void;
+    }
+    class FrameLog {
+        bars: MarkerCollection[];
+        constructor();
+    }
+    class MarkerCollection {
+        markers: Marker[];
+        markCount: number;
+        markerNests: number[];
+        nestCount: number;
+        constructor();
+    }
+    class Marker {
+        markerId: number;
+        beginTime: number;
+        endTime: number;
+        color: number;
+    }
+    class MarkerInfo {
+        name: string;
+        logs: MarkerLog[];
+        constructor(name: any);
+    }
+    class MarkerLog {
+        snapMin: number;
+        snapMax: number;
+        snapAvg: number;
+        min: number;
+        max: number;
+        avg: number;
+        samples: number;
+        color: number;
+        initialized: boolean;
+    }
 }
diff --git a/source/bin/framework.js b/source/bin/framework.js
index c729622d..c83321cc 100644
--- a/source/bin/framework.js
+++ b/source/bin/framework.js
@@ -273,2772 +273,3282 @@ Array.prototype.sum = function (selector) {
     }
     return sum(this, selector);
 };
-var PriorityQueueNode = (function () {
-    function PriorityQueueNode() {
-        this.priority = 0;
-        this.insertionIndex = 0;
-        this.queueIndex = 0;
-    }
-    return PriorityQueueNode;
-}());
-var AStarPathfinder = (function () {
-    function AStarPathfinder() {
-    }
-    AStarPathfinder.search = function (graph, start, goal) {
-        var _this = this;
-        var foundPath = false;
-        var cameFrom = new Map();
-        cameFrom.set(start, start);
-        var costSoFar = new Map();
-        var frontier = new PriorityQueue(1000);
-        frontier.enqueue(new AStarNode(start), 0);
-        costSoFar.set(start, 0);
-        var _loop_2 = function () {
-            var current = frontier.dequeue();
-            if (JSON.stringify(current.data) == JSON.stringify(goal)) {
-                foundPath = true;
-                return "break";
-            }
-            graph.getNeighbors(current.data).forEach(function (next) {
-                var newCost = costSoFar.get(current.data) + graph.cost(current.data, next);
-                if (!_this.hasKey(costSoFar, next) || newCost < costSoFar.get(next)) {
-                    costSoFar.set(next, newCost);
-                    var priority = newCost + graph.heuristic(next, goal);
-                    frontier.enqueue(new AStarNode(next), priority);
-                    cameFrom.set(next, current.data);
+var es;
+(function (es) {
+    var PriorityQueueNode = (function () {
+        function PriorityQueueNode() {
+            this.priority = 0;
+            this.insertionIndex = 0;
+            this.queueIndex = 0;
+        }
+        return PriorityQueueNode;
+    }());
+    es.PriorityQueueNode = PriorityQueueNode;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var AStarPathfinder = (function () {
+        function AStarPathfinder() {
+        }
+        AStarPathfinder.search = function (graph, start, goal) {
+            var _this = this;
+            var foundPath = false;
+            var cameFrom = new Map();
+            cameFrom.set(start, start);
+            var costSoFar = new Map();
+            var frontier = new es.PriorityQueue(1000);
+            frontier.enqueue(new AStarNode(start), 0);
+            costSoFar.set(start, 0);
+            var _loop_2 = function () {
+                var current = frontier.dequeue();
+                if (JSON.stringify(current.data) == JSON.stringify(goal)) {
+                    foundPath = true;
+                    return "break";
                 }
-            });
+                graph.getNeighbors(current.data).forEach(function (next) {
+                    var newCost = costSoFar.get(current.data) + graph.cost(current.data, next);
+                    if (!_this.hasKey(costSoFar, next) || newCost < costSoFar.get(next)) {
+                        costSoFar.set(next, newCost);
+                        var priority = newCost + graph.heuristic(next, goal);
+                        frontier.enqueue(new AStarNode(next), priority);
+                        cameFrom.set(next, current.data);
+                    }
+                });
+            };
+            while (frontier.count > 0) {
+                var state_1 = _loop_2();
+                if (state_1 === "break")
+                    break;
+            }
+            return foundPath ? this.recontructPath(cameFrom, start, goal) : null;
         };
-        while (frontier.count > 0) {
-            var state_1 = _loop_2();
-            if (state_1 === "break")
-                break;
+        AStarPathfinder.hasKey = function (map, compareKey) {
+            var iterator = map.keys();
+            var r;
+            while (r = iterator.next(), !r.done) {
+                if (JSON.stringify(r.value) == JSON.stringify(compareKey))
+                    return true;
+            }
+            return false;
+        };
+        AStarPathfinder.getKey = function (map, compareKey) {
+            var iterator = map.keys();
+            var valueIterator = map.values();
+            var r;
+            var v;
+            while (r = iterator.next(), v = valueIterator.next(), !r.done) {
+                if (JSON.stringify(r.value) == JSON.stringify(compareKey))
+                    return v.value;
+            }
+            return null;
+        };
+        AStarPathfinder.recontructPath = function (cameFrom, start, goal) {
+            var path = [];
+            var current = goal;
+            path.push(goal);
+            while (current != start) {
+                current = this.getKey(cameFrom, current);
+                path.push(current);
+            }
+            path.reverse();
+            return path;
+        };
+        return AStarPathfinder;
+    }());
+    es.AStarPathfinder = AStarPathfinder;
+    var AStarNode = (function (_super) {
+        __extends(AStarNode, _super);
+        function AStarNode(data) {
+            var _this = _super.call(this) || this;
+            _this.data = data;
+            return _this;
         }
-        return foundPath ? this.recontructPath(cameFrom, start, goal) : null;
-    };
-    AStarPathfinder.hasKey = function (map, compareKey) {
-        var iterator = map.keys();
-        var r;
-        while (r = iterator.next(), !r.done) {
-            if (JSON.stringify(r.value) == JSON.stringify(compareKey))
-                return true;
+        return AStarNode;
+    }(es.PriorityQueueNode));
+    es.AStarNode = AStarNode;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var AstarGridGraph = (function () {
+        function AstarGridGraph(width, height) {
+            this.dirs = [
+                new es.Vector2(1, 0),
+                new es.Vector2(0, -1),
+                new es.Vector2(-1, 0),
+                new es.Vector2(0, 1)
+            ];
+            this.walls = [];
+            this.weightedNodes = [];
+            this.defaultWeight = 1;
+            this.weightedNodeWeight = 5;
+            this._neighbors = new Array(4);
+            this._width = width;
+            this._height = height;
         }
-        return false;
-    };
-    AStarPathfinder.getKey = function (map, compareKey) {
-        var iterator = map.keys();
-        var valueIterator = map.values();
-        var r;
-        var v;
-        while (r = iterator.next(), v = valueIterator.next(), !r.done) {
-            if (JSON.stringify(r.value) == JSON.stringify(compareKey))
-                return v.value;
+        AstarGridGraph.prototype.isNodeInBounds = function (node) {
+            return 0 <= node.x && node.x < this._width && 0 <= node.y && node.y < this._height;
+        };
+        AstarGridGraph.prototype.isNodePassable = function (node) {
+            return !this.walls.firstOrDefault(function (wall) { return JSON.stringify(wall) == JSON.stringify(node); });
+        };
+        AstarGridGraph.prototype.search = function (start, goal) {
+            return es.AStarPathfinder.search(this, start, goal);
+        };
+        AstarGridGraph.prototype.getNeighbors = function (node) {
+            var _this = this;
+            this._neighbors.length = 0;
+            this.dirs.forEach(function (dir) {
+                var next = new es.Vector2(node.x + dir.x, node.y + dir.y);
+                if (_this.isNodeInBounds(next) && _this.isNodePassable(next))
+                    _this._neighbors.push(next);
+            });
+            return this._neighbors;
+        };
+        AstarGridGraph.prototype.cost = function (from, to) {
+            return this.weightedNodes.find(function (p) { return JSON.stringify(p) == JSON.stringify(to); }) ? this.weightedNodeWeight : this.defaultWeight;
+        };
+        AstarGridGraph.prototype.heuristic = function (node, goal) {
+            return Math.abs(node.x - goal.x) + Math.abs(node.y - goal.y);
+        };
+        return AstarGridGraph;
+    }());
+    es.AstarGridGraph = AstarGridGraph;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var PriorityQueue = (function () {
+        function PriorityQueue(maxNodes) {
+            this._numNodes = 0;
+            this._nodes = new Array(maxNodes + 1);
+            this._numNodesEverEnqueued = 0;
         }
-        return null;
-    };
-    AStarPathfinder.recontructPath = function (cameFrom, start, goal) {
-        var path = [];
-        var current = goal;
-        path.push(goal);
-        while (current != start) {
-            current = this.getKey(cameFrom, current);
-            path.push(current);
-        }
-        path.reverse();
-        return path;
-    };
-    return AStarPathfinder;
-}());
-var AStarNode = (function (_super) {
-    __extends(AStarNode, _super);
-    function AStarNode(data) {
-        var _this = _super.call(this) || this;
-        _this.data = data;
-        return _this;
-    }
-    return AStarNode;
-}(PriorityQueueNode));
-var AstarGridGraph = (function () {
-    function AstarGridGraph(width, height) {
-        this.dirs = [
-            new Vector2(1, 0),
-            new Vector2(0, -1),
-            new Vector2(-1, 0),
-            new Vector2(0, 1)
-        ];
-        this.walls = [];
-        this.weightedNodes = [];
-        this.defaultWeight = 1;
-        this.weightedNodeWeight = 5;
-        this._neighbors = new Array(4);
-        this._width = width;
-        this._height = height;
-    }
-    AstarGridGraph.prototype.isNodeInBounds = function (node) {
-        return 0 <= node.x && node.x < this._width && 0 <= node.y && node.y < this._height;
-    };
-    AstarGridGraph.prototype.isNodePassable = function (node) {
-        return !this.walls.firstOrDefault(function (wall) { return JSON.stringify(wall) == JSON.stringify(node); });
-    };
-    AstarGridGraph.prototype.search = function (start, goal) {
-        return AStarPathfinder.search(this, start, goal);
-    };
-    AstarGridGraph.prototype.getNeighbors = function (node) {
-        var _this = this;
-        this._neighbors.length = 0;
-        this.dirs.forEach(function (dir) {
-            var next = new Vector2(node.x + dir.x, node.y + dir.y);
-            if (_this.isNodeInBounds(next) && _this.isNodePassable(next))
-                _this._neighbors.push(next);
+        PriorityQueue.prototype.clear = function () {
+            this._nodes.splice(1, this._numNodes);
+            this._numNodes = 0;
+        };
+        Object.defineProperty(PriorityQueue.prototype, "count", {
+            get: function () {
+                return this._numNodes;
+            },
+            enumerable: true,
+            configurable: true
         });
-        return this._neighbors;
-    };
-    AstarGridGraph.prototype.cost = function (from, to) {
-        return this.weightedNodes.find(function (p) { return JSON.stringify(p) == JSON.stringify(to); }) ? this.weightedNodeWeight : this.defaultWeight;
-    };
-    AstarGridGraph.prototype.heuristic = function (node, goal) {
-        return Math.abs(node.x - goal.x) + Math.abs(node.y - goal.y);
-    };
-    return AstarGridGraph;
-}());
-var PriorityQueue = (function () {
-    function PriorityQueue(maxNodes) {
-        this._numNodes = 0;
-        this._nodes = new Array(maxNodes + 1);
-        this._numNodesEverEnqueued = 0;
-    }
-    PriorityQueue.prototype.clear = function () {
-        this._nodes.splice(1, this._numNodes);
-        this._numNodes = 0;
-    };
-    Object.defineProperty(PriorityQueue.prototype, "count", {
-        get: function () {
-            return this._numNodes;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(PriorityQueue.prototype, "maxSize", {
-        get: function () {
-            return this._nodes.length - 1;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    PriorityQueue.prototype.contains = function (node) {
-        if (!node) {
-            console.error("node cannot be null");
-            return false;
-        }
-        if (node.queueIndex < 0 || node.queueIndex >= this._nodes.length) {
-            console.error("node.QueueIndex has been corrupted. Did you change it manually? Or add this node to another queue?");
-            return false;
-        }
-        return (this._nodes[node.queueIndex] == node);
-    };
-    PriorityQueue.prototype.enqueue = function (node, priority) {
-        node.priority = priority;
-        this._numNodes++;
-        this._nodes[this._numNodes] = node;
-        node.queueIndex = this._numNodes;
-        node.insertionIndex = this._numNodesEverEnqueued++;
-        this.cascadeUp(this._nodes[this._numNodes]);
-    };
-    PriorityQueue.prototype.dequeue = function () {
-        var returnMe = this._nodes[1];
-        this.remove(returnMe);
-        return returnMe;
-    };
-    PriorityQueue.prototype.remove = function (node) {
-        if (node.queueIndex == this._numNodes) {
-            this._nodes[this._numNodes] = null;
+        Object.defineProperty(PriorityQueue.prototype, "maxSize", {
+            get: function () {
+                return this._nodes.length - 1;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        PriorityQueue.prototype.contains = function (node) {
+            if (!node) {
+                console.error("node cannot be null");
+                return false;
+            }
+            if (node.queueIndex < 0 || node.queueIndex >= this._nodes.length) {
+                console.error("node.QueueIndex has been corrupted. Did you change it manually? Or add this node to another queue?");
+                return false;
+            }
+            return (this._nodes[node.queueIndex] == node);
+        };
+        PriorityQueue.prototype.enqueue = function (node, priority) {
+            node.priority = priority;
+            this._numNodes++;
+            this._nodes[this._numNodes] = node;
+            node.queueIndex = this._numNodes;
+            node.insertionIndex = this._numNodesEverEnqueued++;
+            this.cascadeUp(this._nodes[this._numNodes]);
+        };
+        PriorityQueue.prototype.dequeue = function () {
+            var returnMe = this._nodes[1];
+            this.remove(returnMe);
+            return returnMe;
+        };
+        PriorityQueue.prototype.remove = function (node) {
+            if (node.queueIndex == this._numNodes) {
+                this._nodes[this._numNodes] = null;
+                this._numNodes--;
+                return;
+            }
+            var formerLastNode = this._nodes[this._numNodes];
+            this.swap(node, formerLastNode);
+            delete this._nodes[this._numNodes];
             this._numNodes--;
-            return;
-        }
-        var formerLastNode = this._nodes[this._numNodes];
-        this.swap(node, formerLastNode);
-        delete this._nodes[this._numNodes];
-        this._numNodes--;
-        this.onNodeUpdated(formerLastNode);
-    };
-    PriorityQueue.prototype.isValidQueue = function () {
-        for (var i = 1; i < this._nodes.length; i++) {
-            if (this._nodes[i]) {
-                var childLeftIndex = 2 * i;
-                if (childLeftIndex < this._nodes.length && this._nodes[childLeftIndex] &&
-                    this.hasHigherPriority(this._nodes[childLeftIndex], this._nodes[i]))
-                    return false;
+            this.onNodeUpdated(formerLastNode);
+        };
+        PriorityQueue.prototype.isValidQueue = function () {
+            for (var i = 1; i < this._nodes.length; i++) {
+                if (this._nodes[i]) {
+                    var childLeftIndex = 2 * i;
+                    if (childLeftIndex < this._nodes.length && this._nodes[childLeftIndex] &&
+                        this.hasHigherPriority(this._nodes[childLeftIndex], this._nodes[i]))
+                        return false;
+                    var childRightIndex = childLeftIndex + 1;
+                    if (childRightIndex < this._nodes.length && this._nodes[childRightIndex] &&
+                        this.hasHigherPriority(this._nodes[childRightIndex], this._nodes[i]))
+                        return false;
+                }
+            }
+            return true;
+        };
+        PriorityQueue.prototype.onNodeUpdated = function (node) {
+            var parentIndex = Math.floor(node.queueIndex / 2);
+            var parentNode = this._nodes[parentIndex];
+            if (parentIndex > 0 && this.hasHigherPriority(node, parentNode)) {
+                this.cascadeUp(node);
+            }
+            else {
+                this.cascadeDown(node);
+            }
+        };
+        PriorityQueue.prototype.cascadeDown = function (node) {
+            var newParent;
+            var finalQueueIndex = node.queueIndex;
+            while (true) {
+                newParent = node;
+                var childLeftIndex = 2 * finalQueueIndex;
+                if (childLeftIndex > this._numNodes) {
+                    node.queueIndex = finalQueueIndex;
+                    this._nodes[finalQueueIndex] = node;
+                    break;
+                }
+                var childLeft = this._nodes[childLeftIndex];
+                if (this.hasHigherPriority(childLeft, newParent)) {
+                    newParent = childLeft;
+                }
                 var childRightIndex = childLeftIndex + 1;
-                if (childRightIndex < this._nodes.length && this._nodes[childRightIndex] &&
-                    this.hasHigherPriority(this._nodes[childRightIndex], this._nodes[i]))
-                    return false;
-            }
-        }
-        return true;
-    };
-    PriorityQueue.prototype.onNodeUpdated = function (node) {
-        var parentIndex = Math.floor(node.queueIndex / 2);
-        var parentNode = this._nodes[parentIndex];
-        if (parentIndex > 0 && this.hasHigherPriority(node, parentNode)) {
-            this.cascadeUp(node);
-        }
-        else {
-            this.cascadeDown(node);
-        }
-    };
-    PriorityQueue.prototype.cascadeDown = function (node) {
-        var newParent;
-        var finalQueueIndex = node.queueIndex;
-        while (true) {
-            newParent = node;
-            var childLeftIndex = 2 * finalQueueIndex;
-            if (childLeftIndex > this._numNodes) {
-                node.queueIndex = finalQueueIndex;
-                this._nodes[finalQueueIndex] = node;
-                break;
-            }
-            var childLeft = this._nodes[childLeftIndex];
-            if (this.hasHigherPriority(childLeft, newParent)) {
-                newParent = childLeft;
-            }
-            var childRightIndex = childLeftIndex + 1;
-            if (childRightIndex <= this._numNodes) {
-                var childRight = this._nodes[childRightIndex];
-                if (this.hasHigherPriority(childRight, newParent)) {
-                    newParent = childRight;
+                if (childRightIndex <= this._numNodes) {
+                    var childRight = this._nodes[childRightIndex];
+                    if (this.hasHigherPriority(childRight, newParent)) {
+                        newParent = childRight;
+                    }
+                }
+                if (newParent != node) {
+                    this._nodes[finalQueueIndex] = newParent;
+                    var temp = newParent.queueIndex;
+                    newParent.queueIndex = finalQueueIndex;
+                    finalQueueIndex = temp;
+                }
+                else {
+                    node.queueIndex = finalQueueIndex;
+                    this._nodes[finalQueueIndex] = node;
+                    break;
                 }
             }
-            if (newParent != node) {
-                this._nodes[finalQueueIndex] = newParent;
-                var temp = newParent.queueIndex;
-                newParent.queueIndex = finalQueueIndex;
-                finalQueueIndex = temp;
-            }
-            else {
-                node.queueIndex = finalQueueIndex;
-                this._nodes[finalQueueIndex] = node;
-                break;
-            }
-        }
-    };
-    PriorityQueue.prototype.cascadeUp = function (node) {
-        var parent = Math.floor(node.queueIndex / 2);
-        while (parent >= 1) {
-            var parentNode = this._nodes[parent];
-            if (this.hasHigherPriority(parentNode, node))
-                break;
-            this.swap(node, parentNode);
-            parent = Math.floor(node.queueIndex / 2);
-        }
-    };
-    PriorityQueue.prototype.swap = function (node1, node2) {
-        this._nodes[node1.queueIndex] = node2;
-        this._nodes[node2.queueIndex] = node1;
-        var temp = node1.queueIndex;
-        node1.queueIndex = node2.queueIndex;
-        node2.queueIndex = temp;
-    };
-    PriorityQueue.prototype.hasHigherPriority = function (higher, lower) {
-        return (higher.priority < lower.priority ||
-            (higher.priority == lower.priority && higher.insertionIndex < lower.insertionIndex));
-    };
-    return PriorityQueue;
-}());
-var BreadthFirstPathfinder = (function () {
-    function BreadthFirstPathfinder() {
-    }
-    BreadthFirstPathfinder.search = function (graph, start, goal) {
-        var _this = this;
-        var foundPath = false;
-        var frontier = [];
-        frontier.unshift(start);
-        var cameFrom = new Map();
-        cameFrom.set(start, start);
-        var _loop_3 = function () {
-            var current = frontier.shift();
-            if (JSON.stringify(current) == JSON.stringify(goal)) {
-                foundPath = true;
-                return "break";
-            }
-            graph.getNeighbors(current).forEach(function (next) {
-                if (!_this.hasKey(cameFrom, next)) {
-                    frontier.unshift(next);
-                    cameFrom.set(next, current);
-                }
-            });
         };
-        while (frontier.length > 0) {
-            var state_2 = _loop_3();
-            if (state_2 === "break")
-                break;
-        }
-        return foundPath ? AStarPathfinder.recontructPath(cameFrom, start, goal) : null;
-    };
-    BreadthFirstPathfinder.hasKey = function (map, compareKey) {
-        var iterator = map.keys();
-        var r;
-        while (r = iterator.next(), !r.done) {
-            if (JSON.stringify(r.value) == JSON.stringify(compareKey))
-                return true;
-        }
-        return false;
-    };
-    return BreadthFirstPathfinder;
-}());
-var UnweightedGraph = (function () {
-    function UnweightedGraph() {
-        this.edges = new Map();
-    }
-    UnweightedGraph.prototype.addEdgesForNode = function (node, edges) {
-        this.edges.set(node, edges);
-        return this;
-    };
-    UnweightedGraph.prototype.getNeighbors = function (node) {
-        return this.edges.get(node);
-    };
-    return UnweightedGraph;
-}());
-var Vector2 = (function () {
-    function Vector2(x, y) {
-        this.x = 0;
-        this.y = 0;
-        this.x = x ? x : 0;
-        this.y = y ? y : this.x;
-    }
-    Object.defineProperty(Vector2, "zero", {
-        get: function () {
-            return Vector2.zeroVector2;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Vector2, "one", {
-        get: function () {
-            return Vector2.unitVector2;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Vector2, "unitX", {
-        get: function () {
-            return Vector2.unitXVector;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Vector2, "unitY", {
-        get: function () {
-            return Vector2.unitYVector;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Vector2.add = function (value1, value2) {
-        var result = new Vector2(0, 0);
-        result.x = value1.x + value2.x;
-        result.y = value1.y + value2.y;
-        return result;
-    };
-    Vector2.divide = function (value1, value2) {
-        var result = new Vector2(0, 0);
-        result.x = value1.x / value2.x;
-        result.y = value1.y / value2.y;
-        return result;
-    };
-    Vector2.multiply = function (value1, value2) {
-        var result = new Vector2(0, 0);
-        result.x = value1.x * value2.x;
-        result.y = value1.y * value2.y;
-        return result;
-    };
-    Vector2.subtract = function (value1, value2) {
-        var result = new Vector2(0, 0);
-        result.x = value1.x - value2.x;
-        result.y = value1.y - value2.y;
-        return result;
-    };
-    Vector2.prototype.normalize = function () {
-        var val = 1 / Math.sqrt((this.x * this.x) + (this.y * this.y));
-        this.x *= val;
-        this.y *= val;
-    };
-    Vector2.prototype.length = function () {
-        return Math.sqrt((this.x * this.x) + (this.y * this.y));
-    };
-    Vector2.prototype.round = function () {
-        return new Vector2(Math.round(this.x), Math.round(this.y));
-    };
-    Vector2.normalize = function (value) {
-        var val = 1 / Math.sqrt((value.x * value.x) + (value.y * value.y));
-        value.x *= val;
-        value.y *= val;
-        return value;
-    };
-    Vector2.dot = function (value1, value2) {
-        return (value1.x * value2.x) + (value1.y * value2.y);
-    };
-    Vector2.distanceSquared = function (value1, value2) {
-        var v1 = value1.x - value2.x, v2 = value1.y - value2.y;
-        return (v1 * v1) + (v2 * v2);
-    };
-    Vector2.clamp = function (value1, min, max) {
-        return new Vector2(MathHelper.clamp(value1.x, min.x, max.x), MathHelper.clamp(value1.y, min.y, max.y));
-    };
-    Vector2.lerp = function (value1, value2, amount) {
-        return new Vector2(MathHelper.lerp(value1.x, value2.x, amount), MathHelper.lerp(value1.y, value2.y, amount));
-    };
-    Vector2.transform = function (position, matrix) {
-        return new Vector2((position.x * matrix.m11) + (position.y * matrix.m21), (position.x * matrix.m12) + (position.y * matrix.m22));
-    };
-    Vector2.distance = function (value1, value2) {
-        var v1 = value1.x - value2.x, v2 = value1.y - value2.y;
-        return Math.sqrt((v1 * v1) + (v2 * v2));
-    };
-    Vector2.negate = function (value) {
-        var result = new Vector2();
-        result.x = -value.x;
-        result.y = -value.y;
-        return result;
-    };
-    Vector2.unitYVector = new Vector2(0, 1);
-    Vector2.unitXVector = new Vector2(1, 0);
-    Vector2.unitVector2 = new Vector2(1, 1);
-    Vector2.zeroVector2 = new Vector2(0, 0);
-    return Vector2;
-}());
-var UnweightedGridGraph = (function () {
-    function UnweightedGridGraph(width, height, allowDiagonalSearch) {
-        if (allowDiagonalSearch === void 0) { allowDiagonalSearch = false; }
-        this.walls = [];
-        this._neighbors = new Array(4);
-        this._width = width;
-        this._hegiht = height;
-        this._dirs = allowDiagonalSearch ? UnweightedGridGraph.COMPASS_DIRS : UnweightedGridGraph.CARDINAL_DIRS;
-    }
-    UnweightedGridGraph.prototype.isNodeInBounds = function (node) {
-        return 0 <= node.x && node.x < this._width && 0 <= node.y && node.y < this._hegiht;
-    };
-    UnweightedGridGraph.prototype.isNodePassable = function (node) {
-        return !this.walls.firstOrDefault(function (wall) { return JSON.stringify(wall) == JSON.stringify(node); });
-    };
-    UnweightedGridGraph.prototype.getNeighbors = function (node) {
-        var _this = this;
-        this._neighbors.length = 0;
-        this._dirs.forEach(function (dir) {
-            var next = new Vector2(node.x + dir.x, node.y + dir.y);
-            if (_this.isNodeInBounds(next) && _this.isNodePassable(next))
-                _this._neighbors.push(next);
-        });
-        return this._neighbors;
-    };
-    UnweightedGridGraph.prototype.search = function (start, goal) {
-        return BreadthFirstPathfinder.search(this, start, goal);
-    };
-    UnweightedGridGraph.CARDINAL_DIRS = [
-        new Vector2(1, 0),
-        new Vector2(0, -1),
-        new Vector2(-1, 0),
-        new Vector2(0, -1)
-    ];
-    UnweightedGridGraph.COMPASS_DIRS = [
-        new Vector2(1, 0),
-        new Vector2(1, -1),
-        new Vector2(0, -1),
-        new Vector2(-1, -1),
-        new Vector2(-1, 0),
-        new Vector2(-1, 1),
-        new Vector2(0, 1),
-        new Vector2(1, 1),
-    ];
-    return UnweightedGridGraph;
-}());
-var WeightedGridGraph = (function () {
-    function WeightedGridGraph(width, height, allowDiagonalSearch) {
-        if (allowDiagonalSearch === void 0) { allowDiagonalSearch = false; }
-        this.walls = [];
-        this.weightedNodes = [];
-        this.defaultWeight = 1;
-        this.weightedNodeWeight = 5;
-        this._neighbors = new Array(4);
-        this._width = width;
-        this._height = height;
-        this._dirs = allowDiagonalSearch ? WeightedGridGraph.COMPASS_DIRS : WeightedGridGraph.CARDINAL_DIRS;
-    }
-    WeightedGridGraph.prototype.isNodeInBounds = function (node) {
-        return 0 <= node.x && node.x < this._width && 0 <= node.y && node.y < this._height;
-    };
-    WeightedGridGraph.prototype.isNodePassable = function (node) {
-        return !this.walls.firstOrDefault(function (wall) { return JSON.stringify(wall) == JSON.stringify(node); });
-    };
-    WeightedGridGraph.prototype.search = function (start, goal) {
-        return WeightedPathfinder.search(this, start, goal);
-    };
-    WeightedGridGraph.prototype.getNeighbors = function (node) {
-        var _this = this;
-        this._neighbors.length = 0;
-        this._dirs.forEach(function (dir) {
-            var next = new Vector2(node.x + dir.x, node.y + dir.y);
-            if (_this.isNodeInBounds(next) && _this.isNodePassable(next))
-                _this._neighbors.push(next);
-        });
-        return this._neighbors;
-    };
-    WeightedGridGraph.prototype.cost = function (from, to) {
-        return this.weightedNodes.find(function (t) { return JSON.stringify(t) == JSON.stringify(to); }) ? this.weightedNodeWeight : this.defaultWeight;
-    };
-    WeightedGridGraph.CARDINAL_DIRS = [
-        new Vector2(1, 0),
-        new Vector2(0, -1),
-        new Vector2(-1, 0),
-        new Vector2(0, 1)
-    ];
-    WeightedGridGraph.COMPASS_DIRS = [
-        new Vector2(1, 0),
-        new Vector2(1, -1),
-        new Vector2(0, -1),
-        new Vector2(-1, -1),
-        new Vector2(-1, 0),
-        new Vector2(-1, 1),
-        new Vector2(0, 1),
-        new Vector2(1, 1),
-    ];
-    return WeightedGridGraph;
-}());
-var WeightedNode = (function (_super) {
-    __extends(WeightedNode, _super);
-    function WeightedNode(data) {
-        var _this = _super.call(this) || this;
-        _this.data = data;
-        return _this;
-    }
-    return WeightedNode;
-}(PriorityQueueNode));
-var WeightedPathfinder = (function () {
-    function WeightedPathfinder() {
-    }
-    WeightedPathfinder.search = function (graph, start, goal) {
-        var _this = this;
-        var foundPath = false;
-        var cameFrom = new Map();
-        cameFrom.set(start, start);
-        var costSoFar = new Map();
-        var frontier = new PriorityQueue(1000);
-        frontier.enqueue(new WeightedNode(start), 0);
-        costSoFar.set(start, 0);
-        var _loop_4 = function () {
-            var current = frontier.dequeue();
-            if (JSON.stringify(current.data) == JSON.stringify(goal)) {
-                foundPath = true;
-                return "break";
+        PriorityQueue.prototype.cascadeUp = function (node) {
+            var parent = Math.floor(node.queueIndex / 2);
+            while (parent >= 1) {
+                var parentNode = this._nodes[parent];
+                if (this.hasHigherPriority(parentNode, node))
+                    break;
+                this.swap(node, parentNode);
+                parent = Math.floor(node.queueIndex / 2);
             }
-            graph.getNeighbors(current.data).forEach(function (next) {
-                var newCost = costSoFar.get(current.data) + graph.cost(current.data, next);
-                if (!_this.hasKey(costSoFar, next) || newCost < costSoFar.get(next)) {
-                    costSoFar.set(next, newCost);
-                    var priprity = newCost;
-                    frontier.enqueue(new WeightedNode(next), priprity);
-                    cameFrom.set(next, current.data);
-                }
-            });
         };
-        while (frontier.count > 0) {
-            var state_3 = _loop_4();
-            if (state_3 === "break")
-                break;
+        PriorityQueue.prototype.swap = function (node1, node2) {
+            this._nodes[node1.queueIndex] = node2;
+            this._nodes[node2.queueIndex] = node1;
+            var temp = node1.queueIndex;
+            node1.queueIndex = node2.queueIndex;
+            node2.queueIndex = temp;
+        };
+        PriorityQueue.prototype.hasHigherPriority = function (higher, lower) {
+            return (higher.priority < lower.priority ||
+                (higher.priority == lower.priority && higher.insertionIndex < lower.insertionIndex));
+        };
+        return PriorityQueue;
+    }());
+    es.PriorityQueue = PriorityQueue;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var BreadthFirstPathfinder = (function () {
+        function BreadthFirstPathfinder() {
         }
-        return foundPath ? this.recontructPath(cameFrom, start, goal) : null;
-    };
-    WeightedPathfinder.hasKey = function (map, compareKey) {
-        var iterator = map.keys();
-        var r;
-        while (r = iterator.next(), !r.done) {
-            if (JSON.stringify(r.value) == JSON.stringify(compareKey))
-                return true;
-        }
-        return false;
-    };
-    WeightedPathfinder.getKey = function (map, compareKey) {
-        var iterator = map.keys();
-        var valueIterator = map.values();
-        var r;
-        var v;
-        while (r = iterator.next(), v = valueIterator.next(), !r.done) {
-            if (JSON.stringify(r.value) == JSON.stringify(compareKey))
-                return v.value;
-        }
-        return null;
-    };
-    WeightedPathfinder.recontructPath = function (cameFrom, start, goal) {
-        var path = [];
-        var current = goal;
-        path.push(goal);
-        while (current != start) {
-            current = this.getKey(cameFrom, current);
-            path.push(current);
-        }
-        path.reverse();
-        return path;
-    };
-    return WeightedPathfinder;
-}());
-var Debug = (function () {
-    function Debug() {
-    }
-    Debug.drawHollowRect = function (rectanle, color, duration) {
-        if (duration === void 0) { duration = 0; }
-        this._debugDrawItems.push(new DebugDrawItem(rectanle, color, duration));
-    };
-    Debug.render = function () {
-        if (this._debugDrawItems.length > 0) {
-            var debugShape = new egret.Shape();
-            if (SceneManager.scene) {
-                SceneManager.scene.addChild(debugShape);
+        BreadthFirstPathfinder.search = function (graph, start, goal) {
+            var _this = this;
+            var foundPath = false;
+            var frontier = [];
+            frontier.unshift(start);
+            var cameFrom = new Map();
+            cameFrom.set(start, start);
+            var _loop_3 = function () {
+                var current = frontier.shift();
+                if (JSON.stringify(current) == JSON.stringify(goal)) {
+                    foundPath = true;
+                    return "break";
+                }
+                graph.getNeighbors(current).forEach(function (next) {
+                    if (!_this.hasKey(cameFrom, next)) {
+                        frontier.unshift(next);
+                        cameFrom.set(next, current);
+                    }
+                });
+            };
+            while (frontier.length > 0) {
+                var state_2 = _loop_3();
+                if (state_2 === "break")
+                    break;
             }
-            for (var i = this._debugDrawItems.length - 1; i >= 0; i--) {
-                var item = this._debugDrawItems[i];
-                if (item.draw(debugShape))
-                    this._debugDrawItems.removeAt(i);
+            return foundPath ? es.AStarPathfinder.recontructPath(cameFrom, start, goal) : null;
+        };
+        BreadthFirstPathfinder.hasKey = function (map, compareKey) {
+            var iterator = map.keys();
+            var r;
+            while (r = iterator.next(), !r.done) {
+                if (JSON.stringify(r.value) == JSON.stringify(compareKey))
+                    return true;
             }
+            return false;
+        };
+        return BreadthFirstPathfinder;
+    }());
+    es.BreadthFirstPathfinder = BreadthFirstPathfinder;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var UnweightedGraph = (function () {
+        function UnweightedGraph() {
+            this.edges = new Map();
         }
-    };
-    Debug._debugDrawItems = [];
-    return Debug;
-}());
-var DebugDefaults = (function () {
-    function DebugDefaults() {
-    }
-    DebugDefaults.verletParticle = 0xDC345E;
-    DebugDefaults.verletConstraintEdge = 0x433E36;
-    return DebugDefaults;
-}());
-var DebugDrawType;
-(function (DebugDrawType) {
-    DebugDrawType[DebugDrawType["line"] = 0] = "line";
-    DebugDrawType[DebugDrawType["hollowRectangle"] = 1] = "hollowRectangle";
-    DebugDrawType[DebugDrawType["pixel"] = 2] = "pixel";
-    DebugDrawType[DebugDrawType["text"] = 3] = "text";
-})(DebugDrawType || (DebugDrawType = {}));
-var DebugDrawItem = (function () {
-    function DebugDrawItem(rectangle, color, duration) {
-        this.rectangle = rectangle;
-        this.color = color;
-        this.duration = duration;
-        this.drawType = DebugDrawType.hollowRectangle;
-    }
-    DebugDrawItem.prototype.draw = function (shape) {
-        switch (this.drawType) {
-            case DebugDrawType.line:
-                DrawUtils.drawLine(shape, this.start, this.end, this.color);
-                break;
-            case DebugDrawType.hollowRectangle:
-                DrawUtils.drawHollowRect(shape, this.rectangle, this.color);
-                break;
-            case DebugDrawType.pixel:
-                DrawUtils.drawPixel(shape, new Vector2(this.x, this.y), this.color, this.size);
-                break;
-            case DebugDrawType.text:
-                break;
+        UnweightedGraph.prototype.addEdgesForNode = function (node, edges) {
+            this.edges.set(node, edges);
+            return this;
+        };
+        UnweightedGraph.prototype.getNeighbors = function (node) {
+            return this.edges.get(node);
+        };
+        return UnweightedGraph;
+    }());
+    es.UnweightedGraph = UnweightedGraph;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Vector2 = (function () {
+        function Vector2(x, y) {
+            this.x = 0;
+            this.y = 0;
+            this.x = x ? x : 0;
+            this.y = y ? y : this.x;
         }
-        this.duration -= Time.deltaTime;
-        return this.duration < 0;
-    };
-    return DebugDrawItem;
-}());
-var Component = (function (_super) {
-    __extends(Component, _super);
-    function Component() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this._enabled = true;
-        _this.updateInterval = 1;
-        _this._updateOrder = 0;
-        return _this;
-    }
-    Object.defineProperty(Component.prototype, "enabled", {
-        get: function () {
-            return this.entity ? this.entity.enabled && this._enabled : this._enabled;
-        },
-        set: function (value) {
-            this.setEnabled(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Component.prototype, "localPosition", {
-        get: function () {
-            return new Vector2(this.entity.x + this.x, this.entity.y + this.y);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Component.prototype.setEnabled = function (isEnabled) {
-        if (this._enabled != isEnabled) {
-            this._enabled = isEnabled;
-            if (this._enabled) {
-                this.onEnabled();
+        Object.defineProperty(Vector2, "zero", {
+            get: function () {
+                return Vector2.zeroVector2;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Vector2, "one", {
+            get: function () {
+                return Vector2.unitVector2;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Vector2, "unitX", {
+            get: function () {
+                return Vector2.unitXVector;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Vector2, "unitY", {
+            get: function () {
+                return Vector2.unitYVector;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Vector2.add = function (value1, value2) {
+            var result = new Vector2(0, 0);
+            result.x = value1.x + value2.x;
+            result.y = value1.y + value2.y;
+            return result;
+        };
+        Vector2.divide = function (value1, value2) {
+            var result = new Vector2(0, 0);
+            result.x = value1.x / value2.x;
+            result.y = value1.y / value2.y;
+            return result;
+        };
+        Vector2.multiply = function (value1, value2) {
+            var result = new Vector2(0, 0);
+            result.x = value1.x * value2.x;
+            result.y = value1.y * value2.y;
+            return result;
+        };
+        Vector2.subtract = function (value1, value2) {
+            var result = new Vector2(0, 0);
+            result.x = value1.x - value2.x;
+            result.y = value1.y - value2.y;
+            return result;
+        };
+        Vector2.prototype.normalize = function () {
+            var val = 1 / Math.sqrt((this.x * this.x) + (this.y * this.y));
+            this.x *= val;
+            this.y *= val;
+        };
+        Vector2.prototype.length = function () {
+            return Math.sqrt((this.x * this.x) + (this.y * this.y));
+        };
+        Vector2.prototype.round = function () {
+            return new Vector2(Math.round(this.x), Math.round(this.y));
+        };
+        Vector2.normalize = function (value) {
+            var val = 1 / Math.sqrt((value.x * value.x) + (value.y * value.y));
+            value.x *= val;
+            value.y *= val;
+            return value;
+        };
+        Vector2.dot = function (value1, value2) {
+            return (value1.x * value2.x) + (value1.y * value2.y);
+        };
+        Vector2.distanceSquared = function (value1, value2) {
+            var v1 = value1.x - value2.x, v2 = value1.y - value2.y;
+            return (v1 * v1) + (v2 * v2);
+        };
+        Vector2.clamp = function (value1, min, max) {
+            return new Vector2(es.MathHelper.clamp(value1.x, min.x, max.x), es.MathHelper.clamp(value1.y, min.y, max.y));
+        };
+        Vector2.lerp = function (value1, value2, amount) {
+            return new Vector2(es.MathHelper.lerp(value1.x, value2.x, amount), es.MathHelper.lerp(value1.y, value2.y, amount));
+        };
+        Vector2.transform = function (position, matrix) {
+            return new Vector2((position.x * matrix.m11) + (position.y * matrix.m21), (position.x * matrix.m12) + (position.y * matrix.m22));
+        };
+        Vector2.distance = function (value1, value2) {
+            var v1 = value1.x - value2.x, v2 = value1.y - value2.y;
+            return Math.sqrt((v1 * v1) + (v2 * v2));
+        };
+        Vector2.negate = function (value) {
+            var result = new Vector2();
+            result.x = -value.x;
+            result.y = -value.y;
+            return result;
+        };
+        Vector2.unitYVector = new Vector2(0, 1);
+        Vector2.unitXVector = new Vector2(1, 0);
+        Vector2.unitVector2 = new Vector2(1, 1);
+        Vector2.zeroVector2 = new Vector2(0, 0);
+        return Vector2;
+    }());
+    es.Vector2 = Vector2;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var UnweightedGridGraph = (function () {
+        function UnweightedGridGraph(width, height, allowDiagonalSearch) {
+            if (allowDiagonalSearch === void 0) { allowDiagonalSearch = false; }
+            this.walls = [];
+            this._neighbors = new Array(4);
+            this._width = width;
+            this._hegiht = height;
+            this._dirs = allowDiagonalSearch ? UnweightedGridGraph.COMPASS_DIRS : UnweightedGridGraph.CARDINAL_DIRS;
+        }
+        UnweightedGridGraph.prototype.isNodeInBounds = function (node) {
+            return 0 <= node.x && node.x < this._width && 0 <= node.y && node.y < this._hegiht;
+        };
+        UnweightedGridGraph.prototype.isNodePassable = function (node) {
+            return !this.walls.firstOrDefault(function (wall) { return JSON.stringify(wall) == JSON.stringify(node); });
+        };
+        UnweightedGridGraph.prototype.getNeighbors = function (node) {
+            var _this = this;
+            this._neighbors.length = 0;
+            this._dirs.forEach(function (dir) {
+                var next = new es.Vector2(node.x + dir.x, node.y + dir.y);
+                if (_this.isNodeInBounds(next) && _this.isNodePassable(next))
+                    _this._neighbors.push(next);
+            });
+            return this._neighbors;
+        };
+        UnweightedGridGraph.prototype.search = function (start, goal) {
+            return es.BreadthFirstPathfinder.search(this, start, goal);
+        };
+        UnweightedGridGraph.CARDINAL_DIRS = [
+            new es.Vector2(1, 0),
+            new es.Vector2(0, -1),
+            new es.Vector2(-1, 0),
+            new es.Vector2(0, -1)
+        ];
+        UnweightedGridGraph.COMPASS_DIRS = [
+            new es.Vector2(1, 0),
+            new es.Vector2(1, -1),
+            new es.Vector2(0, -1),
+            new es.Vector2(-1, -1),
+            new es.Vector2(-1, 0),
+            new es.Vector2(-1, 1),
+            new es.Vector2(0, 1),
+            new es.Vector2(1, 1),
+        ];
+        return UnweightedGridGraph;
+    }());
+    es.UnweightedGridGraph = UnweightedGridGraph;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var WeightedGridGraph = (function () {
+        function WeightedGridGraph(width, height, allowDiagonalSearch) {
+            if (allowDiagonalSearch === void 0) { allowDiagonalSearch = false; }
+            this.walls = [];
+            this.weightedNodes = [];
+            this.defaultWeight = 1;
+            this.weightedNodeWeight = 5;
+            this._neighbors = new Array(4);
+            this._width = width;
+            this._height = height;
+            this._dirs = allowDiagonalSearch ? WeightedGridGraph.COMPASS_DIRS : WeightedGridGraph.CARDINAL_DIRS;
+        }
+        WeightedGridGraph.prototype.isNodeInBounds = function (node) {
+            return 0 <= node.x && node.x < this._width && 0 <= node.y && node.y < this._height;
+        };
+        WeightedGridGraph.prototype.isNodePassable = function (node) {
+            return !this.walls.firstOrDefault(function (wall) { return JSON.stringify(wall) == JSON.stringify(node); });
+        };
+        WeightedGridGraph.prototype.search = function (start, goal) {
+            return es.WeightedPathfinder.search(this, start, goal);
+        };
+        WeightedGridGraph.prototype.getNeighbors = function (node) {
+            var _this = this;
+            this._neighbors.length = 0;
+            this._dirs.forEach(function (dir) {
+                var next = new es.Vector2(node.x + dir.x, node.y + dir.y);
+                if (_this.isNodeInBounds(next) && _this.isNodePassable(next))
+                    _this._neighbors.push(next);
+            });
+            return this._neighbors;
+        };
+        WeightedGridGraph.prototype.cost = function (from, to) {
+            return this.weightedNodes.find(function (t) { return JSON.stringify(t) == JSON.stringify(to); }) ? this.weightedNodeWeight : this.defaultWeight;
+        };
+        WeightedGridGraph.CARDINAL_DIRS = [
+            new es.Vector2(1, 0),
+            new es.Vector2(0, -1),
+            new es.Vector2(-1, 0),
+            new es.Vector2(0, 1)
+        ];
+        WeightedGridGraph.COMPASS_DIRS = [
+            new es.Vector2(1, 0),
+            new es.Vector2(1, -1),
+            new es.Vector2(0, -1),
+            new es.Vector2(-1, -1),
+            new es.Vector2(-1, 0),
+            new es.Vector2(-1, 1),
+            new es.Vector2(0, 1),
+            new es.Vector2(1, 1),
+        ];
+        return WeightedGridGraph;
+    }());
+    es.WeightedGridGraph = WeightedGridGraph;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var WeightedNode = (function (_super) {
+        __extends(WeightedNode, _super);
+        function WeightedNode(data) {
+            var _this = _super.call(this) || this;
+            _this.data = data;
+            return _this;
+        }
+        return WeightedNode;
+    }(es.PriorityQueueNode));
+    es.WeightedNode = WeightedNode;
+    var WeightedPathfinder = (function () {
+        function WeightedPathfinder() {
+        }
+        WeightedPathfinder.search = function (graph, start, goal) {
+            var _this = this;
+            var foundPath = false;
+            var cameFrom = new Map();
+            cameFrom.set(start, start);
+            var costSoFar = new Map();
+            var frontier = new es.PriorityQueue(1000);
+            frontier.enqueue(new WeightedNode(start), 0);
+            costSoFar.set(start, 0);
+            var _loop_4 = function () {
+                var current = frontier.dequeue();
+                if (JSON.stringify(current.data) == JSON.stringify(goal)) {
+                    foundPath = true;
+                    return "break";
+                }
+                graph.getNeighbors(current.data).forEach(function (next) {
+                    var newCost = costSoFar.get(current.data) + graph.cost(current.data, next);
+                    if (!_this.hasKey(costSoFar, next) || newCost < costSoFar.get(next)) {
+                        costSoFar.set(next, newCost);
+                        var priprity = newCost;
+                        frontier.enqueue(new WeightedNode(next), priprity);
+                        cameFrom.set(next, current.data);
+                    }
+                });
+            };
+            while (frontier.count > 0) {
+                var state_3 = _loop_4();
+                if (state_3 === "break")
+                    break;
             }
-            else {
-                this.onDisabled();
+            return foundPath ? this.recontructPath(cameFrom, start, goal) : null;
+        };
+        WeightedPathfinder.hasKey = function (map, compareKey) {
+            var iterator = map.keys();
+            var r;
+            while (r = iterator.next(), !r.done) {
+                if (JSON.stringify(r.value) == JSON.stringify(compareKey))
+                    return true;
             }
+            return false;
+        };
+        WeightedPathfinder.getKey = function (map, compareKey) {
+            var iterator = map.keys();
+            var valueIterator = map.values();
+            var r;
+            var v;
+            while (r = iterator.next(), v = valueIterator.next(), !r.done) {
+                if (JSON.stringify(r.value) == JSON.stringify(compareKey))
+                    return v.value;
+            }
+            return null;
+        };
+        WeightedPathfinder.recontructPath = function (cameFrom, start, goal) {
+            var path = [];
+            var current = goal;
+            path.push(goal);
+            while (current != start) {
+                current = this.getKey(cameFrom, current);
+                path.push(current);
+            }
+            path.reverse();
+            return path;
+        };
+        return WeightedPathfinder;
+    }());
+    es.WeightedPathfinder = WeightedPathfinder;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Debug = (function () {
+        function Debug() {
         }
-        return this;
-    };
-    Object.defineProperty(Component.prototype, "updateOrder", {
-        get: function () {
-            return this._updateOrder;
-        },
-        set: function (value) {
-            this.setUpdateOrder(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Component.prototype.setUpdateOrder = function (updateOrder) {
-        if (this._updateOrder != updateOrder) {
-            this._updateOrder = updateOrder;
+        Debug.drawHollowRect = function (rectanle, color, duration) {
+            if (duration === void 0) { duration = 0; }
+            this._debugDrawItems.push(new es.DebugDrawItem(rectanle, color, duration));
+        };
+        Debug.render = function () {
+            if (this._debugDrawItems.length > 0) {
+                var debugShape = new egret.Shape();
+                if (es.SceneManager.scene) {
+                    es.SceneManager.scene.addChild(debugShape);
+                }
+                for (var i = this._debugDrawItems.length - 1; i >= 0; i--) {
+                    var item = this._debugDrawItems[i];
+                    if (item.draw(debugShape))
+                        this._debugDrawItems.removeAt(i);
+                }
+            }
+        };
+        Debug._debugDrawItems = [];
+        return Debug;
+    }());
+    es.Debug = Debug;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var DebugDefaults = (function () {
+        function DebugDefaults() {
         }
-        return this;
-    };
-    Component.prototype.initialize = function () {
-    };
-    Component.prototype.onAddedToEntity = function () {
-    };
-    Component.prototype.onRemovedFromEntity = function () {
-    };
-    Component.prototype.onEnabled = function () {
-    };
-    Component.prototype.onDisabled = function () {
-    };
-    Component.prototype.debugRender = function () {
-    };
-    Component.prototype.update = function () {
-    };
-    Component.prototype.onEntityTransformChanged = function (comp) {
-    };
-    Component.prototype.registerComponent = function () {
-        this.entity.componentBits.set(ComponentTypeManager.getIndexFor(this), false);
-        this.entity.scene.entityProcessors.onComponentAdded(this.entity);
-    };
-    Component.prototype.deregisterComponent = function () {
-        this.entity.componentBits.set(ComponentTypeManager.getIndexFor(this));
-        this.entity.scene.entityProcessors.onComponentRemoved(this.entity);
-    };
-    return Component;
-}(egret.DisplayObjectContainer));
-var CoreEvents;
-(function (CoreEvents) {
-    CoreEvents[CoreEvents["SceneChanged"] = 0] = "SceneChanged";
-})(CoreEvents || (CoreEvents = {}));
-var Entity = (function (_super) {
-    __extends(Entity, _super);
-    function Entity(name) {
-        var _this = _super.call(this) || this;
-        _this._updateOrder = 0;
-        _this._enabled = true;
-        _this._tag = 0;
-        _this.name = name;
-        _this.components = new ComponentList(_this);
-        _this.id = Entity._idGenerator++;
-        _this.componentBits = new BitSet();
-        _this.addEventListener(egret.Event.ADDED_TO_STAGE, _this.onAddToStage, _this);
-        return _this;
-    }
-    Object.defineProperty(Entity.prototype, "isDestoryed", {
-        get: function () {
-            return this._isDestoryed;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Entity.prototype, "position", {
-        get: function () {
-            return new Vector2(this.x, this.y);
-        },
-        set: function (value) {
-            this.$setX(value.x);
-            this.$setY(value.y);
-            this.onEntityTransformChanged(TransformComponent.position);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Entity.prototype, "scale", {
-        get: function () {
-            return new Vector2(this.scaleX, this.scaleY);
-        },
-        set: function (value) {
-            this.$setScaleX(value.x);
-            this.$setScaleY(value.y);
-            this.onEntityTransformChanged(TransformComponent.scale);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Entity.prototype, "rotation", {
-        get: function () {
-            return this.$getRotation();
-        },
-        set: function (value) {
-            this.$setRotation(value);
-            this.onEntityTransformChanged(TransformComponent.rotation);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Entity.prototype, "enabled", {
-        get: function () {
-            return this._enabled;
-        },
-        set: function (value) {
-            this.setEnabled(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Entity.prototype.setEnabled = function (isEnabled) {
-        if (this._enabled != isEnabled) {
-            this._enabled = isEnabled;
+        DebugDefaults.verletParticle = 0xDC345E;
+        DebugDefaults.verletConstraintEdge = 0x433E36;
+        return DebugDefaults;
+    }());
+    es.DebugDefaults = DebugDefaults;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var DebugDrawType;
+    (function (DebugDrawType) {
+        DebugDrawType[DebugDrawType["line"] = 0] = "line";
+        DebugDrawType[DebugDrawType["hollowRectangle"] = 1] = "hollowRectangle";
+        DebugDrawType[DebugDrawType["pixel"] = 2] = "pixel";
+        DebugDrawType[DebugDrawType["text"] = 3] = "text";
+    })(DebugDrawType = es.DebugDrawType || (es.DebugDrawType = {}));
+    var DebugDrawItem = (function () {
+        function DebugDrawItem(rectangle, color, duration) {
+            this.rectangle = rectangle;
+            this.color = color;
+            this.duration = duration;
+            this.drawType = DebugDrawType.hollowRectangle;
         }
-        return this;
-    };
-    Object.defineProperty(Entity.prototype, "tag", {
-        get: function () {
-            return this._tag;
-        },
-        set: function (value) {
-            this.setTag(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Entity.prototype, "stage", {
-        get: function () {
-            if (!this.scene)
-                return null;
-            return this.scene.stage;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Entity.prototype.onAddToStage = function () {
-        this.onEntityTransformChanged(TransformComponent.position);
-    };
-    Object.defineProperty(Entity.prototype, "updateOrder", {
-        get: function () {
-            return this._updateOrder;
-        },
-        set: function (value) {
-            this.setUpdateOrder(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Entity.prototype.roundPosition = function () {
-        this.position = Vector2Ext.round(this.position);
-    };
-    Entity.prototype.setUpdateOrder = function (updateOrder) {
-        if (this._updateOrder != updateOrder) {
-            this._updateOrder = updateOrder;
-            if (this.scene) {
+        DebugDrawItem.prototype.draw = function (shape) {
+            switch (this.drawType) {
+                case DebugDrawType.line:
+                    es.DrawUtils.drawLine(shape, this.start, this.end, this.color);
+                    break;
+                case DebugDrawType.hollowRectangle:
+                    es.DrawUtils.drawHollowRect(shape, this.rectangle, this.color);
+                    break;
+                case DebugDrawType.pixel:
+                    es.DrawUtils.drawPixel(shape, new es.Vector2(this.x, this.y), this.color, this.size);
+                    break;
+                case DebugDrawType.text:
+                    break;
+            }
+            this.duration -= es.Time.deltaTime;
+            return this.duration < 0;
+        };
+        return DebugDrawItem;
+    }());
+    es.DebugDrawItem = DebugDrawItem;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Component = (function () {
+        function Component() {
+            this.updateInterval = 1;
+            this._enabled = true;
+            this._updateOrder = 0;
+        }
+        Object.defineProperty(Component.prototype, "transform", {
+            get: function () {
+                return this.entity.transform;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Component.prototype, "enabled", {
+            get: function () {
+                return this.entity ? this.entity.enabled && this._enabled : this._enabled;
+            },
+            set: function (value) {
+                this.setEnabled(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Component.prototype, "updateOrder", {
+            get: function () {
+                return this._updateOrder;
+            },
+            set: function (value) {
+                this.setUpdateOrder(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Component.prototype.initialize = function () {
+        };
+        Component.prototype.onAddedToEntity = function () {
+        };
+        Component.prototype.onRemovedFromEntity = function () {
+        };
+        Component.prototype.onEntityTransformChanged = function (comp) {
+        };
+        Component.prototype.debugRender = function () {
+        };
+        Component.prototype.onEnabled = function () {
+        };
+        Component.prototype.onDisabled = function () {
+        };
+        Component.prototype.update = function () {
+        };
+        Component.prototype.setEnabled = function (isEnabled) {
+            if (this._enabled != isEnabled) {
+                this._enabled = isEnabled;
+                if (this._enabled) {
+                    this.onEnabled();
+                }
+                else {
+                    this.onDisabled();
+                }
             }
             return this;
-        }
-    };
-    Entity.prototype.setTag = function (tag) {
-        if (this._tag != tag) {
-            if (this.scene) {
-                this.scene.entities.removeFromTagList(this);
-            }
-            this._tag = tag;
-            if (this.scene) {
-                this.scene.entities.addToTagList(this);
+        };
+        Component.prototype.setUpdateOrder = function (updateOrder) {
+            if (this._updateOrder != updateOrder) {
+                this._updateOrder = updateOrder;
             }
+            return this;
+        };
+        Component.prototype.clone = function () {
+            var component = ObjectUtils.clone(this);
+            component.entity = null;
+            return component;
+        };
+        return Component;
+    }());
+    es.Component = Component;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var CoreEvents;
+    (function (CoreEvents) {
+        CoreEvents[CoreEvents["SceneChanged"] = 0] = "SceneChanged";
+    })(CoreEvents = es.CoreEvents || (es.CoreEvents = {}));
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Entity = (function () {
+        function Entity(name) {
+            this.updateInterval = 1;
+            this._tag = 0;
+            this._enabled = true;
+            this._updateOrder = 0;
+            this.components = new es.ComponentList(this);
+            this.transform = new es.Transform(this);
+            this.name = name;
+            this.id = Entity._idGenerator++;
+            this.componentBits = new es.BitSet();
         }
-        return this;
-    };
-    Entity.prototype.attachToScene = function (newScene) {
-        this.scene = newScene;
-        newScene.entities.add(this);
-        this.components.registerAllComponents();
-        for (var i = 0; i < this.numChildren; i++) {
-            this.getChildAt(i).entity.attachToScene(newScene);
-        }
-    };
-    Entity.prototype.detachFromScene = function () {
-        this.scene.entities.remove(this);
-        this.components.deregisterAllComponents();
-        for (var i = 0; i < this.numChildren; i++)
-            this.getChildAt(i).entity.detachFromScene();
-    };
-    Entity.prototype.addComponent = function (component) {
-        component.entity = this;
-        this.components.add(component);
-        this.addChild(component);
-        component.initialize();
-        return component;
-    };
-    Entity.prototype.hasComponent = function (type) {
-        return this.components.getComponent(type, false) != null;
-    };
-    Entity.prototype.getOrCreateComponent = function (type) {
-        var comp = this.components.getComponent(type, true);
-        if (!comp) {
-            comp = this.addComponent(type);
-        }
-        return comp;
-    };
-    Entity.prototype.getComponent = function (type) {
-        return this.components.getComponent(type, false);
-    };
-    Entity.prototype.getComponents = function (typeName, componentList) {
-        return this.components.getComponents(typeName, componentList);
-    };
-    Entity.prototype.onEntityTransformChanged = function (comp) {
-        this.components.onEntityTransformChanged(comp);
-    };
-    Entity.prototype.removeComponentForType = function (type) {
-        var comp = this.getComponent(type);
-        if (comp) {
-            this.removeComponent(comp);
-            return true;
-        }
-        return false;
-    };
-    Entity.prototype.removeComponent = function (component) {
-        this.components.remove(component);
-    };
-    Entity.prototype.removeAllComponents = function () {
-        for (var i = 0; i < this.components.count; i++) {
-            this.removeComponent(this.components.buffer[i]);
-        }
-    };
-    Entity.prototype.update = function () {
-        this.components.update();
-    };
-    Entity.prototype.onAddedToScene = function () {
-    };
-    Entity.prototype.onRemovedFromScene = function () {
-        if (this._isDestoryed)
-            this.components.removeAllComponents();
-    };
-    Entity.prototype.destroy = function () {
-        this._isDestoryed = true;
-        this.removeEventListener(egret.Event.ADDED_TO_STAGE, this.onAddToStage, this);
-        this.scene.entities.remove(this);
-        this.removeChildren();
-        if (this.parent)
-            this.parent.removeChild(this);
-        for (var i = this.numChildren - 1; i >= 0; i--) {
-            var child = this.getChildAt(i);
-            child.entity.destroy();
-        }
-    };
-    return Entity;
-}(egret.DisplayObjectContainer));
-var TransformComponent;
-(function (TransformComponent) {
-    TransformComponent[TransformComponent["rotation"] = 0] = "rotation";
-    TransformComponent[TransformComponent["scale"] = 1] = "scale";
-    TransformComponent[TransformComponent["position"] = 2] = "position";
-})(TransformComponent || (TransformComponent = {}));
-var Scene = (function (_super) {
-    __extends(Scene, _super);
-    function Scene() {
-        var _this = _super.call(this) || this;
-        _this.enablePostProcessing = true;
-        _this._renderers = [];
-        _this._postProcessors = [];
-        _this.entityProcessors = new EntityProcessorList();
-        _this.renderableComponents = new RenderableComponentList();
-        _this.entities = new EntityList(_this);
-        _this.content = new ContentManager();
-        _this.width = SceneManager.stage.stageWidth;
-        _this.height = SceneManager.stage.stageHeight;
-        _this.addEventListener(egret.Event.ACTIVATE, _this.onActive, _this);
-        _this.addEventListener(egret.Event.DEACTIVATE, _this.onDeactive, _this);
-        return _this;
-    }
-    Scene.prototype.createEntity = function (name) {
-        var entity = new Entity(name);
-        entity.position = new Vector2(0, 0);
-        return this.addEntity(entity);
-    };
-    Scene.prototype.addEntity = function (entity) {
-        this.entities.add(entity);
-        entity.scene = this;
-        this.addChild(entity);
-        for (var i = 0; i < entity.numChildren; i++)
-            this.addEntity(entity.getChildAt(i).entity);
-        return entity;
-    };
-    Scene.prototype.destroyAllEntities = function () {
-        for (var i = 0; i < this.entities.count; i++) {
-            this.entities.buffer[i].destroy();
-        }
-    };
-    Scene.prototype.findEntity = function (name) {
-        return this.entities.findEntity(name);
-    };
-    Scene.prototype.addEntityProcessor = function (processor) {
-        processor.scene = this;
-        this.entityProcessors.add(processor);
-        return processor;
-    };
-    Scene.prototype.removeEntityProcessor = function (processor) {
-        this.entityProcessors.remove(processor);
-    };
-    Scene.prototype.getEntityProcessor = function () {
-        return this.entityProcessors.getProcessor();
-    };
-    Scene.prototype.addRenderer = function (renderer) {
-        this._renderers.push(renderer);
-        this._renderers.sort();
-        renderer.onAddedToScene(this);
-        return renderer;
-    };
-    Scene.prototype.getRenderer = function (type) {
-        for (var i = 0; i < this._renderers.length; i++) {
-            if (this._renderers[i] instanceof type)
-                return this._renderers[i];
-        }
-        return null;
-    };
-    Scene.prototype.removeRenderer = function (renderer) {
-        this._renderers.remove(renderer);
-        renderer.unload();
-    };
-    Scene.prototype.begin = function () {
-        if (SceneManager.sceneTransition) {
-            SceneManager.stage.addChildAt(this, SceneManager.stage.numChildren - 1);
-        }
-        else {
-            SceneManager.stage.addChild(this);
-        }
-        if (this._renderers.length == 0) {
-            this.addRenderer(new DefaultRenderer());
-            console.warn("场景开始时没有渲染器 自动添加DefaultRenderer以保证能够正常渲染");
-        }
-        this.camera = this.createEntity("camera").getOrCreateComponent(new Camera());
-        Physics.reset();
-        if (this.entityProcessors)
-            this.entityProcessors.begin();
-        this.camera.onSceneSizeChanged(this.stage.stageWidth, this.stage.stageHeight);
-        this._didSceneBegin = true;
-        this.onStart();
-    };
-    Scene.prototype.end = function () {
-        this._didSceneBegin = false;
-        this.removeEventListener(egret.Event.DEACTIVATE, this.onDeactive, this);
-        this.removeEventListener(egret.Event.ACTIVATE, this.onActive, this);
-        for (var i = 0; i < this._renderers.length; i++) {
-            this._renderers[i].unload();
-        }
-        for (var i = 0; i < this._postProcessors.length; i++) {
-            this._postProcessors[i].unload();
-        }
-        this.entities.removeAllEntities();
-        this.removeChildren();
-        Physics.clear();
-        this.camera = null;
-        this.content.dispose();
-        if (this.entityProcessors)
-            this.entityProcessors.end();
-        this.unload();
-        if (this.parent)
-            this.parent.removeChild(this);
-    };
-    Scene.prototype.onStart = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2];
-            });
+        Object.defineProperty(Entity.prototype, "tag", {
+            get: function () {
+                return this._tag;
+            },
+            set: function (value) {
+                this.setTag(value);
+            },
+            enumerable: true,
+            configurable: true
         });
-    };
-    Scene.prototype.onActive = function () {
-    };
-    Scene.prototype.onDeactive = function () {
-    };
-    Scene.prototype.unload = function () { };
-    Scene.prototype.update = function () {
-        this.entities.updateLists();
-        if (this.entityProcessors)
-            this.entityProcessors.update();
-        this.entities.update();
-        if (this.entityProcessors)
-            this.entityProcessors.lateUpdate();
-        this.renderableComponents.updateList();
-    };
-    Scene.prototype.postRender = function () {
-        var enabledCounter = 0;
-        if (this.enablePostProcessing) {
+        Object.defineProperty(Entity.prototype, "enabled", {
+            get: function () {
+                return this._enabled;
+            },
+            set: function (value) {
+                this.setEnabled(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Entity.prototype, "updateOrder", {
+            get: function () {
+                return this._updateOrder;
+            },
+            set: function (value) {
+                this.setUpdateOrder(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Entity.prototype, "isDestroyed", {
+            get: function () {
+                return this._isDestroyed;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Entity.prototype, "parent", {
+            get: function () {
+                return this.transform.parent;
+            },
+            set: function (value) {
+                this.transform.setParent(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Entity.prototype, "childCount", {
+            get: function () {
+                return this.transform.childCount;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Entity.prototype, "position", {
+            get: function () {
+                return this.transform.position;
+            },
+            set: function (value) {
+                this.transform.setPosition(value.x, value.y);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Entity.prototype, "rotation", {
+            get: function () {
+                return this.transform.rotation;
+            },
+            set: function (value) {
+                this.transform.setRotation(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Entity.prototype, "scale", {
+            get: function () {
+                return this.transform.scale;
+            },
+            set: function (value) {
+                this.transform.setScale(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Entity.prototype.onTransformChanged = function (comp) {
+            this.components.onEntityTransformChanged(comp);
+        };
+        Entity.prototype.setTag = function (tag) {
+            if (this._tag != tag) {
+                if (this.scene)
+                    this.scene.entities.removeFromTagList(this);
+                this._tag = tag;
+                if (this.scene)
+                    this.scene.entities.addToTagList(this);
+            }
+            return this;
+        };
+        Entity.prototype.setEnabled = function (isEnabled) {
+            if (this._enabled != isEnabled) {
+                this._enabled = isEnabled;
+                if (this._enabled)
+                    this.components.onEntityEnabled();
+                else
+                    this.components.onEntityDisabled();
+            }
+            return this;
+        };
+        Entity.prototype.setUpdateOrder = function (updateOrder) {
+            if (this._updateOrder != updateOrder) {
+                this._updateOrder = updateOrder;
+                if (this.scene) {
+                }
+                return this;
+            }
+        };
+        Entity.prototype.destroy = function () {
+            this._isDestroyed = true;
+            this.scene.entities.remove(this);
+            this.transform.parent = null;
+            for (var i = this.transform.childCount - 1; i >= 0; i--) {
+                var child = this.transform.getChild(i);
+                child.entity.destroy();
+            }
+        };
+        Entity.prototype.detachFromScene = function () {
+            this.scene.entities.remove(this);
+            this.components.deregisterAllComponents();
+            for (var i = 0; i < this.transform.childCount; i++)
+                this.transform.getChild(i).entity.detachFromScene();
+        };
+        Entity.prototype.attachToScene = function (newScene) {
+            this.scene = newScene;
+            newScene.entities.add(this);
+            this.components.registerAllComponents();
+            for (var i = 0; i < this.transform.childCount; i++) {
+                this.transform.getChild(i).entity.attachToScene(newScene);
+            }
+        };
+        Entity.prototype.clone = function (position) {
+            if (position === void 0) { position = new es.Vector2(); }
+            var entity = new Entity(this.name + "(clone)");
+            entity.copyFrom(this);
+            entity.transform.position = position;
+            return entity;
+        };
+        Entity.prototype.copyFrom = function (entity) {
+            this.tag = entity.tag;
+            this.updateInterval = entity.updateInterval;
+            this.updateOrder = entity.updateOrder;
+            this.enabled = entity.enabled;
+            this.transform.scale = entity.transform.scale;
+            this.transform.rotation = entity.transform.rotation;
+            for (var i = 0; i < entity.components.count; i++)
+                this.addComponent(entity.components.buffer[i].clone());
+            for (var i = 0; i < entity.components._componentsToAdd.length; i++)
+                this.addComponent(entity.components._componentsToAdd[i].clone());
+            for (var i = 0; i < entity.transform.childCount; i++) {
+                var child = entity.transform.getChild(i).entity;
+                var childClone = child.clone();
+                childClone.transform.copyFrom(child.transform);
+                childClone.transform.parent = this.transform;
+            }
+        };
+        Entity.prototype.onAddedToScene = function () {
+        };
+        Entity.prototype.onRemovedFromScene = function () {
+            if (this._isDestroyed)
+                this.components.removeAllComponents();
+        };
+        Entity.prototype.update = function () {
+            this.components.update();
+        };
+        Entity.prototype.addComponent = function (component) {
+            component.entity = this;
+            this.components.add(component);
+            component.initialize();
+            return component;
+        };
+        Entity.prototype.getComponent = function (type) {
+            return this.components.getComponent(type, false);
+        };
+        Entity.prototype.hasComponent = function (type) {
+            return this.components.getComponent(type, false) != null;
+        };
+        Entity.prototype.getOrCreateComponent = function (type) {
+            var comp = this.components.getComponent(type, true);
+            if (!comp) {
+                comp = this.addComponent(type);
+            }
+            return comp;
+        };
+        Entity.prototype.getComponents = function (typeName, componentList) {
+            return this.components.getComponents(typeName, componentList);
+        };
+        Entity.prototype.removeComponent = function (component) {
+            this.components.remove(component);
+        };
+        Entity.prototype.removeComponentForType = function (type) {
+            var comp = this.getComponent(type);
+            if (comp) {
+                this.removeComponent(comp);
+                return true;
+            }
+            return false;
+        };
+        Entity.prototype.removeAllComponents = function () {
+            for (var i = 0; i < this.components.count; i++) {
+                this.removeComponent(this.components.buffer[i]);
+            }
+        };
+        Entity.prototype.toString = function () {
+            return "[Entity: name: " + this.name + ", tag: " + this.tag + ", enabled: " + this.enabled + ", depth: " + this.updateOrder + "]";
+        };
+        return Entity;
+    }());
+    es.Entity = Entity;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Scene = (function (_super) {
+        __extends(Scene, _super);
+        function Scene() {
+            var _this = _super.call(this) || this;
+            _this.enablePostProcessing = true;
+            _this._renderers = [];
+            _this._postProcessors = [];
+            _this.entities = new es.EntityList(_this);
+            _this.renderableComponents = new es.RenderableComponentList();
+            _this.content = new es.ContentManager();
+            _this.entityProcessors = new es.EntityProcessorList();
+            _this.width = es.SceneManager.stage.stageWidth;
+            _this.height = es.SceneManager.stage.stageHeight;
+            _this.initialize();
+            return _this;
+        }
+        Scene.createWithDefaultRenderer = function () {
+            var scene = new Scene();
+            scene.addRenderer(new es.DefaultRenderer());
+            return scene;
+        };
+        Scene.prototype.initialize = function () { };
+        Scene.prototype.onStart = function () {
+            return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
+                return [2];
+            }); });
+        };
+        Scene.prototype.unload = function () { };
+        Scene.prototype.onActive = function () { };
+        Scene.prototype.onDeactive = function () { };
+        Scene.prototype.begin = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    if (es.SceneManager.sceneTransition) {
+                        es.SceneManager.stage.addChildAt(this, es.SceneManager.stage.numChildren - 1);
+                    }
+                    else {
+                        es.SceneManager.stage.addChild(this);
+                    }
+                    if (this._renderers.length == 0) {
+                        this.addRenderer(new es.DefaultRenderer());
+                        console.warn("场景开始时没有渲染器 自动添加DefaultRenderer以保证能够正常渲染");
+                    }
+                    this.camera = this.createEntity("camera").getOrCreateComponent(new es.Camera());
+                    es.Physics.reset();
+                    if (this.entityProcessors)
+                        this.entityProcessors.begin();
+                    this.addEventListener(egret.Event.ACTIVATE, this.onActive, this);
+                    this.addEventListener(egret.Event.DEACTIVATE, this.onDeactive, this);
+                    this.camera.onSceneSizeChanged(this.stage.stageWidth, this.stage.stageHeight);
+                    this._didSceneBegin = true;
+                    this.onStart();
+                    return [2];
+                });
+            });
+        };
+        Scene.prototype.end = function () {
+            this._didSceneBegin = false;
+            this.removeEventListener(egret.Event.DEACTIVATE, this.onDeactive, this);
+            this.removeEventListener(egret.Event.ACTIVATE, this.onActive, this);
+            for (var i = 0; i < this._renderers.length; i++) {
+                this._renderers[i].unload();
+            }
             for (var i = 0; i < this._postProcessors.length; i++) {
-                if (this._postProcessors[i].enable) {
-                    var isEven = MathHelper.isEven(enabledCounter);
-                    enabledCounter++;
-                    this._postProcessors[i].process();
-                }
+                this._postProcessors[i].unload();
             }
-        }
-    };
-    Scene.prototype.render = function () {
-        for (var i = 0; i < this._renderers.length; i++) {
-            this._renderers[i].render(this);
-        }
-    };
-    Scene.prototype.addPostProcessor = function (postProcessor) {
-        this._postProcessors.push(postProcessor);
-        this._postProcessors.sort();
-        postProcessor.onAddedToScene(this);
-        if (this._didSceneBegin) {
-            postProcessor.onSceneBackBufferSizeChanged(this.stage.stageWidth, this.stage.stageHeight);
-        }
-        return postProcessor;
-    };
-    return Scene;
-}(egret.DisplayObjectContainer));
-var SceneManager = (function () {
-    function SceneManager(stage) {
-        stage.addEventListener(egret.Event.ENTER_FRAME, SceneManager.update, this);
-        SceneManager._instnace = this;
-        SceneManager.emitter = new Emitter();
-        SceneManager.content = new ContentManager();
-        SceneManager.stage = stage;
-        SceneManager.initialize(stage);
-        SceneManager.timerRuler = new TimeRuler();
-    }
-    Object.defineProperty(SceneManager, "Instance", {
-        get: function () {
-            return this._instnace;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(SceneManager, "scene", {
-        get: function () {
-            return this._scene;
-        },
-        set: function (value) {
-            if (!value)
-                throw new Error("场景不能为空");
-            if (this._scene == null) {
-                this._scene = value;
-                this._scene.begin();
-                SceneManager.Instance.onSceneChanged();
+            this.entities.removeAllEntities();
+            this.removeChildren();
+            this.camera = null;
+            this.content.dispose();
+            if (this.entityProcessors)
+                this.entityProcessors.end();
+            if (this.parent)
+                this.parent.removeChild(this);
+            this.unload();
+        };
+        Scene.prototype.update = function () {
+            this.entities.updateLists();
+            if (this.entityProcessors)
+                this.entityProcessors.update();
+            this.entities.update();
+            if (this.entityProcessors)
+                this.entityProcessors.lateUpdate();
+            this.renderableComponents.updateList();
+        };
+        Scene.prototype.render = function () {
+            if (this._renderers.length == 0) {
+                console.error("there are no renderers in the scene!");
+                return;
             }
-            else {
-                this._nextScene = value;
+            for (var i = 0; i < this._renderers.length; i++) {
+                this._renderers[i].render(this);
             }
-            this.registerActiveSceneChanged(this._scene, this._nextScene);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    SceneManager.initialize = function (stage) {
-        Input.initialize(stage);
-    };
-    SceneManager.update = function () {
-        SceneManager.startDebugUpdate();
-        Time.update(egret.getTimer());
-        if (SceneManager._scene) {
-            for (var i = GlobalManager.globalManagers.length - 1; i >= 0; i--) {
-                if (GlobalManager.globalManagers[i].enabled)
-                    GlobalManager.globalManagers[i].update();
-            }
-            if (!SceneManager.sceneTransition ||
-                (SceneManager.sceneTransition && (!SceneManager.sceneTransition.loadsNewScene || SceneManager.sceneTransition.isNewSceneLoaded))) {
-                SceneManager._scene.update();
-            }
-            if (SceneManager._nextScene) {
-                SceneManager._scene.end();
-                SceneManager._scene = SceneManager._nextScene;
-                SceneManager._nextScene = null;
-                SceneManager._instnace.onSceneChanged();
-                SceneManager._scene.begin();
-            }
-        }
-        SceneManager.endDebugUpdate();
-        SceneManager.render();
-    };
-    SceneManager.render = function () {
-        if (this.sceneTransition) {
-            this.sceneTransition.preRender();
-            if (this._scene && !this.sceneTransition.hasPreviousSceneRender) {
-                this._scene.render();
-                this._scene.postRender();
-                this.sceneTransition.onBeginTransition();
-            }
-            else if (this.sceneTransition) {
-                if (this._scene && this.sceneTransition.isNewSceneLoaded) {
-                    this._scene.render();
-                    this._scene.postRender();
-                }
-                this.sceneTransition.render();
-            }
-        }
-        else if (this._scene) {
-            this._scene.render();
-            Debug.render();
-            this._scene.postRender();
-        }
-    };
-    SceneManager.startSceneTransition = function (sceneTransition) {
-        if (this.sceneTransition) {
-            console.warn("在前一个场景完成之前，不能开始一个新的场景转换。");
-            return;
-        }
-        this.sceneTransition = sceneTransition;
-        return sceneTransition;
-    };
-    SceneManager.registerActiveSceneChanged = function (current, next) {
-        if (this.activeSceneChanged)
-            this.activeSceneChanged(current, next);
-    };
-    SceneManager.prototype.onSceneChanged = function () {
-        SceneManager.emitter.emit(CoreEvents.SceneChanged);
-        Time.sceneChanged();
-    };
-    SceneManager.startDebugUpdate = function () {
-        TimeRuler.Instance.startFrame();
-        TimeRuler.Instance.beginMark("update", 0x00FF00);
-    };
-    SceneManager.endDebugUpdate = function () {
-        TimeRuler.Instance.endMark("update");
-    };
-    return SceneManager;
-}());
-var Camera = (function (_super) {
-    __extends(Camera, _super);
-    function Camera() {
-        var _this = _super.call(this) || this;
-        _this._origin = Vector2.zero;
-        _this._minimumZoom = 0.3;
-        _this._maximumZoom = 3;
-        _this._position = Vector2.zero;
-        _this.followLerp = 0.1;
-        _this.deadzone = new Rectangle();
-        _this.focusOffset = new Vector2();
-        _this.mapLockEnabled = false;
-        _this.mapSize = new Vector2();
-        _this._worldSpaceDeadZone = new Rectangle();
-        _this._desiredPositionDelta = new Vector2();
-        _this.cameraStyle = CameraStyle.lockOn;
-        _this.width = SceneManager.stage.stageWidth;
-        _this.height = SceneManager.stage.stageHeight;
-        _this.setZoom(0);
-        return _this;
-    }
-    Object.defineProperty(Camera.prototype, "zoom", {
-        get: function () {
-            if (this._zoom == 0)
-                return 1;
-            if (this._zoom < 1)
-                return MathHelper.map(this._zoom, this._minimumZoom, 1, -1, 0);
-            return MathHelper.map(this._zoom, 1, this._maximumZoom, 0, 1);
-        },
-        set: function (value) {
-            this.setZoom(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Camera.prototype, "minimumZoom", {
-        get: function () {
-            return this._minimumZoom;
-        },
-        set: function (value) {
-            this.setMinimumZoom(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Camera.prototype, "maximumZoom", {
-        get: function () {
-            return this._maximumZoom;
-        },
-        set: function (value) {
-            this.setMaximumZoom(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Camera.prototype, "origin", {
-        get: function () {
-            return this._origin;
-        },
-        set: function (value) {
-            if (this._origin != value) {
-                this._origin = value;
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Camera.prototype, "position", {
-        get: function () {
-            return this._position;
-        },
-        set: function (value) {
-            this._position = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Camera.prototype, "x", {
-        get: function () {
-            return this._position.x;
-        },
-        set: function (value) {
-            this._position.x = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Camera.prototype, "y", {
-        get: function () {
-            return this._position.y;
-        },
-        set: function (value) {
-            this._position.y = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Camera.prototype.onSceneSizeChanged = function (newWidth, newHeight) {
-        var oldOrigin = this._origin;
-        this.origin = new Vector2(newWidth / 2, newHeight / 2);
-        this.entity.position = Vector2.add(this.entity.position, Vector2.subtract(this._origin, oldOrigin));
-    };
-    Camera.prototype.setMinimumZoom = function (minZoom) {
-        if (this._zoom < minZoom)
-            this._zoom = this.minimumZoom;
-        this._minimumZoom = minZoom;
-        return this;
-    };
-    Camera.prototype.setMaximumZoom = function (maxZoom) {
-        if (this._zoom > maxZoom)
-            this._zoom = maxZoom;
-        this._maximumZoom = maxZoom;
-        return this;
-    };
-    Camera.prototype.setZoom = function (zoom) {
-        var newZoom = MathHelper.clamp(zoom, -1, 1);
-        if (newZoom == 0) {
-            this._zoom = 1;
-        }
-        else if (newZoom < 0) {
-            this._zoom = MathHelper.map(newZoom, -1, 0, this._minimumZoom, 1);
-        }
-        else {
-            this._zoom = MathHelper.map(newZoom, 0, 1, 1, this._maximumZoom);
-        }
-        SceneManager.scene.scaleX = this._zoom;
-        SceneManager.scene.scaleY = this._zoom;
-        return this;
-    };
-    Camera.prototype.setRotation = function (rotation) {
-        SceneManager.scene.rotation = rotation;
-        return this;
-    };
-    Camera.prototype.setPosition = function (position) {
-        this.entity.position = position;
-        return this;
-    };
-    Camera.prototype.follow = function (targetEntity, cameraStyle) {
-        if (cameraStyle === void 0) { cameraStyle = CameraStyle.cameraWindow; }
-        this.targetEntity = targetEntity;
-        this.cameraStyle = cameraStyle;
-        var cameraBounds = new Rectangle(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-        switch (this.cameraStyle) {
-            case CameraStyle.cameraWindow:
-                var w = cameraBounds.width / 6;
-                var h = cameraBounds.height / 3;
-                this.deadzone = new Rectangle((cameraBounds.width - w) / 2, (cameraBounds.height - h) / 2, w, h);
-                break;
-            case CameraStyle.lockOn:
-                this.deadzone = new Rectangle(cameraBounds.width / 2, cameraBounds.height / 2, 10, 10);
-                break;
-        }
-    };
-    Camera.prototype.update = function () {
-        var cameraBounds = new Rectangle(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-        var halfScreen = Vector2.multiply(new Vector2(cameraBounds.width, cameraBounds.height), new Vector2(0.5));
-        this._worldSpaceDeadZone.x = this.position.x - halfScreen.x * SceneManager.scene.scaleX + this.deadzone.x + this.focusOffset.x;
-        this._worldSpaceDeadZone.y = this.position.y - halfScreen.y * SceneManager.scene.scaleY + this.deadzone.y + this.focusOffset.y;
-        this._worldSpaceDeadZone.width = this.deadzone.width;
-        this._worldSpaceDeadZone.height = this.deadzone.height;
-        if (this.targetEntity)
-            this.updateFollow();
-        this.position = Vector2.lerp(this.position, Vector2.add(this.position, this._desiredPositionDelta), this.followLerp);
-        this.entity.roundPosition();
-        if (this.mapLockEnabled) {
-            this.position = this.clampToMapSize(this.position);
-            this.entity.roundPosition();
-        }
-    };
-    Camera.prototype.clampToMapSize = function (position) {
-        var cameraBounds = new Rectangle(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-        var halfScreen = Vector2.multiply(new Vector2(cameraBounds.width, cameraBounds.height), new Vector2(0.5));
-        var cameraMax = new Vector2(this.mapSize.x - halfScreen.x, this.mapSize.y - halfScreen.y);
-        return Vector2.clamp(position, halfScreen, cameraMax);
-    };
-    Camera.prototype.updateFollow = function () {
-        this._desiredPositionDelta.x = this._desiredPositionDelta.y = 0;
-        if (this.cameraStyle == CameraStyle.lockOn) {
-            var targetX = this.targetEntity.position.x;
-            var targetY = this.targetEntity.position.y;
-            if (this._worldSpaceDeadZone.x > targetX)
-                this._desiredPositionDelta.x = targetX - this._worldSpaceDeadZone.x;
-            else if (this._worldSpaceDeadZone.x < targetX)
-                this._desiredPositionDelta.x = targetX - this._worldSpaceDeadZone.x;
-            if (this._worldSpaceDeadZone.y < targetY)
-                this._desiredPositionDelta.y = targetY - this._worldSpaceDeadZone.y;
-            else if (this._worldSpaceDeadZone.y > targetY)
-                this._desiredPositionDelta.y = targetY - this._worldSpaceDeadZone.y;
-        }
-        else {
-            if (!this._targetCollider) {
-                this._targetCollider = this.targetEntity.getComponent(Collider);
-                if (!this._targetCollider)
-                    return;
-            }
-            var targetBounds = this.targetEntity.getComponent(Collider).bounds;
-            if (!this._worldSpaceDeadZone.containsRect(targetBounds)) {
-                if (this._worldSpaceDeadZone.left > targetBounds.left)
-                    this._desiredPositionDelta.x = targetBounds.left - this._worldSpaceDeadZone.left;
-                else if (this._worldSpaceDeadZone.right < targetBounds.right)
-                    this._desiredPositionDelta.x = targetBounds.right - this._worldSpaceDeadZone.right;
-                if (this._worldSpaceDeadZone.bottom < targetBounds.bottom)
-                    this._desiredPositionDelta.y = targetBounds.bottom - this._worldSpaceDeadZone.bottom;
-                else if (this._worldSpaceDeadZone.top > targetBounds.top)
-                    this._desiredPositionDelta.y = targetBounds.top - this._worldSpaceDeadZone.top;
-            }
-        }
-    };
-    return Camera;
-}(Component));
-var CameraStyle;
-(function (CameraStyle) {
-    CameraStyle[CameraStyle["lockOn"] = 0] = "lockOn";
-    CameraStyle[CameraStyle["cameraWindow"] = 1] = "cameraWindow";
-})(CameraStyle || (CameraStyle = {}));
-var ComponentPool = (function () {
-    function ComponentPool(typeClass) {
-        this._type = typeClass;
-        this._cache = [];
-    }
-    ComponentPool.prototype.obtain = function () {
-        try {
-            return this._cache.length > 0 ? this._cache.shift() : new this._type();
-        }
-        catch (err) {
-            throw new Error(this._type + err);
-        }
-    };
-    ComponentPool.prototype.free = function (component) {
-        component.reset();
-        this._cache.push(component);
-    };
-    return ComponentPool;
-}());
-var PooledComponent = (function (_super) {
-    __extends(PooledComponent, _super);
-    function PooledComponent() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return PooledComponent;
-}(Component));
-var RenderableComponent = (function (_super) {
-    __extends(RenderableComponent, _super);
-    function RenderableComponent() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this._areBoundsDirty = true;
-        _this._bounds = new Rectangle();
-        _this._localOffset = Vector2.zero;
-        _this.color = 0x000000;
-        return _this;
-    }
-    Object.defineProperty(RenderableComponent.prototype, "width", {
-        get: function () {
-            return this.getWidth();
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(RenderableComponent.prototype, "height", {
-        get: function () {
-            return this.getHeight();
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(RenderableComponent.prototype, "isVisible", {
-        get: function () {
-            return this._isVisible;
-        },
-        set: function (value) {
-            this._isVisible = value;
-            if (this._isVisible)
-                this.onBecameVisible();
-            else
-                this.onBecameInvisible();
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(RenderableComponent.prototype, "bounds", {
-        get: function () {
-            return new Rectangle(this.getBounds().x, this.getBounds().y, this.getBounds().width, this.getBounds().height);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    RenderableComponent.prototype.getWidth = function () {
-        return this.bounds.width;
-    };
-    RenderableComponent.prototype.getHeight = function () {
-        return this.bounds.height;
-    };
-    RenderableComponent.prototype.onBecameVisible = function () { };
-    RenderableComponent.prototype.onBecameInvisible = function () { };
-    RenderableComponent.prototype.isVisibleFromCamera = function (camera) {
-        this.isVisible = camera.getBounds().intersects(this.getBounds());
-        return this.isVisible;
-    };
-    return RenderableComponent;
-}(PooledComponent));
-var Mesh = (function (_super) {
-    __extends(Mesh, _super);
-    function Mesh() {
-        var _this = _super.call(this) || this;
-        _this._mesh = new egret.Mesh();
-        return _this;
-    }
-    Mesh.prototype.setTexture = function (texture) {
-        this._mesh.texture = texture;
-        return this;
-    };
-    Mesh.prototype.onAddedToEntity = function () {
-        this.addChild(this._mesh);
-    };
-    Mesh.prototype.onRemovedFromEntity = function () {
-        this.removeChild(this._mesh);
-    };
-    Mesh.prototype.render = function (camera) {
-        this.x = this.entity.position.x - camera.position.x + camera.origin.x;
-        this.y = this.entity.position.y - camera.position.y + camera.origin.y;
-    };
-    Mesh.prototype.reset = function () {
-    };
-    return Mesh;
-}(RenderableComponent));
-var SpriteRenderer = (function (_super) {
-    __extends(SpriteRenderer, _super);
-    function SpriteRenderer() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Object.defineProperty(SpriteRenderer.prototype, "sprite", {
-        get: function () {
-            return this._sprite;
-        },
-        set: function (value) {
-            this.setSprite(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    SpriteRenderer.prototype.setSprite = function (sprite) {
-        this.removeChildren();
-        this._sprite = sprite;
-        if (this._sprite) {
-            this.anchorOffsetX = this._sprite.origin.x / this._sprite.sourceRect.width;
-            this.anchorOffsetY = this._sprite.origin.y / this._sprite.sourceRect.height;
-        }
-        this.bitmap = new egret.Bitmap(sprite.texture2D);
-        this.addChild(this.bitmap);
-        return this;
-    };
-    SpriteRenderer.prototype.setColor = function (color) {
-        var colorMatrix = [
-            1, 0, 0, 0, 0,
-            0, 1, 0, 0, 0,
-            0, 0, 1, 0, 0,
-            0, 0, 0, 1, 0
-        ];
-        colorMatrix[0] = Math.floor(color / 256 / 256) / 255;
-        colorMatrix[6] = Math.floor(color / 256 % 256) / 255;
-        colorMatrix[12] = color % 256 / 255;
-        var colorFilter = new egret.ColorMatrixFilter(colorMatrix);
-        this.filters = [colorFilter];
-        return this;
-    };
-    SpriteRenderer.prototype.isVisibleFromCamera = function (camera) {
-        this.isVisible = new Rectangle(0, 0, this.stage.stageWidth, this.stage.stageHeight).intersects(this.bounds);
-        this.visible = this.isVisible;
-        return this.isVisible;
-    };
-    SpriteRenderer.prototype.render = function (camera) {
-        if (this.x != -camera.position.x + camera.origin.x ||
-            this.y != -camera.position.y + camera.origin.y) {
-            this.x = -camera.position.x + camera.origin.x;
-            this.y = -camera.position.y + camera.origin.y;
-            this.entity.onEntityTransformChanged(TransformComponent.position);
-        }
-    };
-    SpriteRenderer.prototype.onRemovedFromEntity = function () {
-        if (this.parent)
-            this.parent.removeChild(this);
-    };
-    SpriteRenderer.prototype.reset = function () {
-    };
-    return SpriteRenderer;
-}(RenderableComponent));
-var TiledSpriteRenderer = (function (_super) {
-    __extends(TiledSpriteRenderer, _super);
-    function TiledSpriteRenderer(sprite) {
-        var _this = _super.call(this) || this;
-        _this.leftTexture = new egret.Bitmap();
-        _this.rightTexture = new egret.Bitmap();
-        _this.leftTexture.texture = sprite.texture2D;
-        _this.rightTexture.texture = sprite.texture2D;
-        _this.setSprite(sprite);
-        _this.sourceRect = sprite.sourceRect;
-        return _this;
-    }
-    Object.defineProperty(TiledSpriteRenderer.prototype, "scrollX", {
-        get: function () {
-            return this.sourceRect.x;
-        },
-        set: function (value) {
-            this.sourceRect.x = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(TiledSpriteRenderer.prototype, "scrollY", {
-        get: function () {
-            return this.sourceRect.y;
-        },
-        set: function (value) {
-            this.sourceRect.y = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    TiledSpriteRenderer.prototype.render = function (camera) {
-        if (!this.sprite)
-            return;
-        _super.prototype.render.call(this, camera);
-        var renderTexture = new egret.RenderTexture();
-        var cacheBitmap = new egret.DisplayObjectContainer();
-        cacheBitmap.removeChildren();
-        cacheBitmap.addChild(this.leftTexture);
-        cacheBitmap.addChild(this.rightTexture);
-        this.leftTexture.x = this.sourceRect.x;
-        this.rightTexture.x = this.sourceRect.x - this.sourceRect.width;
-        this.leftTexture.y = this.sourceRect.y;
-        this.rightTexture.y = this.sourceRect.y;
-        cacheBitmap.cacheAsBitmap = true;
-        renderTexture.drawToTexture(cacheBitmap, new egret.Rectangle(0, 0, this.sourceRect.width, this.sourceRect.height));
-        this.bitmap.texture = renderTexture;
-    };
-    return TiledSpriteRenderer;
-}(SpriteRenderer));
-var ScrollingSpriteRenderer = (function (_super) {
-    __extends(ScrollingSpriteRenderer, _super);
-    function ScrollingSpriteRenderer() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.scrollSpeedX = 15;
-        _this.scroolSpeedY = 0;
-        _this._scrollX = 0;
-        _this._scrollY = 0;
-        return _this;
-    }
-    ScrollingSpriteRenderer.prototype.update = function () {
-        this._scrollX += this.scrollSpeedX * Time.deltaTime;
-        this._scrollY += this.scroolSpeedY * Time.deltaTime;
-        this.sourceRect.x = this._scrollX;
-        this.sourceRect.y = this._scrollY;
-    };
-    ScrollingSpriteRenderer.prototype.render = function (camera) {
-        if (!this.sprite)
-            return;
-        _super.prototype.render.call(this, camera);
-        var renderTexture = new egret.RenderTexture();
-        var cacheBitmap = new egret.DisplayObjectContainer();
-        cacheBitmap.removeChildren();
-        cacheBitmap.addChild(this.leftTexture);
-        cacheBitmap.addChild(this.rightTexture);
-        this.leftTexture.x = this.sourceRect.x;
-        this.rightTexture.x = this.sourceRect.x - this.sourceRect.width;
-        this.leftTexture.y = this.sourceRect.y;
-        this.rightTexture.y = this.sourceRect.y;
-        cacheBitmap.cacheAsBitmap = true;
-        renderTexture.drawToTexture(cacheBitmap, new egret.Rectangle(0, 0, this.sourceRect.width, this.sourceRect.height));
-        this.bitmap.texture = renderTexture;
-    };
-    return ScrollingSpriteRenderer;
-}(TiledSpriteRenderer));
-var Sprite = (function () {
-    function Sprite(texture, sourceRect, origin) {
-        if (sourceRect === void 0) { sourceRect = new Rectangle(0, 0, texture.textureWidth, texture.textureHeight); }
-        if (origin === void 0) { origin = sourceRect.getHalfSize(); }
-        this.uvs = new Rectangle();
-        this.texture2D = texture;
-        this.sourceRect = sourceRect;
-        this.center = new Vector2(sourceRect.width * 0.5, sourceRect.height * 0.5);
-        this.origin = origin;
-        var inverseTexW = 1 / texture.textureWidth;
-        var inverseTexH = 1 / texture.textureHeight;
-        this.uvs.x = sourceRect.x * inverseTexW;
-        this.uvs.y = sourceRect.y * inverseTexH;
-        this.uvs.width = sourceRect.width * inverseTexW;
-        this.uvs.height = sourceRect.height * inverseTexH;
-    }
-    return Sprite;
-}());
-var SpriteAnimation = (function () {
-    function SpriteAnimation(sprites, frameRate) {
-        this.sprites = sprites;
-        this.frameRate = frameRate;
-    }
-    return SpriteAnimation;
-}());
-var SpriteAnimator = (function (_super) {
-    __extends(SpriteAnimator, _super);
-    function SpriteAnimator(sprite) {
-        var _this = _super.call(this) || this;
-        _this.speed = 1;
-        _this.animationState = State.none;
-        _this._animations = new Map();
-        _this._elapsedTime = 0;
-        if (sprite)
-            _this.setSprite(sprite);
-        return _this;
-    }
-    Object.defineProperty(SpriteAnimator.prototype, "isRunning", {
-        get: function () {
-            return this.animationState == State.running;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(SpriteAnimator.prototype, "animations", {
-        get: function () {
-            return this._animations;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    SpriteAnimator.prototype.addAnimation = function (name, animation) {
-        if (!this.sprite && animation.sprites.length > 0)
-            this.setSprite(animation.sprites[0]);
-        this._animations[name] = animation;
-        return this;
-    };
-    SpriteAnimator.prototype.play = function (name, loopMode) {
-        if (loopMode === void 0) { loopMode = null; }
-        this.currentAnimation = this._animations[name];
-        this.currentAnimationName = name;
-        this.currentFrame = 0;
-        this.animationState = State.running;
-        this.sprite = this.currentAnimation.sprites[0];
-        this._elapsedTime = 0;
-        this._loopMode = loopMode ? loopMode : LoopMode.loop;
-    };
-    SpriteAnimator.prototype.isAnimationActive = function (name) {
-        return this.currentAnimation && this.currentAnimationName == name;
-    };
-    SpriteAnimator.prototype.pause = function () {
-        this.animationState = State.paused;
-    };
-    SpriteAnimator.prototype.unPause = function () {
-        this.animationState = State.running;
-    };
-    SpriteAnimator.prototype.stop = function () {
-        this.currentAnimation = null;
-        this.currentAnimationName = null;
-        this.currentFrame = 0;
-        this.animationState = State.none;
-    };
-    SpriteAnimator.prototype.update = function () {
-        if (this.animationState != State.running || !this.currentAnimation)
-            return;
-        var animation = this.currentAnimation;
-        var secondsPerFrame = 1 / (animation.frameRate * this.speed);
-        var iterationDuration = secondsPerFrame * animation.sprites.length;
-        this._elapsedTime += Time.deltaTime;
-        var time = Math.abs(this._elapsedTime);
-        if (this._loopMode == LoopMode.once && time > iterationDuration ||
-            this._loopMode == LoopMode.pingPongOnce && time > iterationDuration * 2) {
-            this.animationState = State.completed;
-            this._elapsedTime = 0;
-            this.currentFrame = 0;
-            this.sprite = animation.sprites[this.currentFrame];
-            return;
-        }
-        var i = Math.floor(time / secondsPerFrame);
-        var n = animation.sprites.length;
-        if (n > 2 && (this._loopMode == LoopMode.pingPong || this._loopMode == LoopMode.pingPongOnce)) {
-            var maxIndex = n - 1;
-            this.currentFrame = maxIndex - Math.abs(maxIndex - i % (maxIndex * 2));
-        }
-        else {
-            this.currentFrame = i % n;
-        }
-        this.sprite = animation.sprites[this.currentFrame];
-    };
-    return SpriteAnimator;
-}(SpriteRenderer));
-var LoopMode;
-(function (LoopMode) {
-    LoopMode[LoopMode["loop"] = 0] = "loop";
-    LoopMode[LoopMode["once"] = 1] = "once";
-    LoopMode[LoopMode["clampForever"] = 2] = "clampForever";
-    LoopMode[LoopMode["pingPong"] = 3] = "pingPong";
-    LoopMode[LoopMode["pingPongOnce"] = 4] = "pingPongOnce";
-})(LoopMode || (LoopMode = {}));
-var State;
-(function (State) {
-    State[State["none"] = 0] = "none";
-    State[State["running"] = 1] = "running";
-    State[State["paused"] = 2] = "paused";
-    State[State["completed"] = 3] = "completed";
-})(State || (State = {}));
-var Mover = (function (_super) {
-    __extends(Mover, _super);
-    function Mover() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Mover.prototype.onAddedToEntity = function () {
-        this._triggerHelper = new ColliderTriggerHelper(this.entity);
-    };
-    Mover.prototype.calculateMovement = function (motion) {
-        var collisionResult = new CollisionResult();
-        if (!this.entity.getComponent(Collider) || !this._triggerHelper) {
-            return null;
-        }
-        var colliders = this.entity.getComponents(Collider);
-        for (var i = 0; i < colliders.length; i++) {
-            var collider = colliders[i];
-            if (collider.isTrigger)
-                continue;
-            var bounds = collider.bounds;
-            bounds.x += motion.x;
-            bounds.y += motion.y;
-            var boxcastResult = Physics.boxcastBroadphaseExcludingSelf(collider, bounds, collider.collidesWithLayers);
-            bounds = boxcastResult.bounds;
-            var neighbors = boxcastResult.tempHashSet;
-            for (var j = 0; j < neighbors.length; j++) {
-                var neighbor = neighbors[j];
-                if (neighbor.isTrigger)
-                    continue;
-                var _internalcollisionResult = collider.collidesWith(neighbor, motion);
-                if (_internalcollisionResult) {
-                    motion = Vector2.subtract(motion, _internalcollisionResult.minimumTranslationVector);
-                    if (_internalcollisionResult.collider) {
-                        collisionResult = _internalcollisionResult;
+        };
+        Scene.prototype.postRender = function () {
+            if (this.enablePostProcessing) {
+                for (var i = 0; i < this._postProcessors.length; i++) {
+                    if (this._postProcessors[i].enabled) {
+                        this._postProcessors[i].process();
                     }
                 }
             }
-        }
-        ListPool.free(colliders);
-        return { collisionResult: collisionResult, motion: motion };
-    };
-    Mover.prototype.applyMovement = function (motion) {
-        this.entity.position = Vector2.add(this.entity.position, motion);
-        if (this._triggerHelper)
-            this._triggerHelper.update();
-    };
-    Mover.prototype.move = function (motion) {
-        var movementResult = this.calculateMovement(motion);
-        var collisionResult = movementResult.collisionResult;
-        motion = movementResult.motion;
-        this.applyMovement(motion);
-        return collisionResult;
-    };
-    return Mover;
-}(Component));
-var ProjectileMover = (function (_super) {
-    __extends(ProjectileMover, _super);
-    function ProjectileMover() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this._tempTriggerList = [];
-        return _this;
-    }
-    ProjectileMover.prototype.onAddedToEntity = function () {
-        this._collider = this.entity.getComponent(Collider);
-        if (!this._collider)
-            console.warn("ProjectileMover has no Collider. ProjectilMover requires a Collider!");
-    };
-    ProjectileMover.prototype.move = function (motion) {
-        if (!this._collider)
-            return false;
-        var didCollide = false;
-        this.entity.position = Vector2.add(this.entity.position, motion);
-        var neighbors = Physics.boxcastBroadphase(this._collider.bounds, this._collider.collidesWithLayers);
-        for (var i = 0; i < neighbors.colliders.length; i++) {
-            var neighbor = neighbors.colliders[i];
-            if (this._collider.overlaps(neighbor) && neighbor.enabled) {
-                didCollide = true;
-                this.notifyTriggerListeners(this._collider, neighbor);
+        };
+        Scene.prototype.addRenderer = function (renderer) {
+            this._renderers.push(renderer);
+            this._renderers.sort();
+            renderer.onAddedToScene(this);
+            return renderer;
+        };
+        Scene.prototype.getRenderer = function (type) {
+            for (var i = 0; i < this._renderers.length; i++) {
+                if (this._renderers[i] instanceof type)
+                    return this._renderers[i];
             }
-        }
-        return didCollide;
-    };
-    ProjectileMover.prototype.notifyTriggerListeners = function (self, other) {
-        other.entity.getComponents("ITriggerListener", this._tempTriggerList);
-        for (var i = 0; i < this._tempTriggerList.length; i++) {
-            this._tempTriggerList[i].onTriggerEnter(self, other);
-        }
-        this._tempTriggerList.length = 0;
-        this.entity.getComponents("ITriggerListener", this._tempTriggerList);
-        for (var i = 0; i < this._tempTriggerList.length; i++) {
-            this._tempTriggerList[i].onTriggerEnter(other, self);
-        }
-        this._tempTriggerList.length = 0;
-    };
-    return ProjectileMover;
-}(Component));
-var Collider = (function (_super) {
-    __extends(Collider, _super);
-    function Collider() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.physicsLayer = 1 << 0;
-        _this.registeredPhysicsBounds = new Rectangle();
-        _this.shouldColliderScaleAndRotateWithTransform = true;
-        _this.collidesWithLayers = Physics.allLayers;
-        return _this;
-    }
-    Object.defineProperty(Collider.prototype, "bounds", {
-        get: function () {
-            var shapeBounds = this.shape.bounds;
-            var colliderBuonds = new Rectangle(this.entity.x, this.entity.y, shapeBounds.width, shapeBounds.height);
-            return colliderBuonds;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Collider.prototype.registerColliderWithPhysicsSystem = function () {
-        if (this._isParentEntityAddedToScene && !this._isColliderRegistered) {
-            Physics.addCollider(this);
-            this._isColliderRegistered = true;
-        }
-    };
-    Collider.prototype.unregisterColliderWithPhysicsSystem = function () {
-        if (this._isParentEntityAddedToScene && this._isColliderRegistered) {
-            Physics.removeCollider(this);
-        }
-        this._isColliderRegistered = false;
-    };
-    Collider.prototype.overlaps = function (other) {
-        return this.shape.overlaps(other.shape);
-    };
-    Collider.prototype.collidesWith = function (collider, motion) {
-        var oldPosition = this.entity.position;
-        this.entity.position = Vector2.add(this.entity.position, motion);
-        var result = this.shape.collidesWithShape(collider.shape);
-        if (result)
-            result.collider = collider;
-        this.entity.position = oldPosition;
-        return result;
-    };
-    Collider.prototype.onAddedToEntity = function () {
-        if (this._colliderRequiresAutoSizing) {
-            if (!(this instanceof BoxCollider || this instanceof CircleCollider)) {
-                console.error("Only box and circle colliders can be created automatically");
+            return null;
+        };
+        Scene.prototype.removeRenderer = function (renderer) {
+            if (!this._renderers.contains(renderer))
+                return;
+            this._renderers.remove(renderer);
+            renderer.unload();
+        };
+        Scene.prototype.addPostProcessor = function (postProcessor) {
+            this._postProcessors.push(postProcessor);
+            this._postProcessors.sort();
+            postProcessor.onAddedToScene(this);
+            if (this._didSceneBegin) {
+                postProcessor.onSceneBackBufferSizeChanged(this.stage.stageWidth, this.stage.stageHeight);
             }
-            var renderable = this.entity.getComponent(RenderableComponent);
-            if (renderable) {
-                var bounds = renderable.bounds;
-                var width = bounds.width / this.entity.scale.x;
-                var height = bounds.height / this.entity.scale.y;
-                if (this instanceof CircleCollider) {
-                    var circleCollider = this;
-                    circleCollider.radius = Math.max(width, height) * 0.5;
+            return postProcessor;
+        };
+        Scene.prototype.getPostProcessor = function (type) {
+            for (var i = 0; i < this._postProcessors.length; i++) {
+                if (this._postProcessors[i] instanceof type)
+                    return this._postProcessors[i];
+            }
+            return null;
+        };
+        Scene.prototype.removePostProcessor = function (postProcessor) {
+            if (!this._postProcessors.contains(postProcessor))
+                return;
+            this._postProcessors.remove(postProcessor);
+            postProcessor.unload();
+        };
+        Scene.prototype.createEntity = function (name) {
+            var entity = new es.Entity(name);
+            return this.addEntity(entity);
+        };
+        Scene.prototype.addEntity = function (entity) {
+            if (this.entities.buffer.contains(entity))
+                console.warn("You are attempting to add the same entity to a scene twice: " + entity);
+            this.entities.add(entity);
+            entity.scene = this;
+            for (var i = 0; i < entity.transform.childCount; i++)
+                this.addEntity(entity.transform.getChild(i).entity);
+            return entity;
+        };
+        Scene.prototype.destroyAllEntities = function () {
+            for (var i = 0; i < this.entities.count; i++) {
+                this.entities.buffer[i].destroy();
+            }
+        };
+        Scene.prototype.findEntity = function (name) {
+            return this.entities.findEntity(name);
+        };
+        Scene.prototype.findEntitiesWithTag = function (tag) {
+            return this.entities.entitiesWithTag(tag);
+        };
+        Scene.prototype.entitiesOfType = function (type) {
+            return this.entities.entitiesOfType(type);
+        };
+        Scene.prototype.findComponentOfType = function (type) {
+            return this.entities.findComponentOfType(type);
+        };
+        Scene.prototype.findComponentsOfType = function (type) {
+            return this.entities.findComponentsOfType(type);
+        };
+        Scene.prototype.addEntityProcessor = function (processor) {
+            processor.scene = this;
+            this.entityProcessors.add(processor);
+            return processor;
+        };
+        Scene.prototype.removeEntityProcessor = function (processor) {
+            this.entityProcessors.remove(processor);
+        };
+        Scene.prototype.getEntityProcessor = function () {
+            return this.entityProcessors.getProcessor();
+        };
+        return Scene;
+    }(egret.DisplayObjectContainer));
+    es.Scene = Scene;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var SceneManager = (function () {
+        function SceneManager(stage) {
+            stage.addEventListener(egret.Event.ENTER_FRAME, SceneManager.update, this);
+            SceneManager._instnace = this;
+            SceneManager.emitter = new es.Emitter();
+            SceneManager.content = new es.ContentManager();
+            SceneManager.stage = stage;
+            SceneManager.initialize(stage);
+            SceneManager.timerRuler = new es.TimeRuler();
+        }
+        Object.defineProperty(SceneManager, "Instance", {
+            get: function () {
+                return this._instnace;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(SceneManager, "scene", {
+            get: function () {
+                return this._scene;
+            },
+            set: function (value) {
+                if (!value)
+                    throw new Error("场景不能为空");
+                if (this._scene == null) {
+                    this._scene = value;
+                    this._scene.begin();
+                    SceneManager.Instance.onSceneChanged();
                 }
                 else {
-                    this.width = width;
-                    this.height = height;
+                    this._nextScene = value;
                 }
-                this.addChild(this.shape);
+                this.registerActiveSceneChanged(this._scene, this._nextScene);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        SceneManager.initialize = function (stage) {
+            es.Input.initialize(stage);
+        };
+        SceneManager.update = function () {
+            SceneManager.startDebugUpdate();
+            es.Time.update(egret.getTimer());
+            if (SceneManager._scene) {
+                for (var i = es.GlobalManager.globalManagers.length - 1; i >= 0; i--) {
+                    if (es.GlobalManager.globalManagers[i].enabled)
+                        es.GlobalManager.globalManagers[i].update();
+                }
+                if (!SceneManager.sceneTransition ||
+                    (SceneManager.sceneTransition && (!SceneManager.sceneTransition.loadsNewScene || SceneManager.sceneTransition.isNewSceneLoaded))) {
+                    SceneManager._scene.update();
+                }
+                if (SceneManager._nextScene) {
+                    SceneManager._scene.end();
+                    SceneManager._scene = SceneManager._nextScene;
+                    SceneManager._nextScene = null;
+                    SceneManager._instnace.onSceneChanged();
+                    SceneManager._scene.begin();
+                }
+            }
+            SceneManager.endDebugUpdate();
+            SceneManager.render();
+        };
+        SceneManager.render = function () {
+            if (this.sceneTransition) {
+                this.sceneTransition.preRender();
+                if (this._scene && !this.sceneTransition.hasPreviousSceneRender) {
+                    this._scene.render();
+                    this._scene.postRender();
+                    this.sceneTransition.onBeginTransition();
+                }
+                else if (this.sceneTransition) {
+                    if (this._scene && this.sceneTransition.isNewSceneLoaded) {
+                        this._scene.render();
+                        this._scene.postRender();
+                    }
+                    this.sceneTransition.render();
+                }
+            }
+            else if (this._scene) {
+                this._scene.render();
+                es.Debug.render();
+                this._scene.postRender();
+            }
+        };
+        SceneManager.startSceneTransition = function (sceneTransition) {
+            if (this.sceneTransition) {
+                console.warn("在前一个场景完成之前，不能开始一个新的场景转换。");
+                return;
+            }
+            this.sceneTransition = sceneTransition;
+            return sceneTransition;
+        };
+        SceneManager.registerActiveSceneChanged = function (current, next) {
+            if (this.activeSceneChanged)
+                this.activeSceneChanged(current, next);
+        };
+        SceneManager.prototype.onSceneChanged = function () {
+            SceneManager.emitter.emit(es.CoreEvents.SceneChanged);
+            es.Time.sceneChanged();
+        };
+        SceneManager.startDebugUpdate = function () {
+            es.TimeRuler.Instance.startFrame();
+            es.TimeRuler.Instance.beginMark("update", 0x00FF00);
+        };
+        SceneManager.endDebugUpdate = function () {
+            es.TimeRuler.Instance.endMark("update");
+        };
+        return SceneManager;
+    }());
+    es.SceneManager = SceneManager;
+})(es || (es = {}));
+var transform;
+(function (transform) {
+    var Component;
+    (function (Component) {
+        Component[Component["position"] = 0] = "position";
+        Component[Component["scale"] = 1] = "scale";
+        Component[Component["rotation"] = 2] = "rotation";
+    })(Component = transform.Component || (transform.Component = {}));
+})(transform || (transform = {}));
+var es;
+(function (es) {
+    var DirtyType;
+    (function (DirtyType) {
+        DirtyType[DirtyType["clean"] = 0] = "clean";
+        DirtyType[DirtyType["positionDirty"] = 1] = "positionDirty";
+        DirtyType[DirtyType["scaleDirty"] = 2] = "scaleDirty";
+        DirtyType[DirtyType["rotationDirty"] = 3] = "rotationDirty";
+    })(DirtyType = es.DirtyType || (es.DirtyType = {}));
+    var Transform = (function () {
+        function Transform(entity) {
+            this.entity = entity;
+            this.scale = es.Vector2.one;
+            this._children = [];
+        }
+        Object.defineProperty(Transform.prototype, "parent", {
+            get: function () {
+                return this._parent;
+            },
+            set: function (value) {
+                this.setParent(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Transform.prototype, "childCount", {
+            get: function () {
+                return this._children.length;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Transform.prototype.getChild = function (index) {
+            return this._children[index];
+        };
+        Transform.prototype.setParent = function (parent) {
+            if (this._parent == parent)
+                return this;
+            if (!this._parent) {
+                this._parent._children.remove(this);
+                this._parent._children.push(this);
+            }
+            this._parent = parent;
+            this.setDirty(DirtyType.positionDirty);
+            return this;
+        };
+        Transform.prototype.setPosition = function (x, y) {
+            this.position = new es.Vector2(x, y);
+            this.setDirty(DirtyType.positionDirty);
+            return this;
+        };
+        Transform.prototype.setRotation = function (degrees) {
+            this.rotation = degrees;
+            this.setDirty(DirtyType.rotationDirty);
+            return this;
+        };
+        Transform.prototype.setScale = function (scale) {
+            this.scale = scale;
+            this.setDirty(DirtyType.scaleDirty);
+            return this;
+        };
+        Transform.prototype.lookAt = function (pos) {
+            var sign = this.position.x > pos.x ? -1 : 1;
+            var vectorToAlignTo = es.Vector2.normalize(es.Vector2.subtract(this.position, pos));
+            this.rotation = sign * Math.acos(es.Vector2.dot(vectorToAlignTo, es.Vector2.unitY));
+        };
+        Transform.prototype.roundPosition = function () {
+            this.position = this.position.round();
+        };
+        Transform.prototype.setDirty = function (dirtyFlagType) {
+            if ((this.hierarchyDirty & dirtyFlagType) == 0) {
+                this.hierarchyDirty |= dirtyFlagType;
+                switch (dirtyFlagType) {
+                    case es.DirtyType.positionDirty:
+                        this.entity.onTransformChanged(transform.Component.position);
+                        break;
+                    case es.DirtyType.rotationDirty:
+                        this.entity.onTransformChanged(transform.Component.rotation);
+                        break;
+                    case es.DirtyType.scaleDirty:
+                        this.entity.onTransformChanged(transform.Component.scale);
+                        break;
+                }
+                if (!this._children)
+                    this._children = [];
+                for (var i = 0; i < this._children.length; i++)
+                    this._children[i].setDirty(dirtyFlagType);
+            }
+        };
+        Transform.prototype.copyFrom = function (transform) {
+            this.position = transform.position;
+            this.rotation = transform.rotation;
+            this.scale = transform.scale;
+            this.setDirty(DirtyType.positionDirty);
+            this.setDirty(DirtyType.rotationDirty);
+            this.setDirty(DirtyType.scaleDirty);
+        };
+        return Transform;
+    }());
+    es.Transform = Transform;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var CameraStyle;
+    (function (CameraStyle) {
+        CameraStyle[CameraStyle["lockOn"] = 0] = "lockOn";
+        CameraStyle[CameraStyle["cameraWindow"] = 1] = "cameraWindow";
+    })(CameraStyle = es.CameraStyle || (es.CameraStyle = {}));
+    var Camera = (function (_super) {
+        __extends(Camera, _super);
+        function Camera(targetEntity, cameraStyle) {
+            if (targetEntity === void 0) { targetEntity = null; }
+            if (cameraStyle === void 0) { cameraStyle = CameraStyle.lockOn; }
+            var _this = _super.call(this) || this;
+            _this._minimumZoom = 0.3;
+            _this._maximumZoom = 3;
+            _this._origin = es.Vector2.zero;
+            _this.followLerp = 0.1;
+            _this.deadzone = new es.Rectangle();
+            _this.focusOffset = new es.Vector2();
+            _this.mapLockEnabled = false;
+            _this.mapSize = new es.Vector2();
+            _this._desiredPositionDelta = new es.Vector2();
+            _this._worldSpaceDeadZone = new es.Rectangle();
+            _this._targetEntity = targetEntity;
+            _this._cameraStyle = cameraStyle;
+            _this.setZoom(0);
+            return _this;
+        }
+        Object.defineProperty(Camera.prototype, "position", {
+            get: function () {
+                return this.entity.transform.position;
+            },
+            set: function (value) {
+                this.entity.transform.position = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Camera.prototype, "rotation", {
+            get: function () {
+                return this.entity.transform.rotation;
+            },
+            set: function (value) {
+                this.entity.transform.rotation = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Camera.prototype, "zoom", {
+            get: function () {
+                if (this._zoom == 0)
+                    return 1;
+                if (this._zoom < 1)
+                    return es.MathHelper.map(this._zoom, this._minimumZoom, 1, -1, 0);
+                return es.MathHelper.map(this._zoom, 1, this._maximumZoom, 0, 1);
+            },
+            set: function (value) {
+                this.setZoom(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Camera.prototype, "minimumZoom", {
+            get: function () {
+                return this._minimumZoom;
+            },
+            set: function (value) {
+                this.setMinimumZoom(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Camera.prototype, "maximumZoom", {
+            get: function () {
+                return this._maximumZoom;
+            },
+            set: function (value) {
+                this.setMaximumZoom(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Camera.prototype, "bounds", {
+            get: function () {
+                return new es.Rectangle(0, 0, es.SceneManager.stage.stageWidth, es.SceneManager.stage.stageHeight);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Camera.prototype, "origin", {
+            get: function () {
+                return this._origin;
+            },
+            set: function (value) {
+                if (this._origin != value) {
+                    this._origin = value;
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Camera.prototype.onSceneSizeChanged = function (newWidth, newHeight) {
+            var oldOrigin = this._origin;
+            this.origin = new es.Vector2(newWidth / 2, newHeight / 2);
+            this.entity.transform.position = es.Vector2.add(this.entity.transform.position, es.Vector2.subtract(this._origin, oldOrigin));
+        };
+        Camera.prototype.setPosition = function (position) {
+            this.entity.transform.setPosition(position.x, position.y);
+            return this;
+        };
+        Camera.prototype.setRotation = function (rotation) {
+            this.entity.transform.setRotation(rotation);
+            return this;
+        };
+        Camera.prototype.setZoom = function (zoom) {
+            var newZoom = es.MathHelper.clamp(zoom, -1, 1);
+            if (newZoom == 0) {
+                this._zoom = 1;
+            }
+            else if (newZoom < 0) {
+                this._zoom = es.MathHelper.map(newZoom, -1, 0, this._minimumZoom, 1);
             }
             else {
-                console.warn("Collider has no shape and no RenderableComponent. Can't figure out how to size it.");
+                this._zoom = es.MathHelper.map(newZoom, 0, 1, 1, this._maximumZoom);
             }
-        }
-        this._isParentEntityAddedToScene = true;
-        this.registerColliderWithPhysicsSystem();
-    };
-    Collider.prototype.onRemovedFromEntity = function () {
-        this.unregisterColliderWithPhysicsSystem();
-        this._isParentEntityAddedToScene = false;
-        this.removeChild(this.shape);
-    };
-    Collider.prototype.onEnabled = function () {
-        this.registerColliderWithPhysicsSystem();
-    };
-    Collider.prototype.onDisabled = function () {
-        this.unregisterColliderWithPhysicsSystem();
-    };
-    Collider.prototype.onEntityTransformChanged = function (comp) {
-        if (this._isColliderRegistered)
-            Physics.updateCollider(this);
-    };
-    Collider.prototype.update = function () {
-        var renderable = this.entity.getComponent(RenderableComponent);
-        if (renderable) {
-            this.$setX(renderable.x);
-            this.$setY(renderable.y);
-        }
-    };
-    return Collider;
-}(Component));
-var BoxCollider = (function (_super) {
-    __extends(BoxCollider, _super);
-    function BoxCollider() {
-        var _this = _super.call(this) || this;
-        _this.shape = new Box(1, 1);
-        _this._colliderRequiresAutoSizing = true;
-        return _this;
-    }
-    Object.defineProperty(BoxCollider.prototype, "width", {
-        get: function () {
-            return this.shape.width;
-        },
-        set: function (value) {
-            this.setWidth(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    BoxCollider.prototype.setWidth = function (width) {
-        this._colliderRequiresAutoSizing = false;
-        var box = this.shape;
-        if (width != box.width) {
-            box.updateBox(width, box.height);
-            if (this.entity && this._isParentEntityAddedToScene)
-                Physics.updateCollider(this);
-        }
-        return this;
-    };
-    Object.defineProperty(BoxCollider.prototype, "height", {
-        get: function () {
-            return this.shape.height;
-        },
-        set: function (value) {
-            this.setHeight(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    BoxCollider.prototype.setHeight = function (height) {
-        this._colliderRequiresAutoSizing = false;
-        var box = this.shape;
-        if (height != box.height) {
-            box.updateBox(box.width, height);
-            if (this.entity && this._isParentEntityAddedToScene)
-                Physics.updateCollider(this);
-        }
-    };
-    BoxCollider.prototype.setSize = function (width, height) {
-        this._colliderRequiresAutoSizing = false;
-        var box = this.shape;
-        if (width != box.width || height != box.height) {
-            box.updateBox(width, height);
-            if (this.entity && this._isParentEntityAddedToScene)
-                Physics.updateCollider(this);
-        }
-        return this;
-    };
-    return BoxCollider;
-}(Collider));
-var CircleCollider = (function (_super) {
-    __extends(CircleCollider, _super);
-    function CircleCollider(radius) {
-        var _this = _super.call(this) || this;
-        if (radius)
-            _this._colliderRequiresAutoSizing = true;
-        _this.shape = new Circle(radius ? radius : 1);
-        return _this;
-    }
-    Object.defineProperty(CircleCollider.prototype, "radius", {
-        get: function () {
-            return this.shape.radius;
-        },
-        set: function (value) {
-            this.setRadius(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    CircleCollider.prototype.setRadius = function (radius) {
-        this._colliderRequiresAutoSizing = false;
-        var circle = this.shape;
-        if (radius != circle.radius) {
-            circle.radius = radius;
-            circle._originalRadius = radius;
-            if (this.entity && this._isParentEntityAddedToScene)
-                Physics.updateCollider(this);
-        }
-        return this;
-    };
-    return CircleCollider;
-}(Collider));
-var PolygonCollider = (function (_super) {
-    __extends(PolygonCollider, _super);
-    function PolygonCollider(points) {
-        var _this = _super.call(this) || this;
-        var isPolygonClosed = points[0] == points[points.length - 1];
-        if (isPolygonClosed)
-            points.splice(points.length - 1, 1);
-        Polygon.recenterPolygonVerts(points);
-        _this.shape = new Polygon(points);
-        return _this;
-    }
-    return PolygonCollider;
-}(Collider));
-var EntitySystem = (function () {
-    function EntitySystem(matcher) {
-        this._entities = [];
-        this._matcher = matcher ? matcher : Matcher.empty();
-    }
-    Object.defineProperty(EntitySystem.prototype, "matcher", {
-        get: function () {
-            return this._matcher;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(EntitySystem.prototype, "scene", {
-        get: function () {
-            return this._scene;
-        },
-        set: function (value) {
-            this._scene = value;
-            this._entities = [];
-        },
-        enumerable: true,
-        configurable: true
-    });
-    EntitySystem.prototype.initialize = function () {
-    };
-    EntitySystem.prototype.onChanged = function (entity) {
-        var contains = this._entities.contains(entity);
-        var interest = this._matcher.IsIntersted(entity);
-        if (interest && !contains)
-            this.add(entity);
-        else if (!interest && contains)
-            this.remove(entity);
-    };
-    EntitySystem.prototype.add = function (entity) {
-        this._entities.push(entity);
-        this.onAdded(entity);
-    };
-    EntitySystem.prototype.onAdded = function (entity) {
-    };
-    EntitySystem.prototype.remove = function (entity) {
-        this._entities.remove(entity);
-        this.onRemoved(entity);
-    };
-    EntitySystem.prototype.onRemoved = function (entity) {
-    };
-    EntitySystem.prototype.update = function () {
-        this.begin();
-        this.process(this._entities);
-    };
-    EntitySystem.prototype.lateUpdate = function () {
-        this.lateProcess(this._entities);
-        this.end();
-    };
-    EntitySystem.prototype.begin = function () {
-    };
-    EntitySystem.prototype.process = function (entities) {
-    };
-    EntitySystem.prototype.lateProcess = function (entities) {
-    };
-    EntitySystem.prototype.end = function () {
-    };
-    return EntitySystem;
-}());
-var EntityProcessingSystem = (function (_super) {
-    __extends(EntityProcessingSystem, _super);
-    function EntityProcessingSystem(matcher) {
-        return _super.call(this, matcher) || this;
-    }
-    EntityProcessingSystem.prototype.lateProcessEntity = function (entity) {
-    };
-    EntityProcessingSystem.prototype.process = function (entities) {
-        var _this = this;
-        entities.forEach(function (entity) { return _this.processEntity(entity); });
-    };
-    EntityProcessingSystem.prototype.lateProcess = function (entities) {
-        var _this = this;
-        entities.forEach(function (entity) { return _this.lateProcessEntity(entity); });
-    };
-    return EntityProcessingSystem;
-}(EntitySystem));
-var PassiveSystem = (function (_super) {
-    __extends(PassiveSystem, _super);
-    function PassiveSystem() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    PassiveSystem.prototype.onChanged = function (entity) {
-    };
-    PassiveSystem.prototype.process = function (entities) {
-        this.begin();
-        this.end();
-    };
-    return PassiveSystem;
-}(EntitySystem));
-var ProcessingSystem = (function (_super) {
-    __extends(ProcessingSystem, _super);
-    function ProcessingSystem() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ProcessingSystem.prototype.onChanged = function (entity) {
-    };
-    ProcessingSystem.prototype.process = function (entities) {
-        this.begin();
-        this.processSystem();
-        this.end();
-    };
-    return ProcessingSystem;
-}(EntitySystem));
-var BitSet = (function () {
-    function BitSet(nbits) {
-        if (nbits === void 0) { nbits = 64; }
-        var length = nbits >> 6;
-        if ((nbits & BitSet.LONG_MASK) != 0)
-            length++;
-        this._bits = new Array(length);
-    }
-    BitSet.prototype.and = function (bs) {
-        var max = Math.min(this._bits.length, bs._bits.length);
-        var i;
-        for (var i_1 = 0; i_1 < max; ++i_1)
-            this._bits[i_1] &= bs._bits[i_1];
-        while (i < this._bits.length)
-            this._bits[i++] = 0;
-    };
-    BitSet.prototype.andNot = function (bs) {
-        var i = Math.min(this._bits.length, bs._bits.length);
-        while (--i >= 0)
-            this._bits[i] &= ~bs._bits[i];
-    };
-    BitSet.prototype.cardinality = function () {
-        var card = 0;
-        for (var i = this._bits.length - 1; i >= 0; i--) {
-            var a = this._bits[i];
-            if (a == 0)
-                continue;
-            if (a == -1) {
-                card += 64;
-                continue;
+            es.SceneManager.scene.scaleX = this._zoom;
+            es.SceneManager.scene.scaleY = this._zoom;
+            return this;
+        };
+        Camera.prototype.setMinimumZoom = function (minZoom) {
+            if (this._zoom < minZoom)
+                this._zoom = this.minimumZoom;
+            this._minimumZoom = minZoom;
+            return this;
+        };
+        Camera.prototype.setMaximumZoom = function (maxZoom) {
+            if (maxZoom <= 0) {
+                console.error("maximumZoom must be greater than zero");
+                return;
             }
-            a = ((a >> 1) & 0x5555555555555555) + (a & 0x5555555555555555);
-            a = ((a >> 2) & 0x3333333333333333) + (a & 0x3333333333333333);
-            var b = ((a >> 32) + a);
-            b = ((b >> 4) & 0x0f0f0f0f) + (b & 0x0f0f0f0f);
-            b = ((b >> 8) & 0x00ff00ff) + (b & 0x00ff00ff);
-            card += ((b >> 16) & 0x0000ffff) + (b & 0x0000ffff);
-        }
-        return card;
-    };
-    BitSet.prototype.clear = function (pos) {
-        if (pos != undefined) {
-            var offset = pos >> 6;
-            this.ensure(offset);
-            this._bits[offset] &= ~(1 << pos);
-        }
-        else {
-            for (var i = 0; i < this._bits.length; i++)
-                this._bits[i] = 0;
-        }
-    };
-    BitSet.prototype.ensure = function (lastElt) {
-        if (lastElt >= this._bits.length) {
-            var nd = new Number[lastElt + 1];
-            nd = this._bits.copyWithin(0, 0, this._bits.length);
-            this._bits = nd;
-        }
-    };
-    BitSet.prototype.get = function (pos) {
-        var offset = pos >> 6;
-        if (offset >= this._bits.length)
-            return false;
-        return (this._bits[offset] & (1 << pos)) != 0;
-    };
-    BitSet.prototype.intersects = function (set) {
-        var i = Math.min(this._bits.length, set._bits.length);
-        while (--i >= 0) {
-            if ((this._bits[i] & set._bits[i]) != 0)
-                return true;
-        }
-        return false;
-    };
-    BitSet.prototype.isEmpty = function () {
-        for (var i = this._bits.length - 1; i >= 0; i--) {
-            if (this._bits[i])
-                return false;
-        }
-        return true;
-    };
-    BitSet.prototype.nextSetBit = function (from) {
-        var offset = from >> 6;
-        var mask = 1 << from;
-        while (offset < this._bits.length) {
-            var h = this._bits[offset];
-            do {
-                if ((h & mask) != 0)
-                    return from;
-                mask <<= 1;
-                from++;
-            } while (mask != 0);
-            mask = 1;
-            offset++;
-        }
-        return -1;
-    };
-    BitSet.prototype.set = function (pos, value) {
-        if (value === void 0) { value = true; }
-        if (value) {
-            var offset = pos >> 6;
-            this.ensure(offset);
-            this._bits[offset] |= 1 << pos;
-        }
-        else {
-            this.clear(pos);
-        }
-    };
-    BitSet.LONG_MASK = 0x3f;
-    return BitSet;
-}());
-var ComponentList = (function () {
-    function ComponentList(entity) {
-        this._components = [];
-        this._componentsToAdd = [];
-        this._componentsToRemove = [];
-        this._tempBufferList = [];
-        this._entity = entity;
-    }
-    Object.defineProperty(ComponentList.prototype, "count", {
-        get: function () {
-            return this._components.length;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(ComponentList.prototype, "buffer", {
-        get: function () {
-            return this._components;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    ComponentList.prototype.add = function (component) {
-        this._componentsToAdd.push(component);
-    };
-    ComponentList.prototype.remove = function (component) {
-        if (this._componentsToRemove.contains(component))
-            console.warn("You are trying to remove a Component (" + component + ") that you already removed");
-        if (this._componentsToAdd.contains(component)) {
-            this._componentsToAdd.remove(component);
-            return;
-        }
-        this._componentsToRemove.push(component);
-    };
-    ComponentList.prototype.removeAllComponents = function () {
-        for (var i = 0; i < this._components.length; i++) {
-            this.handleRemove(this._components[i]);
-        }
-        this._components.length = 0;
-        this._componentsToAdd.length = 0;
-        this._componentsToRemove.length = 0;
-    };
-    ComponentList.prototype.deregisterAllComponents = function () {
-        for (var i = 0; i < this._components.length; i++) {
-            var component = this._components[i];
-            if (component instanceof RenderableComponent)
-                this._entity.scene.renderableComponents.remove(component);
-            this._entity.componentBits.set(ComponentTypeManager.getIndexFor(component), false);
-            this._entity.scene.entityProcessors.onComponentRemoved(this._entity);
-        }
-    };
-    ComponentList.prototype.registerAllComponents = function () {
-        for (var i = 0; i < this._components.length; i++) {
-            var component = this._components[i];
-            if (component instanceof RenderableComponent)
-                this._entity.scene.renderableComponents.add(component);
-            this._entity.componentBits.set(ComponentTypeManager.getIndexFor(component));
-            this._entity.scene.entityProcessors.onComponentAdded(this._entity);
-        }
-    };
-    ComponentList.prototype.updateLists = function () {
-        if (this._componentsToRemove.length > 0) {
-            for (var i = 0; i < this._componentsToRemove.length; i++) {
-                this.handleRemove(this._componentsToRemove[i]);
-                this._components.remove(this._componentsToRemove[i]);
+            if (this._zoom > maxZoom)
+                this._zoom = maxZoom;
+            this._maximumZoom = maxZoom;
+            return this;
+        };
+        Camera.prototype.zoomIn = function (deltaZoom) {
+            this.zoom += deltaZoom;
+        };
+        Camera.prototype.zoomOut = function (deltaZoom) {
+            this.zoom -= deltaZoom;
+        };
+        Camera.prototype.onAddedToEntity = function () {
+            this.follow(this._targetEntity, this._cameraStyle);
+        };
+        Camera.prototype.update = function () {
+            var halfScreen = es.Vector2.multiply(new es.Vector2(this.bounds.width, this.bounds.height), new es.Vector2(0.5));
+            this._worldSpaceDeadZone.x = this.position.x - halfScreen.x * es.SceneManager.scene.scaleX + this.deadzone.x + this.focusOffset.x;
+            this._worldSpaceDeadZone.y = this.position.y - halfScreen.y * es.SceneManager.scene.scaleY + this.deadzone.y + this.focusOffset.y;
+            this._worldSpaceDeadZone.width = this.deadzone.width;
+            this._worldSpaceDeadZone.height = this.deadzone.height;
+            if (this._targetEntity)
+                this.updateFollow();
+            this.position = es.Vector2.lerp(this.position, es.Vector2.add(this.position, this._desiredPositionDelta), this.followLerp);
+            this.entity.transform.roundPosition();
+            if (this.mapLockEnabled) {
+                this.position = this.clampToMapSize(this.position);
+                this.entity.transform.roundPosition();
             }
-            this._componentsToRemove.length = 0;
-        }
-        if (this._componentsToAdd.length > 0) {
-            for (var i = 0, count = this._componentsToAdd.length; i < count; i++) {
-                var component = this._componentsToAdd[i];
-                if (component instanceof RenderableComponent)
-                    this._entity.scene.renderableComponents.add(component);
-                this._entity.componentBits.set(ComponentTypeManager.getIndexFor(component));
-                this._entity.scene.entityProcessors.onComponentAdded(this._entity);
-                this._components.push(component);
-                this._tempBufferList.push(component);
+        };
+        Camera.prototype.clampToMapSize = function (position) {
+            var halfScreen = es.Vector2.multiply(new es.Vector2(this.bounds.width, this.bounds.height), new es.Vector2(0.5));
+            var cameraMax = new es.Vector2(this.mapSize.x - halfScreen.x, this.mapSize.y - halfScreen.y);
+            return es.Vector2.clamp(position, halfScreen, cameraMax);
+        };
+        Camera.prototype.updateFollow = function () {
+            this._desiredPositionDelta.x = this._desiredPositionDelta.y = 0;
+            if (this._cameraStyle == CameraStyle.lockOn) {
+                var targetX = this._targetEntity.transform.position.x;
+                var targetY = this._targetEntity.transform.position.y;
+                if (this._worldSpaceDeadZone.x > targetX)
+                    this._desiredPositionDelta.x = targetX - this._worldSpaceDeadZone.x;
+                else if (this._worldSpaceDeadZone.x < targetX)
+                    this._desiredPositionDelta.x = targetX - this._worldSpaceDeadZone.x;
+                if (this._worldSpaceDeadZone.y < targetY)
+                    this._desiredPositionDelta.y = targetY - this._worldSpaceDeadZone.y;
+                else if (this._worldSpaceDeadZone.y > targetY)
+                    this._desiredPositionDelta.y = targetY - this._worldSpaceDeadZone.y;
             }
-            this._componentsToAdd.length = 0;
-            for (var i = 0; i < this._tempBufferList.length; i++) {
-                var component = this._tempBufferList[i];
-                component.onAddedToEntity();
-                if (component.enabled) {
-                    component.onEnabled();
+            else {
+                if (!this._targetCollider) {
+                    this._targetCollider = this._targetEntity.getComponent(es.Collider);
+                    if (!this._targetCollider)
+                        return;
+                }
+                var targetBounds = this._targetEntity.getComponent(es.Collider).bounds;
+                if (!this._worldSpaceDeadZone.containsRect(targetBounds)) {
+                    if (this._worldSpaceDeadZone.left > targetBounds.left)
+                        this._desiredPositionDelta.x = targetBounds.left - this._worldSpaceDeadZone.left;
+                    else if (this._worldSpaceDeadZone.right < targetBounds.right)
+                        this._desiredPositionDelta.x = targetBounds.right - this._worldSpaceDeadZone.right;
+                    if (this._worldSpaceDeadZone.bottom < targetBounds.bottom)
+                        this._desiredPositionDelta.y = targetBounds.bottom - this._worldSpaceDeadZone.bottom;
+                    else if (this._worldSpaceDeadZone.top > targetBounds.top)
+                        this._desiredPositionDelta.y = targetBounds.top - this._worldSpaceDeadZone.top;
                 }
             }
-            this._tempBufferList.length = 0;
+        };
+        Camera.prototype.follow = function (targetEntity, cameraStyle) {
+            if (cameraStyle === void 0) { cameraStyle = CameraStyle.cameraWindow; }
+            this._targetEntity = targetEntity;
+            this._cameraStyle = cameraStyle;
+            switch (this._cameraStyle) {
+                case CameraStyle.cameraWindow:
+                    var w = this.bounds.width / 6;
+                    var h = this.bounds.height / 3;
+                    this.deadzone = new es.Rectangle((this.bounds.width - w) / 2, (this.bounds.height - h) / 2, w, h);
+                    break;
+                case CameraStyle.lockOn:
+                    this.deadzone = new es.Rectangle(this.bounds.width / 2, this.bounds.height / 2, 10, 10);
+                    break;
+            }
+        };
+        Camera.prototype.setCenteredDeadzone = function (width, height) {
+            this.deadzone = new es.Rectangle((this.bounds.width - width) / 2, (this.bounds.height - height) / 2, width, height);
+        };
+        return Camera;
+    }(es.Component));
+    es.Camera = Camera;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var ComponentPool = (function () {
+        function ComponentPool(typeClass) {
+            this._type = typeClass;
+            this._cache = [];
         }
-    };
-    ComponentList.prototype.onEntityTransformChanged = function (comp) {
-        for (var i = 0; i < this._components.length; i++) {
-            if (this._components[i].enabled)
-                this._components[i].onEntityTransformChanged(comp);
+        ComponentPool.prototype.obtain = function () {
+            try {
+                return this._cache.length > 0 ? this._cache.shift() : new this._type();
+            }
+            catch (err) {
+                throw new Error(this._type + err);
+            }
+        };
+        ComponentPool.prototype.free = function (component) {
+            component.reset();
+            this._cache.push(component);
+        };
+        return ComponentPool;
+    }());
+    es.ComponentPool = ComponentPool;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var IUpdatableComparer = (function () {
+        function IUpdatableComparer() {
         }
-        for (var i = 0; i < this._componentsToAdd.length; i++) {
-            if (this._componentsToAdd[i].enabled)
-                this._componentsToAdd[i].onEntityTransformChanged(comp);
+        IUpdatableComparer.prototype.compare = function (a, b) {
+            return a.updateOrder - b.updateOrder;
+        };
+        return IUpdatableComparer;
+    }());
+    es.IUpdatableComparer = IUpdatableComparer;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var PooledComponent = (function (_super) {
+        __extends(PooledComponent, _super);
+        function PooledComponent() {
+            return _super !== null && _super.apply(this, arguments) || this;
         }
-    };
-    ComponentList.prototype.handleRemove = function (component) {
-        if (component instanceof RenderableComponent)
-            this._entity.scene.renderableComponents.remove(component);
-        this._entity.componentBits.set(ComponentTypeManager.getIndexFor(component), false);
-        this._entity.scene.entityProcessors.onComponentRemoved(this._entity);
-        component.onRemovedFromEntity();
-        component.entity = null;
-    };
-    ComponentList.prototype.getComponent = function (type, onlyReturnInitializedComponents) {
-        for (var i = 0; i < this._components.length; i++) {
-            var component = this._components[i];
-            if (component instanceof type)
-                return component;
+        return PooledComponent;
+    }(es.Component));
+    es.PooledComponent = PooledComponent;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var RenderableComponent = (function (_super) {
+        __extends(RenderableComponent, _super);
+        function RenderableComponent() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.color = 0x000000;
+            _this._localOffset = es.Vector2.zero;
+            _this._renderLayer = 0;
+            _this._bounds = new es.Rectangle();
+            _this._areBoundsDirty = true;
+            return _this;
         }
-        if (!onlyReturnInitializedComponents) {
-            for (var i = 0; i < this._componentsToAdd.length; i++) {
-                var component = this._componentsToAdd[i];
+        Object.defineProperty(RenderableComponent.prototype, "width", {
+            get: function () {
+                return this.bounds.width;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(RenderableComponent.prototype, "height", {
+            get: function () {
+                return this.bounds.height;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(RenderableComponent.prototype, "bounds", {
+            get: function () {
+                if (this._areBoundsDirty) {
+                    this._bounds.calculateBounds(this.entity.transform.position, this._localOffset, es.Vector2.zero, this.entity.transform.scale, this.entity.transform.rotation, this.width, this.height);
+                    this._areBoundsDirty = false;
+                }
+                return this._bounds;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(RenderableComponent.prototype, "renderLayer", {
+            get: function () {
+                return this._renderLayer;
+            },
+            set: function (value) {
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(RenderableComponent.prototype, "localOffset", {
+            get: function () {
+                return this._localOffset;
+            },
+            set: function (value) {
+                this.setLocalOffset(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(RenderableComponent.prototype, "isVisible", {
+            get: function () {
+                return this._isVisible;
+            },
+            set: function (value) {
+                if (this._isVisible != value) {
+                    this._isVisible = value;
+                    if (this._isVisible)
+                        this.onBecameVisible();
+                    else
+                        this.onBecameInvisible();
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        RenderableComponent.prototype.onEntityTransformChanged = function (comp) {
+            this._areBoundsDirty = true;
+        };
+        RenderableComponent.prototype.onBecameVisible = function () {
+        };
+        RenderableComponent.prototype.onBecameInvisible = function () {
+        };
+        RenderableComponent.prototype.isVisibleFromCamera = function (camera) {
+            this.isVisible = camera.bounds.intersects(this.bounds);
+            return this.isVisible;
+        };
+        RenderableComponent.prototype.setRenderLayer = function (renderLayer) {
+            if (renderLayer != this._renderLayer) {
+                var oldRenderLayer = this._renderLayer;
+                this._renderLayer = renderLayer;
+                if (this.entity && this.entity.scene)
+                    this.entity.scene.renderableComponents.updateRenderableRenderLayer(this, oldRenderLayer, this._renderLayer);
+            }
+            return this;
+        };
+        RenderableComponent.prototype.setColor = function (color) {
+            this.color = color;
+            return this;
+        };
+        RenderableComponent.prototype.setLocalOffset = function (offset) {
+            if (this._localOffset != offset) {
+                this._localOffset = offset;
+            }
+            return this;
+        };
+        RenderableComponent.prototype.toString = function () {
+            return "[RenderableComponent] " + this + ", renderLayer: " + this.renderLayer;
+        };
+        return RenderableComponent;
+    }(es.Component));
+    es.RenderableComponent = RenderableComponent;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Mesh = (function (_super) {
+        __extends(Mesh, _super);
+        function Mesh() {
+            var _this = _super.call(this) || this;
+            _this._mesh = new egret.Mesh();
+            return _this;
+        }
+        Mesh.prototype.setTexture = function (texture) {
+            this._mesh.texture = texture;
+            return this;
+        };
+        Mesh.prototype.reset = function () {
+        };
+        Mesh.prototype.render = function (camera) {
+        };
+        return Mesh;
+    }(es.RenderableComponent));
+    es.Mesh = Mesh;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var SpriteRenderer = (function (_super) {
+        __extends(SpriteRenderer, _super);
+        function SpriteRenderer(sprite) {
+            if (sprite === void 0) { sprite = null; }
+            var _this = _super.call(this) || this;
+            if (sprite instanceof es.Sprite)
+                _this.setSprite(sprite);
+            else if (sprite instanceof egret.Texture)
+                _this.setSprite(new es.Sprite(sprite));
+            return _this;
+        }
+        Object.defineProperty(SpriteRenderer.prototype, "bounds", {
+            get: function () {
+                if (this._areBoundsDirty) {
+                    if (this._sprite) {
+                        this._bounds.calculateBounds(this.entity.transform.position, this._localOffset, this._origin, this.entity.transform.scale, this.entity.transform.rotation, this._sprite.sourceRect.width, this._sprite.sourceRect.height);
+                        this._areBoundsDirty = false;
+                    }
+                    return this._bounds;
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(SpriteRenderer.prototype, "origin", {
+            get: function () {
+                return this._origin;
+            },
+            set: function (value) {
+                this.setOrigin(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(SpriteRenderer.prototype, "originNormalized", {
+            get: function () {
+                return new es.Vector2(this._origin.x / this.width * this.entity.transform.scale.x, this._origin.y / this.height * this.entity.transform.scale.y);
+            },
+            set: function (value) {
+                this.setOrigin(new es.Vector2(value.x * this.width / this.entity.transform.scale.x, value.y * this.height / this.entity.transform.scale.y));
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(SpriteRenderer.prototype, "sprite", {
+            get: function () {
+                return this._sprite;
+            },
+            set: function (value) {
+                this.setSprite(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        SpriteRenderer.prototype.setSprite = function (sprite) {
+            this._sprite = sprite;
+            if (this._sprite) {
+                this._origin = this._sprite.origin;
+            }
+            return this;
+        };
+        SpriteRenderer.prototype.setOrigin = function (origin) {
+            if (this._origin != origin) {
+                this._origin = origin;
+                this._areBoundsDirty = true;
+            }
+            return this;
+        };
+        SpriteRenderer.prototype.setOriginNormalized = function (value) {
+            this.setOrigin(new es.Vector2(value.x * this.width / this.entity.transform.scale.x, value.y * this.height / this.entity.transform.scale.y));
+            return this;
+        };
+        SpriteRenderer.prototype.render = function (camera) {
+        };
+        return SpriteRenderer;
+    }(es.RenderableComponent));
+    es.SpriteRenderer = SpriteRenderer;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var TiledSpriteRenderer = (function (_super) {
+        __extends(TiledSpriteRenderer, _super);
+        function TiledSpriteRenderer(sprite) {
+            var _this = _super.call(this, sprite) || this;
+            _this.leftTexture = new egret.Bitmap();
+            _this.rightTexture = new egret.Bitmap();
+            _this.leftTexture.texture = sprite.texture2D;
+            _this.rightTexture.texture = sprite.texture2D;
+            _this.setSprite(sprite);
+            _this.sourceRect = sprite.sourceRect;
+            return _this;
+        }
+        Object.defineProperty(TiledSpriteRenderer.prototype, "scrollX", {
+            get: function () {
+                return this.sourceRect.x;
+            },
+            set: function (value) {
+                this.sourceRect.x = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(TiledSpriteRenderer.prototype, "scrollY", {
+            get: function () {
+                return this.sourceRect.y;
+            },
+            set: function (value) {
+                this.sourceRect.y = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        TiledSpriteRenderer.prototype.render = function (camera) {
+            if (!this.sprite)
+                return;
+            _super.prototype.render.call(this, camera);
+            var renderTexture = new egret.RenderTexture();
+            var cacheBitmap = new egret.DisplayObjectContainer();
+            cacheBitmap.removeChildren();
+            cacheBitmap.addChild(this.leftTexture);
+            cacheBitmap.addChild(this.rightTexture);
+            this.leftTexture.x = this.sourceRect.x;
+            this.rightTexture.x = this.sourceRect.x - this.sourceRect.width;
+            this.leftTexture.y = this.sourceRect.y;
+            this.rightTexture.y = this.sourceRect.y;
+            cacheBitmap.cacheAsBitmap = true;
+            renderTexture.drawToTexture(cacheBitmap, new egret.Rectangle(0, 0, this.sourceRect.width, this.sourceRect.height));
+        };
+        return TiledSpriteRenderer;
+    }(es.SpriteRenderer));
+    es.TiledSpriteRenderer = TiledSpriteRenderer;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var ScrollingSpriteRenderer = (function (_super) {
+        __extends(ScrollingSpriteRenderer, _super);
+        function ScrollingSpriteRenderer() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.scrollSpeedX = 15;
+            _this.scroolSpeedY = 0;
+            _this._scrollX = 0;
+            _this._scrollY = 0;
+            return _this;
+        }
+        ScrollingSpriteRenderer.prototype.update = function () {
+            this._scrollX += this.scrollSpeedX * es.Time.deltaTime;
+            this._scrollY += this.scroolSpeedY * es.Time.deltaTime;
+            this.sourceRect.x = this._scrollX;
+            this.sourceRect.y = this._scrollY;
+        };
+        ScrollingSpriteRenderer.prototype.render = function (camera) {
+            if (!this.sprite)
+                return;
+            _super.prototype.render.call(this, camera);
+            var renderTexture = new egret.RenderTexture();
+            var cacheBitmap = new egret.DisplayObjectContainer();
+            cacheBitmap.removeChildren();
+            cacheBitmap.addChild(this.leftTexture);
+            cacheBitmap.addChild(this.rightTexture);
+            this.leftTexture.x = this.sourceRect.x;
+            this.rightTexture.x = this.sourceRect.x - this.sourceRect.width;
+            this.leftTexture.y = this.sourceRect.y;
+            this.rightTexture.y = this.sourceRect.y;
+            cacheBitmap.cacheAsBitmap = true;
+            renderTexture.drawToTexture(cacheBitmap, new egret.Rectangle(0, 0, this.sourceRect.width, this.sourceRect.height));
+        };
+        return ScrollingSpriteRenderer;
+    }(es.TiledSpriteRenderer));
+    es.ScrollingSpriteRenderer = ScrollingSpriteRenderer;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Sprite = (function () {
+        function Sprite(texture, sourceRect, origin) {
+            if (sourceRect === void 0) { sourceRect = new es.Rectangle(0, 0, texture.textureWidth, texture.textureHeight); }
+            if (origin === void 0) { origin = sourceRect.getHalfSize(); }
+            this.uvs = new es.Rectangle();
+            this.texture2D = texture;
+            this.sourceRect = sourceRect;
+            this.center = new es.Vector2(sourceRect.width * 0.5, sourceRect.height * 0.5);
+            this.origin = origin;
+            var inverseTexW = 1 / texture.textureWidth;
+            var inverseTexH = 1 / texture.textureHeight;
+            this.uvs.x = sourceRect.x * inverseTexW;
+            this.uvs.y = sourceRect.y * inverseTexH;
+            this.uvs.width = sourceRect.width * inverseTexW;
+            this.uvs.height = sourceRect.height * inverseTexH;
+        }
+        return Sprite;
+    }());
+    es.Sprite = Sprite;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var SpriteAnimation = (function () {
+        function SpriteAnimation(sprites, frameRate) {
+            this.sprites = sprites;
+            this.frameRate = frameRate;
+        }
+        return SpriteAnimation;
+    }());
+    es.SpriteAnimation = SpriteAnimation;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var LoopMode;
+    (function (LoopMode) {
+        LoopMode[LoopMode["loop"] = 0] = "loop";
+        LoopMode[LoopMode["once"] = 1] = "once";
+        LoopMode[LoopMode["clampForever"] = 2] = "clampForever";
+        LoopMode[LoopMode["pingPong"] = 3] = "pingPong";
+        LoopMode[LoopMode["pingPongOnce"] = 4] = "pingPongOnce";
+    })(LoopMode = es.LoopMode || (es.LoopMode = {}));
+    var State;
+    (function (State) {
+        State[State["none"] = 0] = "none";
+        State[State["running"] = 1] = "running";
+        State[State["paused"] = 2] = "paused";
+        State[State["completed"] = 3] = "completed";
+    })(State = es.State || (es.State = {}));
+    var SpriteAnimator = (function (_super) {
+        __extends(SpriteAnimator, _super);
+        function SpriteAnimator(sprite) {
+            var _this = _super.call(this, sprite) || this;
+            _this.speed = 1;
+            _this.animationState = State.none;
+            _this._animations = new Map();
+            _this._elapsedTime = 0;
+            return _this;
+        }
+        Object.defineProperty(SpriteAnimator.prototype, "isRunning", {
+            get: function () {
+                return this.animationState == State.running;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(SpriteAnimator.prototype, "animations", {
+            get: function () {
+                return this._animations;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        SpriteAnimator.prototype.update = function () {
+            if (this.animationState != State.running || !this.currentAnimation)
+                return;
+            var animation = this.currentAnimation;
+            var secondsPerFrame = 1 / (animation.frameRate * this.speed);
+            var iterationDuration = secondsPerFrame * animation.sprites.length;
+            this._elapsedTime += es.Time.deltaTime;
+            var time = Math.abs(this._elapsedTime);
+            if (this._loopMode == LoopMode.once && time > iterationDuration ||
+                this._loopMode == LoopMode.pingPongOnce && time > iterationDuration * 2) {
+                this.animationState = State.completed;
+                this._elapsedTime = 0;
+                this.currentFrame = 0;
+                this.sprite = animation.sprites[this.currentFrame];
+                return;
+            }
+            var i = Math.floor(time / secondsPerFrame);
+            var n = animation.sprites.length;
+            if (n > 2 && (this._loopMode == LoopMode.pingPong || this._loopMode == LoopMode.pingPongOnce)) {
+                var maxIndex = n - 1;
+                this.currentFrame = maxIndex - Math.abs(maxIndex - i % (maxIndex * 2));
+            }
+            else {
+                this.currentFrame = i % n;
+            }
+            this.sprite = animation.sprites[this.currentFrame];
+        };
+        SpriteAnimator.prototype.addAnimation = function (name, animation) {
+            if (!this.sprite && animation.sprites.length > 0)
+                this.setSprite(animation.sprites[0]);
+            this._animations[name] = animation;
+            return this;
+        };
+        SpriteAnimator.prototype.play = function (name, loopMode) {
+            if (loopMode === void 0) { loopMode = null; }
+            this.currentAnimation = this._animations[name];
+            this.currentAnimationName = name;
+            this.currentFrame = 0;
+            this.animationState = State.running;
+            this.sprite = this.currentAnimation.sprites[0];
+            this._elapsedTime = 0;
+            this._loopMode = loopMode ? loopMode : LoopMode.loop;
+        };
+        SpriteAnimator.prototype.isAnimationActive = function (name) {
+            return this.currentAnimation && this.currentAnimationName == name;
+        };
+        SpriteAnimator.prototype.pause = function () {
+            this.animationState = State.paused;
+        };
+        SpriteAnimator.prototype.unPause = function () {
+            this.animationState = State.running;
+        };
+        SpriteAnimator.prototype.stop = function () {
+            this.currentAnimation = null;
+            this.currentAnimationName = null;
+            this.currentFrame = 0;
+            this.animationState = State.none;
+        };
+        return SpriteAnimator;
+    }(es.SpriteRenderer));
+    es.SpriteAnimator = SpriteAnimator;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Mover = (function (_super) {
+        __extends(Mover, _super);
+        function Mover() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        Mover.prototype.onAddedToEntity = function () {
+            this._triggerHelper = new es.ColliderTriggerHelper(this.entity);
+        };
+        Mover.prototype.calculateMovement = function (motion) {
+            var collisionResult = new es.CollisionResult();
+            if (!this.entity.getComponent(es.Collider) || !this._triggerHelper) {
+                return null;
+            }
+            var colliders = this.entity.getComponents(es.Collider);
+            for (var i = 0; i < colliders.length; i++) {
+                var collider = colliders[i];
+                if (collider.isTrigger)
+                    continue;
+                var bounds = collider.bounds;
+                bounds.x += motion.x;
+                bounds.y += motion.y;
+                var boxcastResult = es.Physics.boxcastBroadphaseExcludingSelf(collider, bounds, collider.collidesWithLayers);
+                bounds = boxcastResult.bounds;
+                var neighbors = boxcastResult.tempHashSet;
+                for (var j = 0; j < neighbors.length; j++) {
+                    var neighbor = neighbors[j];
+                    if (neighbor.isTrigger)
+                        continue;
+                    var _internalcollisionResult = collider.collidesWith(neighbor, motion);
+                    if (_internalcollisionResult) {
+                        motion = es.Vector2.subtract(motion, _internalcollisionResult.minimumTranslationVector);
+                        if (_internalcollisionResult.collider) {
+                            collisionResult = _internalcollisionResult;
+                        }
+                    }
+                }
+            }
+            es.ListPool.free(colliders);
+            return { collisionResult: collisionResult, motion: motion };
+        };
+        Mover.prototype.applyMovement = function (motion) {
+            this.entity.position = es.Vector2.add(this.entity.position, motion);
+            if (this._triggerHelper)
+                this._triggerHelper.update();
+        };
+        Mover.prototype.move = function (motion) {
+            var movementResult = this.calculateMovement(motion);
+            var collisionResult = movementResult.collisionResult;
+            motion = movementResult.motion;
+            this.applyMovement(motion);
+            return collisionResult;
+        };
+        return Mover;
+    }(es.Component));
+    es.Mover = Mover;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var ProjectileMover = (function (_super) {
+        __extends(ProjectileMover, _super);
+        function ProjectileMover() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this._tempTriggerList = [];
+            return _this;
+        }
+        ProjectileMover.prototype.onAddedToEntity = function () {
+            this._collider = this.entity.getComponent(es.Collider);
+            if (!this._collider)
+                console.warn("ProjectileMover has no Collider. ProjectilMover requires a Collider!");
+        };
+        ProjectileMover.prototype.move = function (motion) {
+            if (!this._collider)
+                return false;
+            var didCollide = false;
+            this.entity.position = es.Vector2.add(this.entity.position, motion);
+            var neighbors = es.Physics.boxcastBroadphase(this._collider.bounds, this._collider.collidesWithLayers);
+            for (var i = 0; i < neighbors.colliders.length; i++) {
+                var neighbor = neighbors.colliders[i];
+                if (this._collider.overlaps(neighbor) && neighbor.enabled) {
+                    didCollide = true;
+                    this.notifyTriggerListeners(this._collider, neighbor);
+                }
+            }
+            return didCollide;
+        };
+        ProjectileMover.prototype.notifyTriggerListeners = function (self, other) {
+            other.entity.getComponents("ITriggerListener", this._tempTriggerList);
+            for (var i = 0; i < this._tempTriggerList.length; i++) {
+                this._tempTriggerList[i].onTriggerEnter(self, other);
+            }
+            this._tempTriggerList.length = 0;
+            this.entity.getComponents("ITriggerListener", this._tempTriggerList);
+            for (var i = 0; i < this._tempTriggerList.length; i++) {
+                this._tempTriggerList[i].onTriggerEnter(other, self);
+            }
+            this._tempTriggerList.length = 0;
+        };
+        return ProjectileMover;
+    }(es.Component));
+    es.ProjectileMover = ProjectileMover;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Collider = (function (_super) {
+        __extends(Collider, _super);
+        function Collider() {
+            var _this = _super !== null && _super.apply(this, arguments) || this;
+            _this.physicsLayer = 1 << 0;
+            _this.collidesWithLayers = es.Physics.allLayers;
+            _this.shouldColliderScaleAndRotateWithTransform = true;
+            _this.registeredPhysicsBounds = new es.Rectangle();
+            _this._localOffset = es.Vector2.zero;
+            return _this;
+        }
+        Object.defineProperty(Collider.prototype, "localOffset", {
+            get: function () {
+                return this._localOffset;
+            },
+            set: function (value) {
+                this.setLocalOffset(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Collider.prototype, "absolutePosition", {
+            get: function () {
+                return es.Vector2.add(this.entity.transform.position, this._localOffset);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Collider.prototype, "rotation", {
+            get: function () {
+                if (this.shouldColliderScaleAndRotateWithTransform && this.entity)
+                    return this.entity.transform.rotation;
+                return 0;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Collider.prototype, "bounds", {
+            get: function () {
+                this.shape.recalculateBounds(this);
+                return this.shape.bounds;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Collider.prototype.setLocalOffset = function (offset) {
+            if (this._localOffset != offset) {
+                this.unregisterColliderWithPhysicsSystem();
+                this._localOffset = offset;
+                this._localOffsetLength = this._localOffset.length();
+                this.registerColliderWithPhysicsSystem();
+            }
+            return this;
+        };
+        Collider.prototype.setShouldColliderScaleAndRotateWithTransform = function (shouldColliderScaleAndRotationWithTransform) {
+            this.shouldColliderScaleAndRotateWithTransform = shouldColliderScaleAndRotationWithTransform;
+            return this;
+        };
+        Collider.prototype.onAddedToEntity = function () {
+            if (this._colliderRequiresAutoSizing) {
+                if (!(this instanceof es.BoxCollider || this instanceof es.CircleCollider)) {
+                    console.error("Only box and circle colliders can be created automatically");
+                    return;
+                }
+                var renderable = this.entity.getComponent(es.RenderableComponent);
+                if (renderable) {
+                    var bounds = renderable.bounds;
+                    var width = bounds.width / this.entity.scale.x;
+                    var height = bounds.height / this.entity.scale.y;
+                    if (this instanceof es.CircleCollider) {
+                        var circleCollider = this;
+                        circleCollider.radius = Math.max(width, height) * 0.5;
+                    }
+                    else {
+                        this.width = width;
+                        this.height = height;
+                    }
+                    this.localOffset = es.Vector2.subtract(bounds.center, this.entity.transform.position);
+                }
+                else {
+                    console.warn("Collider has no shape and no RenderableComponent. Can't figure out how to size it.");
+                }
+            }
+            this._isParentEntityAddedToScene = true;
+            this.registerColliderWithPhysicsSystem();
+        };
+        Collider.prototype.onRemovedFromEntity = function () {
+            this.unregisterColliderWithPhysicsSystem();
+            this._isParentEntityAddedToScene = false;
+        };
+        Collider.prototype.onEntityTransformChanged = function (comp) {
+            if (this._isColliderRegistered)
+                es.Physics.updateCollider(this);
+        };
+        Collider.prototype.onEnabled = function () {
+            this.registerColliderWithPhysicsSystem();
+        };
+        Collider.prototype.onDisabled = function () {
+            this.unregisterColliderWithPhysicsSystem();
+        };
+        Collider.prototype.registerColliderWithPhysicsSystem = function () {
+            if (this._isParentEntityAddedToScene && !this._isColliderRegistered) {
+                es.Physics.addCollider(this);
+                this._isColliderRegistered = true;
+            }
+        };
+        Collider.prototype.unregisterColliderWithPhysicsSystem = function () {
+            if (this._isParentEntityAddedToScene && this._isColliderRegistered) {
+                es.Physics.removeCollider(this);
+            }
+            this._isColliderRegistered = false;
+        };
+        Collider.prototype.overlaps = function (other) {
+            return this.shape.overlaps(other.shape);
+        };
+        Collider.prototype.collidesWith = function (collider, motion) {
+            var oldPosition = this.entity.position;
+            this.entity.position = es.Vector2.add(this.entity.position, motion);
+            var result = this.shape.collidesWithShape(collider.shape);
+            if (result)
+                result.collider = collider;
+            this.entity.position = oldPosition;
+            return result;
+        };
+        return Collider;
+    }(es.Component));
+    es.Collider = Collider;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var BoxCollider = (function (_super) {
+        __extends(BoxCollider, _super);
+        function BoxCollider() {
+            var _this = _super.call(this) || this;
+            _this.shape = new es.Box(1, 1);
+            _this._colliderRequiresAutoSizing = true;
+            return _this;
+        }
+        Object.defineProperty(BoxCollider.prototype, "width", {
+            get: function () {
+                return this.shape.width;
+            },
+            set: function (value) {
+                this.setWidth(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(BoxCollider.prototype, "height", {
+            get: function () {
+                return this.shape.height;
+            },
+            set: function (value) {
+                this.setHeight(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        BoxCollider.prototype.setSize = function (width, height) {
+            this._colliderRequiresAutoSizing = false;
+            var box = this.shape;
+            if (width != box.width || height != box.height) {
+                box.updateBox(width, height);
+                if (this.entity && this._isParentEntityAddedToScene)
+                    es.Physics.updateCollider(this);
+            }
+            return this;
+        };
+        BoxCollider.prototype.setWidth = function (width) {
+            this._colliderRequiresAutoSizing = false;
+            var box = this.shape;
+            if (width != box.width) {
+                box.updateBox(width, box.height);
+                if (this.entity && this._isParentEntityAddedToScene)
+                    es.Physics.updateCollider(this);
+            }
+            return this;
+        };
+        BoxCollider.prototype.setHeight = function (height) {
+            this._colliderRequiresAutoSizing = false;
+            var box = this.shape;
+            if (height != box.height) {
+                box.updateBox(box.width, height);
+                if (this.entity && this._isParentEntityAddedToScene)
+                    es.Physics.updateCollider(this);
+            }
+        };
+        BoxCollider.prototype.toString = function () {
+            return "[BoxCollider: bounds: " + this.bounds + "]";
+        };
+        return BoxCollider;
+    }(es.Collider));
+    es.BoxCollider = BoxCollider;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var CircleCollider = (function (_super) {
+        __extends(CircleCollider, _super);
+        function CircleCollider(radius) {
+            var _this = _super.call(this) || this;
+            if (radius)
+                _this._colliderRequiresAutoSizing = true;
+            _this.shape = new es.Circle(radius ? radius : 1);
+            return _this;
+        }
+        Object.defineProperty(CircleCollider.prototype, "radius", {
+            get: function () {
+                return this.shape.radius;
+            },
+            set: function (value) {
+                this.setRadius(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        CircleCollider.prototype.setRadius = function (radius) {
+            this._colliderRequiresAutoSizing = false;
+            var circle = this.shape;
+            if (radius != circle.radius) {
+                circle.radius = radius;
+                circle._originalRadius = radius;
+                if (this.entity && this._isParentEntityAddedToScene)
+                    es.Physics.updateCollider(this);
+            }
+            return this;
+        };
+        CircleCollider.prototype.toString = function () {
+            return "[CircleCollider: bounds: " + this.bounds + ", radius: " + this.shape.radius + "]";
+        };
+        return CircleCollider;
+    }(es.Collider));
+    es.CircleCollider = CircleCollider;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var PolygonCollider = (function (_super) {
+        __extends(PolygonCollider, _super);
+        function PolygonCollider(points) {
+            var _this = _super.call(this) || this;
+            var isPolygonClosed = points[0] == points[points.length - 1];
+            if (isPolygonClosed)
+                points.splice(points.length - 1, 1);
+            var center = es.Polygon.findPolygonCenter(points);
+            _this.setLocalOffset(center);
+            es.Polygon.recenterPolygonVerts(points);
+            _this.shape = new es.Polygon(points);
+            return _this;
+        }
+        return PolygonCollider;
+    }(es.Collider));
+    es.PolygonCollider = PolygonCollider;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var EntitySystem = (function () {
+        function EntitySystem(matcher) {
+            this._entities = [];
+            this._matcher = matcher ? matcher : es.Matcher.empty();
+        }
+        Object.defineProperty(EntitySystem.prototype, "matcher", {
+            get: function () {
+                return this._matcher;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(EntitySystem.prototype, "scene", {
+            get: function () {
+                return this._scene;
+            },
+            set: function (value) {
+                this._scene = value;
+                this._entities = [];
+            },
+            enumerable: true,
+            configurable: true
+        });
+        EntitySystem.prototype.initialize = function () {
+        };
+        EntitySystem.prototype.onChanged = function (entity) {
+            var contains = this._entities.contains(entity);
+            var interest = this._matcher.IsIntersted(entity);
+            if (interest && !contains)
+                this.add(entity);
+            else if (!interest && contains)
+                this.remove(entity);
+        };
+        EntitySystem.prototype.add = function (entity) {
+            this._entities.push(entity);
+            this.onAdded(entity);
+        };
+        EntitySystem.prototype.onAdded = function (entity) {
+        };
+        EntitySystem.prototype.remove = function (entity) {
+            this._entities.remove(entity);
+            this.onRemoved(entity);
+        };
+        EntitySystem.prototype.onRemoved = function (entity) {
+        };
+        EntitySystem.prototype.update = function () {
+            this.begin();
+            this.process(this._entities);
+        };
+        EntitySystem.prototype.lateUpdate = function () {
+            this.lateProcess(this._entities);
+            this.end();
+        };
+        EntitySystem.prototype.begin = function () {
+        };
+        EntitySystem.prototype.process = function (entities) {
+        };
+        EntitySystem.prototype.lateProcess = function (entities) {
+        };
+        EntitySystem.prototype.end = function () {
+        };
+        return EntitySystem;
+    }());
+    es.EntitySystem = EntitySystem;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var EntityProcessingSystem = (function (_super) {
+        __extends(EntityProcessingSystem, _super);
+        function EntityProcessingSystem(matcher) {
+            return _super.call(this, matcher) || this;
+        }
+        EntityProcessingSystem.prototype.lateProcessEntity = function (entity) {
+        };
+        EntityProcessingSystem.prototype.process = function (entities) {
+            var _this = this;
+            entities.forEach(function (entity) { return _this.processEntity(entity); });
+        };
+        EntityProcessingSystem.prototype.lateProcess = function (entities) {
+            var _this = this;
+            entities.forEach(function (entity) { return _this.lateProcessEntity(entity); });
+        };
+        return EntityProcessingSystem;
+    }(es.EntitySystem));
+    es.EntityProcessingSystem = EntityProcessingSystem;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var PassiveSystem = (function (_super) {
+        __extends(PassiveSystem, _super);
+        function PassiveSystem() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        PassiveSystem.prototype.onChanged = function (entity) {
+        };
+        PassiveSystem.prototype.process = function (entities) {
+            this.begin();
+            this.end();
+        };
+        return PassiveSystem;
+    }(es.EntitySystem));
+    es.PassiveSystem = PassiveSystem;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var ProcessingSystem = (function (_super) {
+        __extends(ProcessingSystem, _super);
+        function ProcessingSystem() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        ProcessingSystem.prototype.onChanged = function (entity) {
+        };
+        ProcessingSystem.prototype.process = function (entities) {
+            this.begin();
+            this.processSystem();
+            this.end();
+        };
+        return ProcessingSystem;
+    }(es.EntitySystem));
+    es.ProcessingSystem = ProcessingSystem;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var BitSet = (function () {
+        function BitSet(nbits) {
+            if (nbits === void 0) { nbits = 64; }
+            var length = nbits >> 6;
+            if ((nbits & BitSet.LONG_MASK) != 0)
+                length++;
+            this._bits = new Array(length);
+        }
+        BitSet.prototype.and = function (bs) {
+            var max = Math.min(this._bits.length, bs._bits.length);
+            var i;
+            for (var i_1 = 0; i_1 < max; ++i_1)
+                this._bits[i_1] &= bs._bits[i_1];
+            while (i < this._bits.length)
+                this._bits[i++] = 0;
+        };
+        BitSet.prototype.andNot = function (bs) {
+            var i = Math.min(this._bits.length, bs._bits.length);
+            while (--i >= 0)
+                this._bits[i] &= ~bs._bits[i];
+        };
+        BitSet.prototype.cardinality = function () {
+            var card = 0;
+            for (var i = this._bits.length - 1; i >= 0; i--) {
+                var a = this._bits[i];
+                if (a == 0)
+                    continue;
+                if (a == -1) {
+                    card += 64;
+                    continue;
+                }
+                a = ((a >> 1) & 0x5555555555555555) + (a & 0x5555555555555555);
+                a = ((a >> 2) & 0x3333333333333333) + (a & 0x3333333333333333);
+                var b = ((a >> 32) + a);
+                b = ((b >> 4) & 0x0f0f0f0f) + (b & 0x0f0f0f0f);
+                b = ((b >> 8) & 0x00ff00ff) + (b & 0x00ff00ff);
+                card += ((b >> 16) & 0x0000ffff) + (b & 0x0000ffff);
+            }
+            return card;
+        };
+        BitSet.prototype.clear = function (pos) {
+            if (pos != undefined) {
+                var offset = pos >> 6;
+                this.ensure(offset);
+                this._bits[offset] &= ~(1 << pos);
+            }
+            else {
+                for (var i = 0; i < this._bits.length; i++)
+                    this._bits[i] = 0;
+            }
+        };
+        BitSet.prototype.ensure = function (lastElt) {
+            if (lastElt >= this._bits.length) {
+                var nd = new Number[lastElt + 1];
+                nd = this._bits.copyWithin(0, 0, this._bits.length);
+                this._bits = nd;
+            }
+        };
+        BitSet.prototype.get = function (pos) {
+            var offset = pos >> 6;
+            if (offset >= this._bits.length)
+                return false;
+            return (this._bits[offset] & (1 << pos)) != 0;
+        };
+        BitSet.prototype.intersects = function (set) {
+            var i = Math.min(this._bits.length, set._bits.length);
+            while (--i >= 0) {
+                if ((this._bits[i] & set._bits[i]) != 0)
+                    return true;
+            }
+            return false;
+        };
+        BitSet.prototype.isEmpty = function () {
+            for (var i = this._bits.length - 1; i >= 0; i--) {
+                if (this._bits[i])
+                    return false;
+            }
+            return true;
+        };
+        BitSet.prototype.nextSetBit = function (from) {
+            var offset = from >> 6;
+            var mask = 1 << from;
+            while (offset < this._bits.length) {
+                var h = this._bits[offset];
+                do {
+                    if ((h & mask) != 0)
+                        return from;
+                    mask <<= 1;
+                    from++;
+                } while (mask != 0);
+                mask = 1;
+                offset++;
+            }
+            return -1;
+        };
+        BitSet.prototype.set = function (pos, value) {
+            if (value === void 0) { value = true; }
+            if (value) {
+                var offset = pos >> 6;
+                this.ensure(offset);
+                this._bits[offset] |= 1 << pos;
+            }
+            else {
+                this.clear(pos);
+            }
+        };
+        BitSet.LONG_MASK = 0x3f;
+        return BitSet;
+    }());
+    es.BitSet = BitSet;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var ComponentList = (function () {
+        function ComponentList(entity) {
+            this._components = [];
+            this._componentsToAdd = [];
+            this._componentsToRemove = [];
+            this._tempBufferList = [];
+            this._entity = entity;
+        }
+        Object.defineProperty(ComponentList.prototype, "count", {
+            get: function () {
+                return this._components.length;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ComponentList.prototype, "buffer", {
+            get: function () {
+                return this._components;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        ComponentList.prototype.markEntityListUnsorted = function () {
+            this._isComponentListUnsorted = true;
+        };
+        ComponentList.prototype.add = function (component) {
+            this._componentsToAdd.push(component);
+        };
+        ComponentList.prototype.remove = function (component) {
+            if (this._componentsToRemove.contains(component))
+                console.warn("You are trying to remove a Component (" + component + ") that you already removed");
+            if (this._componentsToAdd.contains(component)) {
+                this._componentsToAdd.remove(component);
+                return;
+            }
+            this._componentsToRemove.push(component);
+        };
+        ComponentList.prototype.removeAllComponents = function () {
+            for (var i = 0; i < this._components.length; i++) {
+                this.handleRemove(this._components[i]);
+            }
+            this._components.length = 0;
+            this._componentsToAdd.length = 0;
+            this._componentsToRemove.length = 0;
+        };
+        ComponentList.prototype.deregisterAllComponents = function () {
+            for (var i = 0; i < this._components.length; i++) {
+                var component = this._components[i];
+                if (component instanceof es.RenderableComponent)
+                    this._entity.scene.renderableComponents.remove(component);
+                this._entity.componentBits.set(es.ComponentTypeManager.getIndexFor(component), false);
+                this._entity.scene.entityProcessors.onComponentRemoved(this._entity);
+            }
+        };
+        ComponentList.prototype.registerAllComponents = function () {
+            for (var i = 0; i < this._components.length; i++) {
+                var component = this._components[i];
+                if (component instanceof es.RenderableComponent)
+                    this._entity.scene.renderableComponents.add(component);
+                this._entity.componentBits.set(es.ComponentTypeManager.getIndexFor(component));
+                this._entity.scene.entityProcessors.onComponentAdded(this._entity);
+            }
+        };
+        ComponentList.prototype.updateLists = function () {
+            if (this._componentsToRemove.length > 0) {
+                for (var i = 0; i < this._componentsToRemove.length; i++) {
+                    this.handleRemove(this._componentsToRemove[i]);
+                    this._components.remove(this._componentsToRemove[i]);
+                }
+                this._componentsToRemove.length = 0;
+            }
+            if (this._componentsToAdd.length > 0) {
+                for (var i = 0, count = this._componentsToAdd.length; i < count; i++) {
+                    var component = this._componentsToAdd[i];
+                    if (component instanceof es.RenderableComponent)
+                        this._entity.scene.renderableComponents.add(component);
+                    this._entity.componentBits.set(es.ComponentTypeManager.getIndexFor(component));
+                    this._entity.scene.entityProcessors.onComponentAdded(this._entity);
+                    this._components.push(component);
+                    this._tempBufferList.push(component);
+                }
+                this._componentsToAdd.length = 0;
+                this._isComponentListUnsorted = true;
+                for (var i = 0; i < this._tempBufferList.length; i++) {
+                    var component = this._tempBufferList[i];
+                    component.onAddedToEntity();
+                    if (component.enabled) {
+                        component.onEnabled();
+                    }
+                }
+                this._tempBufferList.length = 0;
+            }
+            if (this._isComponentListUnsorted) {
+                this._components.sort(ComponentList.compareUpdatableOrder.compare);
+                this._isComponentListUnsorted = false;
+            }
+        };
+        ComponentList.prototype.handleRemove = function (component) {
+            if (component instanceof es.RenderableComponent)
+                this._entity.scene.renderableComponents.remove(component);
+            this._entity.componentBits.set(es.ComponentTypeManager.getIndexFor(component), false);
+            this._entity.scene.entityProcessors.onComponentRemoved(this._entity);
+            component.onRemovedFromEntity();
+            component.entity = null;
+        };
+        ComponentList.prototype.getComponent = function (type, onlyReturnInitializedComponents) {
+            for (var i = 0; i < this._components.length; i++) {
+                var component = this._components[i];
                 if (component instanceof type)
                     return component;
             }
-        }
-        return null;
-    };
-    ComponentList.prototype.getComponents = function (typeName, components) {
-        if (!components)
-            components = [];
-        for (var i = 0; i < this._components.length; i++) {
-            var component = this._components[i];
-            if (typeof (typeName) == "string") {
-                if (egret.is(component, typeName)) {
-                    components.push(component);
+            if (!onlyReturnInitializedComponents) {
+                for (var i = 0; i < this._componentsToAdd.length; i++) {
+                    var component = this._componentsToAdd[i];
+                    if (component instanceof type)
+                        return component;
                 }
             }
-            else {
-                if (component instanceof typeName) {
-                    components.push(component);
+            return null;
+        };
+        ComponentList.prototype.getComponents = function (typeName, components) {
+            if (!components)
+                components = [];
+            for (var i = 0; i < this._components.length; i++) {
+                var component = this._components[i];
+                if (typeof (typeName) == "string") {
+                    if (egret.is(component, typeName)) {
+                        components.push(component);
+                    }
+                }
+                else {
+                    if (component instanceof typeName) {
+                        components.push(component);
+                    }
                 }
             }
-        }
-        for (var i = 0; i < this._componentsToAdd.length; i++) {
-            var component = this._componentsToAdd[i];
-            if (typeof (typeName) == "string") {
-                if (egret.is(component, typeName)) {
-                    components.push(component);
+            for (var i = 0; i < this._componentsToAdd.length; i++) {
+                var component = this._componentsToAdd[i];
+                if (typeof (typeName) == "string") {
+                    if (egret.is(component, typeName)) {
+                        components.push(component);
+                    }
+                }
+                else {
+                    if (component instanceof typeName) {
+                        components.push(component);
+                    }
                 }
             }
-            else {
-                if (component instanceof typeName) {
-                    components.push(component);
-                }
+            return components;
+        };
+        ComponentList.prototype.update = function () {
+            this.updateLists();
+            for (var i = 0; i < this._components.length; i++) {
+                var updatableComponent = this._components[i];
+                if (updatableComponent.enabled &&
+                    (updatableComponent.updateInterval == 1 ||
+                        es.Time.frameCount % updatableComponent.updateInterval == 0))
+                    updatableComponent.update();
             }
-        }
-        return components;
-    };
-    ComponentList.prototype.update = function () {
-        this.updateLists();
-        for (var i = 0; i < this._components.length; i++) {
-            var updatable = this._components[i];
-            var updateableComponent = void 0;
-            if (updatable instanceof Component)
-                updateableComponent = updatable;
-            if (updatable.enabled &&
-                updateableComponent.enabled &&
-                (updateableComponent.updateInterval == 1 ||
-                    Time.frameCount % updateableComponent.updateInterval == 0))
-                updatable.update();
-        }
-    };
-    return ComponentList;
-}());
-var ComponentTypeManager = (function () {
-    function ComponentTypeManager() {
-    }
-    ComponentTypeManager.add = function (type) {
-        if (!this._componentTypesMask.has(type))
-            this._componentTypesMask[type] = this._componentTypesMask.size;
-    };
-    ComponentTypeManager.getIndexFor = function (type) {
-        var v = -1;
-        if (!this._componentTypesMask.has(type)) {
-            this.add(type);
-            v = this._componentTypesMask.get(type);
-        }
-        return v;
-    };
-    ComponentTypeManager._componentTypesMask = new Map();
-    return ComponentTypeManager;
-}());
-var EntityList = (function () {
-    function EntityList(scene) {
-        this._entitiesToRemove = [];
-        this._entitiesToAdded = [];
-        this._tempEntityList = [];
-        this._entities = [];
-        this._entityDict = new Map();
-        this._unsortedTags = [];
-        this.scene = scene;
-    }
-    Object.defineProperty(EntityList.prototype, "count", {
-        get: function () {
-            return this._entities.length;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(EntityList.prototype, "buffer", {
-        get: function () {
-            return this._entities;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    EntityList.prototype.add = function (entity) {
-        if (this._entitiesToAdded.indexOf(entity) == -1)
-            this._entitiesToAdded.push(entity);
-    };
-    EntityList.prototype.remove = function (entity) {
-        if (this._entitiesToAdded.contains(entity)) {
-            this._entitiesToAdded.remove(entity);
-            return;
-        }
-        if (!this._entitiesToRemove.contains(entity))
-            this._entitiesToRemove.push(entity);
-    };
-    EntityList.prototype.findEntity = function (name) {
-        for (var i = 0; i < this._entities.length; i++) {
-            if (this._entities[i].name == name)
-                return this._entities[i];
-        }
-        return this._entitiesToAdded.firstOrDefault(function (entity) { return entity.name == name; });
-    };
-    EntityList.prototype.getTagList = function (tag) {
-        var list = this._entityDict.get(tag);
-        if (!list) {
-            list = [];
-            this._entityDict.set(tag, list);
-        }
-        return this._entityDict.get(tag);
-    };
-    EntityList.prototype.addToTagList = function (entity) {
-        var list = this.getTagList(entity.tag);
-        if (!list.contains(entity)) {
-            list.push(entity);
-            this._unsortedTags.push(entity.tag);
-        }
-    };
-    EntityList.prototype.removeFromTagList = function (entity) {
-        var list = this._entityDict.get(entity.tag);
-        if (list) {
-            list.remove(entity);
-        }
-    };
-    EntityList.prototype.update = function () {
-        for (var i = 0; i < this._entities.length; i++) {
-            var entity = this._entities[i];
-            if (entity.enabled)
-                entity.update();
-        }
-    };
-    EntityList.prototype.removeAllEntities = function () {
-        this._entitiesToAdded.length = 0;
-        this.updateLists();
-        for (var i = 0; i < this._entities.length; i++) {
-            this._entities[i]._isDestoryed = true;
-            this._entities[i].onRemovedFromScene();
-            this._entities[i].scene = null;
-        }
-        this._entities.length = 0;
-        this._entityDict.clear();
-    };
-    EntityList.prototype.updateLists = function () {
-        var _this = this;
-        if (this._entitiesToRemove.length > 0) {
-            var temp = this._entitiesToRemove;
-            this._entitiesToRemove = this._tempEntityList;
-            this._tempEntityList = temp;
-            this._tempEntityList.forEach(function (entity) {
-                _this._entities.remove(entity);
-                entity.scene = null;
-                _this.scene.entityProcessors.onEntityRemoved(entity);
-            });
-            this._tempEntityList.length = 0;
-        }
-        if (this._entitiesToAdded.length > 0) {
-            var temp = this._entitiesToAdded;
-            this._entitiesToAdded = this._tempEntityList;
-            this._tempEntityList = temp;
-            this._tempEntityList.forEach(function (entity) {
-                if (!_this._entities.contains(entity)) {
-                    _this._entities.push(entity);
-                    entity.scene = _this.scene;
-                    _this.scene.entityProcessors.onEntityAdded(entity);
-                }
-            });
-            this._tempEntityList.forEach(function (entity) { return entity.onAddedToScene(); });
-            this._tempEntityList.length = 0;
-        }
-        if (this._unsortedTags.length > 0) {
-            this._unsortedTags.forEach(function (tag) {
-                _this._entityDict.get(tag).sort();
-            });
-            this._unsortedTags.length = 0;
-        }
-    };
-    return EntityList;
-}());
-var EntityProcessorList = (function () {
-    function EntityProcessorList() {
-        this._processors = [];
-    }
-    EntityProcessorList.prototype.add = function (processor) {
-        this._processors.push(processor);
-    };
-    EntityProcessorList.prototype.remove = function (processor) {
-        this._processors.remove(processor);
-    };
-    EntityProcessorList.prototype.onComponentAdded = function (entity) {
-        this.notifyEntityChanged(entity);
-    };
-    EntityProcessorList.prototype.onComponentRemoved = function (entity) {
-        this.notifyEntityChanged(entity);
-    };
-    EntityProcessorList.prototype.onEntityAdded = function (entity) {
-        this.notifyEntityChanged(entity);
-    };
-    EntityProcessorList.prototype.onEntityRemoved = function (entity) {
-        this.removeFromProcessors(entity);
-    };
-    EntityProcessorList.prototype.notifyEntityChanged = function (entity) {
-        for (var i = 0; i < this._processors.length; i++) {
-            this._processors[i].onChanged(entity);
-        }
-    };
-    EntityProcessorList.prototype.removeFromProcessors = function (entity) {
-        for (var i = 0; i < this._processors.length; i++) {
-            this._processors[i].remove(entity);
-        }
-    };
-    EntityProcessorList.prototype.begin = function () {
-    };
-    EntityProcessorList.prototype.update = function () {
-        for (var i = 0; i < this._processors.length; i++) {
-            this._processors[i].update();
-        }
-    };
-    EntityProcessorList.prototype.lateUpdate = function () {
-        for (var i = 0; i < this._processors.length; i++) {
-            this._processors[i].lateUpdate();
-        }
-    };
-    EntityProcessorList.prototype.end = function () {
-    };
-    EntityProcessorList.prototype.getProcessor = function () {
-        for (var i = 0; i < this._processors.length; i++) {
-            var processor = this._processors[i];
-            if (processor instanceof EntitySystem)
-                return processor;
-        }
-        return null;
-    };
-    return EntityProcessorList;
-}());
-var Matcher = (function () {
-    function Matcher() {
-        this.allSet = new BitSet();
-        this.exclusionSet = new BitSet();
-        this.oneSet = new BitSet();
-    }
-    Matcher.empty = function () {
-        return new Matcher();
-    };
-    Matcher.prototype.getAllSet = function () {
-        return this.allSet;
-    };
-    Matcher.prototype.getExclusionSet = function () {
-        return this.exclusionSet;
-    };
-    Matcher.prototype.getOneSet = function () {
-        return this.oneSet;
-    };
-    Matcher.prototype.IsIntersted = function (e) {
-        if (!this.allSet.isEmpty()) {
-            for (var i = this.allSet.nextSetBit(0); i >= 0; i = this.allSet.nextSetBit(i + 1)) {
-                if (!e.componentBits.get(i))
-                    return false;
+        };
+        ComponentList.prototype.onEntityTransformChanged = function (comp) {
+            for (var i = 0; i < this._components.length; i++) {
+                if (this._components[i].enabled)
+                    this._components[i].onEntityTransformChanged(comp);
             }
+            for (var i = 0; i < this._componentsToAdd.length; i++) {
+                if (this._componentsToAdd[i].enabled)
+                    this._componentsToAdd[i].onEntityTransformChanged(comp);
+            }
+        };
+        ComponentList.prototype.onEntityEnabled = function () {
+            for (var i = 0; i < this._components.length; i++)
+                this._components[i].onEnabled();
+        };
+        ComponentList.prototype.onEntityDisabled = function () {
+            for (var i = 0; i < this._components.length; i++)
+                this._components[i].onDisabled();
+        };
+        ComponentList.compareUpdatableOrder = new es.IUpdatableComparer();
+        return ComponentList;
+    }());
+    es.ComponentList = ComponentList;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var ComponentTypeManager = (function () {
+        function ComponentTypeManager() {
         }
-        if (!this.exclusionSet.isEmpty() && this.exclusionSet.intersects(e.componentBits))
-            return false;
-        if (!this.oneSet.isEmpty() && !this.oneSet.intersects(e.componentBits))
-            return false;
-        return true;
-    };
-    Matcher.prototype.all = function () {
-        var _this = this;
-        var types = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            types[_i] = arguments[_i];
+        ComponentTypeManager.add = function (type) {
+            if (!this._componentTypesMask.has(type))
+                this._componentTypesMask[type] = this._componentTypesMask.size;
+        };
+        ComponentTypeManager.getIndexFor = function (type) {
+            var v = -1;
+            if (!this._componentTypesMask.has(type)) {
+                this.add(type);
+                v = this._componentTypesMask.get(type);
+            }
+            return v;
+        };
+        ComponentTypeManager._componentTypesMask = new Map();
+        return ComponentTypeManager;
+    }());
+    es.ComponentTypeManager = ComponentTypeManager;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var EntityList = (function () {
+        function EntityList(scene) {
+            this._entitiesToRemove = [];
+            this._entitiesToAdded = [];
+            this._tempEntityList = [];
+            this._entities = [];
+            this._entityDict = new Map();
+            this._unsortedTags = [];
+            this.scene = scene;
         }
-        types.forEach(function (type) {
-            _this.allSet.set(ComponentTypeManager.getIndexFor(type));
+        Object.defineProperty(EntityList.prototype, "count", {
+            get: function () {
+                return this._entities.length;
+            },
+            enumerable: true,
+            configurable: true
         });
-        return this;
-    };
-    Matcher.prototype.exclude = function () {
-        var _this = this;
-        var types = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            types[_i] = arguments[_i];
-        }
-        types.forEach(function (type) {
-            _this.exclusionSet.set(ComponentTypeManager.getIndexFor(type));
+        Object.defineProperty(EntityList.prototype, "buffer", {
+            get: function () {
+                return this._entities;
+            },
+            enumerable: true,
+            configurable: true
         });
-        return this;
-    };
-    Matcher.prototype.one = function () {
-        var _this = this;
-        var types = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            types[_i] = arguments[_i];
+        EntityList.prototype.add = function (entity) {
+            if (this._entitiesToAdded.indexOf(entity) == -1)
+                this._entitiesToAdded.push(entity);
+        };
+        EntityList.prototype.remove = function (entity) {
+            if (this._entitiesToAdded.contains(entity)) {
+                this._entitiesToAdded.remove(entity);
+                return;
+            }
+            if (!this._entitiesToRemove.contains(entity))
+                this._entitiesToRemove.push(entity);
+        };
+        EntityList.prototype.findEntity = function (name) {
+            for (var i = 0; i < this._entities.length; i++) {
+                if (this._entities[i].name == name)
+                    return this._entities[i];
+            }
+            return this._entitiesToAdded.firstOrDefault(function (entity) { return entity.name == name; });
+        };
+        EntityList.prototype.entitiesWithTag = function (tag) {
+            var list = this.getTagList(tag);
+            var returnList = es.ListPool.obtain();
+            for (var i = 0; i < list.length; i++)
+                returnList.push(list[i]);
+            return returnList;
+        };
+        EntityList.prototype.entitiesOfType = function (type) {
+            var list = es.ListPool.obtain();
+            for (var i = 0; i < this._entities.length; i++) {
+                if (this._entities[i] instanceof type)
+                    list.push(this._entities[i]);
+            }
+            this._entitiesToAdded.forEach(function (entity) {
+                if (entity instanceof type)
+                    list.push(entity);
+            });
+            return list;
+        };
+        EntityList.prototype.findComponentOfType = function (type) {
+            for (var i = 0; i < this._entities.length; i++) {
+                if (this._entities[i].enabled) {
+                    var comp = this._entities[i].getComponent(type);
+                    if (comp)
+                        return comp;
+                }
+            }
+            for (var i = 0; i < this._entitiesToAdded.length; i++) {
+                var entity = this._entitiesToAdded[i];
+                if (entity.enabled) {
+                    var comp = entity.getComponent(type);
+                    if (comp)
+                        return comp;
+                }
+            }
+            return null;
+        };
+        EntityList.prototype.findComponentsOfType = function (type) {
+            var comps = es.ListPool.obtain();
+            for (var i = 0; i < this._entities.length; i++) {
+                if (this._entities[i].enabled)
+                    this._entities[i].getComponents(type, comps);
+            }
+            for (var i = 0; i < this._entitiesToAdded.length; i++) {
+                var entity = this._entitiesToAdded[i];
+                if (entity.enabled)
+                    entity.getComponents(type, comps);
+            }
+            return comps;
+        };
+        EntityList.prototype.getTagList = function (tag) {
+            var list = this._entityDict.get(tag);
+            if (!list) {
+                list = [];
+                this._entityDict.set(tag, list);
+            }
+            return this._entityDict.get(tag);
+        };
+        EntityList.prototype.addToTagList = function (entity) {
+            var list = this.getTagList(entity.tag);
+            if (!list.contains(entity)) {
+                list.push(entity);
+                this._unsortedTags.push(entity.tag);
+            }
+        };
+        EntityList.prototype.removeFromTagList = function (entity) {
+            var list = this._entityDict.get(entity.tag);
+            if (list) {
+                list.remove(entity);
+            }
+        };
+        EntityList.prototype.update = function () {
+            for (var i = 0; i < this._entities.length; i++) {
+                var entity = this._entities[i];
+                if (entity.enabled)
+                    entity.update();
+            }
+        };
+        EntityList.prototype.removeAllEntities = function () {
+            this._entitiesToAdded.length = 0;
+            this.updateLists();
+            for (var i = 0; i < this._entities.length; i++) {
+                this._entities[i]._isDestroyed = true;
+                this._entities[i].onRemovedFromScene();
+                this._entities[i].scene = null;
+            }
+            this._entities.length = 0;
+            this._entityDict.clear();
+        };
+        EntityList.prototype.updateLists = function () {
+            var _this = this;
+            if (this._entitiesToRemove.length > 0) {
+                var temp = this._entitiesToRemove;
+                this._entitiesToRemove = this._tempEntityList;
+                this._tempEntityList = temp;
+                this._tempEntityList.forEach(function (entity) {
+                    _this._entities.remove(entity);
+                    entity.scene = null;
+                    _this.scene.entityProcessors.onEntityRemoved(entity);
+                });
+                this._tempEntityList.length = 0;
+            }
+            if (this._entitiesToAdded.length > 0) {
+                var temp = this._entitiesToAdded;
+                this._entitiesToAdded = this._tempEntityList;
+                this._tempEntityList = temp;
+                this._tempEntityList.forEach(function (entity) {
+                    if (!_this._entities.contains(entity)) {
+                        _this._entities.push(entity);
+                        entity.scene = _this.scene;
+                        _this.scene.entityProcessors.onEntityAdded(entity);
+                    }
+                });
+                this._tempEntityList.forEach(function (entity) { return entity.onAddedToScene(); });
+                this._tempEntityList.length = 0;
+            }
+            if (this._unsortedTags.length > 0) {
+                this._unsortedTags.forEach(function (tag) {
+                    _this._entityDict.get(tag).sort();
+                });
+                this._unsortedTags.length = 0;
+            }
+        };
+        return EntityList;
+    }());
+    es.EntityList = EntityList;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var EntityProcessorList = (function () {
+        function EntityProcessorList() {
+            this._processors = [];
         }
-        types.forEach(function (type) {
-            _this.oneSet.set(ComponentTypeManager.getIndexFor(type));
-        });
-        return this;
-    };
-    return Matcher;
-}());
+        EntityProcessorList.prototype.add = function (processor) {
+            this._processors.push(processor);
+        };
+        EntityProcessorList.prototype.remove = function (processor) {
+            this._processors.remove(processor);
+        };
+        EntityProcessorList.prototype.onComponentAdded = function (entity) {
+            this.notifyEntityChanged(entity);
+        };
+        EntityProcessorList.prototype.onComponentRemoved = function (entity) {
+            this.notifyEntityChanged(entity);
+        };
+        EntityProcessorList.prototype.onEntityAdded = function (entity) {
+            this.notifyEntityChanged(entity);
+        };
+        EntityProcessorList.prototype.onEntityRemoved = function (entity) {
+            this.removeFromProcessors(entity);
+        };
+        EntityProcessorList.prototype.notifyEntityChanged = function (entity) {
+            for (var i = 0; i < this._processors.length; i++) {
+                this._processors[i].onChanged(entity);
+            }
+        };
+        EntityProcessorList.prototype.removeFromProcessors = function (entity) {
+            for (var i = 0; i < this._processors.length; i++) {
+                this._processors[i].remove(entity);
+            }
+        };
+        EntityProcessorList.prototype.begin = function () {
+        };
+        EntityProcessorList.prototype.update = function () {
+            for (var i = 0; i < this._processors.length; i++) {
+                this._processors[i].update();
+            }
+        };
+        EntityProcessorList.prototype.lateUpdate = function () {
+            for (var i = 0; i < this._processors.length; i++) {
+                this._processors[i].lateUpdate();
+            }
+        };
+        EntityProcessorList.prototype.end = function () {
+        };
+        EntityProcessorList.prototype.getProcessor = function () {
+            for (var i = 0; i < this._processors.length; i++) {
+                var processor = this._processors[i];
+                if (processor instanceof es.EntitySystem)
+                    return processor;
+            }
+            return null;
+        };
+        return EntityProcessorList;
+    }());
+    es.EntityProcessorList = EntityProcessorList;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Matcher = (function () {
+        function Matcher() {
+            this.allSet = new es.BitSet();
+            this.exclusionSet = new es.BitSet();
+            this.oneSet = new es.BitSet();
+        }
+        Matcher.empty = function () {
+            return new Matcher();
+        };
+        Matcher.prototype.getAllSet = function () {
+            return this.allSet;
+        };
+        Matcher.prototype.getExclusionSet = function () {
+            return this.exclusionSet;
+        };
+        Matcher.prototype.getOneSet = function () {
+            return this.oneSet;
+        };
+        Matcher.prototype.IsIntersted = function (e) {
+            if (!this.allSet.isEmpty()) {
+                for (var i = this.allSet.nextSetBit(0); i >= 0; i = this.allSet.nextSetBit(i + 1)) {
+                    if (!e.componentBits.get(i))
+                        return false;
+                }
+            }
+            if (!this.exclusionSet.isEmpty() && this.exclusionSet.intersects(e.componentBits))
+                return false;
+            if (!this.oneSet.isEmpty() && !this.oneSet.intersects(e.componentBits))
+                return false;
+            return true;
+        };
+        Matcher.prototype.all = function () {
+            var _this = this;
+            var types = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                types[_i] = arguments[_i];
+            }
+            types.forEach(function (type) {
+                _this.allSet.set(es.ComponentTypeManager.getIndexFor(type));
+            });
+            return this;
+        };
+        Matcher.prototype.exclude = function () {
+            var _this = this;
+            var types = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                types[_i] = arguments[_i];
+            }
+            types.forEach(function (type) {
+                _this.exclusionSet.set(es.ComponentTypeManager.getIndexFor(type));
+            });
+            return this;
+        };
+        Matcher.prototype.one = function () {
+            var _this = this;
+            var types = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                types[_i] = arguments[_i];
+            }
+            types.forEach(function (type) {
+                _this.oneSet.set(es.ComponentTypeManager.getIndexFor(type));
+            });
+            return this;
+        };
+        return Matcher;
+    }());
+    es.Matcher = Matcher;
+})(es || (es = {}));
 var ObjectUtils = (function () {
     function ObjectUtils() {
     }
@@ -3058,34 +3568,100 @@ var ObjectUtils = (function () {
     };
     return ObjectUtils;
 }());
-var RenderableComponentList = (function () {
-    function RenderableComponentList() {
-        this._components = [];
-    }
-    Object.defineProperty(RenderableComponentList.prototype, "count", {
-        get: function () {
-            return this._components.length;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(RenderableComponentList.prototype, "buffer", {
-        get: function () {
-            return this._components;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    RenderableComponentList.prototype.add = function (component) {
-        this._components.push(component);
-    };
-    RenderableComponentList.prototype.remove = function (component) {
-        this._components.remove(component);
-    };
-    RenderableComponentList.prototype.updateList = function () {
-    };
-    return RenderableComponentList;
-}());
+var es;
+(function (es) {
+    var RenderableComparer = (function () {
+        function RenderableComparer() {
+        }
+        RenderableComparer.prototype.compare = function (self, other) {
+            return other.renderLayer - self.renderLayer;
+        };
+        return RenderableComparer;
+    }());
+    es.RenderableComparer = RenderableComparer;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var RenderableComponentList = (function () {
+        function RenderableComponentList() {
+            this._components = [];
+            this._componentsByRenderLayer = new Map();
+            this._unsortedRenderLayers = [];
+            this._componentsNeedSort = true;
+        }
+        Object.defineProperty(RenderableComponentList.prototype, "count", {
+            get: function () {
+                return this._components.length;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(RenderableComponentList.prototype, "buffer", {
+            get: function () {
+                return this._components;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        RenderableComponentList.prototype.add = function (component) {
+            this._components.push(component);
+            this.addToRenderLayerList(component, component.renderLayer);
+        };
+        RenderableComponentList.prototype.remove = function (component) {
+            this._components.remove(component);
+            this._componentsByRenderLayer.get(component.renderLayer).remove(component);
+        };
+        RenderableComponentList.prototype.updateRenderableRenderLayer = function (component, oldRenderLayer, newRenderLayer) {
+            if (this._componentsByRenderLayer.has(oldRenderLayer) && this._componentsByRenderLayer.get(oldRenderLayer).contains(component)) {
+                this._componentsByRenderLayer.get(oldRenderLayer).remove(component);
+                this.addToRenderLayerList(component, newRenderLayer);
+            }
+        };
+        RenderableComponentList.prototype.setRenderLayerNeedsComponentSort = function (renderLayer) {
+            if (!this._unsortedRenderLayers.contains(renderLayer))
+                this._unsortedRenderLayers.push(renderLayer);
+            this._componentsNeedSort = true;
+        };
+        RenderableComponentList.prototype.setNeedsComponentSort = function () {
+            this._componentsNeedSort = true;
+        };
+        RenderableComponentList.prototype.addToRenderLayerList = function (component, renderLayer) {
+            var list = this.componentsWithRenderLayer(renderLayer);
+            if (!list.contains(component)) {
+                console.warn("Component renderLayer list already contains this component");
+                return;
+            }
+            list.push(component);
+            if (!this._unsortedRenderLayers.contains(renderLayer))
+                this._unsortedRenderLayers.push(renderLayer);
+            this._componentsNeedSort = true;
+        };
+        RenderableComponentList.prototype.componentsWithRenderLayer = function (renderLayer) {
+            if (!this._componentsByRenderLayer.get(renderLayer)) {
+                this._componentsByRenderLayer.set(renderLayer, []);
+            }
+            return this._componentsByRenderLayer.get(renderLayer);
+        };
+        RenderableComponentList.prototype.updateList = function () {
+            if (this._componentsNeedSort) {
+                this._components.sort(RenderableComponentList.compareUpdatableOrder.compare);
+                this._componentsNeedSort = false;
+            }
+            if (this._unsortedRenderLayers.length > 0) {
+                for (var i = 0, count = this._unsortedRenderLayers.length; i < count; i++) {
+                    var renderLayerComponents = this._componentsByRenderLayer.get(this._unsortedRenderLayers[i]);
+                    if (renderLayerComponents) {
+                        renderLayerComponents.sort(RenderableComponentList.compareUpdatableOrder.compare);
+                    }
+                }
+                this._unsortedRenderLayers.length = 0;
+            }
+        };
+        RenderableComponentList.compareUpdatableOrder = new es.RenderableComparer();
+        return RenderableComponentList;
+    }());
+    es.RenderableComponentList = RenderableComponentList;
+})(es || (es = {}));
 var StringUtils = (function () {
     function StringUtils() {
     }
@@ -3230,155 +3806,163 @@ var StringUtils = (function () {
     ];
     return StringUtils;
 }());
-var TextureUtils = (function () {
-    function TextureUtils() {
-    }
-    TextureUtils.convertImageToCanvas = function (texture, rect) {
-        if (!this.sharedCanvas) {
-            this.sharedCanvas = egret.sys.createCanvas();
-            this.sharedContext = this.sharedCanvas.getContext("2d");
+var es;
+(function (es) {
+    var TextureUtils = (function () {
+        function TextureUtils() {
         }
-        var w = texture.$getTextureWidth();
-        var h = texture.$getTextureHeight();
-        if (!rect) {
-            rect = egret.$TempRectangle;
-            rect.x = 0;
-            rect.y = 0;
-            rect.width = w;
-            rect.height = h;
-        }
-        rect.x = Math.min(rect.x, w - 1);
-        rect.y = Math.min(rect.y, h - 1);
-        rect.width = Math.min(rect.width, w - rect.x);
-        rect.height = Math.min(rect.height, h - rect.y);
-        var iWidth = Math.floor(rect.width);
-        var iHeight = Math.floor(rect.height);
-        var surface = this.sharedCanvas;
-        surface["style"]["width"] = iWidth + "px";
-        surface["style"]["height"] = iHeight + "px";
-        this.sharedCanvas.width = iWidth;
-        this.sharedCanvas.height = iHeight;
-        if (egret.Capabilities.renderMode == "webgl") {
-            var renderTexture = void 0;
-            if (!texture.$renderBuffer) {
-                if (egret.sys.systemRenderer["renderClear"]) {
-                    egret.sys.systemRenderer["renderClear"]();
+        TextureUtils.convertImageToCanvas = function (texture, rect) {
+            if (!this.sharedCanvas) {
+                this.sharedCanvas = egret.sys.createCanvas();
+                this.sharedContext = this.sharedCanvas.getContext("2d");
+            }
+            var w = texture.$getTextureWidth();
+            var h = texture.$getTextureHeight();
+            if (!rect) {
+                rect = egret.$TempRectangle;
+                rect.x = 0;
+                rect.y = 0;
+                rect.width = w;
+                rect.height = h;
+            }
+            rect.x = Math.min(rect.x, w - 1);
+            rect.y = Math.min(rect.y, h - 1);
+            rect.width = Math.min(rect.width, w - rect.x);
+            rect.height = Math.min(rect.height, h - rect.y);
+            var iWidth = Math.floor(rect.width);
+            var iHeight = Math.floor(rect.height);
+            var surface = this.sharedCanvas;
+            surface["style"]["width"] = iWidth + "px";
+            surface["style"]["height"] = iHeight + "px";
+            this.sharedCanvas.width = iWidth;
+            this.sharedCanvas.height = iHeight;
+            if (egret.Capabilities.renderMode == "webgl") {
+                var renderTexture = void 0;
+                if (!texture.$renderBuffer) {
+                    if (egret.sys.systemRenderer["renderClear"]) {
+                        egret.sys.systemRenderer["renderClear"]();
+                    }
+                    renderTexture = new egret.RenderTexture();
+                    renderTexture.drawToTexture(new egret.Bitmap(texture));
                 }
-                renderTexture = new egret.RenderTexture();
-                renderTexture.drawToTexture(new egret.Bitmap(texture));
+                else {
+                    renderTexture = texture;
+                }
+                var pixels = renderTexture.$renderBuffer.getPixels(rect.x, rect.y, iWidth, iHeight);
+                var x = 0;
+                var y = 0;
+                for (var i = 0; i < pixels.length; i += 4) {
+                    this.sharedContext.fillStyle =
+                        'rgba(' + pixels[i]
+                            + ',' + pixels[i + 1]
+                            + ',' + pixels[i + 2]
+                            + ',' + (pixels[i + 3] / 255) + ')';
+                    this.sharedContext.fillRect(x, y, 1, 1);
+                    x++;
+                    if (x == iWidth) {
+                        x = 0;
+                        y++;
+                    }
+                }
+                if (!texture.$renderBuffer) {
+                    renderTexture.dispose();
+                }
+                return surface;
             }
             else {
-                renderTexture = texture;
+                var bitmapData = texture;
+                var offsetX = Math.round(bitmapData.$offsetX);
+                var offsetY = Math.round(bitmapData.$offsetY);
+                var bitmapWidth = bitmapData.$bitmapWidth;
+                var bitmapHeight = bitmapData.$bitmapHeight;
+                var $TextureScaleFactor = es.SceneManager.stage.textureScaleFactor;
+                this.sharedContext.drawImage(bitmapData.$bitmapData.source, bitmapData.$bitmapX + rect.x / $TextureScaleFactor, bitmapData.$bitmapY + rect.y / $TextureScaleFactor, bitmapWidth * rect.width / w, bitmapHeight * rect.height / h, offsetX, offsetY, rect.width, rect.height);
+                return surface;
             }
-            var pixels = renderTexture.$renderBuffer.getPixels(rect.x, rect.y, iWidth, iHeight);
-            var x = 0;
-            var y = 0;
-            for (var i = 0; i < pixels.length; i += 4) {
-                this.sharedContext.fillStyle =
-                    'rgba(' + pixels[i]
-                        + ',' + pixels[i + 1]
-                        + ',' + pixels[i + 2]
-                        + ',' + (pixels[i + 3] / 255) + ')';
-                this.sharedContext.fillRect(x, y, 1, 1);
-                x++;
-                if (x == iWidth) {
-                    x = 0;
-                    y++;
-                }
+        };
+        TextureUtils.toDataURL = function (type, texture, rect, encoderOptions) {
+            try {
+                var surface = this.convertImageToCanvas(texture, rect);
+                var result = surface.toDataURL(type, encoderOptions);
+                return result;
             }
-            if (!texture.$renderBuffer) {
-                renderTexture.dispose();
+            catch (e) {
+                egret.$error(1033);
             }
-            return surface;
-        }
-        else {
-            var bitmapData = texture;
-            var offsetX = Math.round(bitmapData.$offsetX);
-            var offsetY = Math.round(bitmapData.$offsetY);
-            var bitmapWidth = bitmapData.$bitmapWidth;
-            var bitmapHeight = bitmapData.$bitmapHeight;
-            var $TextureScaleFactor = SceneManager.stage.textureScaleFactor;
-            this.sharedContext.drawImage(bitmapData.$bitmapData.source, bitmapData.$bitmapX + rect.x / $TextureScaleFactor, bitmapData.$bitmapY + rect.y / $TextureScaleFactor, bitmapWidth * rect.width / w, bitmapHeight * rect.height / h, offsetX, offsetY, rect.width, rect.height);
-            return surface;
-        }
-    };
-    TextureUtils.toDataURL = function (type, texture, rect, encoderOptions) {
-        try {
+            return null;
+        };
+        TextureUtils.eliFoTevas = function (type, texture, filePath, rect, encoderOptions) {
             var surface = this.convertImageToCanvas(texture, rect);
-            var result = surface.toDataURL(type, encoderOptions);
+            var result = surface.toTempFilePathSync({
+                fileType: type.indexOf("png") >= 0 ? "png" : "jpg"
+            });
+            wx.getFileSystemManager().saveFile({
+                tempFilePath: result,
+                filePath: wx.env.USER_DATA_PATH + "/" + filePath,
+                success: function (res) {
+                }
+            });
             return result;
-        }
-        catch (e) {
-            egret.$error(1033);
-        }
-        return null;
-    };
-    TextureUtils.eliFoTevas = function (type, texture, filePath, rect, encoderOptions) {
-        var surface = this.convertImageToCanvas(texture, rect);
-        var result = surface.toTempFilePathSync({
-            fileType: type.indexOf("png") >= 0 ? "png" : "jpg"
-        });
-        wx.getFileSystemManager().saveFile({
-            tempFilePath: result,
-            filePath: wx.env.USER_DATA_PATH + "/" + filePath,
-            success: function (res) {
+        };
+        TextureUtils.getPixel32 = function (texture, x, y) {
+            egret.$warn(1041, "getPixel32", "getPixels");
+            return texture.getPixels(x, y);
+        };
+        TextureUtils.getPixels = function (texture, x, y, width, height) {
+            if (width === void 0) { width = 1; }
+            if (height === void 0) { height = 1; }
+            if (egret.Capabilities.renderMode == "webgl") {
+                var renderTexture = void 0;
+                if (!texture.$renderBuffer) {
+                    renderTexture = new egret.RenderTexture();
+                    renderTexture.drawToTexture(new egret.Bitmap(texture));
+                }
+                else {
+                    renderTexture = texture;
+                }
+                var pixels = renderTexture.$renderBuffer.getPixels(x, y, width, height);
+                return pixels;
             }
-        });
-        return result;
-    };
-    TextureUtils.getPixel32 = function (texture, x, y) {
-        egret.$warn(1041, "getPixel32", "getPixels");
-        return texture.getPixels(x, y);
-    };
-    TextureUtils.getPixels = function (texture, x, y, width, height) {
-        if (width === void 0) { width = 1; }
-        if (height === void 0) { height = 1; }
-        if (egret.Capabilities.renderMode == "webgl") {
-            var renderTexture = void 0;
-            if (!texture.$renderBuffer) {
-                renderTexture = new egret.RenderTexture();
-                renderTexture.drawToTexture(new egret.Bitmap(texture));
+            try {
+                var surface = this.convertImageToCanvas(texture);
+                var result = this.sharedContext.getImageData(x, y, width, height).data;
+                return result;
             }
-            else {
-                renderTexture = texture;
+            catch (e) {
+                egret.$error(1039);
             }
-            var pixels = renderTexture.$renderBuffer.getPixels(x, y, width, height);
-            return pixels;
+        };
+        return TextureUtils;
+    }());
+    es.TextureUtils = TextureUtils;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Time = (function () {
+        function Time() {
         }
-        try {
-            var surface = this.convertImageToCanvas(texture);
-            var result = this.sharedContext.getImageData(x, y, width, height).data;
-            return result;
-        }
-        catch (e) {
-            egret.$error(1039);
-        }
-    };
-    return TextureUtils;
-}());
-var Time = (function () {
-    function Time() {
-    }
-    Time.update = function (currentTime) {
-        var dt = (currentTime - this._lastTime) / 1000;
-        this.deltaTime = dt * this.timeScale;
-        this.unscaledDeltaTime = dt;
-        this._timeSinceSceneLoad += dt;
-        this.frameCount++;
-        this._lastTime = currentTime;
-    };
-    Time.sceneChanged = function () {
-        this._timeSinceSceneLoad = 0;
-    };
-    Time.checkEvery = function (interval) {
-        return (this._timeSinceSceneLoad / interval) > ((this._timeSinceSceneLoad - this.deltaTime) / interval);
-    };
-    Time.deltaTime = 0;
-    Time.timeScale = 1;
-    Time.frameCount = 0;
-    Time._lastTime = 0;
-    return Time;
-}());
+        Time.update = function (currentTime) {
+            var dt = (currentTime - this._lastTime) / 1000;
+            this.deltaTime = dt * this.timeScale;
+            this.unscaledDeltaTime = dt;
+            this._timeSinceSceneLoad += dt;
+            this.frameCount++;
+            this._lastTime = currentTime;
+        };
+        Time.sceneChanged = function () {
+            this._timeSinceSceneLoad = 0;
+        };
+        Time.checkEvery = function (interval) {
+            return (this._timeSinceSceneLoad / interval) > ((this._timeSinceSceneLoad - this.deltaTime) / interval);
+        };
+        Time.deltaTime = 0;
+        Time.timeScale = 1;
+        Time.frameCount = 0;
+        Time._lastTime = 0;
+        return Time;
+    }());
+    es.Time = Time;
+})(es || (es = {}));
 var TimeUtils = (function () {
     function TimeUtils() {
     }
@@ -3532,405 +4116,143 @@ var TimeUtils = (function () {
     };
     return TimeUtils;
 }());
-var GraphicsCapabilities = (function (_super) {
-    __extends(GraphicsCapabilities, _super);
-    function GraphicsCapabilities() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    GraphicsCapabilities.prototype.initialize = function (device) {
-        this.platformInitialize(device);
-    };
-    GraphicsCapabilities.prototype.platformInitialize = function (device) {
-        var capabilities = this;
-        capabilities["isMobile"] = true;
-        var systemInfo = wx.getSystemInfoSync();
-        var systemStr = systemInfo.system.toLowerCase();
-        if (systemStr.indexOf("ios") > -1) {
-            capabilities["os"] = "iOS";
+var es;
+(function (es) {
+    var GraphicsCapabilities = (function (_super) {
+        __extends(GraphicsCapabilities, _super);
+        function GraphicsCapabilities() {
+            return _super !== null && _super.apply(this, arguments) || this;
         }
-        else if (systemStr.indexOf("android") > -1) {
-            capabilities["os"] = "Android";
-        }
-        var language = systemInfo.language;
-        if (language.indexOf('zh') > -1) {
-            language = "zh-CN";
-        }
-        else {
-            language = "en-US";
-        }
-        capabilities["language"] = language;
-    };
-    return GraphicsCapabilities;
-}(egret.Capabilities));
-var GraphicsDevice = (function () {
-    function GraphicsDevice() {
-        this.graphicsCapabilities = new GraphicsCapabilities();
-        this.graphicsCapabilities.initialize(this);
-    }
-    return GraphicsDevice;
-}());
-var Viewport = (function () {
-    function Viewport(x, y, width, height) {
-        this._x = x;
-        this._y = y;
-        this._width = width;
-        this._height = height;
-        this._minDepth = 0;
-        this._maxDepth = 1;
-    }
-    Object.defineProperty(Viewport.prototype, "aspectRatio", {
-        get: function () {
-            if ((this._height != 0) && (this._width != 0))
-                return (this._width / this._height);
-            return 0;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Viewport.prototype, "bounds", {
-        get: function () {
-            return new Rectangle(this._x, this._y, this._width, this._height);
-        },
-        set: function (value) {
-            this._x = value.x;
-            this._y = value.y;
-            this._width = value.width;
-            this._height = value.height;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    return Viewport;
-}());
-var GaussianBlurEffect = (function (_super) {
-    __extends(GaussianBlurEffect, _super);
-    function GaussianBlurEffect() {
-        return _super.call(this, PostProcessor.default_vert, GaussianBlurEffect.blur_frag, {
-            screenWidth: SceneManager.stage.stageWidth,
-            screenHeight: SceneManager.stage.stageHeight
-        }) || this;
-    }
-    GaussianBlurEffect.blur_frag = "precision mediump float;\n" +
-        "uniform sampler2D uSampler;\n" +
-        "uniform float screenWidth;\n" +
-        "uniform float screenHeight;\n" +
-        "float normpdf(in float x, in float sigma)\n" +
-        "{\n" +
-        "return 0.39894*exp(-0.5*x*x/(sigma*sigma))/sigma;\n" +
-        "}\n" +
-        "void main()\n" +
-        "{\n" +
-        "vec3 c = texture2D(uSampler, gl_FragCoord.xy / vec2(screenWidth, screenHeight).xy).rgb;\n" +
-        "const int mSize = 11;\n" +
-        "const int kSize = (mSize - 1)/2;\n" +
-        "float kernel[mSize];\n" +
-        "vec3 final_colour = vec3(0.0);\n" +
-        "float sigma = 7.0;\n" +
-        "float z = 0.0;\n" +
-        "for (int j = 0; j <= kSize; ++j)\n" +
-        "{\n" +
-        "kernel[kSize+j] = kernel[kSize-j] = normpdf(float(j),sigma);\n" +
-        "}\n" +
-        "for (int j = 0; j < mSize; ++j)\n" +
-        "{\n" +
-        "z += kernel[j];\n" +
-        "}\n" +
-        "for (int i = -kSize; i <= kSize; ++i)\n" +
-        "{\n" +
-        "for (int j = -kSize; j <= kSize; ++j)\n" +
-        "{\n" +
-        "final_colour += kernel[kSize+j]*kernel[kSize+i]*texture2D(uSampler, (gl_FragCoord.xy+vec2(float(i),float(j))) / vec2(screenWidth, screenHeight).xy).rgb;\n" +
-        "}\n}\n" +
-        "gl_FragColor = vec4(final_colour/(z*z), 1.0);\n" +
-        "}";
-    return GaussianBlurEffect;
-}(egret.CustomFilter));
-var PolygonLightEffect = (function (_super) {
-    __extends(PolygonLightEffect, _super);
-    function PolygonLightEffect() {
-        return _super.call(this, PolygonLightEffect.vertSrc, PolygonLightEffect.fragmentSrc) || this;
-    }
-    PolygonLightEffect.vertSrc = "attribute vec2 aVertexPosition;\n" +
-        "attribute vec2 aTextureCoord;\n" +
-        "uniform vec2 projectionVector;\n" +
-        "varying vec2 vTextureCoord;\n" +
-        "const vec2 center = vec2(-1.0, 1.0);\n" +
-        "void main(void) {\n" +
-        "   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n" +
-        "   vTextureCoord = aTextureCoord;\n" +
-        "}";
-    PolygonLightEffect.fragmentSrc = "precision lowp float;\n" +
-        "varying vec2 vTextureCoord;\n" +
-        "uniform sampler2D uSampler;\n" +
-        "#define SAMPLE_COUNT 15\n" +
-        "uniform vec2 _sampleOffsets[SAMPLE_COUNT];\n" +
-        "uniform float _sampleWeights[SAMPLE_COUNT];\n" +
-        "void main(void) {\n" +
-        "vec4 c = vec4(0, 0, 0, 0);\n" +
-        "for( int i = 0; i < SAMPLE_COUNT; i++ )\n" +
-        "   c += texture2D( uSampler, vTextureCoord + _sampleOffsets[i] ) * _sampleWeights[i];\n" +
-        "gl_FragColor = c;\n" +
-        "}";
-    return PolygonLightEffect;
-}(egret.CustomFilter));
-var PostProcessor = (function () {
-    function PostProcessor(effect) {
-        if (effect === void 0) { effect = null; }
-        this.enable = true;
-        this.effect = effect;
-    }
-    PostProcessor.prototype.onAddedToScene = function (scene) {
-        this.scene = scene;
-        this.shape = new egret.Shape();
-        this.shape.graphics.beginFill(0xFFFFFF, 1);
-        this.shape.graphics.drawRect(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-        this.shape.graphics.endFill();
-        scene.addChild(this.shape);
-    };
-    PostProcessor.prototype.process = function () {
-        this.drawFullscreenQuad();
-    };
-    PostProcessor.prototype.onSceneBackBufferSizeChanged = function (newWidth, newHeight) { };
-    PostProcessor.prototype.drawFullscreenQuad = function () {
-        this.scene.filters = [this.effect];
-    };
-    PostProcessor.prototype.unload = function () {
-        if (this.effect) {
-            this.effect = null;
-        }
-        this.scene.removeChild(this.shape);
-        this.scene = null;
-    };
-    PostProcessor.default_vert = "attribute vec2 aVertexPosition;\n" +
-        "attribute vec2 aTextureCoord;\n" +
-        "attribute vec2 aColor;\n" +
-        "uniform vec2 projectionVector;\n" +
-        "varying vec2 vTextureCoord;\n" +
-        "varying vec4 vColor;\n" +
-        "const vec2 center = vec2(-1.0, 1.0);\n" +
-        "void main(void) {\n" +
-        "gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n" +
-        "vTextureCoord = aTextureCoord;\n" +
-        "vColor = vec4(aColor.x, aColor.x, aColor.x, aColor.x);\n" +
-        "}";
-    return PostProcessor;
-}());
-var GaussianBlurPostProcessor = (function (_super) {
-    __extends(GaussianBlurPostProcessor, _super);
-    function GaussianBlurPostProcessor() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    GaussianBlurPostProcessor.prototype.onAddedToScene = function (scene) {
-        _super.prototype.onAddedToScene.call(this, scene);
-        this.effect = new GaussianBlurEffect();
-    };
-    return GaussianBlurPostProcessor;
-}(PostProcessor));
-var Renderer = (function () {
-    function Renderer() {
-    }
-    Renderer.prototype.onAddedToScene = function (scene) { };
-    Renderer.prototype.beginRender = function (cam) {
-    };
-    Renderer.prototype.unload = function () { };
-    Renderer.prototype.renderAfterStateCheck = function (renderable, cam) {
-        renderable.render(cam);
-    };
-    return Renderer;
-}());
-var DefaultRenderer = (function (_super) {
-    __extends(DefaultRenderer, _super);
-    function DefaultRenderer() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    DefaultRenderer.prototype.render = function (scene) {
-        var cam = this.camera ? this.camera : scene.camera;
-        this.beginRender(cam);
-        for (var i = 0; i < scene.renderableComponents.count; i++) {
-            var renderable = scene.renderableComponents.buffer[i];
-            if (renderable.enabled && renderable.isVisibleFromCamera(cam))
-                this.renderAfterStateCheck(renderable, cam);
-        }
-    };
-    return DefaultRenderer;
-}(Renderer));
-var ScreenSpaceRenderer = (function (_super) {
-    __extends(ScreenSpaceRenderer, _super);
-    function ScreenSpaceRenderer() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ScreenSpaceRenderer.prototype.render = function (scene) {
-    };
-    return ScreenSpaceRenderer;
-}(Renderer));
-var PolyLight = (function (_super) {
-    __extends(PolyLight, _super);
-    function PolyLight(radius, color, power) {
-        var _this = _super.call(this) || this;
-        _this._indices = [];
-        _this.radius = radius;
-        _this.power = power;
-        _this.color = color;
-        _this.computeTriangleIndices();
-        return _this;
-    }
-    Object.defineProperty(PolyLight.prototype, "radius", {
-        get: function () {
-            return this._radius;
-        },
-        set: function (value) {
-            this.setRadius(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    PolyLight.prototype.computeTriangleIndices = function (totalTris) {
-        if (totalTris === void 0) { totalTris = 20; }
-        this._indices.length = 0;
-        for (var i = 0; i < totalTris; i += 2) {
-            this._indices.push(0);
-            this._indices.push(i + 2);
-            this._indices.push(i + 1);
-        }
-    };
-    PolyLight.prototype.setRadius = function (radius) {
-        if (radius != this._radius) {
-            this._radius = radius;
-            this._areBoundsDirty = true;
-        }
-    };
-    PolyLight.prototype.render = function (camera) {
-    };
-    PolyLight.prototype.reset = function () {
-    };
-    return PolyLight;
-}(RenderableComponent));
-var SceneTransition = (function () {
-    function SceneTransition(sceneLoadAction) {
-        this.sceneLoadAction = sceneLoadAction;
-        this.loadsNewScene = sceneLoadAction != null;
-    }
-    Object.defineProperty(SceneTransition.prototype, "hasPreviousSceneRender", {
-        get: function () {
-            if (!this._hasPreviousSceneRender) {
-                this._hasPreviousSceneRender = true;
-                return false;
+        GraphicsCapabilities.prototype.initialize = function (device) {
+            this.platformInitialize(device);
+        };
+        GraphicsCapabilities.prototype.platformInitialize = function (device) {
+            var capabilities = this;
+            capabilities["isMobile"] = true;
+            var systemInfo = wx.getSystemInfoSync();
+            var systemStr = systemInfo.system.toLowerCase();
+            if (systemStr.indexOf("ios") > -1) {
+                capabilities["os"] = "iOS";
             }
-            return true;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    SceneTransition.prototype.preRender = function () { };
-    SceneTransition.prototype.render = function () {
-    };
-    SceneTransition.prototype.onBeginTransition = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4, this.loadNextScene()];
-                    case 1:
-                        _a.sent();
-                        this.transitionComplete();
-                        return [2];
-                }
-            });
-        });
-    };
-    SceneTransition.prototype.transitionComplete = function () {
-        SceneManager.sceneTransition = null;
-        if (this.onTransitionCompleted) {
-            this.onTransitionCompleted();
+            else if (systemStr.indexOf("android") > -1) {
+                capabilities["os"] = "Android";
+            }
+            var language = systemInfo.language;
+            if (language.indexOf('zh') > -1) {
+                language = "zh-CN";
+            }
+            else {
+                language = "en-US";
+            }
+            capabilities["language"] = language;
+        };
+        return GraphicsCapabilities;
+    }(egret.Capabilities));
+    es.GraphicsCapabilities = GraphicsCapabilities;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var GraphicsDevice = (function () {
+        function GraphicsDevice() {
+            this.graphicsCapabilities = new es.GraphicsCapabilities();
+            this.graphicsCapabilities.initialize(this);
         }
-    };
-    SceneTransition.prototype.loadNextScene = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (this.onScreenObscured)
-                            this.onScreenObscured();
-                        if (!this.loadsNewScene) {
-                            this.isNewSceneLoaded = true;
-                        }
-                        _a = SceneManager;
-                        return [4, this.sceneLoadAction()];
-                    case 1:
-                        _a.scene = _b.sent();
-                        this.isNewSceneLoaded = true;
-                        return [2];
-                }
-            });
+        return GraphicsDevice;
+    }());
+    es.GraphicsDevice = GraphicsDevice;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Viewport = (function () {
+        function Viewport(x, y, width, height) {
+            this._x = x;
+            this._y = y;
+            this._width = width;
+            this._height = height;
+            this._minDepth = 0;
+            this._maxDepth = 1;
+        }
+        Object.defineProperty(Viewport.prototype, "aspectRatio", {
+            get: function () {
+                if ((this._height != 0) && (this._width != 0))
+                    return (this._width / this._height);
+                return 0;
+            },
+            enumerable: true,
+            configurable: true
         });
-    };
-    SceneTransition.prototype.tickEffectProgressProperty = function (filter, duration, easeType, reverseDirection) {
-        if (reverseDirection === void 0) { reverseDirection = false; }
-        return new Promise(function (resolve) {
-            var start = reverseDirection ? 1 : 0;
-            var end = reverseDirection ? 0 : 1;
-            egret.Tween.get(filter.uniforms).set({ _progress: start }).to({ _progress: end }, duration * 1000, easeType).call(function () {
-                resolve();
-            });
+        Object.defineProperty(Viewport.prototype, "bounds", {
+            get: function () {
+                return new es.Rectangle(this._x, this._y, this._width, this._height);
+            },
+            set: function (value) {
+                this._x = value.x;
+                this._y = value.y;
+                this._width = value.width;
+                this._height = value.height;
+            },
+            enumerable: true,
+            configurable: true
         });
-    };
-    return SceneTransition;
-}());
-var FadeTransition = (function (_super) {
-    __extends(FadeTransition, _super);
-    function FadeTransition(sceneLoadAction) {
-        var _this = _super.call(this, sceneLoadAction) || this;
-        _this.fadeToColor = 0x000000;
-        _this.fadeOutDuration = 0.4;
-        _this.fadeEaseType = egret.Ease.quadInOut;
-        _this.delayBeforeFadeInDuration = 0.1;
-        _this._alpha = 0;
-        _this._mask = new egret.Shape();
-        return _this;
-    }
-    FadeTransition.prototype.onBeginTransition = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                this._mask.graphics.beginFill(this.fadeToColor, 1);
-                this._mask.graphics.drawRect(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-                this._mask.graphics.endFill();
-                SceneManager.stage.addChild(this._mask);
-                egret.Tween.get(this).to({ _alpha: 1 }, this.fadeOutDuration * 1000, this.fadeEaseType)
-                    .call(function () { return __awaiter(_this, void 0, void 0, function () {
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0: return [4, this.loadNextScene()];
-                            case 1:
-                                _a.sent();
-                                return [2];
-                        }
-                    });
-                }); }).wait(this.delayBeforeFadeInDuration).call(function () {
-                    egret.Tween.get(_this).to({ _alpha: 0 }, _this.fadeOutDuration * 1000, _this.fadeEaseType).call(function () {
-                        _this.transitionComplete();
-                        SceneManager.stage.removeChild(_this._mask);
-                    });
-                });
-                return [2];
-            });
-        });
-    };
-    FadeTransition.prototype.render = function () {
-        this._mask.graphics.clear();
-        this._mask.graphics.beginFill(this.fadeToColor, this._alpha);
-        this._mask.graphics.drawRect(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-        this._mask.graphics.endFill();
-    };
-    return FadeTransition;
-}(SceneTransition));
-var WindTransition = (function (_super) {
-    __extends(WindTransition, _super);
-    function WindTransition(sceneLoadAction) {
-        var _this = _super.call(this, sceneLoadAction) || this;
-        _this.duration = 1;
-        _this.easeType = egret.Ease.quadOut;
-        var vertexSrc = "attribute vec2 aVertexPosition;\n" +
+        return Viewport;
+    }());
+    es.Viewport = Viewport;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var GaussianBlurEffect = (function (_super) {
+        __extends(GaussianBlurEffect, _super);
+        function GaussianBlurEffect() {
+            return _super.call(this, es.PostProcessor.default_vert, GaussianBlurEffect.blur_frag, {
+                screenWidth: es.SceneManager.stage.stageWidth,
+                screenHeight: es.SceneManager.stage.stageHeight
+            }) || this;
+        }
+        GaussianBlurEffect.blur_frag = "precision mediump float;\n" +
+            "uniform sampler2D uSampler;\n" +
+            "uniform float screenWidth;\n" +
+            "uniform float screenHeight;\n" +
+            "float normpdf(in float x, in float sigma)\n" +
+            "{\n" +
+            "return 0.39894*exp(-0.5*x*x/(sigma*sigma))/sigma;\n" +
+            "}\n" +
+            "void main()\n" +
+            "{\n" +
+            "vec3 c = texture2D(uSampler, gl_FragCoord.xy / vec2(screenWidth, screenHeight).xy).rgb;\n" +
+            "const int mSize = 11;\n" +
+            "const int kSize = (mSize - 1)/2;\n" +
+            "float kernel[mSize];\n" +
+            "vec3 final_colour = vec3(0.0);\n" +
+            "float sigma = 7.0;\n" +
+            "float z = 0.0;\n" +
+            "for (int j = 0; j <= kSize; ++j)\n" +
+            "{\n" +
+            "kernel[kSize+j] = kernel[kSize-j] = normpdf(float(j),sigma);\n" +
+            "}\n" +
+            "for (int j = 0; j < mSize; ++j)\n" +
+            "{\n" +
+            "z += kernel[j];\n" +
+            "}\n" +
+            "for (int i = -kSize; i <= kSize; ++i)\n" +
+            "{\n" +
+            "for (int j = -kSize; j <= kSize; ++j)\n" +
+            "{\n" +
+            "final_colour += kernel[kSize+j]*kernel[kSize+i]*texture2D(uSampler, (gl_FragCoord.xy+vec2(float(i),float(j))) / vec2(screenWidth, screenHeight).xy).rgb;\n" +
+            "}\n}\n" +
+            "gl_FragColor = vec4(final_colour/(z*z), 1.0);\n" +
+            "}";
+        return GaussianBlurEffect;
+    }(egret.CustomFilter));
+    es.GaussianBlurEffect = GaussianBlurEffect;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var PolygonLightEffect = (function (_super) {
+        __extends(PolygonLightEffect, _super);
+        function PolygonLightEffect() {
+            return _super.call(this, PolygonLightEffect.vertSrc, PolygonLightEffect.fragmentSrc) || this;
+        }
+        PolygonLightEffect.vertSrc = "attribute vec2 aVertexPosition;\n" +
             "attribute vec2 aTextureCoord;\n" +
             "uniform vec2 projectionVector;\n" +
             "varying vec2 vTextureCoord;\n" +
@@ -3939,1369 +4261,1761 @@ var WindTransition = (function (_super) {
             "   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n" +
             "   vTextureCoord = aTextureCoord;\n" +
             "}";
-        var fragmentSrc = "precision lowp float;\n" +
+        PolygonLightEffect.fragmentSrc = "precision lowp float;\n" +
             "varying vec2 vTextureCoord;\n" +
             "uniform sampler2D uSampler;\n" +
-            "uniform float _progress;\n" +
-            "uniform float _size;\n" +
-            "uniform float _windSegments;\n" +
+            "#define SAMPLE_COUNT 15\n" +
+            "uniform vec2 _sampleOffsets[SAMPLE_COUNT];\n" +
+            "uniform float _sampleWeights[SAMPLE_COUNT];\n" +
             "void main(void) {\n" +
-            "vec2 co = floor(vec2(0.0, vTextureCoord.y * _windSegments));\n" +
-            "float x = sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453;\n" +
-            "float r = x - floor(x);\n" +
-            "float m = smoothstep(0.0, -_size, vTextureCoord.x * (1.0 - _size) + _size * r - (_progress * (1.0 + _size)));\n" +
-            "vec4 fg = texture2D(uSampler, vTextureCoord);\n" +
-            "gl_FragColor = mix(fg, vec4(0, 0, 0, 0), m);\n" +
+            "vec4 c = vec4(0, 0, 0, 0);\n" +
+            "for( int i = 0; i < SAMPLE_COUNT; i++ )\n" +
+            "   c += texture2D( uSampler, vTextureCoord + _sampleOffsets[i] ) * _sampleWeights[i];\n" +
+            "gl_FragColor = c;\n" +
             "}";
-        _this._windEffect = new egret.CustomFilter(vertexSrc, fragmentSrc, {
-            _progress: 0,
-            _size: 0.3,
-            _windSegments: 100
-        });
-        _this._mask = new egret.Shape();
-        _this._mask.graphics.beginFill(0xFFFFFF, 1);
-        _this._mask.graphics.drawRect(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-        _this._mask.graphics.endFill();
-        _this._mask.filters = [_this._windEffect];
-        SceneManager.stage.addChild(_this._mask);
-        return _this;
-    }
-    Object.defineProperty(WindTransition.prototype, "windSegments", {
-        set: function (value) {
-            this._windEffect.uniforms._windSegments = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(WindTransition.prototype, "size", {
-        set: function (value) {
-            this._windEffect.uniforms._size = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    WindTransition.prototype.onBeginTransition = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.loadNextScene();
-                        return [4, this.tickEffectProgressProperty(this._windEffect, this.duration, this.easeType)];
-                    case 1:
-                        _a.sent();
-                        this.transitionComplete();
-                        SceneManager.stage.removeChild(this._mask);
-                        return [2];
-                }
-            });
-        });
-    };
-    return WindTransition;
-}(SceneTransition));
-var Bezier = (function () {
-    function Bezier() {
-    }
-    Bezier.getPoint = function (p0, p1, p2, t) {
-        t = MathHelper.clamp01(t);
-        var oneMinusT = 1 - t;
-        return Vector2.add(Vector2.add(Vector2.multiply(new Vector2(oneMinusT * oneMinusT), p0), Vector2.multiply(new Vector2(2 * oneMinusT * t), p1)), Vector2.multiply(new Vector2(t * t), p2));
-    };
-    Bezier.getFirstDerivative = function (p0, p1, p2, t) {
-        return Vector2.add(Vector2.multiply(new Vector2(2 * (1 - t)), Vector2.subtract(p1, p0)), Vector2.multiply(new Vector2(2 * t), Vector2.subtract(p2, p1)));
-    };
-    Bezier.getFirstDerivativeThree = function (start, firstControlPoint, secondControlPoint, end, t) {
-        t = MathHelper.clamp01(t);
-        var oneMunusT = 1 - t;
-        return Vector2.add(Vector2.add(Vector2.multiply(new Vector2(3 * oneMunusT * oneMunusT), Vector2.subtract(firstControlPoint, start)), Vector2.multiply(new Vector2(6 * oneMunusT * t), Vector2.subtract(secondControlPoint, firstControlPoint))), Vector2.multiply(new Vector2(3 * t * t), Vector2.subtract(end, secondControlPoint)));
-    };
-    Bezier.getPointThree = function (start, firstControlPoint, secondControlPoint, end, t) {
-        t = MathHelper.clamp01(t);
-        var oneMunusT = 1 - t;
-        return Vector2.add(Vector2.add(Vector2.add(Vector2.multiply(new Vector2(oneMunusT * oneMunusT * oneMunusT), start), Vector2.multiply(new Vector2(3 * oneMunusT * oneMunusT * t), firstControlPoint)), Vector2.multiply(new Vector2(3 * oneMunusT * t * t), secondControlPoint)), Vector2.multiply(new Vector2(t * t * t), end));
-    };
-    Bezier.getOptimizedDrawingPoints = function (start, firstCtrlPoint, secondCtrlPoint, end, distanceTolerance) {
-        if (distanceTolerance === void 0) { distanceTolerance = 1; }
-        var points = ListPool.obtain();
-        points.push(start);
-        this.recursiveGetOptimizedDrawingPoints(start, firstCtrlPoint, secondCtrlPoint, end, points, distanceTolerance);
-        points.push(end);
-        return points;
-    };
-    Bezier.recursiveGetOptimizedDrawingPoints = function (start, firstCtrlPoint, secondCtrlPoint, end, points, distanceTolerance) {
-        var pt12 = Vector2.divide(Vector2.add(start, firstCtrlPoint), new Vector2(2));
-        var pt23 = Vector2.divide(Vector2.add(firstCtrlPoint, secondCtrlPoint), new Vector2(2));
-        var pt34 = Vector2.divide(Vector2.add(secondCtrlPoint, end), new Vector2(2));
-        var pt123 = Vector2.divide(Vector2.add(pt12, pt23), new Vector2(2));
-        var pt234 = Vector2.divide(Vector2.add(pt23, pt34), new Vector2(2));
-        var pt1234 = Vector2.divide(Vector2.add(pt123, pt234), new Vector2(2));
-        var deltaLine = Vector2.subtract(end, start);
-        var d2 = Math.abs(((firstCtrlPoint.x, end.x) * deltaLine.y - (firstCtrlPoint.y - end.y) * deltaLine.x));
-        var d3 = Math.abs(((secondCtrlPoint.x - end.x) * deltaLine.y - (secondCtrlPoint.y - end.y) * deltaLine.x));
-        if ((d2 + d3) * (d2 + d3) < distanceTolerance * (deltaLine.x * deltaLine.x + deltaLine.y * deltaLine.y)) {
-            points.push(pt1234);
-            return;
+        return PolygonLightEffect;
+    }(egret.CustomFilter));
+    es.PolygonLightEffect = PolygonLightEffect;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var PostProcessor = (function () {
+        function PostProcessor(effect) {
+            if (effect === void 0) { effect = null; }
+            this.enabled = true;
+            this.effect = effect;
         }
-        this.recursiveGetOptimizedDrawingPoints(start, pt12, pt123, pt1234, points, distanceTolerance);
-        this.recursiveGetOptimizedDrawingPoints(pt1234, pt234, pt34, end, points, distanceTolerance);
-    };
-    return Bezier;
-}());
-var Flags = (function () {
-    function Flags() {
-    }
-    Flags.isFlagSet = function (self, flag) {
-        return (self & flag) != 0;
-    };
-    Flags.isUnshiftedFlagSet = function (self, flag) {
-        flag = 1 << flag;
-        return (self & flag) != 0;
-    };
-    Flags.setFlagExclusive = function (self, flag) {
-        return 1 << flag;
-    };
-    Flags.setFlag = function (self, flag) {
-        return (self | 1 << flag);
-    };
-    Flags.unsetFlag = function (self, flag) {
-        flag = 1 << flag;
-        return (self & (~flag));
-    };
-    Flags.invertFlags = function (self) {
-        return ~self;
-    };
-    return Flags;
-}());
-var MathHelper = (function () {
-    function MathHelper() {
-    }
-    MathHelper.toDegrees = function (radians) {
-        return radians * 57.295779513082320876798154814105;
-    };
-    MathHelper.toRadians = function (degrees) {
-        return degrees * 0.017453292519943295769236907684886;
-    };
-    MathHelper.map = function (value, leftMin, leftMax, rightMin, rightMax) {
-        return rightMin + (value - leftMin) * (rightMax - rightMin) / (leftMax - leftMin);
-    };
-    MathHelper.lerp = function (value1, value2, amount) {
-        return value1 + (value2 - value1) * amount;
-    };
-    MathHelper.clamp = function (value, min, max) {
-        if (value < min)
-            return min;
-        if (value > max)
-            return max;
-        return value;
-    };
-    MathHelper.pointOnCirlce = function (circleCenter, radius, angleInDegrees) {
-        var radians = MathHelper.toRadians(angleInDegrees);
-        return new Vector2(Math.cos(radians) * radians + circleCenter.x, Math.sin(radians) * radians + circleCenter.y);
-    };
-    MathHelper.isEven = function (value) {
-        return value % 2 == 0;
-    };
-    MathHelper.clamp01 = function (value) {
-        if (value < 0)
-            return 0;
-        if (value > 1)
-            return 1;
-        return value;
-    };
-    MathHelper.angleBetweenVectors = function (from, to) {
-        return Math.atan2(to.y - from.y, to.x - from.x);
-    };
-    MathHelper.Epsilon = 0.00001;
-    MathHelper.Rad2Deg = 57.29578;
-    MathHelper.Deg2Rad = 0.0174532924;
-    return MathHelper;
-}());
-var Matrix2D = (function () {
-    function Matrix2D(m11, m12, m21, m22, m31, m32) {
-        this.m11 = 0;
-        this.m12 = 0;
-        this.m21 = 0;
-        this.m22 = 0;
-        this.m31 = 0;
-        this.m32 = 0;
-        this.m11 = m11 ? m11 : 1;
-        this.m12 = m12 ? m12 : 0;
-        this.m21 = m21 ? m21 : 0;
-        this.m22 = m22 ? m22 : 1;
-        this.m31 = m31 ? m31 : 0;
-        this.m32 = m32 ? m32 : 0;
-    }
-    Object.defineProperty(Matrix2D, "identity", {
-        get: function () {
-            return Matrix2D._identity;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Matrix2D.prototype, "translation", {
-        get: function () {
-            return new Vector2(this.m31, this.m32);
-        },
-        set: function (value) {
-            this.m31 = value.x;
-            this.m32 = value.y;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Matrix2D.prototype, "rotation", {
-        get: function () {
-            return Math.atan2(this.m21, this.m11);
-        },
-        set: function (value) {
-            var val1 = Math.cos(value);
-            var val2 = Math.sin(value);
-            this.m11 = val1;
-            this.m12 = val2;
-            this.m21 = -val2;
-            this.m22 = val1;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Matrix2D.prototype, "rotationDegrees", {
-        get: function () {
-            return MathHelper.toDegrees(this.rotation);
-        },
-        set: function (value) {
-            this.rotation = MathHelper.toRadians(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Matrix2D.prototype, "scale", {
-        get: function () {
-            return new Vector2(this.m11, this.m22);
-        },
-        set: function (value) {
-            this.m11 = value.x;
-            this.m12 = value.y;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Matrix2D.add = function (matrix1, matrix2) {
-        matrix1.m11 += matrix2.m11;
-        matrix1.m12 += matrix2.m12;
-        matrix1.m21 += matrix2.m21;
-        matrix1.m22 += matrix2.m22;
-        matrix1.m31 += matrix2.m31;
-        matrix1.m32 += matrix2.m32;
-        return matrix1;
-    };
-    Matrix2D.divide = function (matrix1, matrix2) {
-        matrix1.m11 /= matrix2.m11;
-        matrix1.m12 /= matrix2.m12;
-        matrix1.m21 /= matrix2.m21;
-        matrix1.m22 /= matrix2.m22;
-        matrix1.m31 /= matrix2.m31;
-        matrix1.m32 /= matrix2.m32;
-        return matrix1;
-    };
-    Matrix2D.multiply = function (matrix1, matrix2) {
-        var result = new Matrix2D();
-        var m11 = (matrix1.m11 * matrix2.m11) + (matrix1.m12 * matrix2.m21);
-        var m12 = (matrix1.m11 * matrix2.m12) + (matrix1.m12 * matrix2.m22);
-        var m21 = (matrix1.m21 * matrix2.m11) + (matrix1.m22 * matrix2.m21);
-        var m22 = (matrix1.m21 * matrix2.m12) + (matrix1.m22 * matrix2.m22);
-        var m31 = (matrix1.m31 * matrix2.m11) + (matrix1.m32 * matrix2.m21) + matrix2.m31;
-        var m32 = (matrix1.m31 * matrix2.m12) + (matrix1.m32 * matrix2.m22) + matrix2.m32;
-        result.m11 = m11;
-        result.m12 = m12;
-        result.m21 = m21;
-        result.m22 = m22;
-        result.m31 = m31;
-        result.m32 = m32;
-        return result;
-    };
-    Matrix2D.multiplyTranslation = function (matrix, x, y) {
-        var trans = Matrix2D.createTranslation(x, y);
-        return Matrix2D.multiply(matrix, trans);
-    };
-    Matrix2D.prototype.determinant = function () {
-        return this.m11 * this.m22 - this.m12 * this.m21;
-    };
-    Matrix2D.invert = function (matrix, result) {
-        if (result === void 0) { result = new Matrix2D(); }
-        var det = 1 / matrix.determinant();
-        result.m11 = matrix.m22 * det;
-        result.m12 = -matrix.m12 * det;
-        result.m21 = -matrix.m21 * det;
-        result.m22 = matrix.m11 * det;
-        result.m31 = (matrix.m32 * matrix.m21 - matrix.m31 * matrix.m22) * det;
-        result.m32 = -(matrix.m32 * matrix.m11 - matrix.m31 * matrix.m12) * det;
-        return result;
-    };
-    Matrix2D.createTranslation = function (xPosition, yPosition) {
-        var result = new Matrix2D();
-        result.m11 = 1;
-        result.m12 = 0;
-        result.m21 = 0;
-        result.m22 = 1;
-        result.m31 = xPosition;
-        result.m32 = yPosition;
-        return result;
-    };
-    Matrix2D.createTranslationVector = function (position) {
-        return this.createTranslation(position.x, position.y);
-    };
-    Matrix2D.createRotation = function (radians, result) {
-        result = new Matrix2D();
-        var val1 = Math.cos(radians);
-        var val2 = Math.sin(radians);
-        result.m11 = val1;
-        result.m12 = val2;
-        result.m21 = -val2;
-        result.m22 = val1;
-        return result;
-    };
-    Matrix2D.createScale = function (xScale, yScale, result) {
-        if (result === void 0) { result = new Matrix2D(); }
-        result.m11 = xScale;
-        result.m12 = 0;
-        result.m21 = 0;
-        result.m22 = yScale;
-        result.m31 = 0;
-        result.m32 = 0;
-        return result;
-    };
-    Matrix2D.prototype.toEgretMatrix = function () {
-        var matrix = new egret.Matrix(this.m11, this.m12, this.m21, this.m22, this.m31, this.m32);
-        return matrix;
-    };
-    Matrix2D._identity = new Matrix2D(1, 0, 0, 1, 0, 0);
-    return Matrix2D;
-}());
-var Rectangle = (function (_super) {
-    __extends(Rectangle, _super);
-    function Rectangle() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Object.defineProperty(Rectangle.prototype, "max", {
-        get: function () {
-            return new Vector2(this.right, this.bottom);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Rectangle.prototype, "center", {
-        get: function () {
-            return new Vector2(this.x + (this.width / 2), this.y + (this.height / 2));
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Rectangle.prototype, "location", {
-        get: function () {
-            return new Vector2(this.x, this.y);
-        },
-        set: function (value) {
-            this.x = value.x;
-            this.y = value.y;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Rectangle.prototype, "size", {
-        get: function () {
-            return new Vector2(this.width, this.height);
-        },
-        set: function (value) {
-            this.width = value.x;
-            this.height = value.y;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Rectangle.prototype.intersects = function (value) {
-        return value.left < this.right &&
-            this.left < value.right &&
-            value.top < this.bottom &&
-            this.top < value.bottom;
-    };
-    Rectangle.prototype.containsRect = function (value) {
-        return ((((this.x <= value.x) && (value.x < (this.x + this.width))) &&
-            (this.y <= value.y)) &&
-            (value.y < (this.y + this.height)));
-    };
-    Rectangle.prototype.getHalfSize = function () {
-        return new Vector2(this.width * 0.5, this.height * 0.5);
-    };
-    Rectangle.fromMinMax = function (minX, minY, maxX, maxY) {
-        return new Rectangle(minX, minY, maxX - minX, maxY - minY);
-    };
-    Rectangle.prototype.getClosestPointOnRectangleBorderToPoint = function (point) {
-        var edgeNormal = Vector2.zero;
-        var res = new Vector2();
-        res.x = MathHelper.clamp(point.x, this.left, this.right);
-        res.y = MathHelper.clamp(point.y, this.top, this.bottom);
-        if (this.contains(res.x, res.y)) {
-            var dl = res.x - this.left;
-            var dr = this.right - res.x;
-            var dt = res.y - this.top;
-            var db = this.bottom - res.y;
-            var min = Math.min(dl, dr, dt, db);
-            if (min == dt) {
-                res.y = this.top;
-                edgeNormal.y = -1;
-            }
-            else if (min == db) {
-                res.y = this.bottom;
-                edgeNormal.y = 1;
-            }
-            else if (min == dl) {
-                res.x = this.left;
-                edgeNormal.x = -1;
-            }
-            else {
-                res.x = this.right;
-                edgeNormal.x = 1;
-            }
-        }
-        else {
-            if (res.x == this.left)
-                edgeNormal.x = -1;
-            if (res.x == this.right)
-                edgeNormal.x = 1;
-            if (res.y == this.top)
-                edgeNormal.y = -1;
-            if (res.y == this.bottom)
-                edgeNormal.y = 1;
-        }
-        return { res: res, edgeNormal: edgeNormal };
-    };
-    Rectangle.prototype.getClosestPointOnBoundsToOrigin = function () {
-        var max = this.max;
-        var minDist = Math.abs(this.location.x);
-        var boundsPoint = new Vector2(this.location.x, 0);
-        if (Math.abs(max.x) < minDist) {
-            minDist = Math.abs(max.x);
-            boundsPoint.x = max.x;
-            boundsPoint.y = 0;
-        }
-        if (Math.abs(max.y) < minDist) {
-            minDist = Math.abs(max.y);
-            boundsPoint.x = 0;
-            boundsPoint.y = max.y;
-        }
-        if (Math.abs(this.location.y) < minDist) {
-            minDist = Math.abs(this.location.y);
-            boundsPoint.x = 0;
-            boundsPoint.y = this.location.y;
-        }
-        return boundsPoint;
-    };
-    Rectangle.prototype.setEgretRect = function (rect) {
-        this.x = rect.x;
-        this.y = rect.y;
-        this.width = rect.width;
-        this.height = rect.height;
-        return this;
-    };
-    Rectangle.rectEncompassingPoints = function (points) {
-        var minX = Number.POSITIVE_INFINITY;
-        var minY = Number.POSITIVE_INFINITY;
-        var maxX = Number.NEGATIVE_INFINITY;
-        var maxY = Number.NEGATIVE_INFINITY;
-        for (var i = 0; i < points.length; i++) {
-            var pt = points[i];
-            if (pt.x < minX)
-                minX = pt.x;
-            if (pt.x > maxX)
-                maxX = pt.x;
-            if (pt.y < minY)
-                minY = pt.y;
-            if (pt.y > maxY)
-                maxY = pt.y;
-        }
-        return this.fromMinMax(minX, minY, maxX, maxY);
-    };
-    return Rectangle;
-}(egret.Rectangle));
-var Vector3 = (function () {
-    function Vector3(x, y, z) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-    }
-    return Vector3;
-}());
-var ColliderTriggerHelper = (function () {
-    function ColliderTriggerHelper(entity) {
-        this._activeTriggerIntersections = [];
-        this._previousTriggerIntersections = [];
-        this._tempTriggerList = [];
-        this._entity = entity;
-    }
-    ColliderTriggerHelper.prototype.update = function () {
-        var colliders = this._entity.getComponents(Collider);
-        for (var i = 0; i < colliders.length; i++) {
-            var collider = colliders[i];
-            var boxcastResult = Physics.boxcastBroadphase(collider.bounds, collider.collidesWithLayers);
-            collider.bounds = boxcastResult.rect;
-            var neighbors = boxcastResult.colliders;
-            var _loop_5 = function (j) {
-                var neighbor = neighbors[j];
-                if (!collider.isTrigger && !neighbor.isTrigger)
-                    return "continue";
-                if (collider.overlaps(neighbor)) {
-                    var pair_1 = new Pair(collider, neighbor);
-                    var shouldReportTriggerEvent = this_1._activeTriggerIntersections.findIndex(function (value) {
-                        return value.first == pair_1.first && value.second == pair_1.second;
-                    }) == -1 && this_1._previousTriggerIntersections.findIndex(function (value) {
-                        return value.first == pair_1.first && value.second == pair_1.second;
-                    }) == -1;
-                    if (shouldReportTriggerEvent)
-                        this_1.notifyTriggerListeners(pair_1, true);
-                    if (!this_1._activeTriggerIntersections.contains(pair_1))
-                        this_1._activeTriggerIntersections.push(pair_1);
-                }
-            };
-            var this_1 = this;
-            for (var j = 0; j < neighbors.length; j++) {
-                _loop_5(j);
-            }
-        }
-        ListPool.free(colliders);
-        this.checkForExitedColliders();
-    };
-    ColliderTriggerHelper.prototype.checkForExitedColliders = function () {
-        var _this = this;
-        var _loop_6 = function (i) {
-            var index = this_2._previousTriggerIntersections.findIndex(function (value) {
-                if (value.first == _this._activeTriggerIntersections[i].first && value.second == _this._activeTriggerIntersections[i].second)
-                    return true;
-                return false;
-            });
-            if (index != -1)
-                this_2._previousTriggerIntersections.removeAt(index);
+        PostProcessor.prototype.onAddedToScene = function (scene) {
+            this.scene = scene;
+            this.shape = new egret.Shape();
+            this.shape.graphics.beginFill(0xFFFFFF, 1);
+            this.shape.graphics.drawRect(0, 0, es.SceneManager.stage.stageWidth, es.SceneManager.stage.stageHeight);
+            this.shape.graphics.endFill();
+            scene.addChild(this.shape);
         };
-        var this_2 = this;
-        for (var i = 0; i < this._activeTriggerIntersections.length; i++) {
-            _loop_6(i);
-        }
-        for (var i = 0; i < this._previousTriggerIntersections.length; i++) {
-            this.notifyTriggerListeners(this._previousTriggerIntersections[i], false);
-        }
-        this._previousTriggerIntersections.length = 0;
-        for (var i = 0; i < this._activeTriggerIntersections.length; i++) {
-            if (!this._previousTriggerIntersections.contains(this._activeTriggerIntersections[i])) {
-                this._previousTriggerIntersections.push(this._activeTriggerIntersections[i]);
+        PostProcessor.prototype.process = function () {
+            this.drawFullscreenQuad();
+        };
+        PostProcessor.prototype.onSceneBackBufferSizeChanged = function (newWidth, newHeight) { };
+        PostProcessor.prototype.drawFullscreenQuad = function () {
+            this.scene.filters = [this.effect];
+        };
+        PostProcessor.prototype.unload = function () {
+            if (this.effect) {
+                this.effect = null;
             }
+            this.scene.removeChild(this.shape);
+            this.scene = null;
+        };
+        PostProcessor.default_vert = "attribute vec2 aVertexPosition;\n" +
+            "attribute vec2 aTextureCoord;\n" +
+            "attribute vec2 aColor;\n" +
+            "uniform vec2 projectionVector;\n" +
+            "varying vec2 vTextureCoord;\n" +
+            "varying vec4 vColor;\n" +
+            "const vec2 center = vec2(-1.0, 1.0);\n" +
+            "void main(void) {\n" +
+            "gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n" +
+            "vTextureCoord = aTextureCoord;\n" +
+            "vColor = vec4(aColor.x, aColor.x, aColor.x, aColor.x);\n" +
+            "}";
+        return PostProcessor;
+    }());
+    es.PostProcessor = PostProcessor;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var GaussianBlurPostProcessor = (function (_super) {
+        __extends(GaussianBlurPostProcessor, _super);
+        function GaussianBlurPostProcessor() {
+            return _super !== null && _super.apply(this, arguments) || this;
         }
-        this._activeTriggerIntersections.length = 0;
-    };
-    ColliderTriggerHelper.prototype.notifyTriggerListeners = function (collisionPair, isEntering) {
-        collisionPair.first.entity.getComponents("ITriggerListener", this._tempTriggerList);
-        for (var i = 0; i < this._tempTriggerList.length; i++) {
-            if (isEntering) {
-                this._tempTriggerList[i].onTriggerEnter(collisionPair.second, collisionPair.first);
+        GaussianBlurPostProcessor.prototype.onAddedToScene = function (scene) {
+            _super.prototype.onAddedToScene.call(this, scene);
+            this.effect = new es.GaussianBlurEffect();
+        };
+        return GaussianBlurPostProcessor;
+    }(es.PostProcessor));
+    es.GaussianBlurPostProcessor = GaussianBlurPostProcessor;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Renderer = (function () {
+        function Renderer() {
+        }
+        Renderer.prototype.onAddedToScene = function (scene) { };
+        Renderer.prototype.beginRender = function (cam) {
+        };
+        Renderer.prototype.unload = function () { };
+        Renderer.prototype.renderAfterStateCheck = function (renderable, cam) {
+            renderable.render(cam);
+        };
+        return Renderer;
+    }());
+    es.Renderer = Renderer;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var DefaultRenderer = (function (_super) {
+        __extends(DefaultRenderer, _super);
+        function DefaultRenderer() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        DefaultRenderer.prototype.render = function (scene) {
+            var cam = this.camera ? this.camera : scene.camera;
+            this.beginRender(cam);
+            for (var i = 0; i < scene.renderableComponents.count; i++) {
+                var renderable = scene.renderableComponents.buffer[i];
+                if (renderable.enabled && renderable.isVisibleFromCamera(cam))
+                    this.renderAfterStateCheck(renderable, cam);
+            }
+        };
+        return DefaultRenderer;
+    }(es.Renderer));
+    es.DefaultRenderer = DefaultRenderer;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var ScreenSpaceRenderer = (function (_super) {
+        __extends(ScreenSpaceRenderer, _super);
+        function ScreenSpaceRenderer() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        ScreenSpaceRenderer.prototype.render = function (scene) {
+        };
+        return ScreenSpaceRenderer;
+    }(es.Renderer));
+    es.ScreenSpaceRenderer = ScreenSpaceRenderer;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var PolyLight = (function (_super) {
+        __extends(PolyLight, _super);
+        function PolyLight(radius, color, power) {
+            var _this = _super.call(this) || this;
+            _this._indices = [];
+            _this.radius = radius;
+            _this.power = power;
+            _this.color = color;
+            _this.computeTriangleIndices();
+            return _this;
+        }
+        Object.defineProperty(PolyLight.prototype, "radius", {
+            get: function () {
+                return this._radius;
+            },
+            set: function (value) {
+                this.setRadius(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        PolyLight.prototype.computeTriangleIndices = function (totalTris) {
+            if (totalTris === void 0) { totalTris = 20; }
+            this._indices.length = 0;
+            for (var i = 0; i < totalTris; i += 2) {
+                this._indices.push(0);
+                this._indices.push(i + 2);
+                this._indices.push(i + 1);
+            }
+        };
+        PolyLight.prototype.setRadius = function (radius) {
+            if (radius != this._radius) {
+                this._radius = radius;
+                this._areBoundsDirty = true;
+            }
+        };
+        PolyLight.prototype.render = function (camera) {
+        };
+        PolyLight.prototype.reset = function () {
+        };
+        return PolyLight;
+    }(es.RenderableComponent));
+    es.PolyLight = PolyLight;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var SceneTransition = (function () {
+        function SceneTransition(sceneLoadAction) {
+            this.sceneLoadAction = sceneLoadAction;
+            this.loadsNewScene = sceneLoadAction != null;
+        }
+        Object.defineProperty(SceneTransition.prototype, "hasPreviousSceneRender", {
+            get: function () {
+                if (!this._hasPreviousSceneRender) {
+                    this._hasPreviousSceneRender = true;
+                    return false;
+                }
+                return true;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        SceneTransition.prototype.preRender = function () { };
+        SceneTransition.prototype.render = function () {
+        };
+        SceneTransition.prototype.onBeginTransition = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4, this.loadNextScene()];
+                        case 1:
+                            _a.sent();
+                            this.transitionComplete();
+                            return [2];
+                    }
+                });
+            });
+        };
+        SceneTransition.prototype.transitionComplete = function () {
+            es.SceneManager.sceneTransition = null;
+            if (this.onTransitionCompleted) {
+                this.onTransitionCompleted();
+            }
+        };
+        SceneTransition.prototype.loadNextScene = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            if (this.onScreenObscured)
+                                this.onScreenObscured();
+                            if (!this.loadsNewScene) {
+                                this.isNewSceneLoaded = true;
+                            }
+                            _a = es.SceneManager;
+                            return [4, this.sceneLoadAction()];
+                        case 1:
+                            _a.scene = _b.sent();
+                            this.isNewSceneLoaded = true;
+                            return [2];
+                    }
+                });
+            });
+        };
+        SceneTransition.prototype.tickEffectProgressProperty = function (filter, duration, easeType, reverseDirection) {
+            if (reverseDirection === void 0) { reverseDirection = false; }
+            return new Promise(function (resolve) {
+                var start = reverseDirection ? 1 : 0;
+                var end = reverseDirection ? 0 : 1;
+                egret.Tween.get(filter.uniforms).set({ _progress: start }).to({ _progress: end }, duration * 1000, easeType).call(function () {
+                    resolve();
+                });
+            });
+        };
+        return SceneTransition;
+    }());
+    es.SceneTransition = SceneTransition;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var FadeTransition = (function (_super) {
+        __extends(FadeTransition, _super);
+        function FadeTransition(sceneLoadAction) {
+            var _this = _super.call(this, sceneLoadAction) || this;
+            _this.fadeToColor = 0x000000;
+            _this.fadeOutDuration = 0.4;
+            _this.fadeEaseType = egret.Ease.quadInOut;
+            _this.delayBeforeFadeInDuration = 0.1;
+            _this._alpha = 0;
+            _this._mask = new egret.Shape();
+            return _this;
+        }
+        FadeTransition.prototype.onBeginTransition = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var _this = this;
+                return __generator(this, function (_a) {
+                    this._mask.graphics.beginFill(this.fadeToColor, 1);
+                    this._mask.graphics.drawRect(0, 0, es.SceneManager.stage.stageWidth, es.SceneManager.stage.stageHeight);
+                    this._mask.graphics.endFill();
+                    es.SceneManager.stage.addChild(this._mask);
+                    egret.Tween.get(this).to({ _alpha: 1 }, this.fadeOutDuration * 1000, this.fadeEaseType)
+                        .call(function () { return __awaiter(_this, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4, this.loadNextScene()];
+                                case 1:
+                                    _a.sent();
+                                    return [2];
+                            }
+                        });
+                    }); }).wait(this.delayBeforeFadeInDuration).call(function () {
+                        egret.Tween.get(_this).to({ _alpha: 0 }, _this.fadeOutDuration * 1000, _this.fadeEaseType).call(function () {
+                            _this.transitionComplete();
+                            es.SceneManager.stage.removeChild(_this._mask);
+                        });
+                    });
+                    return [2];
+                });
+            });
+        };
+        FadeTransition.prototype.render = function () {
+            this._mask.graphics.clear();
+            this._mask.graphics.beginFill(this.fadeToColor, this._alpha);
+            this._mask.graphics.drawRect(0, 0, es.SceneManager.stage.stageWidth, es.SceneManager.stage.stageHeight);
+            this._mask.graphics.endFill();
+        };
+        return FadeTransition;
+    }(es.SceneTransition));
+    es.FadeTransition = FadeTransition;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var WindTransition = (function (_super) {
+        __extends(WindTransition, _super);
+        function WindTransition(sceneLoadAction) {
+            var _this = _super.call(this, sceneLoadAction) || this;
+            _this.duration = 1;
+            _this.easeType = egret.Ease.quadOut;
+            var vertexSrc = "attribute vec2 aVertexPosition;\n" +
+                "attribute vec2 aTextureCoord;\n" +
+                "uniform vec2 projectionVector;\n" +
+                "varying vec2 vTextureCoord;\n" +
+                "const vec2 center = vec2(-1.0, 1.0);\n" +
+                "void main(void) {\n" +
+                "   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n" +
+                "   vTextureCoord = aTextureCoord;\n" +
+                "}";
+            var fragmentSrc = "precision lowp float;\n" +
+                "varying vec2 vTextureCoord;\n" +
+                "uniform sampler2D uSampler;\n" +
+                "uniform float _progress;\n" +
+                "uniform float _size;\n" +
+                "uniform float _windSegments;\n" +
+                "void main(void) {\n" +
+                "vec2 co = floor(vec2(0.0, vTextureCoord.y * _windSegments));\n" +
+                "float x = sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453;\n" +
+                "float r = x - floor(x);\n" +
+                "float m = smoothstep(0.0, -_size, vTextureCoord.x * (1.0 - _size) + _size * r - (_progress * (1.0 + _size)));\n" +
+                "vec4 fg = texture2D(uSampler, vTextureCoord);\n" +
+                "gl_FragColor = mix(fg, vec4(0, 0, 0, 0), m);\n" +
+                "}";
+            _this._windEffect = new egret.CustomFilter(vertexSrc, fragmentSrc, {
+                _progress: 0,
+                _size: 0.3,
+                _windSegments: 100
+            });
+            _this._mask = new egret.Shape();
+            _this._mask.graphics.beginFill(0xFFFFFF, 1);
+            _this._mask.graphics.drawRect(0, 0, es.SceneManager.stage.stageWidth, es.SceneManager.stage.stageHeight);
+            _this._mask.graphics.endFill();
+            _this._mask.filters = [_this._windEffect];
+            es.SceneManager.stage.addChild(_this._mask);
+            return _this;
+        }
+        Object.defineProperty(WindTransition.prototype, "windSegments", {
+            set: function (value) {
+                this._windEffect.uniforms._windSegments = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(WindTransition.prototype, "size", {
+            set: function (value) {
+                this._windEffect.uniforms._size = value;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        WindTransition.prototype.onBeginTransition = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            this.loadNextScene();
+                            return [4, this.tickEffectProgressProperty(this._windEffect, this.duration, this.easeType)];
+                        case 1:
+                            _a.sent();
+                            this.transitionComplete();
+                            es.SceneManager.stage.removeChild(this._mask);
+                            return [2];
+                    }
+                });
+            });
+        };
+        return WindTransition;
+    }(es.SceneTransition));
+    es.WindTransition = WindTransition;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Bezier = (function () {
+        function Bezier() {
+        }
+        Bezier.getPoint = function (p0, p1, p2, t) {
+            t = es.MathHelper.clamp01(t);
+            var oneMinusT = 1 - t;
+            return es.Vector2.add(es.Vector2.add(es.Vector2.multiply(new es.Vector2(oneMinusT * oneMinusT), p0), es.Vector2.multiply(new es.Vector2(2 * oneMinusT * t), p1)), es.Vector2.multiply(new es.Vector2(t * t), p2));
+        };
+        Bezier.getFirstDerivative = function (p0, p1, p2, t) {
+            return es.Vector2.add(es.Vector2.multiply(new es.Vector2(2 * (1 - t)), es.Vector2.subtract(p1, p0)), es.Vector2.multiply(new es.Vector2(2 * t), es.Vector2.subtract(p2, p1)));
+        };
+        Bezier.getFirstDerivativeThree = function (start, firstControlPoint, secondControlPoint, end, t) {
+            t = es.MathHelper.clamp01(t);
+            var oneMunusT = 1 - t;
+            return es.Vector2.add(es.Vector2.add(es.Vector2.multiply(new es.Vector2(3 * oneMunusT * oneMunusT), es.Vector2.subtract(firstControlPoint, start)), es.Vector2.multiply(new es.Vector2(6 * oneMunusT * t), es.Vector2.subtract(secondControlPoint, firstControlPoint))), es.Vector2.multiply(new es.Vector2(3 * t * t), es.Vector2.subtract(end, secondControlPoint)));
+        };
+        Bezier.getPointThree = function (start, firstControlPoint, secondControlPoint, end, t) {
+            t = es.MathHelper.clamp01(t);
+            var oneMunusT = 1 - t;
+            return es.Vector2.add(es.Vector2.add(es.Vector2.add(es.Vector2.multiply(new es.Vector2(oneMunusT * oneMunusT * oneMunusT), start), es.Vector2.multiply(new es.Vector2(3 * oneMunusT * oneMunusT * t), firstControlPoint)), es.Vector2.multiply(new es.Vector2(3 * oneMunusT * t * t), secondControlPoint)), es.Vector2.multiply(new es.Vector2(t * t * t), end));
+        };
+        Bezier.getOptimizedDrawingPoints = function (start, firstCtrlPoint, secondCtrlPoint, end, distanceTolerance) {
+            if (distanceTolerance === void 0) { distanceTolerance = 1; }
+            var points = es.ListPool.obtain();
+            points.push(start);
+            this.recursiveGetOptimizedDrawingPoints(start, firstCtrlPoint, secondCtrlPoint, end, points, distanceTolerance);
+            points.push(end);
+            return points;
+        };
+        Bezier.recursiveGetOptimizedDrawingPoints = function (start, firstCtrlPoint, secondCtrlPoint, end, points, distanceTolerance) {
+            var pt12 = es.Vector2.divide(es.Vector2.add(start, firstCtrlPoint), new es.Vector2(2));
+            var pt23 = es.Vector2.divide(es.Vector2.add(firstCtrlPoint, secondCtrlPoint), new es.Vector2(2));
+            var pt34 = es.Vector2.divide(es.Vector2.add(secondCtrlPoint, end), new es.Vector2(2));
+            var pt123 = es.Vector2.divide(es.Vector2.add(pt12, pt23), new es.Vector2(2));
+            var pt234 = es.Vector2.divide(es.Vector2.add(pt23, pt34), new es.Vector2(2));
+            var pt1234 = es.Vector2.divide(es.Vector2.add(pt123, pt234), new es.Vector2(2));
+            var deltaLine = es.Vector2.subtract(end, start);
+            var d2 = Math.abs(((firstCtrlPoint.x, end.x) * deltaLine.y - (firstCtrlPoint.y - end.y) * deltaLine.x));
+            var d3 = Math.abs(((secondCtrlPoint.x - end.x) * deltaLine.y - (secondCtrlPoint.y - end.y) * deltaLine.x));
+            if ((d2 + d3) * (d2 + d3) < distanceTolerance * (deltaLine.x * deltaLine.x + deltaLine.y * deltaLine.y)) {
+                points.push(pt1234);
+                return;
+            }
+            this.recursiveGetOptimizedDrawingPoints(start, pt12, pt123, pt1234, points, distanceTolerance);
+            this.recursiveGetOptimizedDrawingPoints(pt1234, pt234, pt34, end, points, distanceTolerance);
+        };
+        return Bezier;
+    }());
+    es.Bezier = Bezier;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Flags = (function () {
+        function Flags() {
+        }
+        Flags.isFlagSet = function (self, flag) {
+            return (self & flag) != 0;
+        };
+        Flags.isUnshiftedFlagSet = function (self, flag) {
+            flag = 1 << flag;
+            return (self & flag) != 0;
+        };
+        Flags.setFlagExclusive = function (self, flag) {
+            return 1 << flag;
+        };
+        Flags.setFlag = function (self, flag) {
+            return (self | 1 << flag);
+        };
+        Flags.unsetFlag = function (self, flag) {
+            flag = 1 << flag;
+            return (self & (~flag));
+        };
+        Flags.invertFlags = function (self) {
+            return ~self;
+        };
+        return Flags;
+    }());
+    es.Flags = Flags;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var MathHelper = (function () {
+        function MathHelper() {
+        }
+        MathHelper.toDegrees = function (radians) {
+            return radians * 57.295779513082320876798154814105;
+        };
+        MathHelper.toRadians = function (degrees) {
+            return degrees * 0.017453292519943295769236907684886;
+        };
+        MathHelper.map = function (value, leftMin, leftMax, rightMin, rightMax) {
+            return rightMin + (value - leftMin) * (rightMax - rightMin) / (leftMax - leftMin);
+        };
+        MathHelper.lerp = function (value1, value2, amount) {
+            return value1 + (value2 - value1) * amount;
+        };
+        MathHelper.clamp = function (value, min, max) {
+            if (value < min)
+                return min;
+            if (value > max)
+                return max;
+            return value;
+        };
+        MathHelper.pointOnCirlce = function (circleCenter, radius, angleInDegrees) {
+            var radians = MathHelper.toRadians(angleInDegrees);
+            return new es.Vector2(Math.cos(radians) * radians + circleCenter.x, Math.sin(radians) * radians + circleCenter.y);
+        };
+        MathHelper.isEven = function (value) {
+            return value % 2 == 0;
+        };
+        MathHelper.clamp01 = function (value) {
+            if (value < 0)
+                return 0;
+            if (value > 1)
+                return 1;
+            return value;
+        };
+        MathHelper.angleBetweenVectors = function (from, to) {
+            return Math.atan2(to.y - from.y, to.x - from.x);
+        };
+        MathHelper.Epsilon = 0.00001;
+        MathHelper.Rad2Deg = 57.29578;
+        MathHelper.Deg2Rad = 0.0174532924;
+        return MathHelper;
+    }());
+    es.MathHelper = MathHelper;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Matrix2D = (function () {
+        function Matrix2D(m11, m12, m21, m22, m31, m32) {
+            this.m11 = 0;
+            this.m12 = 0;
+            this.m21 = 0;
+            this.m22 = 0;
+            this.m31 = 0;
+            this.m32 = 0;
+            this.m11 = m11 ? m11 : 1;
+            this.m12 = m12 ? m12 : 0;
+            this.m21 = m21 ? m21 : 0;
+            this.m22 = m22 ? m22 : 1;
+            this.m31 = m31 ? m31 : 0;
+            this.m32 = m32 ? m32 : 0;
+        }
+        Object.defineProperty(Matrix2D, "identity", {
+            get: function () {
+                return Matrix2D._identity;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Matrix2D.prototype, "translation", {
+            get: function () {
+                return new es.Vector2(this.m31, this.m32);
+            },
+            set: function (value) {
+                this.m31 = value.x;
+                this.m32 = value.y;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Matrix2D.prototype, "rotation", {
+            get: function () {
+                return Math.atan2(this.m21, this.m11);
+            },
+            set: function (value) {
+                var val1 = Math.cos(value);
+                var val2 = Math.sin(value);
+                this.m11 = val1;
+                this.m12 = val2;
+                this.m21 = -val2;
+                this.m22 = val1;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Matrix2D.prototype, "rotationDegrees", {
+            get: function () {
+                return es.MathHelper.toDegrees(this.rotation);
+            },
+            set: function (value) {
+                this.rotation = es.MathHelper.toRadians(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Matrix2D.prototype, "scale", {
+            get: function () {
+                return new es.Vector2(this.m11, this.m22);
+            },
+            set: function (value) {
+                this.m11 = value.x;
+                this.m12 = value.y;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Matrix2D.add = function (matrix1, matrix2) {
+            matrix1.m11 += matrix2.m11;
+            matrix1.m12 += matrix2.m12;
+            matrix1.m21 += matrix2.m21;
+            matrix1.m22 += matrix2.m22;
+            matrix1.m31 += matrix2.m31;
+            matrix1.m32 += matrix2.m32;
+            return matrix1;
+        };
+        Matrix2D.divide = function (matrix1, matrix2) {
+            matrix1.m11 /= matrix2.m11;
+            matrix1.m12 /= matrix2.m12;
+            matrix1.m21 /= matrix2.m21;
+            matrix1.m22 /= matrix2.m22;
+            matrix1.m31 /= matrix2.m31;
+            matrix1.m32 /= matrix2.m32;
+            return matrix1;
+        };
+        Matrix2D.multiply = function (matrix1, matrix2) {
+            var result = new Matrix2D();
+            var m11 = (matrix1.m11 * matrix2.m11) + (matrix1.m12 * matrix2.m21);
+            var m12 = (matrix1.m11 * matrix2.m12) + (matrix1.m12 * matrix2.m22);
+            var m21 = (matrix1.m21 * matrix2.m11) + (matrix1.m22 * matrix2.m21);
+            var m22 = (matrix1.m21 * matrix2.m12) + (matrix1.m22 * matrix2.m22);
+            var m31 = (matrix1.m31 * matrix2.m11) + (matrix1.m32 * matrix2.m21) + matrix2.m31;
+            var m32 = (matrix1.m31 * matrix2.m12) + (matrix1.m32 * matrix2.m22) + matrix2.m32;
+            result.m11 = m11;
+            result.m12 = m12;
+            result.m21 = m21;
+            result.m22 = m22;
+            result.m31 = m31;
+            result.m32 = m32;
+            return result;
+        };
+        Matrix2D.multiplyTranslation = function (matrix, x, y) {
+            var trans = Matrix2D.createTranslation(x, y);
+            return Matrix2D.multiply(matrix, trans);
+        };
+        Matrix2D.prototype.determinant = function () {
+            return this.m11 * this.m22 - this.m12 * this.m21;
+        };
+        Matrix2D.invert = function (matrix, result) {
+            if (result === void 0) { result = new Matrix2D(); }
+            var det = 1 / matrix.determinant();
+            result.m11 = matrix.m22 * det;
+            result.m12 = -matrix.m12 * det;
+            result.m21 = -matrix.m21 * det;
+            result.m22 = matrix.m11 * det;
+            result.m31 = (matrix.m32 * matrix.m21 - matrix.m31 * matrix.m22) * det;
+            result.m32 = -(matrix.m32 * matrix.m11 - matrix.m31 * matrix.m12) * det;
+            return result;
+        };
+        Matrix2D.createTranslation = function (xPosition, yPosition) {
+            var result = new Matrix2D();
+            result.m11 = 1;
+            result.m12 = 0;
+            result.m21 = 0;
+            result.m22 = 1;
+            result.m31 = xPosition;
+            result.m32 = yPosition;
+            return result;
+        };
+        Matrix2D.createTranslationVector = function (position) {
+            return this.createTranslation(position.x, position.y);
+        };
+        Matrix2D.createRotation = function (radians, result) {
+            result = new Matrix2D();
+            var val1 = Math.cos(radians);
+            var val2 = Math.sin(radians);
+            result.m11 = val1;
+            result.m12 = val2;
+            result.m21 = -val2;
+            result.m22 = val1;
+            return result;
+        };
+        Matrix2D.createScale = function (xScale, yScale, result) {
+            if (result === void 0) { result = new Matrix2D(); }
+            result.m11 = xScale;
+            result.m12 = 0;
+            result.m21 = 0;
+            result.m22 = yScale;
+            result.m31 = 0;
+            result.m32 = 0;
+            return result;
+        };
+        Matrix2D.prototype.toEgretMatrix = function () {
+            var matrix = new egret.Matrix(this.m11, this.m12, this.m21, this.m22, this.m31, this.m32);
+            return matrix;
+        };
+        Matrix2D._identity = new Matrix2D(1, 0, 0, 1, 0, 0);
+        return Matrix2D;
+    }());
+    es.Matrix2D = Matrix2D;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Rectangle = (function (_super) {
+        __extends(Rectangle, _super);
+        function Rectangle() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        Object.defineProperty(Rectangle.prototype, "max", {
+            get: function () {
+                return new es.Vector2(this.right, this.bottom);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Rectangle.prototype, "center", {
+            get: function () {
+                return new es.Vector2(this.x + (this.width / 2), this.y + (this.height / 2));
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Rectangle.prototype, "location", {
+            get: function () {
+                return new es.Vector2(this.x, this.y);
+            },
+            set: function (value) {
+                this.x = value.x;
+                this.y = value.y;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Rectangle.prototype, "size", {
+            get: function () {
+                return new es.Vector2(this.width, this.height);
+            },
+            set: function (value) {
+                this.width = value.x;
+                this.height = value.y;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Rectangle.prototype.intersects = function (value) {
+            return value.left < this.right &&
+                this.left < value.right &&
+                value.top < this.bottom &&
+                this.top < value.bottom;
+        };
+        Rectangle.prototype.containsRect = function (value) {
+            return ((((this.x <= value.x) && (value.x < (this.x + this.width))) &&
+                (this.y <= value.y)) &&
+                (value.y < (this.y + this.height)));
+        };
+        Rectangle.prototype.getHalfSize = function () {
+            return new es.Vector2(this.width * 0.5, this.height * 0.5);
+        };
+        Rectangle.fromMinMax = function (minX, minY, maxX, maxY) {
+            return new Rectangle(minX, minY, maxX - minX, maxY - minY);
+        };
+        Rectangle.prototype.getClosestPointOnRectangleBorderToPoint = function (point) {
+            var edgeNormal = es.Vector2.zero;
+            var res = new es.Vector2();
+            res.x = es.MathHelper.clamp(point.x, this.left, this.right);
+            res.y = es.MathHelper.clamp(point.y, this.top, this.bottom);
+            if (this.contains(res.x, res.y)) {
+                var dl = res.x - this.left;
+                var dr = this.right - res.x;
+                var dt = res.y - this.top;
+                var db = this.bottom - res.y;
+                var min = Math.min(dl, dr, dt, db);
+                if (min == dt) {
+                    res.y = this.top;
+                    edgeNormal.y = -1;
+                }
+                else if (min == db) {
+                    res.y = this.bottom;
+                    edgeNormal.y = 1;
+                }
+                else if (min == dl) {
+                    res.x = this.left;
+                    edgeNormal.x = -1;
+                }
+                else {
+                    res.x = this.right;
+                    edgeNormal.x = 1;
+                }
             }
             else {
-                this._tempTriggerList[i].onTriggerExit(collisionPair.second, collisionPair.first);
+                if (res.x == this.left)
+                    edgeNormal.x = -1;
+                if (res.x == this.right)
+                    edgeNormal.x = 1;
+                if (res.y == this.top)
+                    edgeNormal.y = -1;
+                if (res.y == this.bottom)
+                    edgeNormal.y = 1;
             }
-            this._tempTriggerList.length = 0;
-            if (collisionPair.second.entity) {
-                collisionPair.second.entity.getComponents("ITriggerListener", this._tempTriggerList);
-                for (var i_2 = 0; i_2 < this._tempTriggerList.length; i_2++) {
-                    if (isEntering) {
-                        this._tempTriggerList[i_2].onTriggerEnter(collisionPair.first, collisionPair.second);
-                    }
-                    else {
-                        this._tempTriggerList[i_2].onTriggerExit(collisionPair.first, collisionPair.second);
+            return { res: res, edgeNormal: edgeNormal };
+        };
+        Rectangle.prototype.getClosestPointOnBoundsToOrigin = function () {
+            var max = this.max;
+            var minDist = Math.abs(this.location.x);
+            var boundsPoint = new es.Vector2(this.location.x, 0);
+            if (Math.abs(max.x) < minDist) {
+                minDist = Math.abs(max.x);
+                boundsPoint.x = max.x;
+                boundsPoint.y = 0;
+            }
+            if (Math.abs(max.y) < minDist) {
+                minDist = Math.abs(max.y);
+                boundsPoint.x = 0;
+                boundsPoint.y = max.y;
+            }
+            if (Math.abs(this.location.y) < minDist) {
+                minDist = Math.abs(this.location.y);
+                boundsPoint.x = 0;
+                boundsPoint.y = this.location.y;
+            }
+            return boundsPoint;
+        };
+        Rectangle.prototype.calculateBounds = function (parentPosition, position, origin, scale, rotation, width, height) {
+            this.x = parentPosition.x + position.x - origin.x * scale.x;
+            this.y = parentPosition.y + position.y - origin.y * scale.y;
+            this.width = width * scale.x;
+            this.height = height * scale.y;
+        };
+        Rectangle.prototype.setEgretRect = function (rect) {
+            this.x = rect.x;
+            this.y = rect.y;
+            this.width = rect.width;
+            this.height = rect.height;
+            return this;
+        };
+        Rectangle.rectEncompassingPoints = function (points) {
+            var minX = Number.POSITIVE_INFINITY;
+            var minY = Number.POSITIVE_INFINITY;
+            var maxX = Number.NEGATIVE_INFINITY;
+            var maxY = Number.NEGATIVE_INFINITY;
+            for (var i = 0; i < points.length; i++) {
+                var pt = points[i];
+                if (pt.x < minX)
+                    minX = pt.x;
+                if (pt.x > maxX)
+                    maxX = pt.x;
+                if (pt.y < minY)
+                    minY = pt.y;
+                if (pt.y > maxY)
+                    maxY = pt.y;
+            }
+            return this.fromMinMax(minX, minY, maxX, maxY);
+        };
+        return Rectangle;
+    }(egret.Rectangle));
+    es.Rectangle = Rectangle;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Vector3 = (function () {
+        function Vector3(x, y, z) {
+            this.x = x;
+            this.y = y;
+            this.z = z;
+        }
+        return Vector3;
+    }());
+    es.Vector3 = Vector3;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var ColliderTriggerHelper = (function () {
+        function ColliderTriggerHelper(entity) {
+            this._activeTriggerIntersections = [];
+            this._previousTriggerIntersections = [];
+            this._tempTriggerList = [];
+            this._entity = entity;
+        }
+        ColliderTriggerHelper.prototype.update = function () {
+            var colliders = this._entity.getComponents(es.Collider);
+            for (var i = 0; i < colliders.length; i++) {
+                var collider = colliders[i];
+                var boxcastResult = es.Physics.boxcastBroadphase(collider.bounds, collider.collidesWithLayers);
+                collider.bounds = boxcastResult.rect;
+                var neighbors = boxcastResult.colliders;
+                var _loop_5 = function (j) {
+                    var neighbor = neighbors[j];
+                    if (!collider.isTrigger && !neighbor.isTrigger)
+                        return "continue";
+                    if (collider.overlaps(neighbor)) {
+                        var pair_1 = new es.Pair(collider, neighbor);
+                        var shouldReportTriggerEvent = this_1._activeTriggerIntersections.findIndex(function (value) {
+                            return value.first == pair_1.first && value.second == pair_1.second;
+                        }) == -1 && this_1._previousTriggerIntersections.findIndex(function (value) {
+                            return value.first == pair_1.first && value.second == pair_1.second;
+                        }) == -1;
+                        if (shouldReportTriggerEvent)
+                            this_1.notifyTriggerListeners(pair_1, true);
+                        if (!this_1._activeTriggerIntersections.contains(pair_1))
+                            this_1._activeTriggerIntersections.push(pair_1);
                     }
+                };
+                var this_1 = this;
+                for (var j = 0; j < neighbors.length; j++) {
+                    _loop_5(j);
+                }
+            }
+            es.ListPool.free(colliders);
+            this.checkForExitedColliders();
+        };
+        ColliderTriggerHelper.prototype.checkForExitedColliders = function () {
+            var _this = this;
+            var _loop_6 = function (i) {
+                var index = this_2._previousTriggerIntersections.findIndex(function (value) {
+                    if (value.first == _this._activeTriggerIntersections[i].first && value.second == _this._activeTriggerIntersections[i].second)
+                        return true;
+                    return false;
+                });
+                if (index != -1)
+                    this_2._previousTriggerIntersections.removeAt(index);
+            };
+            var this_2 = this;
+            for (var i = 0; i < this._activeTriggerIntersections.length; i++) {
+                _loop_6(i);
+            }
+            for (var i = 0; i < this._previousTriggerIntersections.length; i++) {
+                this.notifyTriggerListeners(this._previousTriggerIntersections[i], false);
+            }
+            this._previousTriggerIntersections.length = 0;
+            for (var i = 0; i < this._activeTriggerIntersections.length; i++) {
+                if (!this._previousTriggerIntersections.contains(this._activeTriggerIntersections[i])) {
+                    this._previousTriggerIntersections.push(this._activeTriggerIntersections[i]);
+                }
+            }
+            this._activeTriggerIntersections.length = 0;
+        };
+        ColliderTriggerHelper.prototype.notifyTriggerListeners = function (collisionPair, isEntering) {
+            collisionPair.first.entity.getComponents("ITriggerListener", this._tempTriggerList);
+            for (var i = 0; i < this._tempTriggerList.length; i++) {
+                if (isEntering) {
+                    this._tempTriggerList[i].onTriggerEnter(collisionPair.second, collisionPair.first);
+                }
+                else {
+                    this._tempTriggerList[i].onTriggerExit(collisionPair.second, collisionPair.first);
                 }
                 this._tempTriggerList.length = 0;
+                if (collisionPair.second.entity) {
+                    collisionPair.second.entity.getComponents("ITriggerListener", this._tempTriggerList);
+                    for (var i_2 = 0; i_2 < this._tempTriggerList.length; i_2++) {
+                        if (isEntering) {
+                            this._tempTriggerList[i_2].onTriggerEnter(collisionPair.first, collisionPair.second);
+                        }
+                        else {
+                            this._tempTriggerList[i_2].onTriggerExit(collisionPair.first, collisionPair.second);
+                        }
+                    }
+                    this._tempTriggerList.length = 0;
+                }
             }
+        };
+        return ColliderTriggerHelper;
+    }());
+    es.ColliderTriggerHelper = ColliderTriggerHelper;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var PointSectors;
+    (function (PointSectors) {
+        PointSectors[PointSectors["center"] = 0] = "center";
+        PointSectors[PointSectors["top"] = 1] = "top";
+        PointSectors[PointSectors["bottom"] = 2] = "bottom";
+        PointSectors[PointSectors["topLeft"] = 9] = "topLeft";
+        PointSectors[PointSectors["topRight"] = 5] = "topRight";
+        PointSectors[PointSectors["left"] = 8] = "left";
+        PointSectors[PointSectors["right"] = 4] = "right";
+        PointSectors[PointSectors["bottomLeft"] = 10] = "bottomLeft";
+        PointSectors[PointSectors["bottomRight"] = 6] = "bottomRight";
+    })(PointSectors = es.PointSectors || (es.PointSectors = {}));
+    var Collisions = (function () {
+        function Collisions() {
         }
-    };
-    return ColliderTriggerHelper;
-}());
-var PointSectors;
-(function (PointSectors) {
-    PointSectors[PointSectors["center"] = 0] = "center";
-    PointSectors[PointSectors["top"] = 1] = "top";
-    PointSectors[PointSectors["bottom"] = 2] = "bottom";
-    PointSectors[PointSectors["topLeft"] = 9] = "topLeft";
-    PointSectors[PointSectors["topRight"] = 5] = "topRight";
-    PointSectors[PointSectors["left"] = 8] = "left";
-    PointSectors[PointSectors["right"] = 4] = "right";
-    PointSectors[PointSectors["bottomLeft"] = 10] = "bottomLeft";
-    PointSectors[PointSectors["bottomRight"] = 6] = "bottomRight";
-})(PointSectors || (PointSectors = {}));
-var Collisions = (function () {
-    function Collisions() {
-    }
-    Collisions.isLineToLine = function (a1, a2, b1, b2) {
-        var b = Vector2.subtract(a2, a1);
-        var d = Vector2.subtract(b2, b1);
-        var bDotDPerp = b.x * d.y - b.y * d.x;
-        if (bDotDPerp == 0)
-            return false;
-        var c = Vector2.subtract(b1, a1);
-        var t = (c.x * d.y - c.y * d.x) / bDotDPerp;
-        if (t < 0 || t > 1)
-            return false;
-        var u = (c.x * b.y - c.y * b.x) / bDotDPerp;
-        if (u < 0 || u > 1)
-            return false;
-        return true;
-    };
-    Collisions.lineToLineIntersection = function (a1, a2, b1, b2) {
-        var intersection = new Vector2(0, 0);
-        var b = Vector2.subtract(a2, a1);
-        var d = Vector2.subtract(b2, b1);
-        var bDotDPerp = b.x * d.y - b.y * d.x;
-        if (bDotDPerp == 0)
-            return intersection;
-        var c = Vector2.subtract(b1, a1);
-        var t = (c.x * d.y - c.y * d.x) / bDotDPerp;
-        if (t < 0 || t > 1)
-            return intersection;
-        var u = (c.x * b.y - c.y * b.x) / bDotDPerp;
-        if (u < 0 || u > 1)
-            return intersection;
-        intersection = Vector2.add(a1, new Vector2(t * b.x, t * b.y));
-        return intersection;
-    };
-    Collisions.closestPointOnLine = function (lineA, lineB, closestTo) {
-        var v = Vector2.subtract(lineB, lineA);
-        var w = Vector2.subtract(closestTo, lineA);
-        var t = Vector2.dot(w, v) / Vector2.dot(v, v);
-        t = MathHelper.clamp(t, 0, 1);
-        return Vector2.add(lineA, new Vector2(v.x * t, v.y * t));
-    };
-    Collisions.isCircleToCircle = function (circleCenter1, circleRadius1, circleCenter2, circleRadius2) {
-        return Vector2.distanceSquared(circleCenter1, circleCenter2) < (circleRadius1 + circleRadius2) * (circleRadius1 + circleRadius2);
-    };
-    Collisions.isCircleToLine = function (circleCenter, radius, lineFrom, lineTo) {
-        return Vector2.distanceSquared(circleCenter, this.closestPointOnLine(lineFrom, lineTo, circleCenter)) < radius * radius;
-    };
-    Collisions.isCircleToPoint = function (circleCenter, radius, point) {
-        return Vector2.distanceSquared(circleCenter, point) < radius * radius;
-    };
-    Collisions.isRectToCircle = function (rect, cPosition, cRadius) {
-        var ew = rect.width * 0.5;
-        var eh = rect.height * 0.5;
-        var vx = Math.max(0, Math.max(cPosition.x - rect.x) - ew);
-        var vy = Math.max(0, Math.max(cPosition.y - rect.y) - eh);
-        return vx * vx + vy * vy < cRadius * cRadius;
-    };
-    Collisions.isRectToLine = function (rect, lineFrom, lineTo) {
-        var fromSector = this.getSector(rect.x, rect.y, rect.width, rect.height, lineFrom);
-        var toSector = this.getSector(rect.x, rect.y, rect.width, rect.height, lineTo);
-        if (fromSector == PointSectors.center || toSector == PointSectors.center) {
+        Collisions.isLineToLine = function (a1, a2, b1, b2) {
+            var b = es.Vector2.subtract(a2, a1);
+            var d = es.Vector2.subtract(b2, b1);
+            var bDotDPerp = b.x * d.y - b.y * d.x;
+            if (bDotDPerp == 0)
+                return false;
+            var c = es.Vector2.subtract(b1, a1);
+            var t = (c.x * d.y - c.y * d.x) / bDotDPerp;
+            if (t < 0 || t > 1)
+                return false;
+            var u = (c.x * b.y - c.y * b.x) / bDotDPerp;
+            if (u < 0 || u > 1)
+                return false;
             return true;
-        }
-        else if ((fromSector & toSector) != 0) {
+        };
+        Collisions.lineToLineIntersection = function (a1, a2, b1, b2) {
+            var intersection = new es.Vector2(0, 0);
+            var b = es.Vector2.subtract(a2, a1);
+            var d = es.Vector2.subtract(b2, b1);
+            var bDotDPerp = b.x * d.y - b.y * d.x;
+            if (bDotDPerp == 0)
+                return intersection;
+            var c = es.Vector2.subtract(b1, a1);
+            var t = (c.x * d.y - c.y * d.x) / bDotDPerp;
+            if (t < 0 || t > 1)
+                return intersection;
+            var u = (c.x * b.y - c.y * b.x) / bDotDPerp;
+            if (u < 0 || u > 1)
+                return intersection;
+            intersection = es.Vector2.add(a1, new es.Vector2(t * b.x, t * b.y));
+            return intersection;
+        };
+        Collisions.closestPointOnLine = function (lineA, lineB, closestTo) {
+            var v = es.Vector2.subtract(lineB, lineA);
+            var w = es.Vector2.subtract(closestTo, lineA);
+            var t = es.Vector2.dot(w, v) / es.Vector2.dot(v, v);
+            t = es.MathHelper.clamp(t, 0, 1);
+            return es.Vector2.add(lineA, new es.Vector2(v.x * t, v.y * t));
+        };
+        Collisions.isCircleToCircle = function (circleCenter1, circleRadius1, circleCenter2, circleRadius2) {
+            return es.Vector2.distanceSquared(circleCenter1, circleCenter2) < (circleRadius1 + circleRadius2) * (circleRadius1 + circleRadius2);
+        };
+        Collisions.isCircleToLine = function (circleCenter, radius, lineFrom, lineTo) {
+            return es.Vector2.distanceSquared(circleCenter, this.closestPointOnLine(lineFrom, lineTo, circleCenter)) < radius * radius;
+        };
+        Collisions.isCircleToPoint = function (circleCenter, radius, point) {
+            return es.Vector2.distanceSquared(circleCenter, point) < radius * radius;
+        };
+        Collisions.isRectToCircle = function (rect, cPosition, cRadius) {
+            var ew = rect.width * 0.5;
+            var eh = rect.height * 0.5;
+            var vx = Math.max(0, Math.max(cPosition.x - rect.x) - ew);
+            var vy = Math.max(0, Math.max(cPosition.y - rect.y) - eh);
+            return vx * vx + vy * vy < cRadius * cRadius;
+        };
+        Collisions.isRectToLine = function (rect, lineFrom, lineTo) {
+            var fromSector = this.getSector(rect.x, rect.y, rect.width, rect.height, lineFrom);
+            var toSector = this.getSector(rect.x, rect.y, rect.width, rect.height, lineTo);
+            if (fromSector == PointSectors.center || toSector == PointSectors.center) {
+                return true;
+            }
+            else if ((fromSector & toSector) != 0) {
+                return false;
+            }
+            else {
+                var both = fromSector | toSector;
+                var edgeFrom = void 0;
+                var edgeTo = void 0;
+                if ((both & PointSectors.top) != 0) {
+                    edgeFrom = new es.Vector2(rect.x, rect.y);
+                    edgeTo = new es.Vector2(rect.x + rect.width, rect.y);
+                    if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
+                        return true;
+                }
+                if ((both & PointSectors.bottom) != 0) {
+                    edgeFrom = new es.Vector2(rect.x, rect.y + rect.height);
+                    edgeTo = new es.Vector2(rect.x + rect.width, rect.y + rect.height);
+                    if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
+                        return true;
+                }
+                if ((both & PointSectors.left) != 0) {
+                    edgeFrom = new es.Vector2(rect.x, rect.y);
+                    edgeTo = new es.Vector2(rect.x, rect.y + rect.height);
+                    if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
+                        return true;
+                }
+                if ((both & PointSectors.right) != 0) {
+                    edgeFrom = new es.Vector2(rect.x + rect.width, rect.y);
+                    edgeTo = new es.Vector2(rect.x + rect.width, rect.y + rect.height);
+                    if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
+                        return true;
+                }
+            }
             return false;
+        };
+        Collisions.isRectToPoint = function (rX, rY, rW, rH, point) {
+            return point.x >= rX && point.y >= rY && point.x < rX + rW && point.y < rY + rH;
+        };
+        Collisions.getSector = function (rX, rY, rW, rH, point) {
+            var sector = PointSectors.center;
+            if (point.x < rX)
+                sector |= PointSectors.left;
+            else if (point.x >= rX + rW)
+                sector |= PointSectors.right;
+            if (point.y < rY)
+                sector |= PointSectors.top;
+            else if (point.y >= rY + rH)
+                sector |= PointSectors.bottom;
+            return sector;
+        };
+        return Collisions;
+    }());
+    es.Collisions = Collisions;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Physics = (function () {
+        function Physics() {
         }
-        else {
-            var both = fromSector | toSector;
-            var edgeFrom = void 0;
-            var edgeTo = void 0;
-            if ((both & PointSectors.top) != 0) {
-                edgeFrom = new Vector2(rect.x, rect.y);
-                edgeTo = new Vector2(rect.x + rect.width, rect.y);
-                if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
-                    return true;
+        Physics.reset = function () {
+            this._spatialHash = new es.SpatialHash(this.spatialHashCellSize);
+        };
+        Physics.clear = function () {
+            this._spatialHash.clear();
+        };
+        Physics.overlapCircleAll = function (center, randius, results, layerMask) {
+            if (layerMask === void 0) { layerMask = -1; }
+            return this._spatialHash.overlapCircle(center, randius, results, layerMask);
+        };
+        Physics.boxcastBroadphase = function (rect, layerMask) {
+            if (layerMask === void 0) { layerMask = this.allLayers; }
+            var boxcastResult = this._spatialHash.aabbBroadphase(rect, null, layerMask);
+            return { colliders: boxcastResult.tempHashSet, rect: boxcastResult.bounds };
+        };
+        Physics.boxcastBroadphaseExcludingSelf = function (collider, rect, layerMask) {
+            if (layerMask === void 0) { layerMask = this.allLayers; }
+            return this._spatialHash.aabbBroadphase(rect, collider, layerMask);
+        };
+        Physics.addCollider = function (collider) {
+            Physics._spatialHash.register(collider);
+        };
+        Physics.removeCollider = function (collider) {
+            Physics._spatialHash.remove(collider);
+        };
+        Physics.updateCollider = function (collider) {
+            this._spatialHash.remove(collider);
+            this._spatialHash.register(collider);
+        };
+        Physics.debugDraw = function (secondsToDisplay) {
+            this._spatialHash.debugDraw(secondsToDisplay, 2);
+        };
+        Physics.spatialHashCellSize = 100;
+        Physics.allLayers = -1;
+        return Physics;
+    }());
+    es.Physics = Physics;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Shape = (function () {
+        function Shape() {
+        }
+        return Shape;
+    }());
+    es.Shape = Shape;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Polygon = (function (_super) {
+        __extends(Polygon, _super);
+        function Polygon(points, isBox) {
+            var _this = _super.call(this) || this;
+            _this._areEdgeNormalsDirty = true;
+            _this.isUnrotated = true;
+            _this.setPoints(points);
+            _this.isBox = isBox;
+            return _this;
+        }
+        Object.defineProperty(Polygon.prototype, "edgeNormals", {
+            get: function () {
+                if (this._areEdgeNormalsDirty)
+                    this.buildEdgeNormals();
+                return this._edgeNormals;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Polygon.prototype.setPoints = function (points) {
+            this.points = points;
+            this.recalculateCenterAndEdgeNormals();
+            this._originalPoints = [];
+            for (var i = 0; i < this.points.length; i++) {
+                this._originalPoints.push(this.points[i]);
             }
-            if ((both & PointSectors.bottom) != 0) {
-                edgeFrom = new Vector2(rect.x, rect.y + rect.height);
-                edgeTo = new Vector2(rect.x + rect.width, rect.y + rect.height);
-                if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
-                    return true;
+        };
+        Polygon.prototype.recalculateCenterAndEdgeNormals = function () {
+            this._polygonCenter = Polygon.findPolygonCenter(this.points);
+            this._areEdgeNormalsDirty = true;
+        };
+        Polygon.prototype.buildEdgeNormals = function () {
+            var totalEdges = this.isBox ? 2 : this.points.length;
+            if (this._edgeNormals == null || this._edgeNormals.length != totalEdges)
+                this._edgeNormals = new Array(totalEdges);
+            var p2;
+            for (var i = 0; i < totalEdges; i++) {
+                var p1 = this.points[i];
+                if (i + 1 >= this.points.length)
+                    p2 = this.points[0];
+                else
+                    p2 = this.points[i + 1];
+                var perp = es.Vector2Ext.perpendicular(p1, p2);
+                perp = es.Vector2.normalize(perp);
+                this._edgeNormals[i] = perp;
             }
-            if ((both & PointSectors.left) != 0) {
-                edgeFrom = new Vector2(rect.x, rect.y);
-                edgeTo = new Vector2(rect.x, rect.y + rect.height);
-                if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
-                    return true;
+        };
+        Polygon.buildSymmetricalPolygon = function (vertCount, radius) {
+            var verts = new Array(vertCount);
+            for (var i = 0; i < vertCount; i++) {
+                var a = 2 * Math.PI * (i / vertCount);
+                verts[i] = new es.Vector2(Math.cos(a), Math.sin(a) * radius);
             }
-            if ((both & PointSectors.right) != 0) {
-                edgeFrom = new Vector2(rect.x + rect.width, rect.y);
-                edgeTo = new Vector2(rect.x + rect.width, rect.y + rect.height);
-                if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
-                    return true;
+            return verts;
+        };
+        Polygon.recenterPolygonVerts = function (points) {
+            var center = this.findPolygonCenter(points);
+            for (var i = 0; i < points.length; i++)
+                points[i] = es.Vector2.subtract(points[i], center);
+        };
+        Polygon.findPolygonCenter = function (points) {
+            var x = 0, y = 0;
+            for (var i = 0; i < points.length; i++) {
+                x += points[i].x;
+                y += points[i].y;
             }
+            return new es.Vector2(x / points.length, y / points.length);
+        };
+        Polygon.getClosestPointOnPolygonToPoint = function (points, point) {
+            var distanceSquared = Number.MAX_VALUE;
+            var edgeNormal = new es.Vector2(0, 0);
+            var closestPoint = new es.Vector2(0, 0);
+            var tempDistanceSquared;
+            for (var i = 0; i < points.length; i++) {
+                var j = i + 1;
+                if (j == points.length)
+                    j = 0;
+                var closest = es.ShapeCollisions.closestPointOnLine(points[i], points[j], point);
+                tempDistanceSquared = es.Vector2.distanceSquared(point, closest);
+                if (tempDistanceSquared < distanceSquared) {
+                    distanceSquared = tempDistanceSquared;
+                    closestPoint = closest;
+                    var line = es.Vector2.subtract(points[j], points[i]);
+                    edgeNormal.x = -line.y;
+                    edgeNormal.y = line.x;
+                }
+            }
+            edgeNormal = es.Vector2.normalize(edgeNormal);
+            return { closestPoint: closestPoint, distanceSquared: distanceSquared, edgeNormal: edgeNormal };
+        };
+        Polygon.prototype.recalculateBounds = function (collider) {
+            this.center = collider.localOffset;
+            if (collider.shouldColliderScaleAndRotateWithTransform) {
+                this.isUnrotated = collider.entity.transform.rotation == 0;
+            }
+            this.position = es.Vector2.add(collider.entity.transform.position, this.center);
+            this.bounds = es.Rectangle.rectEncompassingPoints(this.points);
+            this.bounds.location = es.Vector2.add(this.bounds.location, this.position);
+        };
+        Polygon.prototype.overlaps = function (other) {
+            var result;
+            if (other instanceof Polygon)
+                return es.ShapeCollisions.polygonToPolygon(this, other);
+            if (other instanceof es.Circle) {
+                result = es.ShapeCollisions.circleToPolygon(other, this);
+                if (result) {
+                    result.invertResult();
+                    return true;
+                }
+                return false;
+            }
+            throw new Error("overlaps of Pologon to " + other + " are not supported");
+        };
+        Polygon.prototype.collidesWithShape = function (other) {
+            var result = new es.CollisionResult();
+            if (other instanceof Polygon) {
+                return es.ShapeCollisions.polygonToPolygon(this, other);
+            }
+            if (other instanceof es.Circle) {
+                result = es.ShapeCollisions.circleToPolygon(other, this);
+                if (result) {
+                    result.invertResult();
+                    return result;
+                }
+                return null;
+            }
+            throw new Error("overlaps of Polygon to " + other + " are not supported");
+        };
+        Polygon.prototype.containsPoint = function (point) {
+            point = es.Vector2.subtract(point, this.position);
+            var isInside = false;
+            for (var i = 0, j = this.points.length - 1; i < this.points.length; j = i++) {
+                if (((this.points[i].y > point.y) != (this.points[j].y > point.y)) &&
+                    (point.x < (this.points[j].x - this.points[i].x) * (point.y - this.points[i].y) / (this.points[j].y - this.points[i].y) +
+                        this.points[i].x)) {
+                    isInside = !isInside;
+                }
+            }
+            return isInside;
+        };
+        Polygon.prototype.pointCollidesWithShape = function (point) {
+            return es.ShapeCollisions.pointToPoly(point, this);
+        };
+        return Polygon;
+    }(es.Shape));
+    es.Polygon = Polygon;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Box = (function (_super) {
+        __extends(Box, _super);
+        function Box(width, height) {
+            var _this = _super.call(this, Box.buildBox(width, height), true) || this;
+            _this.width = width;
+            _this.height = height;
+            return _this;
         }
-        return false;
-    };
-    Collisions.isRectToPoint = function (rX, rY, rW, rH, point) {
-        return point.x >= rX && point.y >= rY && point.x < rX + rW && point.y < rY + rH;
-    };
-    Collisions.getSector = function (rX, rY, rW, rH, point) {
-        var sector = PointSectors.center;
-        if (point.x < rX)
-            sector |= PointSectors.left;
-        else if (point.x >= rX + rW)
-            sector |= PointSectors.right;
-        if (point.y < rY)
-            sector |= PointSectors.top;
-        else if (point.y >= rY + rH)
-            sector |= PointSectors.bottom;
-        return sector;
-    };
-    return Collisions;
-}());
-var Physics = (function () {
-    function Physics() {
-    }
-    Physics.reset = function () {
-        this._spatialHash = new SpatialHash(this.spatialHashCellSize);
-    };
-    Physics.clear = function () {
-        this._spatialHash.clear();
-    };
-    Physics.overlapCircleAll = function (center, randius, results, layerMask) {
-        if (layerMask === void 0) { layerMask = -1; }
-        return this._spatialHash.overlapCircle(center, randius, results, layerMask);
-    };
-    Physics.boxcastBroadphase = function (rect, layerMask) {
-        if (layerMask === void 0) { layerMask = this.allLayers; }
-        var boxcastResult = this._spatialHash.aabbBroadphase(rect, null, layerMask);
-        return { colliders: boxcastResult.tempHashSet, rect: boxcastResult.bounds };
-    };
-    Physics.boxcastBroadphaseExcludingSelf = function (collider, rect, layerMask) {
-        if (layerMask === void 0) { layerMask = this.allLayers; }
-        return this._spatialHash.aabbBroadphase(rect, collider, layerMask);
-    };
-    Physics.addCollider = function (collider) {
-        Physics._spatialHash.register(collider);
-    };
-    Physics.removeCollider = function (collider) {
-        Physics._spatialHash.remove(collider);
-    };
-    Physics.updateCollider = function (collider) {
-        this._spatialHash.remove(collider);
-        this._spatialHash.register(collider);
-    };
-    Physics.debugDraw = function (secondsToDisplay) {
-        this._spatialHash.debugDraw(secondsToDisplay, 2);
-    };
-    Physics.spatialHashCellSize = 100;
-    Physics.allLayers = -1;
-    return Physics;
-}());
-var Shape = (function (_super) {
-    __extends(Shape, _super);
-    function Shape() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return Shape;
-}(egret.DisplayObject));
-var Polygon = (function (_super) {
-    __extends(Polygon, _super);
-    function Polygon(points, isBox) {
-        var _this = _super.call(this) || this;
-        _this._areEdgeNormalsDirty = true;
-        _this.center = new Vector2();
-        _this.setPoints(points);
-        _this.isBox = isBox;
-        return _this;
-    }
-    Object.defineProperty(Polygon.prototype, "position", {
-        get: function () {
-            return new Vector2(this.parent.x, this.parent.y);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Polygon.prototype, "bounds", {
-        get: function () {
-            return new Rectangle(this.x, this.y, this.width, this.height);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Polygon.prototype, "edgeNormals", {
-        get: function () {
-            if (this._areEdgeNormalsDirty)
-                this.buildEdgeNormals();
-            return this._edgeNormals;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Polygon.prototype.buildEdgeNormals = function () {
-        var totalEdges = this.isBox ? 2 : this.points.length;
-        if (this._edgeNormals == null || this._edgeNormals.length != totalEdges)
-            this._edgeNormals = new Array(totalEdges);
-        var p2;
-        for (var i = 0; i < totalEdges; i++) {
-            var p1 = this.points[i];
-            if (i + 1 >= this.points.length)
-                p2 = this.points[0];
-            else
-                p2 = this.points[i + 1];
-            var perp = Vector2Ext.perpendicular(p1, p2);
-            perp = Vector2.normalize(perp);
-            this._edgeNormals[i] = perp;
+        Box.buildBox = function (width, height) {
+            var halfWidth = width / 2;
+            var halfHeight = height / 2;
+            var verts = new Array(4);
+            verts[0] = new es.Vector2(-halfWidth, -halfHeight);
+            verts[1] = new es.Vector2(halfWidth, -halfHeight);
+            verts[2] = new es.Vector2(halfWidth, halfHeight);
+            verts[3] = new es.Vector2(-halfWidth, halfHeight);
+            return verts;
+        };
+        Box.prototype.updateBox = function (width, height) {
+            this.width = width;
+            this.height = height;
+            var halfWidth = width / 2;
+            var halfHeight = height / 2;
+            this.points[0] = new es.Vector2(-halfWidth, -halfHeight);
+            this.points[1] = new es.Vector2(halfWidth, -halfHeight);
+            this.points[2] = new es.Vector2(halfWidth, halfHeight);
+            this.points[3] = new es.Vector2(-halfWidth, halfHeight);
+            for (var i = 0; i < this.points.length; i++)
+                this._originalPoints[i] = this.points[i];
+        };
+        Box.prototype.overlaps = function (other) {
+            if (this.isUnrotated) {
+                if (other instanceof Box)
+                    return this.bounds.intersects(other.bounds);
+                if (other instanceof es.Circle)
+                    return es.Collisions.isRectToCircle(this.bounds, other.position, other.radius);
+            }
+            return _super.prototype.overlaps.call(this, other);
+        };
+        Box.prototype.collidesWithShape = function (other) {
+            if (other instanceof Box && other.isUnrotated) {
+                return es.ShapeCollisions.boxToBox(this, other);
+            }
+            return _super.prototype.collidesWithShape.call(this, other);
+        };
+        Box.prototype.containsPoint = function (point) {
+            if (this.isUnrotated)
+                return this.bounds.contains(point.x, point.y);
+            return _super.prototype.containsPoint.call(this, point);
+        };
+        return Box;
+    }(es.Polygon));
+    es.Box = Box;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Circle = (function (_super) {
+        __extends(Circle, _super);
+        function Circle(radius) {
+            var _this = _super.call(this) || this;
+            _this.radius = radius;
+            _this._originalRadius = radius;
+            return _this;
         }
-    };
-    Polygon.prototype.setPoints = function (points) {
-        this.points = points;
-        this.recalculateCenterAndEdgeNormals();
-        this._originalPoints = [];
-        for (var i = 0; i < this.points.length; i++) {
-            this._originalPoints.push(this.points[i]);
+        Circle.prototype.recalculateBounds = function (collider) {
+            this.center = collider.localOffset;
+            if (collider.shouldColliderScaleAndRotateWithTransform) {
+                var scale = collider.entity.transform.scale;
+                var hasUnitScale = scale.x == 1 && scale.y == 1;
+                var maxScale = Math.max(scale.x, scale.y);
+                this.radius = this._originalRadius * maxScale;
+                if (collider.entity.transform.rotation != 0) {
+                    var offsetAngle = Math.atan2(collider.localOffset.y, collider.localOffset.x) * es.MathHelper.Rad2Deg;
+                    var offsetLength = hasUnitScale ? collider._localOffsetLength : es.Vector2.multiply(collider.localOffset, collider.entity.transform.scale).length();
+                    this.center = es.MathHelper.pointOnCirlce(es.Vector2.zero, offsetLength, collider.entity.transform.rotation + offsetAngle);
+                }
+            }
+            this.position = es.Vector2.add(collider.transform.position, this.center);
+            this.bounds = new es.Rectangle(this.position.x - this.radius, this.position.y - this.radius, this.radius * 2, this.radius * 2);
+        };
+        Circle.prototype.overlaps = function (other) {
+            if (other instanceof es.Box && other.isUnrotated)
+                return es.Collisions.isRectToCircle(other.bounds, this.position, this.radius);
+            if (other instanceof Circle)
+                return es.Collisions.isCircleToCircle(this.position, this.radius, other.position, other.radius);
+            if (other instanceof es.Polygon)
+                return es.ShapeCollisions.circleToPolygon(this, other);
+            throw new Error("overlaps of circle to " + other + " are not supported");
+        };
+        Circle.prototype.collidesWithShape = function (other) {
+            if (other instanceof es.Box && other.isUnrotated) {
+                return es.ShapeCollisions.circleToBox(this, other);
+            }
+            if (other instanceof Circle) {
+                return es.ShapeCollisions.circleToCircle(this, other);
+            }
+            if (other instanceof es.Polygon) {
+                return es.ShapeCollisions.circleToPolygon(this, other);
+            }
+            throw new Error("Collisions of Circle to " + other + " are not supported");
+        };
+        Circle.prototype.pointCollidesWithShape = function (point) {
+            return es.ShapeCollisions.pointToCircle(point, this);
+        };
+        return Circle;
+    }(es.Shape));
+    es.Circle = Circle;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var CollisionResult = (function () {
+        function CollisionResult() {
+            this.minimumTranslationVector = es.Vector2.zero;
+            this.normal = es.Vector2.zero;
+            this.point = es.Vector2.zero;
         }
-    };
-    Polygon.prototype.collidesWithShape = function (other) {
-        var result = new CollisionResult();
-        if (other instanceof Polygon) {
-            return ShapeCollisions.polygonToPolygon(this, other);
+        CollisionResult.prototype.invertResult = function () {
+            this.minimumTranslationVector = es.Vector2.negate(this.minimumTranslationVector);
+            this.normal = es.Vector2.negate(this.normal);
+        };
+        return CollisionResult;
+    }());
+    es.CollisionResult = CollisionResult;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var ShapeCollisions = (function () {
+        function ShapeCollisions() {
         }
-        if (other instanceof Circle) {
-            result = ShapeCollisions.circleToPolygon(other, this);
-            if (result) {
-                result.invertResult();
+        ShapeCollisions.polygonToPolygon = function (first, second) {
+            var result = new es.CollisionResult();
+            var isIntersecting = true;
+            var firstEdges = first.edgeNormals;
+            var secondEdges = second.edgeNormals;
+            var minIntervalDistance = Number.POSITIVE_INFINITY;
+            var translationAxis = new es.Vector2();
+            var polygonOffset = es.Vector2.subtract(first.position, second.position);
+            var axis;
+            for (var edgeIndex = 0; edgeIndex < firstEdges.length + secondEdges.length; edgeIndex++) {
+                if (edgeIndex < firstEdges.length) {
+                    axis = firstEdges[edgeIndex];
+                }
+                else {
+                    axis = secondEdges[edgeIndex - firstEdges.length];
+                }
+                var minA = 0;
+                var minB = 0;
+                var maxA = 0;
+                var maxB = 0;
+                var intervalDist = 0;
+                var ta = this.getInterval(axis, first, minA, maxA);
+                minA = ta.min;
+                minB = ta.max;
+                var tb = this.getInterval(axis, second, minB, maxB);
+                minB = tb.min;
+                maxB = tb.max;
+                var relativeIntervalOffset = es.Vector2.dot(polygonOffset, axis);
+                minA += relativeIntervalOffset;
+                maxA += relativeIntervalOffset;
+                intervalDist = this.intervalDistance(minA, maxA, minB, maxB);
+                if (intervalDist > 0)
+                    isIntersecting = false;
+                if (!isIntersecting)
+                    return null;
+                intervalDist = Math.abs(intervalDist);
+                if (intervalDist < minIntervalDistance) {
+                    minIntervalDistance = intervalDist;
+                    translationAxis = axis;
+                    if (es.Vector2.dot(translationAxis, polygonOffset) < 0)
+                        translationAxis = new es.Vector2(-translationAxis);
+                }
+            }
+            result.normal = translationAxis;
+            result.minimumTranslationVector = es.Vector2.multiply(new es.Vector2(-translationAxis.x, -translationAxis.y), new es.Vector2(minIntervalDistance));
+            return result;
+        };
+        ShapeCollisions.intervalDistance = function (minA, maxA, minB, maxB) {
+            if (minA < minB)
+                return minB - maxA;
+            return minA - minB;
+        };
+        ShapeCollisions.getInterval = function (axis, polygon, min, max) {
+            var dot = es.Vector2.dot(polygon.points[0], axis);
+            min = max = dot;
+            for (var i = 1; i < polygon.points.length; i++) {
+                dot = es.Vector2.dot(polygon.points[i], axis);
+                if (dot < min) {
+                    min = dot;
+                }
+                else if (dot > max) {
+                    max = dot;
+                }
+            }
+            return { min: min, max: max };
+        };
+        ShapeCollisions.circleToPolygon = function (circle, polygon) {
+            var result = new es.CollisionResult();
+            var poly2Circle = es.Vector2.subtract(circle.position, polygon.position);
+            var gpp = es.Polygon.getClosestPointOnPolygonToPoint(polygon.points, poly2Circle);
+            var closestPoint = gpp.closestPoint;
+            var distanceSquared = gpp.distanceSquared;
+            result.normal = gpp.edgeNormal;
+            var circleCenterInsidePoly = polygon.containsPoint(circle.position);
+            if (distanceSquared > circle.radius * circle.radius && !circleCenterInsidePoly)
+                return null;
+            var mtv;
+            if (circleCenterInsidePoly) {
+                mtv = es.Vector2.multiply(result.normal, new es.Vector2(Math.sqrt(distanceSquared) - circle.radius));
+            }
+            else {
+                if (distanceSquared == 0) {
+                    mtv = es.Vector2.multiply(result.normal, new es.Vector2(circle.radius));
+                }
+                else {
+                    var distance = Math.sqrt(distanceSquared);
+                    mtv = es.Vector2.multiply(new es.Vector2(-es.Vector2.subtract(poly2Circle, closestPoint)), new es.Vector2((circle.radius - distanceSquared) / distance));
+                }
+            }
+            result.minimumTranslationVector = mtv;
+            result.point = es.Vector2.add(closestPoint, polygon.position);
+            return result;
+        };
+        ShapeCollisions.circleToBox = function (circle, box) {
+            var result = new es.CollisionResult();
+            var closestPointOnBounds = box.bounds.getClosestPointOnRectangleBorderToPoint(circle.position).res;
+            if (box.containsPoint(circle.position)) {
+                result.point = closestPointOnBounds;
+                var safePlace = es.Vector2.add(closestPointOnBounds, es.Vector2.subtract(result.normal, new es.Vector2(circle.radius)));
+                result.minimumTranslationVector = es.Vector2.subtract(circle.position, safePlace);
+                return result;
+            }
+            var sqrDistance = es.Vector2.distanceSquared(closestPointOnBounds, circle.position);
+            if (sqrDistance == 0) {
+                result.minimumTranslationVector = es.Vector2.multiply(result.normal, new es.Vector2(circle.radius));
+            }
+            else if (sqrDistance <= circle.radius * circle.radius) {
+                result.normal = es.Vector2.subtract(circle.position, closestPointOnBounds);
+                var depth = result.normal.length() - circle.radius;
+                result.normal = es.Vector2Ext.normalize(result.normal);
+                result.minimumTranslationVector = es.Vector2.multiply(new es.Vector2(depth), result.normal);
                 return result;
             }
             return null;
-        }
-        throw new Error("overlaps of Polygon to " + other + " are not supported");
-    };
-    Polygon.prototype.recalculateCenterAndEdgeNormals = function () {
-        this._polygonCenter = Polygon.findPolygonCenter(this.points);
-        this._areEdgeNormalsDirty = true;
-    };
-    Polygon.prototype.overlaps = function (other) {
-        var result;
-        if (other instanceof Polygon)
-            return ShapeCollisions.polygonToPolygon(this, other);
-        if (other instanceof Circle) {
-            result = ShapeCollisions.circleToPolygon(other, this);
-            if (result) {
-                result.invertResult();
-                return true;
+        };
+        ShapeCollisions.pointToCircle = function (point, circle) {
+            var result = new es.CollisionResult();
+            var distanceSquared = es.Vector2.distanceSquared(point, circle.position);
+            var sumOfRadii = 1 + circle.radius;
+            var collided = distanceSquared < sumOfRadii * sumOfRadii;
+            if (collided) {
+                result.normal = es.Vector2.normalize(es.Vector2.subtract(point, circle.position));
+                var depth = sumOfRadii - Math.sqrt(distanceSquared);
+                result.minimumTranslationVector = es.Vector2.multiply(new es.Vector2(-depth, -depth), result.normal);
+                result.point = es.Vector2.add(circle.position, es.Vector2.multiply(result.normal, new es.Vector2(circle.radius, circle.radius)));
+                return result;
             }
-            return false;
-        }
-        throw new Error("overlaps of Pologon to " + other + " are not supported");
-    };
-    Polygon.findPolygonCenter = function (points) {
-        var x = 0, y = 0;
-        for (var i = 0; i < points.length; i++) {
-            x += points[i].x;
-            y += points[i].y;
-        }
-        return new Vector2(x / points.length, y / points.length);
-    };
-    Polygon.recenterPolygonVerts = function (points) {
-        var center = this.findPolygonCenter(points);
-        for (var i = 0; i < points.length; i++)
-            points[i] = Vector2.subtract(points[i], center);
-    };
-    Polygon.getClosestPointOnPolygonToPoint = function (points, point) {
-        var distanceSquared = Number.MAX_VALUE;
-        var edgeNormal = new Vector2(0, 0);
-        var closestPoint = new Vector2(0, 0);
-        var tempDistanceSquared;
-        for (var i = 0; i < points.length; i++) {
-            var j = i + 1;
-            if (j == points.length)
-                j = 0;
-            var closest = ShapeCollisions.closestPointOnLine(points[i], points[j], point);
-            tempDistanceSquared = Vector2.distanceSquared(point, closest);
-            if (tempDistanceSquared < distanceSquared) {
-                distanceSquared = tempDistanceSquared;
-                closestPoint = closest;
-                var line = Vector2.subtract(points[j], points[i]);
-                edgeNormal.x = -line.y;
-                edgeNormal.y = line.x;
-            }
-        }
-        edgeNormal = Vector2.normalize(edgeNormal);
-        return { closestPoint: closestPoint, distanceSquared: distanceSquared, edgeNormal: edgeNormal };
-    };
-    Polygon.prototype.pointCollidesWithShape = function (point) {
-        return ShapeCollisions.pointToPoly(point, this);
-    };
-    Polygon.prototype.containsPoint = function (point) {
-        point = Vector2.subtract(point, this.position);
-        var isInside = false;
-        for (var i = 0, j = this.points.length - 1; i < this.points.length; j = i++) {
-            if (((this.points[i].y > point.y) != (this.points[j].y > point.y)) &&
-                (point.x < (this.points[j].x - this.points[i].x) * (point.y - this.points[i].y) / (this.points[j].y - this.points[i].y) +
-                    this.points[i].x)) {
-                isInside = !isInside;
-            }
-        }
-        return isInside;
-    };
-    Polygon.buildSymmertricalPolygon = function (vertCount, radius) {
-        var verts = new Array(vertCount);
-        for (var i = 0; i < vertCount; i++) {
-            var a = 2 * Math.PI * (i / vertCount);
-            verts[i] = new Vector2(Math.cos(a), Math.sin(a) * radius);
-        }
-        return verts;
-    };
-    return Polygon;
-}(Shape));
-var Box = (function (_super) {
-    __extends(Box, _super);
-    function Box(width, height) {
-        var _this = _super.call(this, Box.buildBox(width, height), true) || this;
-        _this.width = width;
-        _this.height = height;
-        return _this;
-    }
-    Box.buildBox = function (width, height) {
-        var halfWidth = width / 2;
-        var halfHeight = height / 2;
-        var verts = new Array(4);
-        verts[0] = new Vector2(-halfWidth, -halfHeight);
-        verts[1] = new Vector2(halfWidth, -halfHeight);
-        verts[2] = new Vector2(halfWidth, halfHeight);
-        verts[3] = new Vector2(-halfWidth, halfHeight);
-        return verts;
-    };
-    Box.prototype.overlaps = function (other) {
-        if (other instanceof Box)
-            return this.bounds.intersects(other.bounds);
-        if (other instanceof Circle)
-            return Collisions.isRectToCircle(this.bounds, other.position, other.radius);
-        return _super.prototype.overlaps.call(this, other);
-    };
-    Box.prototype.collidesWithShape = function (other) {
-        if (other instanceof Box) {
-            return ShapeCollisions.boxToBox(this, other);
-        }
-        return _super.prototype.collidesWithShape.call(this, other);
-    };
-    Box.prototype.updateBox = function (width, height) {
-        this.width = width;
-        this.height = height;
-        var halfWidth = width / 2;
-        var halfHeight = height / 2;
-        this.points[0] = new Vector2(-halfWidth, -halfHeight);
-        this.points[1] = new Vector2(halfWidth, -halfHeight);
-        this.points[2] = new Vector2(halfWidth, halfHeight);
-        this.points[3] = new Vector2(-halfWidth, halfHeight);
-        for (var i = 0; i < this.points.length; i++)
-            this._originalPoints[i] = this.points[i];
-    };
-    Box.prototype.containsPoint = function (point) {
-        return this.bounds.contains(point.x, point.y);
-    };
-    return Box;
-}(Polygon));
-var Circle = (function (_super) {
-    __extends(Circle, _super);
-    function Circle(radius) {
-        var _this = _super.call(this) || this;
-        _this.center = new Vector2();
-        _this.radius = radius;
-        _this._originalRadius = radius;
-        return _this;
-    }
-    Object.defineProperty(Circle.prototype, "position", {
-        get: function () {
-            return new Vector2(this.parent.x, this.parent.y);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Circle.prototype, "bounds", {
-        get: function () {
-            return new Rectangle().setEgretRect(this.getBounds());
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Circle.prototype.pointCollidesWithShape = function (point) {
-        return ShapeCollisions.pointToCircle(point, this);
-    };
-    Circle.prototype.collidesWithShape = function (other) {
-        if (other instanceof Box) {
-            return ShapeCollisions.circleToBox(this, other);
-        }
-        if (other instanceof Circle) {
-            return ShapeCollisions.circleToCircle(this, other);
-        }
-        if (other instanceof Polygon) {
-            return ShapeCollisions.circleToPolygon(this, other);
-        }
-        throw new Error("Collisions of Circle to " + other + " are not supported");
-    };
-    Circle.prototype.overlaps = function (other) {
-        if (other instanceof Box)
-            return Collisions.isRectToCircle(other.bounds, this.position, this.radius);
-        if (other instanceof Circle)
-            return Collisions.isCircleToCircle(this.position, this.radius, other.position, other.radius);
-        if (other instanceof Polygon)
-            return ShapeCollisions.circleToPolygon(this, other);
-        throw new Error("overlaps of circle to " + other + " are not supported");
-    };
-    return Circle;
-}(Shape));
-var CollisionResult = (function () {
-    function CollisionResult() {
-        this.minimumTranslationVector = Vector2.zero;
-        this.normal = Vector2.zero;
-        this.point = Vector2.zero;
-    }
-    CollisionResult.prototype.invertResult = function () {
-        this.minimumTranslationVector = Vector2.negate(this.minimumTranslationVector);
-        this.normal = Vector2.negate(this.normal);
-    };
-    return CollisionResult;
-}());
-var ShapeCollisions = (function () {
-    function ShapeCollisions() {
-    }
-    ShapeCollisions.polygonToPolygon = function (first, second) {
-        var result = new CollisionResult();
-        var isIntersecting = true;
-        var firstEdges = first.edgeNormals;
-        var secondEdges = second.edgeNormals;
-        var minIntervalDistance = Number.POSITIVE_INFINITY;
-        var translationAxis = new Vector2();
-        var polygonOffset = Vector2.subtract(first.position, second.position);
-        var axis;
-        for (var edgeIndex = 0; edgeIndex < firstEdges.length + secondEdges.length; edgeIndex++) {
-            if (edgeIndex < firstEdges.length) {
-                axis = firstEdges[edgeIndex];
-            }
-            else {
-                axis = secondEdges[edgeIndex - firstEdges.length];
-            }
-            var minA = 0;
-            var minB = 0;
-            var maxA = 0;
-            var maxB = 0;
-            var intervalDist = 0;
-            var ta = this.getInterval(axis, first, minA, maxA);
-            minA = ta.min;
-            minB = ta.max;
-            var tb = this.getInterval(axis, second, minB, maxB);
-            minB = tb.min;
-            maxB = tb.max;
-            var relativeIntervalOffset = Vector2.dot(polygonOffset, axis);
-            minA += relativeIntervalOffset;
-            maxA += relativeIntervalOffset;
-            intervalDist = this.intervalDistance(minA, maxA, minB, maxB);
-            if (intervalDist > 0)
-                isIntersecting = false;
-            if (!isIntersecting)
-                return null;
-            intervalDist = Math.abs(intervalDist);
-            if (intervalDist < minIntervalDistance) {
-                minIntervalDistance = intervalDist;
-                translationAxis = axis;
-                if (Vector2.dot(translationAxis, polygonOffset) < 0)
-                    translationAxis = new Vector2(-translationAxis);
-            }
-        }
-        result.normal = translationAxis;
-        result.minimumTranslationVector = Vector2.multiply(new Vector2(-translationAxis.x, -translationAxis.y), new Vector2(minIntervalDistance));
-        return result;
-    };
-    ShapeCollisions.intervalDistance = function (minA, maxA, minB, maxB) {
-        if (minA < minB)
-            return minB - maxA;
-        return minA - minB;
-    };
-    ShapeCollisions.getInterval = function (axis, polygon, min, max) {
-        var dot = Vector2.dot(polygon.points[0], axis);
-        min = max = dot;
-        for (var i = 1; i < polygon.points.length; i++) {
-            dot = Vector2.dot(polygon.points[i], axis);
-            if (dot < min) {
-                min = dot;
-            }
-            else if (dot > max) {
-                max = dot;
-            }
-        }
-        return { min: min, max: max };
-    };
-    ShapeCollisions.circleToPolygon = function (circle, polygon) {
-        var result = new CollisionResult();
-        var poly2Circle = Vector2.subtract(circle.position, polygon.position);
-        var gpp = Polygon.getClosestPointOnPolygonToPoint(polygon.points, poly2Circle);
-        var closestPoint = gpp.closestPoint;
-        var distanceSquared = gpp.distanceSquared;
-        result.normal = gpp.edgeNormal;
-        var circleCenterInsidePoly = polygon.containsPoint(circle.position);
-        if (distanceSquared > circle.radius * circle.radius && !circleCenterInsidePoly)
             return null;
-        var mtv;
-        if (circleCenterInsidePoly) {
-            mtv = Vector2.multiply(result.normal, new Vector2(Math.sqrt(distanceSquared) - circle.radius));
-        }
-        else {
-            if (distanceSquared == 0) {
-                mtv = Vector2.multiply(result.normal, new Vector2(circle.radius));
+        };
+        ShapeCollisions.closestPointOnLine = function (lineA, lineB, closestTo) {
+            var v = es.Vector2.subtract(lineB, lineA);
+            var w = es.Vector2.subtract(closestTo, lineA);
+            var t = es.Vector2.dot(w, v) / es.Vector2.dot(v, v);
+            t = es.MathHelper.clamp(t, 0, 1);
+            return es.Vector2.add(lineA, es.Vector2.multiply(v, new es.Vector2(t, t)));
+        };
+        ShapeCollisions.pointToPoly = function (point, poly) {
+            var result = new es.CollisionResult();
+            if (poly.containsPoint(point)) {
+                var distanceSquared = void 0;
+                var gpp = es.Polygon.getClosestPointOnPolygonToPoint(poly.points, es.Vector2.subtract(point, poly.position));
+                var closestPoint = gpp.closestPoint;
+                distanceSquared = gpp.distanceSquared;
+                result.normal = gpp.edgeNormal;
+                result.minimumTranslationVector = es.Vector2.multiply(result.normal, new es.Vector2(Math.sqrt(distanceSquared), Math.sqrt(distanceSquared)));
+                result.point = es.Vector2.add(closestPoint, poly.position);
+                return result;
             }
-            else {
-                var distance = Math.sqrt(distanceSquared);
-                mtv = Vector2.multiply(new Vector2(-Vector2.subtract(poly2Circle, closestPoint)), new Vector2((circle.radius - distanceSquared) / distance));
+            return null;
+        };
+        ShapeCollisions.circleToCircle = function (first, second) {
+            var result = new es.CollisionResult();
+            var distanceSquared = es.Vector2.distanceSquared(first.position, second.position);
+            var sumOfRadii = first.radius + second.radius;
+            var collided = distanceSquared < sumOfRadii * sumOfRadii;
+            if (collided) {
+                result.normal = es.Vector2.normalize(es.Vector2.subtract(first.position, second.position));
+                var depth = sumOfRadii - Math.sqrt(distanceSquared);
+                result.minimumTranslationVector = es.Vector2.multiply(new es.Vector2(-depth), result.normal);
+                result.point = es.Vector2.add(second.position, es.Vector2.multiply(result.normal, new es.Vector2(second.radius)));
+                return result;
             }
-        }
-        result.minimumTranslationVector = mtv;
-        result.point = Vector2.add(closestPoint, polygon.position);
-        return result;
-    };
-    ShapeCollisions.circleToBox = function (circle, box) {
-        var result = new CollisionResult();
-        var closestPointOnBounds = box.bounds.getClosestPointOnRectangleBorderToPoint(circle.position).res;
-        if (box.containsPoint(circle.position)) {
-            result.point = closestPointOnBounds;
-            var safePlace = Vector2.add(closestPointOnBounds, Vector2.subtract(result.normal, new Vector2(circle.radius)));
-            result.minimumTranslationVector = Vector2.subtract(circle.position, safePlace);
-            return result;
-        }
-        var sqrDistance = Vector2.distanceSquared(closestPointOnBounds, circle.position);
-        if (sqrDistance == 0) {
-            result.minimumTranslationVector = Vector2.multiply(result.normal, new Vector2(circle.radius));
-        }
-        else if (sqrDistance <= circle.radius * circle.radius) {
-            result.normal = Vector2.subtract(circle.position, closestPointOnBounds);
-            var depth = result.normal.length() - circle.radius;
-            result.normal = Vector2Ext.normalize(result.normal);
-            result.minimumTranslationVector = Vector2.multiply(new Vector2(depth), result.normal);
-            return result;
-        }
-        return null;
-    };
-    ShapeCollisions.pointToCircle = function (point, circle) {
-        var result = new CollisionResult();
-        var distanceSquared = Vector2.distanceSquared(point, circle.position);
-        var sumOfRadii = 1 + circle.radius;
-        var collided = distanceSquared < sumOfRadii * sumOfRadii;
-        if (collided) {
-            result.normal = Vector2.normalize(Vector2.subtract(point, circle.position));
-            var depth = sumOfRadii - Math.sqrt(distanceSquared);
-            result.minimumTranslationVector = Vector2.multiply(new Vector2(-depth, -depth), result.normal);
-            result.point = Vector2.add(circle.position, Vector2.multiply(result.normal, new Vector2(circle.radius, circle.radius)));
-            return result;
-        }
-        return null;
-    };
-    ShapeCollisions.closestPointOnLine = function (lineA, lineB, closestTo) {
-        var v = Vector2.subtract(lineB, lineA);
-        var w = Vector2.subtract(closestTo, lineA);
-        var t = Vector2.dot(w, v) / Vector2.dot(v, v);
-        t = MathHelper.clamp(t, 0, 1);
-        return Vector2.add(lineA, Vector2.multiply(v, new Vector2(t, t)));
-    };
-    ShapeCollisions.pointToPoly = function (point, poly) {
-        var result = new CollisionResult();
-        if (poly.containsPoint(point)) {
-            var distanceSquared = void 0;
-            var gpp = Polygon.getClosestPointOnPolygonToPoint(poly.points, Vector2.subtract(point, poly.position));
-            var closestPoint = gpp.closestPoint;
-            distanceSquared = gpp.distanceSquared;
-            result.normal = gpp.edgeNormal;
-            result.minimumTranslationVector = Vector2.multiply(result.normal, new Vector2(Math.sqrt(distanceSquared), Math.sqrt(distanceSquared)));
-            result.point = Vector2.add(closestPoint, poly.position);
-            return result;
-        }
-        return null;
-    };
-    ShapeCollisions.circleToCircle = function (first, second) {
-        var result = new CollisionResult();
-        var distanceSquared = Vector2.distanceSquared(first.position, second.position);
-        var sumOfRadii = first.radius + second.radius;
-        var collided = distanceSquared < sumOfRadii * sumOfRadii;
-        if (collided) {
-            result.normal = Vector2.normalize(Vector2.subtract(first.position, second.position));
-            var depth = sumOfRadii - Math.sqrt(distanceSquared);
-            result.minimumTranslationVector = Vector2.multiply(new Vector2(-depth), result.normal);
-            result.point = Vector2.add(second.position, Vector2.multiply(result.normal, new Vector2(second.radius)));
-            return result;
-        }
-        return null;
-    };
-    ShapeCollisions.boxToBox = function (first, second) {
-        var result = new CollisionResult();
-        var minkowskiDiff = this.minkowskiDifference(first, second);
-        if (minkowskiDiff.contains(0, 0)) {
-            result.minimumTranslationVector = minkowskiDiff.getClosestPointOnBoundsToOrigin();
-            if (result.minimumTranslationVector.x == 0 && result.minimumTranslationVector.y == 0)
-                return null;
-            result.normal = new Vector2(-result.minimumTranslationVector.x, -result.minimumTranslationVector.y);
-            result.normal.normalize();
-            return result;
-        }
-        return null;
-    };
-    ShapeCollisions.minkowskiDifference = function (first, second) {
-        var positionOffset = Vector2.subtract(first.position, Vector2.add(first.bounds.location, Vector2.divide(first.bounds.size, new Vector2(2))));
-        var topLeft = Vector2.subtract(Vector2.add(first.bounds.location, positionOffset), second.bounds.max);
-        var fullSize = Vector2.add(first.bounds.size, second.bounds.size);
-        return new Rectangle(topLeft.x, topLeft.y, fullSize.x, fullSize.y);
-    };
-    return ShapeCollisions;
-}());
-var SpatialHash = (function () {
-    function SpatialHash(cellSize) {
-        if (cellSize === void 0) { cellSize = 100; }
-        this.gridBounds = new Rectangle();
-        this._overlapTestCircle = new Circle(0);
-        this._tempHashSet = [];
-        this._cellDict = new NumberDictionary();
-        this._cellSize = cellSize;
-        this._inverseCellSize = 1 / this._cellSize;
-        this._raycastParser = new RaycastResultParser();
-    }
-    SpatialHash.prototype.remove = function (collider) {
-        var bounds = collider.registeredPhysicsBounds;
-        var p1 = this.cellCoords(bounds.x, bounds.y);
-        var p2 = this.cellCoords(bounds.right, bounds.bottom);
-        for (var x = p1.x; x <= p2.x; x++) {
-            for (var y = p1.y; y <= p2.y; y++) {
-                var cell = this.cellAtPosition(x, y);
-                if (!cell)
-                    console.error("removing Collider [" + collider + "] from a cell that it is not present in");
-                else
-                    cell.remove(collider);
+            return null;
+        };
+        ShapeCollisions.boxToBox = function (first, second) {
+            var result = new es.CollisionResult();
+            var minkowskiDiff = this.minkowskiDifference(first, second);
+            if (minkowskiDiff.contains(0, 0)) {
+                result.minimumTranslationVector = minkowskiDiff.getClosestPointOnBoundsToOrigin();
+                if (result.minimumTranslationVector.x == 0 && result.minimumTranslationVector.y == 0)
+                    return null;
+                result.normal = new es.Vector2(-result.minimumTranslationVector.x, -result.minimumTranslationVector.y);
+                result.normal.normalize();
+                return result;
             }
+            return null;
+        };
+        ShapeCollisions.minkowskiDifference = function (first, second) {
+            var positionOffset = es.Vector2.subtract(first.position, es.Vector2.add(first.bounds.location, es.Vector2.divide(first.bounds.size, new es.Vector2(2))));
+            var topLeft = es.Vector2.subtract(es.Vector2.add(first.bounds.location, positionOffset), second.bounds.max);
+            var fullSize = es.Vector2.add(first.bounds.size, second.bounds.size);
+            return new es.Rectangle(topLeft.x, topLeft.y, fullSize.x, fullSize.y);
+        };
+        return ShapeCollisions;
+    }());
+    es.ShapeCollisions = ShapeCollisions;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var SpatialHash = (function () {
+        function SpatialHash(cellSize) {
+            if (cellSize === void 0) { cellSize = 100; }
+            this.gridBounds = new es.Rectangle();
+            this._overlapTestCircle = new es.Circle(0);
+            this._cellDict = new NumberDictionary();
+            this._tempHashSet = [];
+            this._cellSize = cellSize;
+            this._inverseCellSize = 1 / this._cellSize;
+            this._raycastParser = new RaycastResultParser();
         }
-    };
-    SpatialHash.prototype.register = function (collider) {
-        var bounds = collider.bounds;
-        collider.registeredPhysicsBounds = bounds;
-        var p1 = this.cellCoords(bounds.x, bounds.y);
-        var p2 = this.cellCoords(bounds.right, bounds.bottom);
-        if (!this.gridBounds.contains(p1.x, p1.y)) {
-            this.gridBounds = RectangleExt.union(this.gridBounds, p1);
-        }
-        if (!this.gridBounds.contains(p2.x, p2.y)) {
-            this.gridBounds = RectangleExt.union(this.gridBounds, p2);
-        }
-        for (var x = p1.x; x <= p2.x; x++) {
-            for (var y = p1.y; y <= p2.y; y++) {
-                var c = this.cellAtPosition(x, y, true);
-                if (c.indexOf(collider) == -1)
-                    c.push(collider);
-            }
-        }
-    };
-    SpatialHash.prototype.clear = function () {
-        this._cellDict.clear();
-    };
-    SpatialHash.prototype.overlapCircle = function (circleCenter, radius, results, layerMask) {
-        var bounds = new Rectangle(circleCenter.x - radius, circleCenter.y - radius, radius * 2, radius * 2);
-        this._overlapTestCircle.radius = radius;
-        var resultCounter = 0;
-        var aabbBroadphaseResult = this.aabbBroadphase(bounds, null, layerMask);
-        bounds = aabbBroadphaseResult.bounds;
-        var potentials = aabbBroadphaseResult.tempHashSet;
-        for (var i = 0; i < potentials.length; i++) {
-            var collider = potentials[i];
-            if (collider instanceof BoxCollider) {
-                results[resultCounter] = collider;
-                resultCounter++;
-            }
-            else if (collider instanceof CircleCollider) {
-                if (collider.shape.overlaps(this._overlapTestCircle)) {
-                    results[resultCounter] = collider;
-                    resultCounter++;
+        SpatialHash.prototype.cellCoords = function (x, y) {
+            return new es.Vector2(Math.floor(x * this._inverseCellSize), Math.floor(y * this._inverseCellSize));
+        };
+        SpatialHash.prototype.cellAtPosition = function (x, y, createCellIfEmpty) {
+            if (createCellIfEmpty === void 0) { createCellIfEmpty = false; }
+            var cell = this._cellDict.tryGetValue(x, y);
+            if (!cell) {
+                if (createCellIfEmpty) {
+                    cell = [];
+                    this._cellDict.add(x, y, cell);
                 }
             }
-            else if (collider instanceof PolygonCollider) {
-                if (collider.shape.overlaps(this._overlapTestCircle)) {
-                    results[resultCounter] = collider;
-                    resultCounter++;
+            return cell;
+        };
+        SpatialHash.prototype.register = function (collider) {
+            var bounds = collider.bounds;
+            collider.registeredPhysicsBounds = bounds;
+            var p1 = this.cellCoords(bounds.x, bounds.y);
+            var p2 = this.cellCoords(bounds.right, bounds.bottom);
+            if (!this.gridBounds.contains(p1.x, p1.y)) {
+                this.gridBounds = es.RectangleExt.union(this.gridBounds, p1);
+            }
+            if (!this.gridBounds.contains(p2.x, p2.y)) {
+                this.gridBounds = es.RectangleExt.union(this.gridBounds, p2);
+            }
+            for (var x = p1.x; x <= p2.x; x++) {
+                for (var y = p1.y; y <= p2.y; y++) {
+                    var c = this.cellAtPosition(x, y, true);
+                    if (c.indexOf(collider) == -1)
+                        c.push(collider);
                 }
             }
-            else {
-                throw new Error("overlapCircle against this collider type is not implemented!");
+        };
+        SpatialHash.prototype.remove = function (collider) {
+            var bounds = collider.registeredPhysicsBounds;
+            var p1 = this.cellCoords(bounds.x, bounds.y);
+            var p2 = this.cellCoords(bounds.right, bounds.bottom);
+            for (var x = p1.x; x <= p2.x; x++) {
+                for (var y = p1.y; y <= p2.y; y++) {
+                    var cell = this.cellAtPosition(x, y);
+                    if (!cell)
+                        console.error("removing Collider [" + collider + "] from a cell that it is not present in");
+                    else
+                        cell.remove(collider);
+                }
             }
-            if (resultCounter == results.length)
-                return resultCounter;
-        }
-        return resultCounter;
-    };
-    SpatialHash.prototype.aabbBroadphase = function (bounds, excludeCollider, layerMask) {
-        this._tempHashSet.length = 0;
-        var p1 = this.cellCoords(bounds.x, bounds.y);
-        var p2 = this.cellCoords(bounds.right, bounds.bottom);
-        for (var x = p1.x; x <= p2.x; x++) {
-            for (var y = p1.y; y <= p2.y; y++) {
-                var cell = this.cellAtPosition(x, y);
-                if (!cell)
-                    continue;
-                for (var i = 0; i < cell.length; i++) {
-                    var collider = cell[i];
-                    if (collider == excludeCollider || !Flags.isFlagSet(layerMask, collider.physicsLayer))
+        };
+        SpatialHash.prototype.removeWithBruteForce = function (obj) {
+            this._cellDict.remove(obj);
+        };
+        SpatialHash.prototype.clear = function () {
+            this._cellDict.clear();
+        };
+        SpatialHash.prototype.debugDraw = function (secondsToDisplay, textScale) {
+            if (textScale === void 0) { textScale = 1; }
+            for (var x = this.gridBounds.x; x <= this.gridBounds.right; x++) {
+                for (var y = this.gridBounds.y; y <= this.gridBounds.bottom; y++) {
+                    var cell = this.cellAtPosition(x, y);
+                    if (cell && cell.length > 0)
+                        this.debugDrawCellDetails(x, y, cell.length, secondsToDisplay, textScale);
+                }
+            }
+        };
+        SpatialHash.prototype.debugDrawCellDetails = function (x, y, cellCount, secondsToDisplay, textScale) {
+            if (secondsToDisplay === void 0) { secondsToDisplay = 0.5; }
+            if (textScale === void 0) { textScale = 1; }
+        };
+        SpatialHash.prototype.aabbBroadphase = function (bounds, excludeCollider, layerMask) {
+            this._tempHashSet.length = 0;
+            var p1 = this.cellCoords(bounds.x, bounds.y);
+            var p2 = this.cellCoords(bounds.right, bounds.bottom);
+            for (var x = p1.x; x <= p2.x; x++) {
+                for (var y = p1.y; y <= p2.y; y++) {
+                    var cell = this.cellAtPosition(x, y);
+                    if (!cell)
                         continue;
-                    if (bounds.intersects(collider.bounds)) {
-                        if (this._tempHashSet.indexOf(collider) == -1)
-                            this._tempHashSet.push(collider);
+                    for (var i = 0; i < cell.length; i++) {
+                        var collider = cell[i];
+                        if (collider == excludeCollider || !es.Flags.isFlagSet(layerMask, collider.physicsLayer))
+                            continue;
+                        if (bounds.intersects(collider.bounds)) {
+                            if (this._tempHashSet.indexOf(collider) == -1)
+                                this._tempHashSet.push(collider);
+                        }
                     }
                 }
             }
-        }
-        return { tempHashSet: this._tempHashSet, bounds: bounds };
-    };
-    SpatialHash.prototype.cellAtPosition = function (x, y, createCellIfEmpty) {
-        if (createCellIfEmpty === void 0) { createCellIfEmpty = false; }
-        var cell = this._cellDict.tryGetValue(x, y);
-        if (!cell) {
-            if (createCellIfEmpty) {
-                cell = [];
-                this._cellDict.add(x, y, cell);
+            return { tempHashSet: this._tempHashSet, bounds: bounds };
+        };
+        SpatialHash.prototype.overlapCircle = function (circleCenter, radius, results, layerMask) {
+            var bounds = new es.Rectangle(circleCenter.x - radius, circleCenter.y - radius, radius * 2, radius * 2);
+            this._overlapTestCircle.radius = radius;
+            this._overlapTestCircle.position = circleCenter;
+            var resultCounter = 0;
+            var aabbBroadphaseResult = this.aabbBroadphase(bounds, null, layerMask);
+            bounds = aabbBroadphaseResult.bounds;
+            var potentials = aabbBroadphaseResult.tempHashSet;
+            for (var i = 0; i < potentials.length; i++) {
+                var collider = potentials[i];
+                if (collider instanceof es.BoxCollider) {
+                    results[resultCounter] = collider;
+                    resultCounter++;
+                }
+                else if (collider instanceof es.CircleCollider) {
+                    if (collider.shape.overlaps(this._overlapTestCircle)) {
+                        results[resultCounter] = collider;
+                        resultCounter++;
+                    }
+                }
+                else if (collider instanceof es.PolygonCollider) {
+                    if (collider.shape.overlaps(this._overlapTestCircle)) {
+                        results[resultCounter] = collider;
+                        resultCounter++;
+                    }
+                }
+                else {
+                    throw new Error("overlapCircle against this collider type is not implemented!");
+                }
+                if (resultCounter == results.length)
+                    return resultCounter;
             }
+            return resultCounter;
+        };
+        return SpatialHash;
+    }());
+    es.SpatialHash = SpatialHash;
+    var NumberDictionary = (function () {
+        function NumberDictionary() {
+            this._store = new Map();
         }
-        return cell;
-    };
-    SpatialHash.prototype.cellCoords = function (x, y) {
-        return new Vector2(Math.floor(x * this._inverseCellSize), Math.floor(y * this._inverseCellSize));
-    };
-    SpatialHash.prototype.debugDraw = function (secondsToDisplay, textScale) {
-        if (textScale === void 0) { textScale = 1; }
-        for (var x = this.gridBounds.x; x <= this.gridBounds.right; x++) {
-            for (var y = this.gridBounds.y; y <= this.gridBounds.bottom; y++) {
-                var cell = this.cellAtPosition(x, y);
-                if (cell && cell.length > 0)
-                    this.debugDrawCellDetails(x, y, cell.length, secondsToDisplay, textScale);
-            }
+        NumberDictionary.prototype.getKey = function (x, y) {
+            return Long.fromNumber(x).shiftLeft(32).or(Long.fromNumber(y, false)).toString();
+        };
+        NumberDictionary.prototype.add = function (x, y, list) {
+            this._store.set(this.getKey(x, y), list);
+        };
+        NumberDictionary.prototype.remove = function (obj) {
+            this._store.forEach(function (list) {
+                if (list.contains(obj))
+                    list.remove(obj);
+            });
+        };
+        NumberDictionary.prototype.tryGetValue = function (x, y) {
+            return this._store.get(this.getKey(x, y));
+        };
+        NumberDictionary.prototype.clear = function () {
+            this._store.clear();
+        };
+        return NumberDictionary;
+    }());
+    es.NumberDictionary = NumberDictionary;
+    var RaycastResultParser = (function () {
+        function RaycastResultParser() {
         }
-    };
-    SpatialHash.prototype.debugDrawCellDetails = function (x, y, cellCount, secondsToDisplay, textScale) {
-        if (secondsToDisplay === void 0) { secondsToDisplay = 0.5; }
-        if (textScale === void 0) { textScale = 1; }
-    };
-    return SpatialHash;
-}());
-var RaycastResultParser = (function () {
-    function RaycastResultParser() {
-    }
-    return RaycastResultParser;
-}());
-var NumberDictionary = (function () {
-    function NumberDictionary() {
-        this._store = new Map();
-    }
-    NumberDictionary.prototype.getKey = function (x, y) {
-        return Long.fromNumber(x).shiftLeft(32).or(Long.fromNumber(y, false)).toString();
-    };
-    NumberDictionary.prototype.add = function (x, y, list) {
-        this._store.set(this.getKey(x, y), list);
-    };
-    NumberDictionary.prototype.remove = function (obj) {
-        this._store.forEach(function (list) {
-            if (list.contains(obj))
-                list.remove(obj);
-        });
-    };
-    NumberDictionary.prototype.tryGetValue = function (x, y) {
-        return this._store.get(this.getKey(x, y));
-    };
-    NumberDictionary.prototype.clear = function () {
-        this._store.clear();
-    };
-    return NumberDictionary;
-}());
+        return RaycastResultParser;
+    }());
+    es.RaycastResultParser = RaycastResultParser;
+})(es || (es = {}));
 var ArrayUtils = (function () {
     function ArrayUtils() {
     }
@@ -5588,329 +6302,363 @@ var Base64Utils = (function () {
     };
     return Base64Utils;
 }());
-var ContentManager = (function () {
-    function ContentManager() {
-        this.loadedAssets = new Map();
-    }
-    ContentManager.prototype.loadRes = function (name, local) {
-        var _this = this;
-        if (local === void 0) { local = true; }
-        return new Promise(function (resolve, reject) {
-            var res = _this.loadedAssets.get(name);
-            if (res) {
-                resolve(res);
+var es;
+(function (es) {
+    var ContentManager = (function () {
+        function ContentManager() {
+            this.loadedAssets = new Map();
+        }
+        ContentManager.prototype.loadRes = function (name, local) {
+            var _this = this;
+            if (local === void 0) { local = true; }
+            return new Promise(function (resolve, reject) {
+                var res = _this.loadedAssets.get(name);
+                if (res) {
+                    resolve(res);
+                    return;
+                }
+                if (local) {
+                    RES.getResAsync(name).then(function (data) {
+                        _this.loadedAssets.set(name, data);
+                        resolve(data);
+                    }).catch(function (err) {
+                        console.error("资源加载错误:", name, err);
+                        reject(err);
+                    });
+                }
+                else {
+                    RES.getResByUrl(name).then(function (data) {
+                        _this.loadedAssets.set(name, data);
+                        resolve(data);
+                    }).catch(function (err) {
+                        console.error("资源加载错误:", name, err);
+                        reject(err);
+                    });
+                }
+            });
+        };
+        ContentManager.prototype.dispose = function () {
+            this.loadedAssets.forEach(function (value) {
+                var assetsToRemove = value;
+                assetsToRemove.dispose();
+            });
+            this.loadedAssets.clear();
+        };
+        return ContentManager;
+    }());
+    es.ContentManager = ContentManager;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var DrawUtils = (function () {
+        function DrawUtils() {
+        }
+        DrawUtils.drawLine = function (shape, start, end, color, thickness) {
+            if (thickness === void 0) { thickness = 1; }
+            this.drawLineAngle(shape, start, es.MathHelper.angleBetweenVectors(start, end), es.Vector2.distance(start, end), color, thickness);
+        };
+        DrawUtils.drawLineAngle = function (shape, start, radians, length, color, thickness) {
+            if (thickness === void 0) { thickness = 1; }
+            shape.graphics.beginFill(color);
+            shape.graphics.drawRect(start.x, start.y, 1, 1);
+            shape.graphics.endFill();
+            shape.scaleX = length;
+            shape.scaleY = thickness;
+            shape.$anchorOffsetX = 0;
+            shape.$anchorOffsetY = 0;
+            shape.rotation = radians;
+        };
+        DrawUtils.drawHollowRect = function (shape, rect, color, thickness) {
+            if (thickness === void 0) { thickness = 1; }
+            this.drawHollowRectR(shape, rect.x, rect.y, rect.width, rect.height, color, thickness);
+        };
+        DrawUtils.drawHollowRectR = function (shape, x, y, width, height, color, thickness) {
+            if (thickness === void 0) { thickness = 1; }
+            var tl = new es.Vector2(x, y).round();
+            var tr = new es.Vector2(x + width, y).round();
+            var br = new es.Vector2(x + width, y + height).round();
+            var bl = new es.Vector2(x, y + height).round();
+            this.drawLine(shape, tl, tr, color, thickness);
+            this.drawLine(shape, tr, br, color, thickness);
+            this.drawLine(shape, br, bl, color, thickness);
+            this.drawLine(shape, bl, tl, color, thickness);
+        };
+        DrawUtils.drawPixel = function (shape, position, color, size) {
+            if (size === void 0) { size = 1; }
+            var destRect = new es.Rectangle(position.x, position.y, size, size);
+            if (size != 1) {
+                destRect.x -= size * 0.5;
+                destRect.y -= size * 0.5;
+            }
+            shape.graphics.beginFill(color);
+            shape.graphics.drawRect(destRect.x, destRect.y, destRect.width, destRect.height);
+            shape.graphics.endFill();
+        };
+        DrawUtils.getColorMatrix = function (color) {
+            var colorMatrix = [
+                1, 0, 0, 0, 0,
+                0, 1, 0, 0, 0,
+                0, 0, 1, 0, 0,
+                0, 0, 0, 1, 0
+            ];
+            colorMatrix[0] = Math.floor(color / 256 / 256) / 255;
+            colorMatrix[6] = Math.floor(color / 256 % 256) / 255;
+            colorMatrix[12] = color % 256 / 255;
+            return new egret.ColorMatrixFilter(colorMatrix);
+        };
+        return DrawUtils;
+    }());
+    es.DrawUtils = DrawUtils;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var FuncPack = (function () {
+        function FuncPack(func, context) {
+            this.func = func;
+            this.context = context;
+        }
+        return FuncPack;
+    }());
+    es.FuncPack = FuncPack;
+    var Emitter = (function () {
+        function Emitter() {
+            this._messageTable = new Map();
+        }
+        Emitter.prototype.addObserver = function (eventType, handler, context) {
+            var list = this._messageTable.get(eventType);
+            if (!list) {
+                list = [];
+                this._messageTable.set(eventType, list);
+            }
+            if (list.contains(handler))
+                console.warn("您试图添加相同的观察者两次");
+            list.push(new FuncPack(handler, context));
+        };
+        Emitter.prototype.removeObserver = function (eventType, handler) {
+            var messageData = this._messageTable.get(eventType);
+            var index = messageData.findIndex(function (data) { return data.func == handler; });
+            if (index != -1)
+                messageData.removeAt(index);
+        };
+        Emitter.prototype.emit = function (eventType, data) {
+            var list = this._messageTable.get(eventType);
+            if (list) {
+                for (var i = list.length - 1; i >= 0; i--)
+                    list[i].func.call(list[i].context, data);
+            }
+        };
+        return Emitter;
+    }());
+    es.Emitter = Emitter;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var GlobalManager = (function () {
+        function GlobalManager() {
+        }
+        Object.defineProperty(GlobalManager.prototype, "enabled", {
+            get: function () {
+                return this._enabled;
+            },
+            set: function (value) {
+                this.setEnabled(value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        GlobalManager.prototype.setEnabled = function (isEnabled) {
+            if (this._enabled != isEnabled) {
+                this._enabled = isEnabled;
+                if (this._enabled) {
+                    this.onEnabled();
+                }
+                else {
+                    this.onDisabled();
+                }
+            }
+        };
+        GlobalManager.prototype.onEnabled = function () { };
+        GlobalManager.prototype.onDisabled = function () { };
+        GlobalManager.prototype.update = function () { };
+        GlobalManager.registerGlobalManager = function (manager) {
+            this.globalManagers.push(manager);
+            manager.enabled = true;
+        };
+        GlobalManager.unregisterGlobalManager = function (manager) {
+            this.globalManagers.remove(manager);
+            manager.enabled = false;
+        };
+        GlobalManager.getGlobalManager = function (type) {
+            for (var i = 0; i < this.globalManagers.length; i++) {
+                if (this.globalManagers[i] instanceof type)
+                    return this.globalManagers[i];
+            }
+            return null;
+        };
+        GlobalManager.globalManagers = [];
+        return GlobalManager;
+    }());
+    es.GlobalManager = GlobalManager;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var TouchState = (function () {
+        function TouchState() {
+            this.x = 0;
+            this.y = 0;
+            this.touchPoint = -1;
+            this.touchDown = false;
+        }
+        Object.defineProperty(TouchState.prototype, "position", {
+            get: function () {
+                return new es.Vector2(this.x, this.y);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        TouchState.prototype.reset = function () {
+            this.x = 0;
+            this.y = 0;
+            this.touchDown = false;
+            this.touchPoint = -1;
+        };
+        return TouchState;
+    }());
+    es.TouchState = TouchState;
+    var Input = (function () {
+        function Input() {
+        }
+        Object.defineProperty(Input, "touchPosition", {
+            get: function () {
+                if (!this._gameTouchs[0])
+                    return es.Vector2.zero;
+                return this._gameTouchs[0].position;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Input, "maxSupportedTouch", {
+            get: function () {
+                return this._stage.maxTouches;
+            },
+            set: function (value) {
+                this._stage.maxTouches = value;
+                this.initTouchCache();
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Input, "resolutionScale", {
+            get: function () {
+                return this._resolutionScale;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Input, "totalTouchCount", {
+            get: function () {
+                return this._totalTouchCount;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Input, "gameTouchs", {
+            get: function () {
+                return this._gameTouchs;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Input, "touchPositionDelta", {
+            get: function () {
+                var delta = es.Vector2.subtract(this.touchPosition, this._previousTouchState.position);
+                if (delta.length() > 0) {
+                    this.setpreviousTouchState(this._gameTouchs[0]);
+                }
+                return delta;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Input.initialize = function (stage) {
+            if (this._init)
                 return;
-            }
-            if (local) {
-                RES.getResAsync(name).then(function (data) {
-                    _this.loadedAssets.set(name, data);
-                    resolve(data);
-                }).catch(function (err) {
-                    console.error("资源加载错误:", name, err);
-                    reject(err);
-                });
-            }
-            else {
-                RES.getResByUrl(name).then(function (data) {
-                    _this.loadedAssets.set(name, data);
-                    resolve(data);
-                }).catch(function (err) {
-                    console.error("资源加载错误:", name, err);
-                    reject(err);
-                });
-            }
-        });
-    };
-    ContentManager.prototype.dispose = function () {
-        this.loadedAssets.forEach(function (value) {
-            var assetsToRemove = value;
-            assetsToRemove.dispose();
-        });
-        this.loadedAssets.clear();
-    };
-    return ContentManager;
-}());
-var DrawUtils = (function () {
-    function DrawUtils() {
-    }
-    DrawUtils.drawLine = function (shape, start, end, color, thickness) {
-        if (thickness === void 0) { thickness = 1; }
-        this.drawLineAngle(shape, start, MathHelper.angleBetweenVectors(start, end), Vector2.distance(start, end), color, thickness);
-    };
-    DrawUtils.drawLineAngle = function (shape, start, radians, length, color, thickness) {
-        if (thickness === void 0) { thickness = 1; }
-        shape.graphics.beginFill(color);
-        shape.graphics.drawRect(start.x, start.y, 1, 1);
-        shape.graphics.endFill();
-        shape.scaleX = length;
-        shape.scaleY = thickness;
-        shape.$anchorOffsetX = 0;
-        shape.$anchorOffsetY = 0;
-        shape.rotation = radians;
-    };
-    DrawUtils.drawHollowRect = function (shape, rect, color, thickness) {
-        if (thickness === void 0) { thickness = 1; }
-        this.drawHollowRectR(shape, rect.x, rect.y, rect.width, rect.height, color, thickness);
-    };
-    DrawUtils.drawHollowRectR = function (shape, x, y, width, height, color, thickness) {
-        if (thickness === void 0) { thickness = 1; }
-        var tl = new Vector2(x, y).round();
-        var tr = new Vector2(x + width, y).round();
-        var br = new Vector2(x + width, y + height).round();
-        var bl = new Vector2(x, y + height).round();
-        this.drawLine(shape, tl, tr, color, thickness);
-        this.drawLine(shape, tr, br, color, thickness);
-        this.drawLine(shape, br, bl, color, thickness);
-        this.drawLine(shape, bl, tl, color, thickness);
-    };
-    DrawUtils.drawPixel = function (shape, position, color, size) {
-        if (size === void 0) { size = 1; }
-        var destRect = new Rectangle(position.x, position.y, size, size);
-        if (size != 1) {
-            destRect.x -= size * 0.5;
-            destRect.y -= size * 0.5;
-        }
-        shape.graphics.beginFill(color);
-        shape.graphics.drawRect(destRect.x, destRect.y, destRect.width, destRect.height);
-        shape.graphics.endFill();
-    };
-    return DrawUtils;
-}());
-var Emitter = (function () {
-    function Emitter() {
-        this._messageTable = new Map();
-    }
-    Emitter.prototype.addObserver = function (eventType, handler, context) {
-        var list = this._messageTable.get(eventType);
-        if (!list) {
-            list = [];
-            this._messageTable.set(eventType, list);
-        }
-        if (list.contains(handler))
-            console.warn("您试图添加相同的观察者两次");
-        list.push(new FuncPack(handler, context));
-    };
-    Emitter.prototype.removeObserver = function (eventType, handler) {
-        var messageData = this._messageTable.get(eventType);
-        var index = messageData.findIndex(function (data) { return data.func == handler; });
-        if (index != -1)
-            messageData.removeAt(index);
-    };
-    Emitter.prototype.emit = function (eventType, data) {
-        var list = this._messageTable.get(eventType);
-        if (list) {
-            for (var i = list.length - 1; i >= 0; i--)
-                list[i].func.call(list[i].context, data);
-        }
-    };
-    return Emitter;
-}());
-var FuncPack = (function () {
-    function FuncPack(func, context) {
-        this.func = func;
-        this.context = context;
-    }
-    return FuncPack;
-}());
-var GlobalManager = (function () {
-    function GlobalManager() {
-    }
-    Object.defineProperty(GlobalManager.prototype, "enabled", {
-        get: function () {
-            return this._enabled;
-        },
-        set: function (value) {
-            this.setEnabled(value);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    GlobalManager.prototype.setEnabled = function (isEnabled) {
-        if (this._enabled != isEnabled) {
-            this._enabled = isEnabled;
-            if (this._enabled) {
-                this.onEnabled();
-            }
-            else {
-                this.onDisabled();
-            }
-        }
-    };
-    GlobalManager.prototype.onEnabled = function () { };
-    GlobalManager.prototype.onDisabled = function () { };
-    GlobalManager.prototype.update = function () { };
-    GlobalManager.registerGlobalManager = function (manager) {
-        this.globalManagers.push(manager);
-        manager.enabled = true;
-    };
-    GlobalManager.unregisterGlobalManager = function (manager) {
-        this.globalManagers.remove(manager);
-        manager.enabled = false;
-    };
-    GlobalManager.getGlobalManager = function (type) {
-        for (var i = 0; i < this.globalManagers.length; i++) {
-            if (this.globalManagers[i] instanceof type)
-                return this.globalManagers[i];
-        }
-        return null;
-    };
-    GlobalManager.globalManagers = [];
-    return GlobalManager;
-}());
-var TouchState = (function () {
-    function TouchState() {
-        this.x = 0;
-        this.y = 0;
-        this.touchPoint = -1;
-        this.touchDown = false;
-    }
-    Object.defineProperty(TouchState.prototype, "position", {
-        get: function () {
-            return new Vector2(this.x, this.y);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    TouchState.prototype.reset = function () {
-        this.x = 0;
-        this.y = 0;
-        this.touchDown = false;
-        this.touchPoint = -1;
-    };
-    return TouchState;
-}());
-var Input = (function () {
-    function Input() {
-    }
-    Object.defineProperty(Input, "touchPosition", {
-        get: function () {
-            if (!this._gameTouchs[0])
-                return Vector2.zero;
-            return this._gameTouchs[0].position;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Input, "maxSupportedTouch", {
-        get: function () {
-            return this._stage.maxTouches;
-        },
-        set: function (value) {
-            this._stage.maxTouches = value;
+            this._init = true;
+            this._stage = stage;
+            this._stage.addEventListener(egret.TouchEvent.TOUCH_BEGIN, this.touchBegin, this);
+            this._stage.addEventListener(egret.TouchEvent.TOUCH_MOVE, this.touchMove, this);
+            this._stage.addEventListener(egret.TouchEvent.TOUCH_END, this.touchEnd, this);
+            this._stage.addEventListener(egret.TouchEvent.TOUCH_CANCEL, this.touchEnd, this);
+            this._stage.addEventListener(egret.TouchEvent.TOUCH_RELEASE_OUTSIDE, this.touchEnd, this);
             this.initTouchCache();
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Input, "resolutionScale", {
-        get: function () {
-            return this._resolutionScale;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Input, "totalTouchCount", {
-        get: function () {
-            return this._totalTouchCount;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Input, "gameTouchs", {
-        get: function () {
-            return this._gameTouchs;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(Input, "touchPositionDelta", {
-        get: function () {
-            var delta = Vector2.subtract(this.touchPosition, this._previousTouchState.position);
-            if (delta.length() > 0) {
+        };
+        Input.initTouchCache = function () {
+            this._totalTouchCount = 0;
+            this._touchIndex = 0;
+            this._gameTouchs.length = 0;
+            for (var i = 0; i < this.maxSupportedTouch; i++) {
+                this._gameTouchs.push(new TouchState());
+            }
+        };
+        Input.touchBegin = function (evt) {
+            if (this._touchIndex < this.maxSupportedTouch) {
+                this._gameTouchs[this._touchIndex].touchPoint = evt.touchPointID;
+                this._gameTouchs[this._touchIndex].touchDown = evt.touchDown;
+                this._gameTouchs[this._touchIndex].x = evt.stageX;
+                this._gameTouchs[this._touchIndex].y = evt.stageY;
+                if (this._touchIndex == 0) {
+                    this.setpreviousTouchState(this._gameTouchs[0]);
+                }
+                this._touchIndex++;
+                this._totalTouchCount++;
+            }
+        };
+        Input.touchMove = function (evt) {
+            if (evt.touchPointID == this._gameTouchs[0].touchPoint) {
                 this.setpreviousTouchState(this._gameTouchs[0]);
             }
-            return delta;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Input.initialize = function (stage) {
-        if (this._init)
-            return;
-        this._init = true;
-        this._stage = stage;
-        this._stage.addEventListener(egret.TouchEvent.TOUCH_BEGIN, this.touchBegin, this);
-        this._stage.addEventListener(egret.TouchEvent.TOUCH_MOVE, this.touchMove, this);
-        this._stage.addEventListener(egret.TouchEvent.TOUCH_END, this.touchEnd, this);
-        this._stage.addEventListener(egret.TouchEvent.TOUCH_CANCEL, this.touchEnd, this);
-        this._stage.addEventListener(egret.TouchEvent.TOUCH_RELEASE_OUTSIDE, this.touchEnd, this);
-        this.initTouchCache();
-    };
-    Input.initTouchCache = function () {
-        this._totalTouchCount = 0;
-        this._touchIndex = 0;
-        this._gameTouchs.length = 0;
-        for (var i = 0; i < this.maxSupportedTouch; i++) {
-            this._gameTouchs.push(new TouchState());
-        }
-    };
-    Input.touchBegin = function (evt) {
-        if (this._touchIndex < this.maxSupportedTouch) {
-            this._gameTouchs[this._touchIndex].touchPoint = evt.touchPointID;
-            this._gameTouchs[this._touchIndex].touchDown = evt.touchDown;
-            this._gameTouchs[this._touchIndex].x = evt.stageX;
-            this._gameTouchs[this._touchIndex].y = evt.stageY;
-            if (this._touchIndex == 0) {
-                this.setpreviousTouchState(this._gameTouchs[0]);
+            var touchIndex = this._gameTouchs.findIndex(function (touch) { return touch.touchPoint == evt.touchPointID; });
+            if (touchIndex != -1) {
+                var touchData = this._gameTouchs[touchIndex];
+                touchData.x = evt.stageX;
+                touchData.y = evt.stageY;
             }
-            this._touchIndex++;
-            this._totalTouchCount++;
-        }
-    };
-    Input.touchMove = function (evt) {
-        if (evt.touchPointID == this._gameTouchs[0].touchPoint) {
-            this.setpreviousTouchState(this._gameTouchs[0]);
-        }
-        var touchIndex = this._gameTouchs.findIndex(function (touch) { return touch.touchPoint == evt.touchPointID; });
-        if (touchIndex != -1) {
-            var touchData = this._gameTouchs[touchIndex];
-            touchData.x = evt.stageX;
-            touchData.y = evt.stageY;
-        }
-    };
-    Input.touchEnd = function (evt) {
-        var touchIndex = this._gameTouchs.findIndex(function (touch) { return touch.touchPoint == evt.touchPointID; });
-        if (touchIndex != -1) {
-            var touchData = this._gameTouchs[touchIndex];
-            touchData.reset();
-            if (touchIndex == 0)
-                this._previousTouchState.reset();
-            this._totalTouchCount--;
-            if (this.totalTouchCount == 0) {
-                this._touchIndex = 0;
+        };
+        Input.touchEnd = function (evt) {
+            var touchIndex = this._gameTouchs.findIndex(function (touch) { return touch.touchPoint == evt.touchPointID; });
+            if (touchIndex != -1) {
+                var touchData = this._gameTouchs[touchIndex];
+                touchData.reset();
+                if (touchIndex == 0)
+                    this._previousTouchState.reset();
+                this._totalTouchCount--;
+                if (this.totalTouchCount == 0) {
+                    this._touchIndex = 0;
+                }
             }
-        }
-    };
-    Input.setpreviousTouchState = function (touchState) {
-        this._previousTouchState = new TouchState();
-        this._previousTouchState.x = touchState.position.x;
-        this._previousTouchState.y = touchState.position.y;
-        this._previousTouchState.touchPoint = touchState.touchPoint;
-        this._previousTouchState.touchDown = touchState.touchDown;
-    };
-    Input.scaledPosition = function (position) {
-        var scaledPos = new Vector2(position.x - this._resolutionOffset.x, position.y - this._resolutionOffset.y);
-        return Vector2.multiply(scaledPos, this.resolutionScale);
-    };
-    Input._init = false;
-    Input._previousTouchState = new TouchState();
-    Input._gameTouchs = [];
-    Input._resolutionOffset = new Vector2();
-    Input._resolutionScale = Vector2.one;
-    Input._touchIndex = 0;
-    Input._totalTouchCount = 0;
-    return Input;
-}());
+        };
+        Input.setpreviousTouchState = function (touchState) {
+            this._previousTouchState = new TouchState();
+            this._previousTouchState.x = touchState.position.x;
+            this._previousTouchState.y = touchState.position.y;
+            this._previousTouchState.touchPoint = touchState.touchPoint;
+            this._previousTouchState.touchDown = touchState.touchDown;
+        };
+        Input.scaledPosition = function (position) {
+            var scaledPos = new es.Vector2(position.x - this._resolutionOffset.x, position.y - this._resolutionOffset.y);
+            return es.Vector2.multiply(scaledPos, this.resolutionScale);
+        };
+        Input._init = false;
+        Input._previousTouchState = new TouchState();
+        Input._gameTouchs = [];
+        Input._resolutionOffset = new es.Vector2();
+        Input._resolutionScale = es.Vector2.one;
+        Input._touchIndex = 0;
+        Input._totalTouchCount = 0;
+        return Input;
+    }());
+    es.Input = Input;
+})(es || (es = {}));
 var KeyboardUtils = (function () {
     function KeyboardUtils() {
     }
@@ -6111,36 +6859,40 @@ var KeyboardUtils = (function () {
     KeyboardUtils.WINDOWS = "Windows";
     return KeyboardUtils;
 }());
-var ListPool = (function () {
-    function ListPool() {
-    }
-    ListPool.warmCache = function (cacheCount) {
-        cacheCount -= this._objectQueue.length;
-        if (cacheCount > 0) {
-            for (var i = 0; i < cacheCount; i++) {
-                this._objectQueue.unshift([]);
-            }
+var es;
+(function (es) {
+    var ListPool = (function () {
+        function ListPool() {
         }
-    };
-    ListPool.trimCache = function (cacheCount) {
-        while (cacheCount > this._objectQueue.length)
-            this._objectQueue.shift();
-    };
-    ListPool.clearCache = function () {
-        this._objectQueue.length = 0;
-    };
-    ListPool.obtain = function () {
-        if (this._objectQueue.length > 0)
-            return this._objectQueue.shift();
-        return [];
-    };
-    ListPool.free = function (obj) {
-        this._objectQueue.unshift(obj);
-        obj.length = 0;
-    };
-    ListPool._objectQueue = [];
-    return ListPool;
-}());
+        ListPool.warmCache = function (cacheCount) {
+            cacheCount -= this._objectQueue.length;
+            if (cacheCount > 0) {
+                for (var i = 0; i < cacheCount; i++) {
+                    this._objectQueue.unshift([]);
+                }
+            }
+        };
+        ListPool.trimCache = function (cacheCount) {
+            while (cacheCount > this._objectQueue.length)
+                this._objectQueue.shift();
+        };
+        ListPool.clearCache = function () {
+            this._objectQueue.length = 0;
+        };
+        ListPool.obtain = function () {
+            if (this._objectQueue.length > 0)
+                return this._objectQueue.shift();
+            return [];
+        };
+        ListPool.free = function (obj) {
+            this._objectQueue.unshift(obj);
+            obj.length = 0;
+        };
+        ListPool._objectQueue = [];
+        return ListPool;
+    }());
+    es.ListPool = ListPool;
+})(es || (es = {}));
 var THREAD_ID = Math.floor(Math.random() * 1000) + "-" + Date.now();
 var setItem = egret.localStorage.setItem.bind(localStorage);
 var getItem = egret.localStorage.getItem.bind(localStorage);
@@ -6182,19 +6934,23 @@ var LockUtils = (function () {
     };
     return LockUtils;
 }());
-var Pair = (function () {
-    function Pair(first, second) {
-        this.first = first;
-        this.second = second;
-    }
-    Pair.prototype.clear = function () {
-        this.first = this.second = null;
-    };
-    Pair.prototype.equals = function (other) {
-        return this.first == other.first && this.second == other.second;
-    };
-    return Pair;
-}());
+var es;
+(function (es) {
+    var Pair = (function () {
+        function Pair(first, second) {
+            this.first = first;
+            this.second = second;
+        }
+        Pair.prototype.clear = function () {
+            this.first = this.second = null;
+        };
+        Pair.prototype.equals = function (other) {
+            return this.first == other.first && this.second == other.second;
+        };
+        return Pair;
+    }());
+    es.Pair = Pair;
+})(es || (es = {}));
 var RandomUtils = (function () {
     function RandomUtils() {
     }
@@ -6262,142 +7018,154 @@ var RandomUtils = (function () {
     };
     return RandomUtils;
 }());
-var RectangleExt = (function () {
-    function RectangleExt() {
-    }
-    RectangleExt.union = function (first, point) {
-        var rect = new Rectangle(point.x, point.y, 0, 0);
-        var result = new Rectangle();
-        result.x = Math.min(first.x, rect.x);
-        result.y = Math.min(first.y, rect.y);
-        result.width = Math.max(first.right, rect.right) - result.x;
-        result.height = Math.max(first.bottom, result.bottom) - result.y;
-        return result;
-    };
-    return RectangleExt;
-}());
-var Triangulator = (function () {
-    function Triangulator() {
-        this.triangleIndices = [];
-        this._triPrev = new Array(12);
-        this._triNext = new Array(12);
-    }
-    Triangulator.prototype.triangulate = function (points, arePointsCCW) {
-        if (arePointsCCW === void 0) { arePointsCCW = true; }
-        var count = points.length;
-        this.initialize(count);
-        var iterations = 0;
-        var index = 0;
-        while (count > 3 && iterations < 500) {
-            iterations++;
-            var isEar = true;
-            var a = points[this._triPrev[index]];
-            var b = points[index];
-            var c = points[this._triNext[index]];
-            if (Vector2Ext.isTriangleCCW(a, b, c)) {
-                var k = this._triNext[this._triNext[index]];
-                do {
-                    if (Triangulator.testPointTriangle(points[k], a, b, c)) {
-                        isEar = false;
-                        break;
-                    }
-                    k = this._triNext[k];
-                } while (k != this._triPrev[index]);
+var es;
+(function (es) {
+    var RectangleExt = (function () {
+        function RectangleExt() {
+        }
+        RectangleExt.union = function (first, point) {
+            var rect = new es.Rectangle(point.x, point.y, 0, 0);
+            var result = new es.Rectangle();
+            result.x = Math.min(first.x, rect.x);
+            result.y = Math.min(first.y, rect.y);
+            result.width = Math.max(first.right, rect.right) - result.x;
+            result.height = Math.max(first.bottom, result.bottom) - result.y;
+            return result;
+        };
+        return RectangleExt;
+    }());
+    es.RectangleExt = RectangleExt;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Triangulator = (function () {
+        function Triangulator() {
+            this.triangleIndices = [];
+            this._triPrev = new Array(12);
+            this._triNext = new Array(12);
+        }
+        Triangulator.prototype.triangulate = function (points, arePointsCCW) {
+            if (arePointsCCW === void 0) { arePointsCCW = true; }
+            var count = points.length;
+            this.initialize(count);
+            var iterations = 0;
+            var index = 0;
+            while (count > 3 && iterations < 500) {
+                iterations++;
+                var isEar = true;
+                var a = points[this._triPrev[index]];
+                var b = points[index];
+                var c = points[this._triNext[index]];
+                if (es.Vector2Ext.isTriangleCCW(a, b, c)) {
+                    var k = this._triNext[this._triNext[index]];
+                    do {
+                        if (Triangulator.testPointTriangle(points[k], a, b, c)) {
+                            isEar = false;
+                            break;
+                        }
+                        k = this._triNext[k];
+                    } while (k != this._triPrev[index]);
+                }
+                else {
+                    isEar = false;
+                }
+                if (isEar) {
+                    this.triangleIndices.push(this._triPrev[index]);
+                    this.triangleIndices.push(index);
+                    this.triangleIndices.push(this._triNext[index]);
+                    this._triNext[this._triPrev[index]] = this._triNext[index];
+                    this._triPrev[this._triNext[index]] = this._triPrev[index];
+                    count--;
+                    index = this._triPrev[index];
+                }
+                else {
+                    index = this._triNext[index];
+                }
+            }
+            this.triangleIndices.push(this._triPrev[index]);
+            this.triangleIndices.push(index);
+            this.triangleIndices.push(this._triNext[index]);
+            if (!arePointsCCW)
+                this.triangleIndices.reverse();
+        };
+        Triangulator.prototype.initialize = function (count) {
+            this.triangleIndices.length = 0;
+            if (this._triNext.length < count) {
+                this._triNext.reverse();
+                this._triNext = new Array(Math.max(this._triNext.length * 2, count));
+            }
+            if (this._triPrev.length < count) {
+                this._triPrev.reverse();
+                this._triPrev = new Array(Math.max(this._triPrev.length * 2, count));
+            }
+            for (var i = 0; i < count; i++) {
+                this._triPrev[i] = i - 1;
+                this._triNext[i] = i + 1;
+            }
+            this._triPrev[0] = count - 1;
+            this._triNext[count - 1] = 0;
+        };
+        Triangulator.testPointTriangle = function (point, a, b, c) {
+            if (es.Vector2Ext.cross(es.Vector2.subtract(point, a), es.Vector2.subtract(b, a)) < 0)
+                return false;
+            if (es.Vector2Ext.cross(es.Vector2.subtract(point, b), es.Vector2.subtract(c, b)) < 0)
+                return false;
+            if (es.Vector2Ext.cross(es.Vector2.subtract(point, c), es.Vector2.subtract(a, c)) < 0)
+                return false;
+            return true;
+        };
+        return Triangulator;
+    }());
+    es.Triangulator = Triangulator;
+})(es || (es = {}));
+var es;
+(function (es) {
+    var Vector2Ext = (function () {
+        function Vector2Ext() {
+        }
+        Vector2Ext.isTriangleCCW = function (a, center, c) {
+            return this.cross(es.Vector2.subtract(center, a), es.Vector2.subtract(c, center)) < 0;
+        };
+        Vector2Ext.cross = function (u, v) {
+            return u.y * v.x - u.x * v.y;
+        };
+        Vector2Ext.perpendicular = function (first, second) {
+            return new es.Vector2(-1 * (second.y - first.y), second.x - first.x);
+        };
+        Vector2Ext.normalize = function (vec) {
+            var magnitude = Math.sqrt((vec.x * vec.x) + (vec.y * vec.y));
+            if (magnitude > es.MathHelper.Epsilon) {
+                vec = es.Vector2.divide(vec, new es.Vector2(magnitude));
             }
             else {
-                isEar = false;
+                vec.x = vec.y = 0;
             }
-            if (isEar) {
-                this.triangleIndices.push(this._triPrev[index]);
-                this.triangleIndices.push(index);
-                this.triangleIndices.push(this._triNext[index]);
-                this._triNext[this._triPrev[index]] = this._triNext[index];
-                this._triPrev[this._triNext[index]] = this._triPrev[index];
-                count--;
-                index = this._triPrev[index];
+            return vec;
+        };
+        Vector2Ext.transformA = function (sourceArray, sourceIndex, matrix, destinationArray, destinationIndex, length) {
+            for (var i = 0; i < length; i++) {
+                var position = sourceArray[sourceIndex + i];
+                var destination = destinationArray[destinationIndex + i];
+                destination.x = (position.x * matrix.m11) + (position.y * matrix.m21) + matrix.m31;
+                destination.y = (position.x * matrix.m12) + (position.y * matrix.m22) + matrix.m32;
+                destinationArray[destinationIndex + i] = destination;
             }
-            else {
-                index = this._triNext[index];
-            }
-        }
-        this.triangleIndices.push(this._triPrev[index]);
-        this.triangleIndices.push(index);
-        this.triangleIndices.push(this._triNext[index]);
-        if (!arePointsCCW)
-            this.triangleIndices.reverse();
-    };
-    Triangulator.prototype.initialize = function (count) {
-        this.triangleIndices.length = 0;
-        if (this._triNext.length < count) {
-            this._triNext.reverse();
-            this._triNext = new Array(Math.max(this._triNext.length * 2, count));
-        }
-        if (this._triPrev.length < count) {
-            this._triPrev.reverse();
-            this._triPrev = new Array(Math.max(this._triPrev.length * 2, count));
-        }
-        for (var i = 0; i < count; i++) {
-            this._triPrev[i] = i - 1;
-            this._triNext[i] = i + 1;
-        }
-        this._triPrev[0] = count - 1;
-        this._triNext[count - 1] = 0;
-    };
-    Triangulator.testPointTriangle = function (point, a, b, c) {
-        if (Vector2Ext.cross(Vector2.subtract(point, a), Vector2.subtract(b, a)) < 0)
-            return false;
-        if (Vector2Ext.cross(Vector2.subtract(point, b), Vector2.subtract(c, b)) < 0)
-            return false;
-        if (Vector2Ext.cross(Vector2.subtract(point, c), Vector2.subtract(a, c)) < 0)
-            return false;
-        return true;
-    };
-    return Triangulator;
-}());
-var Vector2Ext = (function () {
-    function Vector2Ext() {
-    }
-    Vector2Ext.isTriangleCCW = function (a, center, c) {
-        return this.cross(Vector2.subtract(center, a), Vector2.subtract(c, center)) < 0;
-    };
-    Vector2Ext.cross = function (u, v) {
-        return u.y * v.x - u.x * v.y;
-    };
-    Vector2Ext.perpendicular = function (first, second) {
-        return new Vector2(-1 * (second.y - first.y), second.x - first.x);
-    };
-    Vector2Ext.normalize = function (vec) {
-        var magnitude = Math.sqrt((vec.x * vec.x) + (vec.y * vec.y));
-        if (magnitude > MathHelper.Epsilon) {
-            vec = Vector2.divide(vec, new Vector2(magnitude));
-        }
-        else {
-            vec.x = vec.y = 0;
-        }
-        return vec;
-    };
-    Vector2Ext.transformA = function (sourceArray, sourceIndex, matrix, destinationArray, destinationIndex, length) {
-        for (var i = 0; i < length; i++) {
-            var position = sourceArray[sourceIndex + i];
-            var destination = destinationArray[destinationIndex + i];
-            destination.x = (position.x * matrix.m11) + (position.y * matrix.m21) + matrix.m31;
-            destination.y = (position.x * matrix.m12) + (position.y * matrix.m22) + matrix.m32;
-            destinationArray[destinationIndex + i] = destination;
-        }
-    };
-    Vector2Ext.transformR = function (position, matrix) {
-        var x = (position.x * matrix.m11) + (position.y * matrix.m21) + matrix.m31;
-        var y = (position.x * matrix.m12) + (position.y * matrix.m22) + matrix.m32;
-        return new Vector2(x, y);
-    };
-    Vector2Ext.transform = function (sourceArray, matrix, destinationArray) {
-        this.transformA(sourceArray, 0, matrix, destinationArray, 0, sourceArray.length);
-    };
-    Vector2Ext.round = function (vec) {
-        return new Vector2(Math.round(vec.x), Math.round(vec.y));
-    };
-    return Vector2Ext;
-}());
+        };
+        Vector2Ext.transformR = function (position, matrix) {
+            var x = (position.x * matrix.m11) + (position.y * matrix.m21) + matrix.m31;
+            var y = (position.x * matrix.m12) + (position.y * matrix.m22) + matrix.m32;
+            return new es.Vector2(x, y);
+        };
+        Vector2Ext.transform = function (sourceArray, matrix, destinationArray) {
+            this.transformA(sourceArray, 0, matrix, destinationArray, 0, sourceArray.length);
+        };
+        Vector2Ext.round = function (vec) {
+            return new es.Vector2(Math.round(vec.x), Math.round(vec.y));
+        };
+        return Vector2Ext;
+    }());
+    es.Vector2Ext = Vector2Ext;
+})(es || (es = {}));
 var WebGLUtils = (function () {
     function WebGLUtils() {
     }
@@ -6407,66 +7175,70 @@ var WebGLUtils = (function () {
     };
     return WebGLUtils;
 }());
-var Layout = (function () {
-    function Layout() {
-        this.clientArea = new Rectangle(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-        this.safeArea = this.clientArea;
-    }
-    Layout.prototype.place = function (size, horizontalMargin, verticalMargine, alignment) {
-        var rc = new Rectangle(0, 0, size.x, size.y);
-        if ((alignment & Alignment.left) != 0) {
-            rc.x = this.clientArea.x + (this.clientArea.width * horizontalMargin);
+var es;
+(function (es) {
+    var Layout = (function () {
+        function Layout() {
+            this.clientArea = new es.Rectangle(0, 0, es.SceneManager.stage.stageWidth, es.SceneManager.stage.stageHeight);
+            this.safeArea = this.clientArea;
         }
-        else if ((alignment & Alignment.right) != 0) {
-            rc.x = this.clientArea.x + (this.clientArea.width * (1 - horizontalMargin)) - rc.width;
-        }
-        else if ((alignment & Alignment.horizontalCenter) != 0) {
-            rc.x = this.clientArea.x + (this.clientArea.width - rc.width) / 2 + (horizontalMargin * this.clientArea.width);
-        }
-        else {
-        }
-        if ((alignment & Alignment.top) != 0) {
-            rc.y = this.clientArea.y + (this.clientArea.height * verticalMargine);
-        }
-        else if ((alignment & Alignment.bottom) != 0) {
-            rc.y = this.clientArea.y + (this.clientArea.height * (1 - verticalMargine)) - rc.height;
-        }
-        else if ((alignment & Alignment.verticalCenter) != 0) {
-            rc.y = this.clientArea.y + (this.clientArea.height - rc.height) / 2 + (verticalMargine * this.clientArea.height);
-        }
-        else {
-        }
-        if (rc.left < this.safeArea.left)
-            rc.x = this.safeArea.left;
-        if (rc.right > this.safeArea.right)
-            rc.x = this.safeArea.right - rc.width;
-        if (rc.top < this.safeArea.top)
-            rc.y = this.safeArea.top;
-        if (rc.bottom > this.safeArea.bottom)
-            rc.y = this.safeArea.bottom - rc.height;
-        return rc;
-    };
-    return Layout;
-}());
-var Alignment;
-(function (Alignment) {
-    Alignment[Alignment["none"] = 0] = "none";
-    Alignment[Alignment["left"] = 1] = "left";
-    Alignment[Alignment["right"] = 2] = "right";
-    Alignment[Alignment["horizontalCenter"] = 4] = "horizontalCenter";
-    Alignment[Alignment["top"] = 8] = "top";
-    Alignment[Alignment["bottom"] = 16] = "bottom";
-    Alignment[Alignment["verticalCenter"] = 32] = "verticalCenter";
-    Alignment[Alignment["topLeft"] = 9] = "topLeft";
-    Alignment[Alignment["topRight"] = 10] = "topRight";
-    Alignment[Alignment["topCenter"] = 12] = "topCenter";
-    Alignment[Alignment["bottomLeft"] = 17] = "bottomLeft";
-    Alignment[Alignment["bottomRight"] = 18] = "bottomRight";
-    Alignment[Alignment["bottomCenter"] = 20] = "bottomCenter";
-    Alignment[Alignment["centerLeft"] = 33] = "centerLeft";
-    Alignment[Alignment["centerRight"] = 34] = "centerRight";
-    Alignment[Alignment["center"] = 36] = "center";
-})(Alignment || (Alignment = {}));
+        Layout.prototype.place = function (size, horizontalMargin, verticalMargine, alignment) {
+            var rc = new es.Rectangle(0, 0, size.x, size.y);
+            if ((alignment & Alignment.left) != 0) {
+                rc.x = this.clientArea.x + (this.clientArea.width * horizontalMargin);
+            }
+            else if ((alignment & Alignment.right) != 0) {
+                rc.x = this.clientArea.x + (this.clientArea.width * (1 - horizontalMargin)) - rc.width;
+            }
+            else if ((alignment & Alignment.horizontalCenter) != 0) {
+                rc.x = this.clientArea.x + (this.clientArea.width - rc.width) / 2 + (horizontalMargin * this.clientArea.width);
+            }
+            else {
+            }
+            if ((alignment & Alignment.top) != 0) {
+                rc.y = this.clientArea.y + (this.clientArea.height * verticalMargine);
+            }
+            else if ((alignment & Alignment.bottom) != 0) {
+                rc.y = this.clientArea.y + (this.clientArea.height * (1 - verticalMargine)) - rc.height;
+            }
+            else if ((alignment & Alignment.verticalCenter) != 0) {
+                rc.y = this.clientArea.y + (this.clientArea.height - rc.height) / 2 + (verticalMargine * this.clientArea.height);
+            }
+            else {
+            }
+            if (rc.left < this.safeArea.left)
+                rc.x = this.safeArea.left;
+            if (rc.right > this.safeArea.right)
+                rc.x = this.safeArea.right - rc.width;
+            if (rc.top < this.safeArea.top)
+                rc.y = this.safeArea.top;
+            if (rc.bottom > this.safeArea.bottom)
+                rc.y = this.safeArea.bottom - rc.height;
+            return rc;
+        };
+        return Layout;
+    }());
+    es.Layout = Layout;
+    var Alignment;
+    (function (Alignment) {
+        Alignment[Alignment["none"] = 0] = "none";
+        Alignment[Alignment["left"] = 1] = "left";
+        Alignment[Alignment["right"] = 2] = "right";
+        Alignment[Alignment["horizontalCenter"] = 4] = "horizontalCenter";
+        Alignment[Alignment["top"] = 8] = "top";
+        Alignment[Alignment["bottom"] = 16] = "bottom";
+        Alignment[Alignment["verticalCenter"] = 32] = "verticalCenter";
+        Alignment[Alignment["topLeft"] = 9] = "topLeft";
+        Alignment[Alignment["topRight"] = 10] = "topRight";
+        Alignment[Alignment["topCenter"] = 12] = "topCenter";
+        Alignment[Alignment["bottomLeft"] = 17] = "bottomLeft";
+        Alignment[Alignment["bottomRight"] = 18] = "bottomRight";
+        Alignment[Alignment["bottomCenter"] = 20] = "bottomCenter";
+        Alignment[Alignment["centerLeft"] = 33] = "centerLeft";
+        Alignment[Alignment["centerRight"] = 34] = "centerRight";
+        Alignment[Alignment["center"] = 36] = "center";
+    })(Alignment = es.Alignment || (es.Alignment = {}));
+})(es || (es = {}));
 var stopwatch;
 (function (stopwatch) {
     var Stopwatch = (function () {
@@ -6598,251 +7370,260 @@ var stopwatch;
     stopwatch.setDefaultSystemTimeGetter = setDefaultSystemTimeGetter;
     var _defaultSystemTimeGetter = Date.now;
 })(stopwatch || (stopwatch = {}));
-var TimeRuler = (function () {
-    function TimeRuler() {
-        this._frameKey = 'frame';
-        this._logKey = 'log';
-        this.markers = [];
-        this.stopwacth = new stopwatch.Stopwatch();
-        this._markerNameToIdMap = new Map();
-        this.showLog = false;
-        TimeRuler.Instance = this;
-        this._logs = new Array(2);
-        for (var i = 0; i < this._logs.length; ++i)
-            this._logs[i] = new FrameLog();
-        this.sampleFrames = this.targetSampleFrames = 1;
-        this.width = SceneManager.stage.stageWidth * 0.8;
-        this.onGraphicsDeviceReset();
-    }
-    TimeRuler.prototype.onGraphicsDeviceReset = function () {
-        var layout = new Layout();
-        this._position = layout.place(new Vector2(this.width, TimeRuler.barHeight), 0, 0.01, Alignment.bottomCenter).location;
-    };
-    TimeRuler.prototype.startFrame = function () {
-        var _this = this;
-        var lock = new LockUtils(this._frameKey);
-        lock.lock().then(function () {
-            _this._updateCount = parseInt(egret.localStorage.getItem(_this._frameKey), 10);
-            if (isNaN(_this._updateCount))
-                _this._updateCount = 0;
-            var count = _this._updateCount;
-            count += 1;
-            egret.localStorage.setItem(_this._frameKey, count.toString());
-            if (_this.enabled && (1 < count && count < TimeRuler.maxSampleFrames))
-                return;
-            _this._prevLog = _this._logs[_this.frameCount++ & 0x1];
-            _this._curLog = _this._logs[_this.frameCount & 0x1];
-            var endFrameTime = _this.stopwacth.getTime();
-            for (var barIndex = 0; barIndex < _this._prevLog.bars.length; ++barIndex) {
-                var prevBar = _this._prevLog.bars[barIndex];
-                var nextBar = _this._curLog.bars[barIndex];
-                for (var nest = 0; nest < prevBar.nestCount; ++nest) {
-                    var markerIdx = prevBar.markerNests[nest];
-                    prevBar.markers[markerIdx].endTime = endFrameTime;
-                    nextBar.markerNests[nest] = nest;
-                    nextBar.markers[nest].markerId = prevBar.markers[markerIdx].markerId;
-                    nextBar.markers[nest].beginTime = 0;
-                    nextBar.markers[nest].endTime = -1;
-                    nextBar.markers[nest].color = prevBar.markers[markerIdx].color;
-                }
-                for (var markerIdx = 0; markerIdx < prevBar.markCount; ++markerIdx) {
-                    var duration = prevBar.markers[markerIdx].endTime - prevBar.markers[markerIdx].beginTime;
-                    var markerId = prevBar.markers[markerIdx].markerId;
-                    var m = _this.markers[markerId];
-                    m.logs[barIndex].color = prevBar.markers[markerIdx].color;
-                    if (!m.logs[barIndex].initialized) {
-                        m.logs[barIndex].min = duration;
-                        m.logs[barIndex].max = duration;
-                        m.logs[barIndex].avg = duration;
-                        m.logs[barIndex].initialized = true;
+var es;
+(function (es) {
+    var TimeRuler = (function () {
+        function TimeRuler() {
+            this._frameKey = 'frame';
+            this._logKey = 'log';
+            this.markers = [];
+            this.stopwacth = new stopwatch.Stopwatch();
+            this._markerNameToIdMap = new Map();
+            this.showLog = false;
+            TimeRuler.Instance = this;
+            this._logs = new Array(2);
+            for (var i = 0; i < this._logs.length; ++i)
+                this._logs[i] = new FrameLog();
+            this.sampleFrames = this.targetSampleFrames = 1;
+            this.width = es.SceneManager.stage.stageWidth * 0.8;
+            this.onGraphicsDeviceReset();
+        }
+        TimeRuler.prototype.onGraphicsDeviceReset = function () {
+            var layout = new es.Layout();
+            this._position = layout.place(new es.Vector2(this.width, TimeRuler.barHeight), 0, 0.01, es.Alignment.bottomCenter).location;
+        };
+        TimeRuler.prototype.startFrame = function () {
+            var _this = this;
+            var lock = new LockUtils(this._frameKey);
+            lock.lock().then(function () {
+                _this._updateCount = parseInt(egret.localStorage.getItem(_this._frameKey), 10);
+                if (isNaN(_this._updateCount))
+                    _this._updateCount = 0;
+                var count = _this._updateCount;
+                count += 1;
+                egret.localStorage.setItem(_this._frameKey, count.toString());
+                if (_this.enabled && (1 < count && count < TimeRuler.maxSampleFrames))
+                    return;
+                _this._prevLog = _this._logs[_this.frameCount++ & 0x1];
+                _this._curLog = _this._logs[_this.frameCount & 0x1];
+                var endFrameTime = _this.stopwacth.getTime();
+                for (var barIndex = 0; barIndex < _this._prevLog.bars.length; ++barIndex) {
+                    var prevBar = _this._prevLog.bars[barIndex];
+                    var nextBar = _this._curLog.bars[barIndex];
+                    for (var nest = 0; nest < prevBar.nestCount; ++nest) {
+                        var markerIdx = prevBar.markerNests[nest];
+                        prevBar.markers[markerIdx].endTime = endFrameTime;
+                        nextBar.markerNests[nest] = nest;
+                        nextBar.markers[nest].markerId = prevBar.markers[markerIdx].markerId;
+                        nextBar.markers[nest].beginTime = 0;
+                        nextBar.markers[nest].endTime = -1;
+                        nextBar.markers[nest].color = prevBar.markers[markerIdx].color;
                     }
-                    else {
-                        m.logs[barIndex].min = Math.min(m.logs[barIndex].min, duration);
-                        m.logs[barIndex].max = Math.min(m.logs[barIndex].max, duration);
-                        m.logs[barIndex].avg += duration;
-                        m.logs[barIndex].avg *= 0.5;
-                        if (m.logs[barIndex].samples++ >= TimeRuler.logSnapDuration) {
-                            m.logs[barIndex].snapMin = m.logs[barIndex].min;
-                            m.logs[barIndex].snapMax = m.logs[barIndex].max;
-                            m.logs[barIndex].snapAvg = m.logs[barIndex].avg;
-                            m.logs[barIndex].samples = 0;
+                    for (var markerIdx = 0; markerIdx < prevBar.markCount; ++markerIdx) {
+                        var duration = prevBar.markers[markerIdx].endTime - prevBar.markers[markerIdx].beginTime;
+                        var markerId = prevBar.markers[markerIdx].markerId;
+                        var m = _this.markers[markerId];
+                        m.logs[barIndex].color = prevBar.markers[markerIdx].color;
+                        if (!m.logs[barIndex].initialized) {
+                            m.logs[barIndex].min = duration;
+                            m.logs[barIndex].max = duration;
+                            m.logs[barIndex].avg = duration;
+                            m.logs[barIndex].initialized = true;
+                        }
+                        else {
+                            m.logs[barIndex].min = Math.min(m.logs[barIndex].min, duration);
+                            m.logs[barIndex].max = Math.min(m.logs[barIndex].max, duration);
+                            m.logs[barIndex].avg += duration;
+                            m.logs[barIndex].avg *= 0.5;
+                            if (m.logs[barIndex].samples++ >= TimeRuler.logSnapDuration) {
+                                m.logs[barIndex].snapMin = m.logs[barIndex].min;
+                                m.logs[barIndex].snapMax = m.logs[barIndex].max;
+                                m.logs[barIndex].snapAvg = m.logs[barIndex].avg;
+                                m.logs[barIndex].samples = 0;
+                            }
                         }
                     }
+                    nextBar.markCount = prevBar.nestCount;
+                    nextBar.nestCount = prevBar.nestCount;
                 }
-                nextBar.markCount = prevBar.nestCount;
-                nextBar.nestCount = prevBar.nestCount;
-            }
-            _this.stopwacth.reset();
-            _this.stopwacth.start();
-        });
-    };
-    TimeRuler.prototype.beginMark = function (markerName, color, barIndex) {
-        var _this = this;
-        if (barIndex === void 0) { barIndex = 0; }
-        var lock = new LockUtils(this._frameKey);
-        lock.lock().then(function () {
-            if (barIndex < 0 || barIndex >= TimeRuler.maxBars)
+                _this.stopwacth.reset();
+                _this.stopwacth.start();
+            });
+        };
+        TimeRuler.prototype.beginMark = function (markerName, color, barIndex) {
+            var _this = this;
+            if (barIndex === void 0) { barIndex = 0; }
+            var lock = new LockUtils(this._frameKey);
+            lock.lock().then(function () {
+                if (barIndex < 0 || barIndex >= TimeRuler.maxBars)
+                    throw new Error("barIndex argument out of range");
+                var bar = _this._curLog.bars[barIndex];
+                if (bar.markCount >= TimeRuler.maxSamples) {
+                    throw new Error("exceeded sample count. either set larger number to timeruler.maxsaple or lower sample count");
+                }
+                if (bar.nestCount >= TimeRuler.maxNestCall) {
+                    throw new Error("exceeded nest count. either set larger number to timeruler.maxnestcall or lower nest calls");
+                }
+                var markerId = _this._markerNameToIdMap.get(markerName);
+                if (isNaN(markerId)) {
+                    markerId = _this.markers.length;
+                    _this._markerNameToIdMap.set(markerName, markerId);
+                }
+                bar.markerNests[bar.nestCount++] = bar.markCount;
+                bar.markers[bar.markCount].markerId = markerId;
+                bar.markers[bar.markCount].color = color;
+                bar.markers[bar.markCount].beginTime = _this.stopwacth.getTime();
+                bar.markers[bar.markCount].endTime = -1;
+            });
+        };
+        TimeRuler.prototype.endMark = function (markerName, barIndex) {
+            var _this = this;
+            if (barIndex === void 0) { barIndex = 0; }
+            var lock = new LockUtils(this._frameKey);
+            lock.lock().then(function () {
+                if (barIndex < 0 || barIndex >= TimeRuler.maxBars)
+                    throw new Error("barIndex argument out of range");
+                var bar = _this._curLog.bars[barIndex];
+                if (bar.nestCount <= 0) {
+                    throw new Error("call beginMark method before calling endMark method");
+                }
+                var markerId = _this._markerNameToIdMap.get(markerName);
+                if (isNaN(markerId)) {
+                    throw new Error("Marker " + markerName + " is not registered. Make sure you specifed same name as you used for beginMark method");
+                }
+                var markerIdx = bar.markerNests[--bar.nestCount];
+                if (bar.markers[markerIdx].markerId != markerId) {
+                    throw new Error("Incorrect call order of beginMark/endMark method. beginMark(A), beginMark(B), endMark(B), endMark(A) But you can't called it like beginMark(A), beginMark(B), endMark(A), endMark(B).");
+                }
+                bar.markers[markerIdx].endTime = _this.stopwacth.getTime();
+            });
+        };
+        TimeRuler.prototype.getAverageTime = function (barIndex, markerName) {
+            if (barIndex < 0 || barIndex >= TimeRuler.maxBars) {
                 throw new Error("barIndex argument out of range");
-            var bar = _this._curLog.bars[barIndex];
-            if (bar.markCount >= TimeRuler.maxSamples) {
-                throw new Error("exceeded sample count. either set larger number to timeruler.maxsaple or lower sample count");
             }
-            if (bar.nestCount >= TimeRuler.maxNestCall) {
-                throw new Error("exceeded nest count. either set larger number to timeruler.maxnestcall or lower nest calls");
+            var result = 0;
+            var markerId = this._markerNameToIdMap.get(markerName);
+            if (markerId) {
+                result = this.markers[markerId].logs[barIndex].avg;
             }
-            var markerId = _this._markerNameToIdMap.get(markerName);
-            if (isNaN(markerId)) {
-                markerId = _this.markers.length;
-                _this._markerNameToIdMap.set(markerName, markerId);
-            }
-            bar.markerNests[bar.nestCount++] = bar.markCount;
-            bar.markers[bar.markCount].markerId = markerId;
-            bar.markers[bar.markCount].color = color;
-            bar.markers[bar.markCount].beginTime = _this.stopwacth.getTime();
-            bar.markers[bar.markCount].endTime = -1;
-        });
-    };
-    TimeRuler.prototype.endMark = function (markerName, barIndex) {
-        var _this = this;
-        if (barIndex === void 0) { barIndex = 0; }
-        var lock = new LockUtils(this._frameKey);
-        lock.lock().then(function () {
-            if (barIndex < 0 || barIndex >= TimeRuler.maxBars)
-                throw new Error("barIndex argument out of range");
-            var bar = _this._curLog.bars[barIndex];
-            if (bar.nestCount <= 0) {
-                throw new Error("call beginMark method before calling endMark method");
-            }
-            var markerId = _this._markerNameToIdMap.get(markerName);
-            if (isNaN(markerId)) {
-                throw new Error("Marker " + markerName + " is not registered. Make sure you specifed same name as you used for beginMark method");
-            }
-            var markerIdx = bar.markerNests[--bar.nestCount];
-            if (bar.markers[markerIdx].markerId != markerId) {
-                throw new Error("Incorrect call order of beginMark/endMark method. beginMark(A), beginMark(B), endMark(B), endMark(A) But you can't called it like beginMark(A), beginMark(B), endMark(A), endMark(B).");
-            }
-            bar.markers[markerIdx].endTime = _this.stopwacth.getTime();
-        });
-    };
-    TimeRuler.prototype.getAverageTime = function (barIndex, markerName) {
-        if (barIndex < 0 || barIndex >= TimeRuler.maxBars) {
-            throw new Error("barIndex argument out of range");
-        }
-        var result = 0;
-        var markerId = this._markerNameToIdMap.get(markerName);
-        if (markerId) {
-            result = this.markers[markerId].logs[barIndex].avg;
-        }
-        return result;
-    };
-    TimeRuler.prototype.resetLog = function () {
-        var _this = this;
-        var lock = new LockUtils(this._logKey);
-        lock.lock().then(function () {
-            var count = parseInt(egret.localStorage.getItem(_this._logKey), 10);
-            count += 1;
-            egret.localStorage.setItem(_this._logKey, count.toString());
-            _this.markers.forEach(function (markerInfo) {
-                for (var i = 0; i < markerInfo.logs.length; ++i) {
-                    markerInfo.logs[i].initialized = false;
-                    markerInfo.logs[i].snapMin = 0;
-                    markerInfo.logs[i].snapMax = 0;
-                    markerInfo.logs[i].snapAvg = 0;
-                    markerInfo.logs[i].min = 0;
-                    markerInfo.logs[i].max = 0;
-                    markerInfo.logs[i].avg = 0;
-                    markerInfo.logs[i].samples = 0;
+            return result;
+        };
+        TimeRuler.prototype.resetLog = function () {
+            var _this = this;
+            var lock = new LockUtils(this._logKey);
+            lock.lock().then(function () {
+                var count = parseInt(egret.localStorage.getItem(_this._logKey), 10);
+                count += 1;
+                egret.localStorage.setItem(_this._logKey, count.toString());
+                _this.markers.forEach(function (markerInfo) {
+                    for (var i = 0; i < markerInfo.logs.length; ++i) {
+                        markerInfo.logs[i].initialized = false;
+                        markerInfo.logs[i].snapMin = 0;
+                        markerInfo.logs[i].snapMax = 0;
+                        markerInfo.logs[i].snapAvg = 0;
+                        markerInfo.logs[i].min = 0;
+                        markerInfo.logs[i].max = 0;
+                        markerInfo.logs[i].avg = 0;
+                        markerInfo.logs[i].samples = 0;
+                    }
+                });
+            });
+        };
+        TimeRuler.prototype.render = function (position, width) {
+            if (position === void 0) { position = this._position; }
+            if (width === void 0) { width = this.width; }
+            egret.localStorage.setItem(this._frameKey, "0");
+            if (!this.showLog)
+                return;
+            var height = 0;
+            var maxTime = 0;
+            this._prevLog.bars.forEach(function (bar) {
+                if (bar.markCount > 0) {
+                    height += TimeRuler.barHeight + TimeRuler.barPadding * 2;
+                    maxTime = Math.max(maxTime, bar.markers[bar.markCount - 1].endTime);
                 }
             });
-        });
-    };
-    TimeRuler.prototype.render = function (position, width) {
-        if (position === void 0) { position = this._position; }
-        if (width === void 0) { width = this.width; }
-        egret.localStorage.setItem(this._frameKey, "0");
-        if (!this.showLog)
-            return;
-        var height = 0;
-        var maxTime = 0;
-        this._prevLog.bars.forEach(function (bar) {
-            if (bar.markCount > 0) {
-                height += TimeRuler.barHeight + TimeRuler.barPadding * 2;
-                maxTime = Math.max(maxTime, bar.markers[bar.markCount - 1].endTime);
+            var frameSpan = 1 / 60 * 1000;
+            var sampleSpan = this.sampleFrames * frameSpan;
+            if (maxTime > sampleSpan) {
+                this._frameAdjust = Math.max(0, this._frameAdjust) + 1;
             }
-        });
-        var frameSpan = 1 / 60 * 1000;
-        var sampleSpan = this.sampleFrames * frameSpan;
-        if (maxTime > sampleSpan) {
-            this._frameAdjust = Math.max(0, this._frameAdjust) + 1;
+            else {
+                this._frameAdjust = Math.min(0, this._frameAdjust) - 1;
+            }
+            if (Math.max(this._frameAdjust) > TimeRuler.autoAdjustDelay) {
+                this.sampleFrames = Math.min(TimeRuler.maxSampleFrames, this.sampleFrames);
+                this.sampleFrames = Math.max(this.targetSampleFrames, (maxTime / frameSpan) + 1);
+                this._frameAdjust = 0;
+            }
+            var msToPs = width / sampleSpan;
+            var startY = position.y - (height - TimeRuler.barHeight);
+            var y = startY;
+        };
+        TimeRuler.maxBars = 8;
+        TimeRuler.maxSamples = 256;
+        TimeRuler.maxNestCall = 32;
+        TimeRuler.barHeight = 8;
+        TimeRuler.maxSampleFrames = 4;
+        TimeRuler.logSnapDuration = 120;
+        TimeRuler.barPadding = 2;
+        TimeRuler.autoAdjustDelay = 30;
+        return TimeRuler;
+    }());
+    es.TimeRuler = TimeRuler;
+    var FrameLog = (function () {
+        function FrameLog() {
+            this.bars = new Array(TimeRuler.maxBars);
+            this.bars.fill(new MarkerCollection(), 0, TimeRuler.maxBars);
         }
-        else {
-            this._frameAdjust = Math.min(0, this._frameAdjust) - 1;
+        return FrameLog;
+    }());
+    es.FrameLog = FrameLog;
+    var MarkerCollection = (function () {
+        function MarkerCollection() {
+            this.markers = new Array(TimeRuler.maxSamples);
+            this.markCount = 0;
+            this.markerNests = new Array(TimeRuler.maxNestCall);
+            this.nestCount = 0;
+            this.markers.fill(new Marker(), 0, TimeRuler.maxSamples);
+            this.markerNests.fill(0, 0, TimeRuler.maxNestCall);
         }
-        if (Math.max(this._frameAdjust) > TimeRuler.autoAdjustDelay) {
-            this.sampleFrames = Math.min(TimeRuler.maxSampleFrames, this.sampleFrames);
-            this.sampleFrames = Math.max(this.targetSampleFrames, (maxTime / frameSpan) + 1);
-            this._frameAdjust = 0;
+        return MarkerCollection;
+    }());
+    es.MarkerCollection = MarkerCollection;
+    var Marker = (function () {
+        function Marker() {
+            this.markerId = 0;
+            this.beginTime = 0;
+            this.endTime = 0;
+            this.color = 0x000000;
         }
-        var msToPs = width / sampleSpan;
-        var startY = position.y - (height - TimeRuler.barHeight);
-        var y = startY;
-    };
-    TimeRuler.maxBars = 8;
-    TimeRuler.maxSamples = 256;
-    TimeRuler.maxNestCall = 32;
-    TimeRuler.barHeight = 8;
-    TimeRuler.maxSampleFrames = 4;
-    TimeRuler.logSnapDuration = 120;
-    TimeRuler.barPadding = 2;
-    TimeRuler.autoAdjustDelay = 30;
-    return TimeRuler;
-}());
-var FrameLog = (function () {
-    function FrameLog() {
-        this.bars = new Array(TimeRuler.maxBars);
-        this.bars.fill(new MarkerCollection(), 0, TimeRuler.maxBars);
-    }
-    return FrameLog;
-}());
-var MarkerCollection = (function () {
-    function MarkerCollection() {
-        this.markers = new Array(TimeRuler.maxSamples);
-        this.markCount = 0;
-        this.markerNests = new Array(TimeRuler.maxNestCall);
-        this.nestCount = 0;
-        this.markers.fill(new Marker(), 0, TimeRuler.maxSamples);
-        this.markerNests.fill(0, 0, TimeRuler.maxNestCall);
-    }
-    return MarkerCollection;
-}());
-var Marker = (function () {
-    function Marker() {
-        this.markerId = 0;
-        this.beginTime = 0;
-        this.endTime = 0;
-        this.color = 0x000000;
-    }
-    return Marker;
-}());
-var MarkerInfo = (function () {
-    function MarkerInfo(name) {
-        this.logs = new Array(TimeRuler.maxBars);
-        this.name = name;
-        this.logs.fill(new MarkerLog(), 0, TimeRuler.maxBars);
-    }
-    return MarkerInfo;
-}());
-var MarkerLog = (function () {
-    function MarkerLog() {
-        this.snapMin = 0;
-        this.snapMax = 0;
-        this.snapAvg = 0;
-        this.min = 0;
-        this.max = 0;
-        this.avg = 0;
-        this.samples = 0;
-        this.color = 0x000000;
-        this.initialized = false;
-    }
-    return MarkerLog;
-}());
+        return Marker;
+    }());
+    es.Marker = Marker;
+    var MarkerInfo = (function () {
+        function MarkerInfo(name) {
+            this.logs = new Array(TimeRuler.maxBars);
+            this.name = name;
+            this.logs.fill(new MarkerLog(), 0, TimeRuler.maxBars);
+        }
+        return MarkerInfo;
+    }());
+    es.MarkerInfo = MarkerInfo;
+    var MarkerLog = (function () {
+        function MarkerLog() {
+            this.snapMin = 0;
+            this.snapMax = 0;
+            this.snapAvg = 0;
+            this.min = 0;
+            this.max = 0;
+            this.avg = 0;
+            this.samples = 0;
+            this.color = 0x000000;
+            this.initialized = false;
+        }
+        return MarkerLog;
+    }());
+    es.MarkerLog = MarkerLog;
+})(es || (es = {}));
diff --git a/source/bin/framework.min.js b/source/bin/framework.min.js
index d6c96e6d..21b482eb 100644
--- a/source/bin/framework.min.js
+++ b/source/bin/framework.min.js
@@ -1 +1 @@
-window.framework={},window.__extends=this&&this.__extends||function(){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n])};return function(e,n){function i(){this.constructor=e}t(e,n),e.prototype=null===n?Object.create(n):(i.prototype=n.prototype,new i)}}();var __awaiter=this&&this.__awaiter||function(t,e,n,i){return new(n||(n=Promise))(function(r,o){function s(t){try{c(i.next(t))}catch(t){o(t)}}function a(t){try{c(i.throw(t))}catch(t){o(t)}}function c(t){t.done?r(t.value):new n(function(e){e(t.value)}).then(s,a)}c((i=i.apply(t,e||[])).next())})},__generator=this&&this.__generator||function(t,e){var n,i,r,o,s={label:0,sent:function(){if(1&r[0])throw r[1];return r[1]},trys:[],ops:[]};return o={next:a(0),throw:a(1),return:a(2)},"function"==typeof Symbol&&(o[Symbol.iterator]=function(){return this}),o;function a(o){return function(a){return function(o){if(n)throw new TypeError("Generator is already executing.");for(;s;)try{if(n=1,i&&(r=2&o[0]?i.return:o[0]?i.throw||((r=i.return)&&r.call(i),0):i.next)&&!(r=r.call(i,o[1])).done)return r;switch(i=0,r&&(o=[2&o[0],r.value]),o[0]){case 0:case 1:r=o;break;case 4:return s.label++,{value:o[1],done:!1};case 5:s.label++,i=o[1],o=[0];continue;case 7:o=s.ops.pop(),s.trys.pop();continue;default:if(!(r=(r=s.trys).length>0&&r[r.length-1])&&(6===o[0]||2===o[0])){s=0;continue}if(3===o[0]&&(!r||o[1]>r[0]&&o[1]<r[3])){s.label=o[1];break}if(6===o[0]&&s.label<r[1]){s.label=r[1],r=o;break}if(r&&s.label<r[2]){s.label=r[2],s.ops.push(o);break}r[2]&&s.ops.pop(),s.trys.pop();continue}o=e.call(t,s)}catch(t){o=[6,t],i=0}finally{n=r=0}if(5&o[0])throw o[1];return{value:o[0]?o[1]:void 0,done:!0}}([o,a])}}};Array.prototype.findIndex=function(t){return function(t,e){for(var n=0,i=t.length;n<i;n++)if(e.call(arguments[2],t[n],n,t))return n;return-1}(this,t)},Array.prototype.any=function(t){return function(t,e){return t.findIndex(e)>-1}(this,t)},Array.prototype.firstOrDefault=function(t){return function(t,e){var n=t.findIndex(e);return-1==n?null:t[n]}(this,t)},Array.prototype.find=function(t){return function(t,e){return t.firstOrDefault(e)}(this,t)},Array.prototype.where=function(t){return function(t,e){if("function"==typeof t.reduce)return t.reduce(function(n,i,r){return e.call(arguments[2],i,r,t)&&n.push(i),n},[]);for(var n=[],i=0,r=t.length;i<r;i++){var o=t[i];e.call(arguments[2],o,i,t)&&n.push(o)}return n}(this,t)},Array.prototype.count=function(t){return function(t,e){return t.where(e).length}(this,t)},Array.prototype.findAll=function(t){return function(t,e){return t.where(e)}(this,t)},Array.prototype.contains=function(t){return function(t,e){for(var n=0,i=t.length;n<i;n++)if(t[n]==e)return!0;return!1}(this,t)},Array.prototype.removeAll=function(t){!function(t,e){var n;do{(n=t.findIndex(e))>=0&&t.splice(n,1)}while(n>=0)}(this,t)},Array.prototype.remove=function(t){return function(t,e){var n=t.findIndex(function(t){return t===e});return n>=0&&(t.splice(n,1),!0)}(this,t)},Array.prototype.removeAt=function(t){return function(t,e){t.splice(e,1)}(this,t)},Array.prototype.removeRange=function(t,e){return function(t,e,n){t.splice(e,n)}(this,t,e)},Array.prototype.select=function(t){return function(t,e){if("function"==typeof t.reduce)return t.reduce(function(n,i,r){return n.push(e.call(arguments[2],i,r,t)),n},[]);for(var n=[],i=0,r=t.length;i<r;i++)n.push(e.call(arguments[2],t[i],i,t));return n}(this,t)},Array.prototype.orderBy=function(t,e){return function(t,e,n){return t.sort(function(t,i){var r=e(t),o=e(i);return n?n(r,o):r>o?1:-1}),t}(this,t,e)},Array.prototype.orderByDescending=function(t,e){return function(t,e,n){return t.sort(function(t,i){var r=e(t),o=e(i);return n?-n(r,o):r<o?1:-1}),t}(this,t,e)},Array.prototype.groupBy=function(t){return function(t,e){if("function"==typeof t.reduce){var n=[];return t.reduce(function(i,r,o){var s=JSON.stringify(e.call(arguments[1],r,o,t)),a=n.findIndex(function(t){return t===s});return a<0&&(a=n.push(s)-1),i[a]||(i[a]=[]),i[a].push(r),i},[])}for(var i=[],r=[],o=function(n,o){var a=JSON.stringify(e.call(s[1],t[n],n,t)),c=r.findIndex(function(t){return t===a});c<0&&(c=r.push(a)-1),i[c]||(i[c]=[]),i[c].push(t[n])},s=arguments,a=0,c=t.length;a<c;a++)o(a);return i}(this,t)},Array.prototype.sum=function(t){return function(t,e){for(var n,i=0,r=t.length;i<r;i++)0==i?n=e?e.call(arguments[2],t[i],i,t):t[i]:n+=e?e.call(arguments[2],t[i],i,t):t[i];return n}(this,t)};var DebugDrawType,PriorityQueueNode=function(){return function(){this.priority=0,this.insertionIndex=0,this.queueIndex=0}}(),AStarPathfinder=function(){function t(){}return t.search=function(t,e,n){var i=this,r=!1,o=new Map;o.set(e,e);var s=new Map,a=new PriorityQueue(1e3);a.enqueue(new AStarNode(e),0),s.set(e,0);for(var c=function(){var e=a.dequeue();if(JSON.stringify(e.data)==JSON.stringify(n))return r=!0,"break";t.getNeighbors(e.data).forEach(function(r){var c=s.get(e.data)+t.cost(e.data,r);if(!i.hasKey(s,r)||c<s.get(r)){s.set(r,c);var h=c+t.heuristic(r,n);a.enqueue(new AStarNode(r),h),o.set(r,e.data)}})};a.count>0;){if("break"===c())break}return r?this.recontructPath(o,e,n):null},t.hasKey=function(t,e){for(var n,i=t.keys();!(n=i.next()).done;)if(JSON.stringify(n.value)==JSON.stringify(e))return!0;return!1},t.getKey=function(t,e){for(var n,i,r=t.keys(),o=t.values();n=r.next(),i=o.next(),!n.done;)if(JSON.stringify(n.value)==JSON.stringify(e))return i.value;return null},t.recontructPath=function(t,e,n){var i=[],r=n;for(i.push(n);r!=e;)r=this.getKey(t,r),i.push(r);return i.reverse(),i},t}(),AStarNode=function(t){function e(e){var n=t.call(this)||this;return n.data=e,n}return __extends(e,t),e}(PriorityQueueNode),AstarGridGraph=function(){function t(t,e){this.dirs=[new Vector2(1,0),new Vector2(0,-1),new Vector2(-1,0),new Vector2(0,1)],this.walls=[],this.weightedNodes=[],this.defaultWeight=1,this.weightedNodeWeight=5,this._neighbors=new Array(4),this._width=t,this._height=e}return t.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._height},t.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},t.prototype.search=function(t,e){return AStarPathfinder.search(this,t,e)},t.prototype.getNeighbors=function(t){var e=this;return this._neighbors.length=0,this.dirs.forEach(function(n){var i=new Vector2(t.x+n.x,t.y+n.y);e.isNodeInBounds(i)&&e.isNodePassable(i)&&e._neighbors.push(i)}),this._neighbors},t.prototype.cost=function(t,e){return this.weightedNodes.find(function(t){return JSON.stringify(t)==JSON.stringify(e)})?this.weightedNodeWeight:this.defaultWeight},t.prototype.heuristic=function(t,e){return Math.abs(t.x-e.x)+Math.abs(t.y-e.y)},t}(),PriorityQueue=function(){function t(t){this._numNodes=0,this._nodes=new Array(t+1),this._numNodesEverEnqueued=0}return t.prototype.clear=function(){this._nodes.splice(1,this._numNodes),this._numNodes=0},Object.defineProperty(t.prototype,"count",{get:function(){return this._numNodes},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"maxSize",{get:function(){return this._nodes.length-1},enumerable:!0,configurable:!0}),t.prototype.contains=function(t){return t?t.queueIndex<0||t.queueIndex>=this._nodes.length?(console.error("node.QueueIndex has been corrupted. Did you change it manually? Or add this node to another queue?"),!1):this._nodes[t.queueIndex]==t:(console.error("node cannot be null"),!1)},t.prototype.enqueue=function(t,e){t.priority=e,this._numNodes++,this._nodes[this._numNodes]=t,t.queueIndex=this._numNodes,t.insertionIndex=this._numNodesEverEnqueued++,this.cascadeUp(this._nodes[this._numNodes])},t.prototype.dequeue=function(){var t=this._nodes[1];return this.remove(t),t},t.prototype.remove=function(t){if(t.queueIndex==this._numNodes)return this._nodes[this._numNodes]=null,void this._numNodes--;var e=this._nodes[this._numNodes];this.swap(t,e),delete this._nodes[this._numNodes],this._numNodes--,this.onNodeUpdated(e)},t.prototype.isValidQueue=function(){for(var t=1;t<this._nodes.length;t++)if(this._nodes[t]){var e=2*t;if(e<this._nodes.length&&this._nodes[e]&&this.hasHigherPriority(this._nodes[e],this._nodes[t]))return!1;var n=e+1;if(n<this._nodes.length&&this._nodes[n]&&this.hasHigherPriority(this._nodes[n],this._nodes[t]))return!1}return!0},t.prototype.onNodeUpdated=function(t){var e=Math.floor(t.queueIndex/2),n=this._nodes[e];e>0&&this.hasHigherPriority(t,n)?this.cascadeUp(t):this.cascadeDown(t)},t.prototype.cascadeDown=function(t){for(var e,n=t.queueIndex;;){e=t;var i=2*n;if(i>this._numNodes){t.queueIndex=n,this._nodes[n]=t;break}var r=this._nodes[i];this.hasHigherPriority(r,e)&&(e=r);var o=i+1;if(o<=this._numNodes){var s=this._nodes[o];this.hasHigherPriority(s,e)&&(e=s)}if(e==t){t.queueIndex=n,this._nodes[n]=t;break}this._nodes[n]=e;var a=e.queueIndex;e.queueIndex=n,n=a}},t.prototype.cascadeUp=function(t){for(var e=Math.floor(t.queueIndex/2);e>=1;){var n=this._nodes[e];if(this.hasHigherPriority(n,t))break;this.swap(t,n),e=Math.floor(t.queueIndex/2)}},t.prototype.swap=function(t,e){this._nodes[t.queueIndex]=e,this._nodes[e.queueIndex]=t;var n=t.queueIndex;t.queueIndex=e.queueIndex,e.queueIndex=n},t.prototype.hasHigherPriority=function(t,e){return t.priority<e.priority||t.priority==e.priority&&t.insertionIndex<e.insertionIndex},t}(),BreadthFirstPathfinder=function(){function t(){}return t.search=function(t,e,n){var i=this,r=!1,o=[];o.unshift(e);var s=new Map;s.set(e,e);for(var a=function(){var e=o.shift();if(JSON.stringify(e)==JSON.stringify(n))return r=!0,"break";t.getNeighbors(e).forEach(function(t){i.hasKey(s,t)||(o.unshift(t),s.set(t,e))})};o.length>0;){if("break"===a())break}return r?AStarPathfinder.recontructPath(s,e,n):null},t.hasKey=function(t,e){for(var n,i=t.keys();!(n=i.next()).done;)if(JSON.stringify(n.value)==JSON.stringify(e))return!0;return!1},t}(),UnweightedGraph=function(){function t(){this.edges=new Map}return t.prototype.addEdgesForNode=function(t,e){return this.edges.set(t,e),this},t.prototype.getNeighbors=function(t){return this.edges.get(t)},t}(),Vector2=function(){function t(t,e){this.x=0,this.y=0,this.x=t||0,this.y=e||this.x}return Object.defineProperty(t,"zero",{get:function(){return t.zeroVector2},enumerable:!0,configurable:!0}),Object.defineProperty(t,"one",{get:function(){return t.unitVector2},enumerable:!0,configurable:!0}),Object.defineProperty(t,"unitX",{get:function(){return t.unitXVector},enumerable:!0,configurable:!0}),Object.defineProperty(t,"unitY",{get:function(){return t.unitYVector},enumerable:!0,configurable:!0}),t.add=function(e,n){var i=new t(0,0);return i.x=e.x+n.x,i.y=e.y+n.y,i},t.divide=function(e,n){var i=new t(0,0);return i.x=e.x/n.x,i.y=e.y/n.y,i},t.multiply=function(e,n){var i=new t(0,0);return i.x=e.x*n.x,i.y=e.y*n.y,i},t.subtract=function(e,n){var i=new t(0,0);return i.x=e.x-n.x,i.y=e.y-n.y,i},t.prototype.normalize=function(){var t=1/Math.sqrt(this.x*this.x+this.y*this.y);this.x*=t,this.y*=t},t.prototype.length=function(){return Math.sqrt(this.x*this.x+this.y*this.y)},t.prototype.round=function(){return new t(Math.round(this.x),Math.round(this.y))},t.normalize=function(t){var e=1/Math.sqrt(t.x*t.x+t.y*t.y);return t.x*=e,t.y*=e,t},t.dot=function(t,e){return t.x*e.x+t.y*e.y},t.distanceSquared=function(t,e){var n=t.x-e.x,i=t.y-e.y;return n*n+i*i},t.clamp=function(e,n,i){return new t(MathHelper.clamp(e.x,n.x,i.x),MathHelper.clamp(e.y,n.y,i.y))},t.lerp=function(e,n,i){return new t(MathHelper.lerp(e.x,n.x,i),MathHelper.lerp(e.y,n.y,i))},t.transform=function(e,n){return new t(e.x*n.m11+e.y*n.m21,e.x*n.m12+e.y*n.m22)},t.distance=function(t,e){var n=t.x-e.x,i=t.y-e.y;return Math.sqrt(n*n+i*i)},t.negate=function(e){var n=new t;return n.x=-e.x,n.y=-e.y,n},t.unitYVector=new t(0,1),t.unitXVector=new t(1,0),t.unitVector2=new t(1,1),t.zeroVector2=new t(0,0),t}(),UnweightedGridGraph=function(){function t(e,n,i){void 0===i&&(i=!1),this.walls=[],this._neighbors=new Array(4),this._width=e,this._hegiht=n,this._dirs=i?t.COMPASS_DIRS:t.CARDINAL_DIRS}return t.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._hegiht},t.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},t.prototype.getNeighbors=function(t){var e=this;return this._neighbors.length=0,this._dirs.forEach(function(n){var i=new Vector2(t.x+n.x,t.y+n.y);e.isNodeInBounds(i)&&e.isNodePassable(i)&&e._neighbors.push(i)}),this._neighbors},t.prototype.search=function(t,e){return BreadthFirstPathfinder.search(this,t,e)},t.CARDINAL_DIRS=[new Vector2(1,0),new Vector2(0,-1),new Vector2(-1,0),new Vector2(0,-1)],t.COMPASS_DIRS=[new Vector2(1,0),new Vector2(1,-1),new Vector2(0,-1),new Vector2(-1,-1),new Vector2(-1,0),new Vector2(-1,1),new Vector2(0,1),new Vector2(1,1)],t}(),WeightedGridGraph=function(){function t(e,n,i){void 0===i&&(i=!1),this.walls=[],this.weightedNodes=[],this.defaultWeight=1,this.weightedNodeWeight=5,this._neighbors=new Array(4),this._width=e,this._height=n,this._dirs=i?t.COMPASS_DIRS:t.CARDINAL_DIRS}return t.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._height},t.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},t.prototype.search=function(t,e){return WeightedPathfinder.search(this,t,e)},t.prototype.getNeighbors=function(t){var e=this;return this._neighbors.length=0,this._dirs.forEach(function(n){var i=new Vector2(t.x+n.x,t.y+n.y);e.isNodeInBounds(i)&&e.isNodePassable(i)&&e._neighbors.push(i)}),this._neighbors},t.prototype.cost=function(t,e){return this.weightedNodes.find(function(t){return JSON.stringify(t)==JSON.stringify(e)})?this.weightedNodeWeight:this.defaultWeight},t.CARDINAL_DIRS=[new Vector2(1,0),new Vector2(0,-1),new Vector2(-1,0),new Vector2(0,1)],t.COMPASS_DIRS=[new Vector2(1,0),new Vector2(1,-1),new Vector2(0,-1),new Vector2(-1,-1),new Vector2(-1,0),new Vector2(-1,1),new Vector2(0,1),new Vector2(1,1)],t}(),WeightedNode=function(t){function e(e){var n=t.call(this)||this;return n.data=e,n}return __extends(e,t),e}(PriorityQueueNode),WeightedPathfinder=function(){function t(){}return t.search=function(t,e,n){var i=this,r=!1,o=new Map;o.set(e,e);var s=new Map,a=new PriorityQueue(1e3);a.enqueue(new WeightedNode(e),0),s.set(e,0);for(var c=function(){var e=a.dequeue();if(JSON.stringify(e.data)==JSON.stringify(n))return r=!0,"break";t.getNeighbors(e.data).forEach(function(n){var r=s.get(e.data)+t.cost(e.data,n);if(!i.hasKey(s,n)||r<s.get(n)){s.set(n,r);var c=r;a.enqueue(new WeightedNode(n),c),o.set(n,e.data)}})};a.count>0;){if("break"===c())break}return r?this.recontructPath(o,e,n):null},t.hasKey=function(t,e){for(var n,i=t.keys();!(n=i.next()).done;)if(JSON.stringify(n.value)==JSON.stringify(e))return!0;return!1},t.getKey=function(t,e){for(var n,i,r=t.keys(),o=t.values();n=r.next(),i=o.next(),!n.done;)if(JSON.stringify(n.value)==JSON.stringify(e))return i.value;return null},t.recontructPath=function(t,e,n){var i=[],r=n;for(i.push(n);r!=e;)r=this.getKey(t,r),i.push(r);return i.reverse(),i},t}(),Debug=function(){function t(){}return t.drawHollowRect=function(t,e,n){void 0===n&&(n=0),this._debugDrawItems.push(new DebugDrawItem(t,e,n))},t.render=function(){if(this._debugDrawItems.length>0){var t=new egret.Shape;SceneManager.scene&&SceneManager.scene.addChild(t);for(var e=this._debugDrawItems.length-1;e>=0;e--){this._debugDrawItems[e].draw(t)&&this._debugDrawItems.removeAt(e)}}},t._debugDrawItems=[],t}(),DebugDefaults=function(){function t(){}return t.verletParticle=14431326,t.verletConstraintEdge=4406838,t}();!function(t){t[t.line=0]="line",t[t.hollowRectangle=1]="hollowRectangle",t[t.pixel=2]="pixel",t[t.text=3]="text"}(DebugDrawType||(DebugDrawType={}));var CoreEvents,DebugDrawItem=function(){function t(t,e,n){this.rectangle=t,this.color=e,this.duration=n,this.drawType=DebugDrawType.hollowRectangle}return t.prototype.draw=function(t){switch(this.drawType){case DebugDrawType.line:DrawUtils.drawLine(t,this.start,this.end,this.color);break;case DebugDrawType.hollowRectangle:DrawUtils.drawHollowRect(t,this.rectangle,this.color);break;case DebugDrawType.pixel:DrawUtils.drawPixel(t,new Vector2(this.x,this.y),this.color,this.size);break;case DebugDrawType.text:}return this.duration-=Time.deltaTime,this.duration<0},t}(),Component=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e._enabled=!0,e.updateInterval=1,e._updateOrder=0,e}return __extends(e,t),Object.defineProperty(e.prototype,"enabled",{get:function(){return this.entity?this.entity.enabled&&this._enabled:this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"localPosition",{get:function(){return new Vector2(this.entity.x+this.x,this.entity.y+this.y)},enumerable:!0,configurable:!0}),e.prototype.setEnabled=function(t){return this._enabled!=t&&(this._enabled=t,this._enabled?this.onEnabled():this.onDisabled()),this},Object.defineProperty(e.prototype,"updateOrder",{get:function(){return this._updateOrder},set:function(t){this.setUpdateOrder(t)},enumerable:!0,configurable:!0}),e.prototype.setUpdateOrder=function(t){return this._updateOrder!=t&&(this._updateOrder=t),this},e.prototype.initialize=function(){},e.prototype.onAddedToEntity=function(){},e.prototype.onRemovedFromEntity=function(){},e.prototype.onEnabled=function(){},e.prototype.onDisabled=function(){},e.prototype.debugRender=function(){},e.prototype.update=function(){},e.prototype.onEntityTransformChanged=function(t){},e.prototype.registerComponent=function(){this.entity.componentBits.set(ComponentTypeManager.getIndexFor(this),!1),this.entity.scene.entityProcessors.onComponentAdded(this.entity)},e.prototype.deregisterComponent=function(){this.entity.componentBits.set(ComponentTypeManager.getIndexFor(this)),this.entity.scene.entityProcessors.onComponentRemoved(this.entity)},e}(egret.DisplayObjectContainer);!function(t){t[t.SceneChanged=0]="SceneChanged"}(CoreEvents||(CoreEvents={}));var TransformComponent,Entity=function(t){function e(n){var i=t.call(this)||this;return i._updateOrder=0,i._enabled=!0,i._tag=0,i.name=n,i.components=new ComponentList(i),i.id=e._idGenerator++,i.componentBits=new BitSet,i.addEventListener(egret.Event.ADDED_TO_STAGE,i.onAddToStage,i),i}return __extends(e,t),Object.defineProperty(e.prototype,"isDestoryed",{get:function(){return this._isDestoryed},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"position",{get:function(){return new Vector2(this.x,this.y)},set:function(t){this.$setX(t.x),this.$setY(t.y),this.onEntityTransformChanged(TransformComponent.position)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"scale",{get:function(){return new Vector2(this.scaleX,this.scaleY)},set:function(t){this.$setScaleX(t.x),this.$setScaleY(t.y),this.onEntityTransformChanged(TransformComponent.scale)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"rotation",{get:function(){return this.$getRotation()},set:function(t){this.$setRotation(t),this.onEntityTransformChanged(TransformComponent.rotation)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"enabled",{get:function(){return this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),e.prototype.setEnabled=function(t){return this._enabled!=t&&(this._enabled=t),this},Object.defineProperty(e.prototype,"tag",{get:function(){return this._tag},set:function(t){this.setTag(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"stage",{get:function(){return this.scene?this.scene.stage:null},enumerable:!0,configurable:!0}),e.prototype.onAddToStage=function(){this.onEntityTransformChanged(TransformComponent.position)},Object.defineProperty(e.prototype,"updateOrder",{get:function(){return this._updateOrder},set:function(t){this.setUpdateOrder(t)},enumerable:!0,configurable:!0}),e.prototype.roundPosition=function(){this.position=Vector2Ext.round(this.position)},e.prototype.setUpdateOrder=function(t){if(this._updateOrder!=t)return this._updateOrder=t,this.scene,this},e.prototype.setTag=function(t){return this._tag!=t&&(this.scene&&this.scene.entities.removeFromTagList(this),this._tag=t,this.scene&&this.scene.entities.addToTagList(this)),this},e.prototype.attachToScene=function(t){this.scene=t,t.entities.add(this),this.components.registerAllComponents();for(var e=0;e<this.numChildren;e++)this.getChildAt(e).entity.attachToScene(t)},e.prototype.detachFromScene=function(){this.scene.entities.remove(this),this.components.deregisterAllComponents();for(var t=0;t<this.numChildren;t++)this.getChildAt(t).entity.detachFromScene()},e.prototype.addComponent=function(t){return t.entity=this,this.components.add(t),this.addChild(t),t.initialize(),t},e.prototype.hasComponent=function(t){return null!=this.components.getComponent(t,!1)},e.prototype.getOrCreateComponent=function(t){var e=this.components.getComponent(t,!0);return e||(e=this.addComponent(t)),e},e.prototype.getComponent=function(t){return this.components.getComponent(t,!1)},e.prototype.getComponents=function(t,e){return this.components.getComponents(t,e)},e.prototype.onEntityTransformChanged=function(t){this.components.onEntityTransformChanged(t)},e.prototype.removeComponentForType=function(t){var e=this.getComponent(t);return!!e&&(this.removeComponent(e),!0)},e.prototype.removeComponent=function(t){this.components.remove(t)},e.prototype.removeAllComponents=function(){for(var t=0;t<this.components.count;t++)this.removeComponent(this.components.buffer[t])},e.prototype.update=function(){this.components.update()},e.prototype.onAddedToScene=function(){},e.prototype.onRemovedFromScene=function(){this._isDestoryed&&this.components.removeAllComponents()},e.prototype.destroy=function(){this._isDestoryed=!0,this.removeEventListener(egret.Event.ADDED_TO_STAGE,this.onAddToStage,this),this.scene.entities.remove(this),this.removeChildren(),this.parent&&this.parent.removeChild(this);for(var t=this.numChildren-1;t>=0;t--){this.getChildAt(t).entity.destroy()}},e}(egret.DisplayObjectContainer);!function(t){t[t.rotation=0]="rotation",t[t.scale=1]="scale",t[t.position=2]="position"}(TransformComponent||(TransformComponent={}));var CameraStyle,Scene=function(t){function e(){var e=t.call(this)||this;return e.enablePostProcessing=!0,e._renderers=[],e._postProcessors=[],e.entityProcessors=new EntityProcessorList,e.renderableComponents=new RenderableComponentList,e.entities=new EntityList(e),e.content=new ContentManager,e.width=SceneManager.stage.stageWidth,e.height=SceneManager.stage.stageHeight,e.addEventListener(egret.Event.ACTIVATE,e.onActive,e),e.addEventListener(egret.Event.DEACTIVATE,e.onDeactive,e),e}return __extends(e,t),e.prototype.createEntity=function(t){var e=new Entity(t);return e.position=new Vector2(0,0),this.addEntity(e)},e.prototype.addEntity=function(t){this.entities.add(t),t.scene=this,this.addChild(t);for(var e=0;e<t.numChildren;e++)this.addEntity(t.getChildAt(e).entity);return t},e.prototype.destroyAllEntities=function(){for(var t=0;t<this.entities.count;t++)this.entities.buffer[t].destroy()},e.prototype.findEntity=function(t){return this.entities.findEntity(t)},e.prototype.addEntityProcessor=function(t){return t.scene=this,this.entityProcessors.add(t),t},e.prototype.removeEntityProcessor=function(t){this.entityProcessors.remove(t)},e.prototype.getEntityProcessor=function(){return this.entityProcessors.getProcessor()},e.prototype.addRenderer=function(t){return this._renderers.push(t),this._renderers.sort(),t.onAddedToScene(this),t},e.prototype.getRenderer=function(t){for(var e=0;e<this._renderers.length;e++)if(this._renderers[e]instanceof t)return this._renderers[e];return null},e.prototype.removeRenderer=function(t){this._renderers.remove(t),t.unload()},e.prototype.begin=function(){SceneManager.sceneTransition?SceneManager.stage.addChildAt(this,SceneManager.stage.numChildren-1):SceneManager.stage.addChild(this),0==this._renderers.length&&(this.addRenderer(new DefaultRenderer),console.warn("场景开始时没有渲染器 自动添加DefaultRenderer以保证能够正常渲染")),this.camera=this.createEntity("camera").getOrCreateComponent(new Camera),Physics.reset(),this.entityProcessors&&this.entityProcessors.begin(),this.camera.onSceneSizeChanged(this.stage.stageWidth,this.stage.stageHeight),this._didSceneBegin=!0,this.onStart()},e.prototype.end=function(){this._didSceneBegin=!1,this.removeEventListener(egret.Event.DEACTIVATE,this.onDeactive,this),this.removeEventListener(egret.Event.ACTIVATE,this.onActive,this);for(var t=0;t<this._renderers.length;t++)this._renderers[t].unload();for(t=0;t<this._postProcessors.length;t++)this._postProcessors[t].unload();this.entities.removeAllEntities(),this.removeChildren(),Physics.clear(),this.camera=null,this.content.dispose(),this.entityProcessors&&this.entityProcessors.end(),this.unload(),this.parent&&this.parent.removeChild(this)},e.prototype.onStart=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(t){return[2]})})},e.prototype.onActive=function(){},e.prototype.onDeactive=function(){},e.prototype.unload=function(){},e.prototype.update=function(){this.entities.updateLists(),this.entityProcessors&&this.entityProcessors.update(),this.entities.update(),this.entityProcessors&&this.entityProcessors.lateUpdate(),this.renderableComponents.updateList()},e.prototype.postRender=function(){var t=0;if(this.enablePostProcessing)for(var e=0;e<this._postProcessors.length;e++)if(this._postProcessors[e].enable){MathHelper.isEven(t);t++,this._postProcessors[e].process()}},e.prototype.render=function(){for(var t=0;t<this._renderers.length;t++)this._renderers[t].render(this)},e.prototype.addPostProcessor=function(t){return this._postProcessors.push(t),this._postProcessors.sort(),t.onAddedToScene(this),this._didSceneBegin&&t.onSceneBackBufferSizeChanged(this.stage.stageWidth,this.stage.stageHeight),t},e}(egret.DisplayObjectContainer),SceneManager=function(){function t(e){e.addEventListener(egret.Event.ENTER_FRAME,t.update,this),t._instnace=this,t.emitter=new Emitter,t.content=new ContentManager,t.stage=e,t.initialize(e),t.timerRuler=new TimeRuler}return Object.defineProperty(t,"Instance",{get:function(){return this._instnace},enumerable:!0,configurable:!0}),Object.defineProperty(t,"scene",{get:function(){return this._scene},set:function(e){if(!e)throw new Error("场景不能为空");null==this._scene?(this._scene=e,this._scene.begin(),t.Instance.onSceneChanged()):this._nextScene=e,this.registerActiveSceneChanged(this._scene,this._nextScene)},enumerable:!0,configurable:!0}),t.initialize=function(t){Input.initialize(t)},t.update=function(){if(t.startDebugUpdate(),Time.update(egret.getTimer()),t._scene){for(var e=GlobalManager.globalManagers.length-1;e>=0;e--)GlobalManager.globalManagers[e].enabled&&GlobalManager.globalManagers[e].update();t.sceneTransition&&(!t.sceneTransition||t.sceneTransition.loadsNewScene&&!t.sceneTransition.isNewSceneLoaded)||t._scene.update(),t._nextScene&&(t._scene.end(),t._scene=t._nextScene,t._nextScene=null,t._instnace.onSceneChanged(),t._scene.begin())}t.endDebugUpdate(),t.render()},t.render=function(){this.sceneTransition?(this.sceneTransition.preRender(),this._scene&&!this.sceneTransition.hasPreviousSceneRender?(this._scene.render(),this._scene.postRender(),this.sceneTransition.onBeginTransition()):this.sceneTransition&&(this._scene&&this.sceneTransition.isNewSceneLoaded&&(this._scene.render(),this._scene.postRender()),this.sceneTransition.render())):this._scene&&(this._scene.render(),Debug.render(),this._scene.postRender())},t.startSceneTransition=function(t){if(!this.sceneTransition)return this.sceneTransition=t,t;console.warn("在前一个场景完成之前，不能开始一个新的场景转换。")},t.registerActiveSceneChanged=function(t,e){this.activeSceneChanged&&this.activeSceneChanged(t,e)},t.prototype.onSceneChanged=function(){t.emitter.emit(CoreEvents.SceneChanged),Time.sceneChanged()},t.startDebugUpdate=function(){TimeRuler.Instance.startFrame(),TimeRuler.Instance.beginMark("update",65280)},t.endDebugUpdate=function(){TimeRuler.Instance.endMark("update")},t}(),Camera=function(t){function e(){var e=t.call(this)||this;return e._origin=Vector2.zero,e._minimumZoom=.3,e._maximumZoom=3,e._position=Vector2.zero,e.followLerp=.1,e.deadzone=new Rectangle,e.focusOffset=new Vector2,e.mapLockEnabled=!1,e.mapSize=new Vector2,e._worldSpaceDeadZone=new Rectangle,e._desiredPositionDelta=new Vector2,e.cameraStyle=CameraStyle.lockOn,e.width=SceneManager.stage.stageWidth,e.height=SceneManager.stage.stageHeight,e.setZoom(0),e}return __extends(e,t),Object.defineProperty(e.prototype,"zoom",{get:function(){return 0==this._zoom?1:this._zoom<1?MathHelper.map(this._zoom,this._minimumZoom,1,-1,0):MathHelper.map(this._zoom,1,this._maximumZoom,0,1)},set:function(t){this.setZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"minimumZoom",{get:function(){return this._minimumZoom},set:function(t){this.setMinimumZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"maximumZoom",{get:function(){return this._maximumZoom},set:function(t){this.setMaximumZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"origin",{get:function(){return this._origin},set:function(t){this._origin!=t&&(this._origin=t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"position",{get:function(){return this._position},set:function(t){this._position=t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"x",{get:function(){return this._position.x},set:function(t){this._position.x=t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"y",{get:function(){return this._position.y},set:function(t){this._position.y=t},enumerable:!0,configurable:!0}),e.prototype.onSceneSizeChanged=function(t,e){var n=this._origin;this.origin=new Vector2(t/2,e/2),this.entity.position=Vector2.add(this.entity.position,Vector2.subtract(this._origin,n))},e.prototype.setMinimumZoom=function(t){return this._zoom<t&&(this._zoom=this.minimumZoom),this._minimumZoom=t,this},e.prototype.setMaximumZoom=function(t){return this._zoom>t&&(this._zoom=t),this._maximumZoom=t,this},e.prototype.setZoom=function(t){var e=MathHelper.clamp(t,-1,1);return this._zoom=0==e?1:e<0?MathHelper.map(e,-1,0,this._minimumZoom,1):MathHelper.map(e,0,1,1,this._maximumZoom),SceneManager.scene.scaleX=this._zoom,SceneManager.scene.scaleY=this._zoom,this},e.prototype.setRotation=function(t){return SceneManager.scene.rotation=t,this},e.prototype.setPosition=function(t){return this.entity.position=t,this},e.prototype.follow=function(t,e){void 0===e&&(e=CameraStyle.cameraWindow),this.targetEntity=t,this.cameraStyle=e;var n=new Rectangle(0,0,SceneManager.stage.stageWidth,SceneManager.stage.stageHeight);switch(this.cameraStyle){case CameraStyle.cameraWindow:var i=n.width/6,r=n.height/3;this.deadzone=new Rectangle((n.width-i)/2,(n.height-r)/2,i,r);break;case CameraStyle.lockOn:this.deadzone=new Rectangle(n.width/2,n.height/2,10,10)}},e.prototype.update=function(){var t=new Rectangle(0,0,SceneManager.stage.stageWidth,SceneManager.stage.stageHeight),e=Vector2.multiply(new Vector2(t.width,t.height),new Vector2(.5));this._worldSpaceDeadZone.x=this.position.x-e.x*SceneManager.scene.scaleX+this.deadzone.x+this.focusOffset.x,this._worldSpaceDeadZone.y=this.position.y-e.y*SceneManager.scene.scaleY+this.deadzone.y+this.focusOffset.y,this._worldSpaceDeadZone.width=this.deadzone.width,this._worldSpaceDeadZone.height=this.deadzone.height,this.targetEntity&&this.updateFollow(),this.position=Vector2.lerp(this.position,Vector2.add(this.position,this._desiredPositionDelta),this.followLerp),this.entity.roundPosition(),this.mapLockEnabled&&(this.position=this.clampToMapSize(this.position),this.entity.roundPosition())},e.prototype.clampToMapSize=function(t){var e=new Rectangle(0,0,SceneManager.stage.stageWidth,SceneManager.stage.stageHeight),n=Vector2.multiply(new Vector2(e.width,e.height),new Vector2(.5)),i=new Vector2(this.mapSize.x-n.x,this.mapSize.y-n.y);return Vector2.clamp(t,n,i)},e.prototype.updateFollow=function(){if(this._desiredPositionDelta.x=this._desiredPositionDelta.y=0,this.cameraStyle==CameraStyle.lockOn){var t=this.targetEntity.position.x,e=this.targetEntity.position.y;this._worldSpaceDeadZone.x>t?this._desiredPositionDelta.x=t-this._worldSpaceDeadZone.x:this._worldSpaceDeadZone.x<t&&(this._desiredPositionDelta.x=t-this._worldSpaceDeadZone.x),this._worldSpaceDeadZone.y<e?this._desiredPositionDelta.y=e-this._worldSpaceDeadZone.y:this._worldSpaceDeadZone.y>e&&(this._desiredPositionDelta.y=e-this._worldSpaceDeadZone.y)}else{if(!this._targetCollider&&(this._targetCollider=this.targetEntity.getComponent(Collider),!this._targetCollider))return;var n=this.targetEntity.getComponent(Collider).bounds;this._worldSpaceDeadZone.containsRect(n)||(this._worldSpaceDeadZone.left>n.left?this._desiredPositionDelta.x=n.left-this._worldSpaceDeadZone.left:this._worldSpaceDeadZone.right<n.right&&(this._desiredPositionDelta.x=n.right-this._worldSpaceDeadZone.right),this._worldSpaceDeadZone.bottom<n.bottom?this._desiredPositionDelta.y=n.bottom-this._worldSpaceDeadZone.bottom:this._worldSpaceDeadZone.top>n.top&&(this._desiredPositionDelta.y=n.top-this._worldSpaceDeadZone.top))}},e}(Component);!function(t){t[t.lockOn=0]="lockOn",t[t.cameraWindow=1]="cameraWindow"}(CameraStyle||(CameraStyle={}));var LoopMode,State,ComponentPool=function(){function t(t){this._type=t,this._cache=[]}return t.prototype.obtain=function(){try{return this._cache.length>0?this._cache.shift():new this._type}catch(t){throw new Error(this._type+t)}},t.prototype.free=function(t){t.reset(),this._cache.push(t)},t}(),PooledComponent=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e}(Component),RenderableComponent=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e._areBoundsDirty=!0,e._bounds=new Rectangle,e._localOffset=Vector2.zero,e.color=0,e}return __extends(e,t),Object.defineProperty(e.prototype,"width",{get:function(){return this.getWidth()},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"height",{get:function(){return this.getHeight()},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isVisible",{get:function(){return this._isVisible},set:function(t){this._isVisible=t,this._isVisible?this.onBecameVisible():this.onBecameInvisible()},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"bounds",{get:function(){return new Rectangle(this.getBounds().x,this.getBounds().y,this.getBounds().width,this.getBounds().height)},enumerable:!0,configurable:!0}),e.prototype.getWidth=function(){return this.bounds.width},e.prototype.getHeight=function(){return this.bounds.height},e.prototype.onBecameVisible=function(){},e.prototype.onBecameInvisible=function(){},e.prototype.isVisibleFromCamera=function(t){return this.isVisible=t.getBounds().intersects(this.getBounds()),this.isVisible},e}(PooledComponent),Mesh=function(t){function e(){var e=t.call(this)||this;return e._mesh=new egret.Mesh,e}return __extends(e,t),e.prototype.setTexture=function(t){return this._mesh.texture=t,this},e.prototype.onAddedToEntity=function(){this.addChild(this._mesh)},e.prototype.onRemovedFromEntity=function(){this.removeChild(this._mesh)},e.prototype.render=function(t){this.x=this.entity.position.x-t.position.x+t.origin.x,this.y=this.entity.position.y-t.position.y+t.origin.y},e.prototype.reset=function(){},e}(RenderableComponent),SpriteRenderer=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),Object.defineProperty(e.prototype,"sprite",{get:function(){return this._sprite},set:function(t){this.setSprite(t)},enumerable:!0,configurable:!0}),e.prototype.setSprite=function(t){return this.removeChildren(),this._sprite=t,this._sprite&&(this.anchorOffsetX=this._sprite.origin.x/this._sprite.sourceRect.width,this.anchorOffsetY=this._sprite.origin.y/this._sprite.sourceRect.height),this.bitmap=new egret.Bitmap(t.texture2D),this.addChild(this.bitmap),this},e.prototype.setColor=function(t){var e=[1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0];e[0]=Math.floor(t/256/256)/255,e[6]=Math.floor(t/256%256)/255,e[12]=t%256/255;var n=new egret.ColorMatrixFilter(e);return this.filters=[n],this},e.prototype.isVisibleFromCamera=function(t){return this.isVisible=new Rectangle(0,0,this.stage.stageWidth,this.stage.stageHeight).intersects(this.bounds),this.visible=this.isVisible,this.isVisible},e.prototype.render=function(t){this.x==-t.position.x+t.origin.x&&this.y==-t.position.y+t.origin.y||(this.x=-t.position.x+t.origin.x,this.y=-t.position.y+t.origin.y,this.entity.onEntityTransformChanged(TransformComponent.position))},e.prototype.onRemovedFromEntity=function(){this.parent&&this.parent.removeChild(this)},e.prototype.reset=function(){},e}(RenderableComponent),TiledSpriteRenderer=function(t){function e(e){var n=t.call(this)||this;return n.leftTexture=new egret.Bitmap,n.rightTexture=new egret.Bitmap,n.leftTexture.texture=e.texture2D,n.rightTexture.texture=e.texture2D,n.setSprite(e),n.sourceRect=e.sourceRect,n}return __extends(e,t),Object.defineProperty(e.prototype,"scrollX",{get:function(){return this.sourceRect.x},set:function(t){this.sourceRect.x=t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"scrollY",{get:function(){return this.sourceRect.y},set:function(t){this.sourceRect.y=t},enumerable:!0,configurable:!0}),e.prototype.render=function(e){if(this.sprite){t.prototype.render.call(this,e);var n=new egret.RenderTexture,i=new egret.DisplayObjectContainer;i.removeChildren(),i.addChild(this.leftTexture),i.addChild(this.rightTexture),this.leftTexture.x=this.sourceRect.x,this.rightTexture.x=this.sourceRect.x-this.sourceRect.width,this.leftTexture.y=this.sourceRect.y,this.rightTexture.y=this.sourceRect.y,i.cacheAsBitmap=!0,n.drawToTexture(i,new egret.Rectangle(0,0,this.sourceRect.width,this.sourceRect.height)),this.bitmap.texture=n}},e}(SpriteRenderer),ScrollingSpriteRenderer=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.scrollSpeedX=15,e.scroolSpeedY=0,e._scrollX=0,e._scrollY=0,e}return __extends(e,t),e.prototype.update=function(){this._scrollX+=this.scrollSpeedX*Time.deltaTime,this._scrollY+=this.scroolSpeedY*Time.deltaTime,this.sourceRect.x=this._scrollX,this.sourceRect.y=this._scrollY},e.prototype.render=function(e){if(this.sprite){t.prototype.render.call(this,e);var n=new egret.RenderTexture,i=new egret.DisplayObjectContainer;i.removeChildren(),i.addChild(this.leftTexture),i.addChild(this.rightTexture),this.leftTexture.x=this.sourceRect.x,this.rightTexture.x=this.sourceRect.x-this.sourceRect.width,this.leftTexture.y=this.sourceRect.y,this.rightTexture.y=this.sourceRect.y,i.cacheAsBitmap=!0,n.drawToTexture(i,new egret.Rectangle(0,0,this.sourceRect.width,this.sourceRect.height)),this.bitmap.texture=n}},e}(TiledSpriteRenderer),Sprite=function(){return function(t,e,n){void 0===e&&(e=new Rectangle(0,0,t.textureWidth,t.textureHeight)),void 0===n&&(n=e.getHalfSize()),this.uvs=new Rectangle,this.texture2D=t,this.sourceRect=e,this.center=new Vector2(.5*e.width,.5*e.height),this.origin=n;var i=1/t.textureWidth,r=1/t.textureHeight;this.uvs.x=e.x*i,this.uvs.y=e.y*r,this.uvs.width=e.width*i,this.uvs.height=e.height*r}}(),SpriteAnimation=function(){return function(t,e){this.sprites=t,this.frameRate=e}}(),SpriteAnimator=function(t){function e(e){var n=t.call(this)||this;return n.speed=1,n.animationState=State.none,n._animations=new Map,n._elapsedTime=0,e&&n.setSprite(e),n}return __extends(e,t),Object.defineProperty(e.prototype,"isRunning",{get:function(){return this.animationState==State.running},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"animations",{get:function(){return this._animations},enumerable:!0,configurable:!0}),e.prototype.addAnimation=function(t,e){return!this.sprite&&e.sprites.length>0&&this.setSprite(e.sprites[0]),this._animations[t]=e,this},e.prototype.play=function(t,e){void 0===e&&(e=null),this.currentAnimation=this._animations[t],this.currentAnimationName=t,this.currentFrame=0,this.animationState=State.running,this.sprite=this.currentAnimation.sprites[0],this._elapsedTime=0,this._loopMode=e||LoopMode.loop},e.prototype.isAnimationActive=function(t){return this.currentAnimation&&this.currentAnimationName==t},e.prototype.pause=function(){this.animationState=State.paused},e.prototype.unPause=function(){this.animationState=State.running},e.prototype.stop=function(){this.currentAnimation=null,this.currentAnimationName=null,this.currentFrame=0,this.animationState=State.none},e.prototype.update=function(){if(this.animationState==State.running&&this.currentAnimation){var t=this.currentAnimation,e=1/(t.frameRate*this.speed),n=e*t.sprites.length;this._elapsedTime+=Time.deltaTime;var i=Math.abs(this._elapsedTime);if(this._loopMode==LoopMode.once&&i>n||this._loopMode==LoopMode.pingPongOnce&&i>2*n)return this.animationState=State.completed,this._elapsedTime=0,this.currentFrame=0,void(this.sprite=t.sprites[this.currentFrame]);var r=Math.floor(i/e),o=t.sprites.length;if(o>2&&(this._loopMode==LoopMode.pingPong||this._loopMode==LoopMode.pingPongOnce)){var s=o-1;this.currentFrame=s-Math.abs(s-r%(2*s))}else this.currentFrame=r%o;this.sprite=t.sprites[this.currentFrame]}},e}(SpriteRenderer);!function(t){t[t.loop=0]="loop",t[t.once=1]="once",t[t.clampForever=2]="clampForever",t[t.pingPong=3]="pingPong",t[t.pingPongOnce=4]="pingPongOnce"}(LoopMode||(LoopMode={})),function(t){t[t.none=0]="none",t[t.running=1]="running",t[t.paused=2]="paused",t[t.completed=3]="completed"}(State||(State={}));var PointSectors,Mover=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.onAddedToEntity=function(){this._triggerHelper=new ColliderTriggerHelper(this.entity)},e.prototype.calculateMovement=function(t){var e=new CollisionResult;if(!this.entity.getComponent(Collider)||!this._triggerHelper)return null;for(var n=this.entity.getComponents(Collider),i=0;i<n.length;i++){var r=n[i];if(!r.isTrigger){var o=r.bounds;o.x+=t.x,o.y+=t.y;var s=Physics.boxcastBroadphaseExcludingSelf(r,o,r.collidesWithLayers);o=s.bounds;for(var a=s.tempHashSet,c=0;c<a.length;c++){var h=a[c];if(!h.isTrigger){var u=r.collidesWith(h,t);u&&(t=Vector2.subtract(t,u.minimumTranslationVector),u.collider&&(e=u))}}}}return ListPool.free(n),{collisionResult:e,motion:t}},e.prototype.applyMovement=function(t){this.entity.position=Vector2.add(this.entity.position,t),this._triggerHelper&&this._triggerHelper.update()},e.prototype.move=function(t){var e=this.calculateMovement(t),n=e.collisionResult;return t=e.motion,this.applyMovement(t),n},e}(Component),ProjectileMover=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e._tempTriggerList=[],e}return __extends(e,t),e.prototype.onAddedToEntity=function(){this._collider=this.entity.getComponent(Collider),this._collider||console.warn("ProjectileMover has no Collider. ProjectilMover requires a Collider!")},e.prototype.move=function(t){if(!this._collider)return!1;var e=!1;this.entity.position=Vector2.add(this.entity.position,t);for(var n=Physics.boxcastBroadphase(this._collider.bounds,this._collider.collidesWithLayers),i=0;i<n.colliders.length;i++){var r=n.colliders[i];this._collider.overlaps(r)&&r.enabled&&(e=!0,this.notifyTriggerListeners(this._collider,r))}return e},e.prototype.notifyTriggerListeners=function(t,e){e.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var n=0;n<this._tempTriggerList.length;n++)this._tempTriggerList[n].onTriggerEnter(t,e);this._tempTriggerList.length=0,this.entity.getComponents("ITriggerListener",this._tempTriggerList);for(n=0;n<this._tempTriggerList.length;n++)this._tempTriggerList[n].onTriggerEnter(e,t);this._tempTriggerList.length=0},e}(Component),Collider=function(t){function e(){var e=null!==t&&t.apply(this,arguments)||this;return e.physicsLayer=1,e.registeredPhysicsBounds=new Rectangle,e.shouldColliderScaleAndRotateWithTransform=!0,e.collidesWithLayers=Physics.allLayers,e}return __extends(e,t),Object.defineProperty(e.prototype,"bounds",{get:function(){var t=this.shape.bounds;return new Rectangle(this.entity.x,this.entity.y,t.width,t.height)},enumerable:!0,configurable:!0}),e.prototype.registerColliderWithPhysicsSystem=function(){this._isParentEntityAddedToScene&&!this._isColliderRegistered&&(Physics.addCollider(this),this._isColliderRegistered=!0)},e.prototype.unregisterColliderWithPhysicsSystem=function(){this._isParentEntityAddedToScene&&this._isColliderRegistered&&Physics.removeCollider(this),this._isColliderRegistered=!1},e.prototype.overlaps=function(t){return this.shape.overlaps(t.shape)},e.prototype.collidesWith=function(t,e){var n=this.entity.position;this.entity.position=Vector2.add(this.entity.position,e);var i=this.shape.collidesWithShape(t.shape);return i&&(i.collider=t),this.entity.position=n,i},e.prototype.onAddedToEntity=function(){if(this._colliderRequiresAutoSizing){this instanceof BoxCollider||this instanceof CircleCollider||console.error("Only box and circle colliders can be created automatically");var t=this.entity.getComponent(RenderableComponent);if(t){var e=t.bounds,n=e.width/this.entity.scale.x,i=e.height/this.entity.scale.y;if(this instanceof CircleCollider){this.radius=.5*Math.max(n,i)}else this.width=n,this.height=i;this.addChild(this.shape)}else console.warn("Collider has no shape and no RenderableComponent. Can't figure out how to size it.")}this._isParentEntityAddedToScene=!0,this.registerColliderWithPhysicsSystem()},e.prototype.onRemovedFromEntity=function(){this.unregisterColliderWithPhysicsSystem(),this._isParentEntityAddedToScene=!1,this.removeChild(this.shape)},e.prototype.onEnabled=function(){this.registerColliderWithPhysicsSystem()},e.prototype.onDisabled=function(){this.unregisterColliderWithPhysicsSystem()},e.prototype.onEntityTransformChanged=function(t){this._isColliderRegistered&&Physics.updateCollider(this)},e.prototype.update=function(){var t=this.entity.getComponent(RenderableComponent);t&&(this.$setX(t.x),this.$setY(t.y))},e}(Component),BoxCollider=function(t){function e(){var e=t.call(this)||this;return e.shape=new Box(1,1),e._colliderRequiresAutoSizing=!0,e}return __extends(e,t),Object.defineProperty(e.prototype,"width",{get:function(){return this.shape.width},set:function(t){this.setWidth(t)},enumerable:!0,configurable:!0}),e.prototype.setWidth=function(t){this._colliderRequiresAutoSizing=!1;var e=this.shape;return t!=e.width&&(e.updateBox(t,e.height),this.entity&&this._isParentEntityAddedToScene&&Physics.updateCollider(this)),this},Object.defineProperty(e.prototype,"height",{get:function(){return this.shape.height},set:function(t){this.setHeight(t)},enumerable:!0,configurable:!0}),e.prototype.setHeight=function(t){this._colliderRequiresAutoSizing=!1;var e=this.shape;t!=e.height&&(e.updateBox(e.width,t),this.entity&&this._isParentEntityAddedToScene&&Physics.updateCollider(this))},e.prototype.setSize=function(t,e){this._colliderRequiresAutoSizing=!1;var n=this.shape;return t==n.width&&e==n.height||(n.updateBox(t,e),this.entity&&this._isParentEntityAddedToScene&&Physics.updateCollider(this)),this},e}(Collider),CircleCollider=function(t){function e(e){var n=t.call(this)||this;return e&&(n._colliderRequiresAutoSizing=!0),n.shape=new Circle(e||1),n}return __extends(e,t),Object.defineProperty(e.prototype,"radius",{get:function(){return this.shape.radius},set:function(t){this.setRadius(t)},enumerable:!0,configurable:!0}),e.prototype.setRadius=function(t){this._colliderRequiresAutoSizing=!1;var e=this.shape;return t!=e.radius&&(e.radius=t,e._originalRadius=t,this.entity&&this._isParentEntityAddedToScene&&Physics.updateCollider(this)),this},e}(Collider),PolygonCollider=function(t){function e(e){var n=t.call(this)||this;return e[0]==e[e.length-1]&&e.splice(e.length-1,1),Polygon.recenterPolygonVerts(e),n.shape=new Polygon(e),n}return __extends(e,t),e}(Collider),EntitySystem=function(){function t(t){this._entities=[],this._matcher=t||Matcher.empty()}return Object.defineProperty(t.prototype,"matcher",{get:function(){return this._matcher},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"scene",{get:function(){return this._scene},set:function(t){this._scene=t,this._entities=[]},enumerable:!0,configurable:!0}),t.prototype.initialize=function(){},t.prototype.onChanged=function(t){var e=this._entities.contains(t),n=this._matcher.IsIntersted(t);n&&!e?this.add(t):!n&&e&&this.remove(t)},t.prototype.add=function(t){this._entities.push(t),this.onAdded(t)},t.prototype.onAdded=function(t){},t.prototype.remove=function(t){this._entities.remove(t),this.onRemoved(t)},t.prototype.onRemoved=function(t){},t.prototype.update=function(){this.begin(),this.process(this._entities)},t.prototype.lateUpdate=function(){this.lateProcess(this._entities),this.end()},t.prototype.begin=function(){},t.prototype.process=function(t){},t.prototype.lateProcess=function(t){},t.prototype.end=function(){},t}(),EntityProcessingSystem=function(t){function e(e){return t.call(this,e)||this}return __extends(e,t),e.prototype.lateProcessEntity=function(t){},e.prototype.process=function(t){var e=this;t.forEach(function(t){return e.processEntity(t)})},e.prototype.lateProcess=function(t){var e=this;t.forEach(function(t){return e.lateProcessEntity(t)})},e}(EntitySystem),PassiveSystem=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.onChanged=function(t){},e.prototype.process=function(t){this.begin(),this.end()},e}(EntitySystem),ProcessingSystem=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.onChanged=function(t){},e.prototype.process=function(t){this.begin(),this.processSystem(),this.end()},e}(EntitySystem),BitSet=function(){function t(e){void 0===e&&(e=64);var n=e>>6;0!=(e&t.LONG_MASK)&&n++,this._bits=new Array(n)}return t.prototype.and=function(t){for(var e,n=Math.min(this._bits.length,t._bits.length),i=0;i<n;++i)this._bits[i]&=t._bits[i];for(;e<this._bits.length;)this._bits[e++]=0},t.prototype.andNot=function(t){for(var e=Math.min(this._bits.length,t._bits.length);--e>=0;)this._bits[e]&=~t._bits[e]},t.prototype.cardinality=function(){for(var t=0,e=this._bits.length-1;e>=0;e--){var n=this._bits[e];if(0!=n)if(-1!=n){var i=((n=((n=(n>>1&0x5555555555555400)+(0x5555555555555400&n))>>2&0x3333333333333400)+(0x3333333333333400&n))>>32)+n;t+=((i=((i=(i>>4&252645135)+(252645135&i))>>8&16711935)+(16711935&i))>>16&65535)+(65535&i)}else t+=64}return t},t.prototype.clear=function(t){if(null!=t){var e=t>>6;this.ensure(e),this._bits[e]&=~(1<<t)}else for(var n=0;n<this._bits.length;n++)this._bits[n]=0},t.prototype.ensure=function(t){if(t>=this._bits.length){var e=new Number[t+1];e=this._bits.copyWithin(0,0,this._bits.length),this._bits=e}},t.prototype.get=function(t){var e=t>>6;return!(e>=this._bits.length)&&0!=(this._bits[e]&1<<t)},t.prototype.intersects=function(t){for(var e=Math.min(this._bits.length,t._bits.length);--e>=0;)if(0!=(this._bits[e]&t._bits[e]))return!0;return!1},t.prototype.isEmpty=function(){for(var t=this._bits.length-1;t>=0;t--)if(this._bits[t])return!1;return!0},t.prototype.nextSetBit=function(t){for(var e=t>>6,n=1<<t;e<this._bits.length;){var i=this._bits[e];do{if(0!=(i&n))return t;n<<=1,t++}while(0!=n);n=1,e++}return-1},t.prototype.set=function(t,e){if(void 0===e&&(e=!0),e){var n=t>>6;this.ensure(n),this._bits[n]|=1<<t}else this.clear(t)},t.LONG_MASK=63,t}(),ComponentList=function(){function t(t){this._components=[],this._componentsToAdd=[],this._componentsToRemove=[],this._tempBufferList=[],this._entity=t}return Object.defineProperty(t.prototype,"count",{get:function(){return this._components.length},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"buffer",{get:function(){return this._components},enumerable:!0,configurable:!0}),t.prototype.add=function(t){this._componentsToAdd.push(t)},t.prototype.remove=function(t){this._componentsToRemove.contains(t)&&console.warn("You are trying to remove a Component ("+t+") that you already removed"),this._componentsToAdd.contains(t)?this._componentsToAdd.remove(t):this._componentsToRemove.push(t)},t.prototype.removeAllComponents=function(){for(var t=0;t<this._components.length;t++)this.handleRemove(this._components[t]);this._components.length=0,this._componentsToAdd.length=0,this._componentsToRemove.length=0},t.prototype.deregisterAllComponents=function(){for(var t=0;t<this._components.length;t++){var e=this._components[t];e instanceof RenderableComponent&&this._entity.scene.renderableComponents.remove(e),this._entity.componentBits.set(ComponentTypeManager.getIndexFor(e),!1),this._entity.scene.entityProcessors.onComponentRemoved(this._entity)}},t.prototype.registerAllComponents=function(){for(var t=0;t<this._components.length;t++){var e=this._components[t];e instanceof RenderableComponent&&this._entity.scene.renderableComponents.add(e),this._entity.componentBits.set(ComponentTypeManager.getIndexFor(e)),this._entity.scene.entityProcessors.onComponentAdded(this._entity)}},t.prototype.updateLists=function(){if(this._componentsToRemove.length>0){for(var t=0;t<this._componentsToRemove.length;t++)this.handleRemove(this._componentsToRemove[t]),this._components.remove(this._componentsToRemove[t]);this._componentsToRemove.length=0}if(this._componentsToAdd.length>0){t=0;for(var e=this._componentsToAdd.length;t<e;t++){(n=this._componentsToAdd[t])instanceof RenderableComponent&&this._entity.scene.renderableComponents.add(n),this._entity.componentBits.set(ComponentTypeManager.getIndexFor(n)),this._entity.scene.entityProcessors.onComponentAdded(this._entity),this._components.push(n),this._tempBufferList.push(n)}this._componentsToAdd.length=0;for(t=0;t<this._tempBufferList.length;t++){var n;(n=this._tempBufferList[t]).onAddedToEntity(),n.enabled&&n.onEnabled()}this._tempBufferList.length=0}},t.prototype.onEntityTransformChanged=function(t){for(var e=0;e<this._components.length;e++)this._components[e].enabled&&this._components[e].onEntityTransformChanged(t);for(e=0;e<this._componentsToAdd.length;e++)this._componentsToAdd[e].enabled&&this._componentsToAdd[e].onEntityTransformChanged(t)},t.prototype.handleRemove=function(t){t instanceof RenderableComponent&&this._entity.scene.renderableComponents.remove(t),this._entity.componentBits.set(ComponentTypeManager.getIndexFor(t),!1),this._entity.scene.entityProcessors.onComponentRemoved(this._entity),t.onRemovedFromEntity(),t.entity=null},t.prototype.getComponent=function(t,e){for(var n=0;n<this._components.length;n++){if((i=this._components[n])instanceof t)return i}if(!e)for(n=0;n<this._componentsToAdd.length;n++){var i;if((i=this._componentsToAdd[n])instanceof t)return i}return null},t.prototype.getComponents=function(t,e){e||(e=[]);for(var n=0;n<this._components.length;n++){var i=this._components[n];"string"==typeof t?egret.is(i,t)&&e.push(i):i instanceof t&&e.push(i)}for(n=0;n<this._componentsToAdd.length;n++){i=this._componentsToAdd[n];"string"==typeof t?egret.is(i,t)&&e.push(i):i instanceof t&&e.push(i)}return e},t.prototype.update=function(){this.updateLists();for(var t=0;t<this._components.length;t++){var e=this._components[t],n=void 0;e instanceof Component&&(n=e),e.enabled&&n.enabled&&(1==n.updateInterval||Time.frameCount%n.updateInterval==0)&&e.update()}},t}(),ComponentTypeManager=function(){function t(){}return t.add=function(t){this._componentTypesMask.has(t)||(this._componentTypesMask[t]=this._componentTypesMask.size)},t.getIndexFor=function(t){var e=-1;return this._componentTypesMask.has(t)||(this.add(t),e=this._componentTypesMask.get(t)),e},t._componentTypesMask=new Map,t}(),EntityList=function(){function t(t){this._entitiesToRemove=[],this._entitiesToAdded=[],this._tempEntityList=[],this._entities=[],this._entityDict=new Map,this._unsortedTags=[],this.scene=t}return Object.defineProperty(t.prototype,"count",{get:function(){return this._entities.length},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"buffer",{get:function(){return this._entities},enumerable:!0,configurable:!0}),t.prototype.add=function(t){-1==this._entitiesToAdded.indexOf(t)&&this._entitiesToAdded.push(t)},t.prototype.remove=function(t){this._entitiesToAdded.contains(t)?this._entitiesToAdded.remove(t):this._entitiesToRemove.contains(t)||this._entitiesToRemove.push(t)},t.prototype.findEntity=function(t){for(var e=0;e<this._entities.length;e++)if(this._entities[e].name==t)return this._entities[e];return this._entitiesToAdded.firstOrDefault(function(e){return e.name==t})},t.prototype.getTagList=function(t){var e=this._entityDict.get(t);return e||(e=[],this._entityDict.set(t,e)),this._entityDict.get(t)},t.prototype.addToTagList=function(t){var e=this.getTagList(t.tag);e.contains(t)||(e.push(t),this._unsortedTags.push(t.tag))},t.prototype.removeFromTagList=function(t){var e=this._entityDict.get(t.tag);e&&e.remove(t)},t.prototype.update=function(){for(var t=0;t<this._entities.length;t++){var e=this._entities[t];e.enabled&&e.update()}},t.prototype.removeAllEntities=function(){this._entitiesToAdded.length=0,this.updateLists();for(var t=0;t<this._entities.length;t++)this._entities[t]._isDestoryed=!0,this._entities[t].onRemovedFromScene(),this._entities[t].scene=null;this._entities.length=0,this._entityDict.clear()},t.prototype.updateLists=function(){var t=this;if(this._entitiesToRemove.length>0){var e=this._entitiesToRemove;this._entitiesToRemove=this._tempEntityList,this._tempEntityList=e,this._tempEntityList.forEach(function(e){t._entities.remove(e),e.scene=null,t.scene.entityProcessors.onEntityRemoved(e)}),this._tempEntityList.length=0}if(this._entitiesToAdded.length>0){e=this._entitiesToAdded;this._entitiesToAdded=this._tempEntityList,this._tempEntityList=e,this._tempEntityList.forEach(function(e){t._entities.contains(e)||(t._entities.push(e),e.scene=t.scene,t.scene.entityProcessors.onEntityAdded(e))}),this._tempEntityList.forEach(function(t){return t.onAddedToScene()}),this._tempEntityList.length=0}this._unsortedTags.length>0&&(this._unsortedTags.forEach(function(e){t._entityDict.get(e).sort()}),this._unsortedTags.length=0)},t}(),EntityProcessorList=function(){function t(){this._processors=[]}return t.prototype.add=function(t){this._processors.push(t)},t.prototype.remove=function(t){this._processors.remove(t)},t.prototype.onComponentAdded=function(t){this.notifyEntityChanged(t)},t.prototype.onComponentRemoved=function(t){this.notifyEntityChanged(t)},t.prototype.onEntityAdded=function(t){this.notifyEntityChanged(t)},t.prototype.onEntityRemoved=function(t){this.removeFromProcessors(t)},t.prototype.notifyEntityChanged=function(t){for(var e=0;e<this._processors.length;e++)this._processors[e].onChanged(t)},t.prototype.removeFromProcessors=function(t){for(var e=0;e<this._processors.length;e++)this._processors[e].remove(t)},t.prototype.begin=function(){},t.prototype.update=function(){for(var t=0;t<this._processors.length;t++)this._processors[t].update()},t.prototype.lateUpdate=function(){for(var t=0;t<this._processors.length;t++)this._processors[t].lateUpdate()},t.prototype.end=function(){},t.prototype.getProcessor=function(){for(var t=0;t<this._processors.length;t++){var e=this._processors[t];if(e instanceof EntitySystem)return e}return null},t}(),Matcher=function(){function t(){this.allSet=new BitSet,this.exclusionSet=new BitSet,this.oneSet=new BitSet}return t.empty=function(){return new t},t.prototype.getAllSet=function(){return this.allSet},t.prototype.getExclusionSet=function(){return this.exclusionSet},t.prototype.getOneSet=function(){return this.oneSet},t.prototype.IsIntersted=function(t){if(!this.allSet.isEmpty())for(var e=this.allSet.nextSetBit(0);e>=0;e=this.allSet.nextSetBit(e+1))if(!t.componentBits.get(e))return!1;return!(!this.exclusionSet.isEmpty()&&this.exclusionSet.intersects(t.componentBits))&&!(!this.oneSet.isEmpty()&&!this.oneSet.intersects(t.componentBits))},t.prototype.all=function(){for(var t=this,e=[],n=0;n<arguments.length;n++)e[n]=arguments[n];return e.forEach(function(e){t.allSet.set(ComponentTypeManager.getIndexFor(e))}),this},t.prototype.exclude=function(){for(var t=this,e=[],n=0;n<arguments.length;n++)e[n]=arguments[n];return e.forEach(function(e){t.exclusionSet.set(ComponentTypeManager.getIndexFor(e))}),this},t.prototype.one=function(){for(var t=this,e=[],n=0;n<arguments.length;n++)e[n]=arguments[n];return e.forEach(function(e){t.oneSet.set(ComponentTypeManager.getIndexFor(e))}),this},t}(),ObjectUtils=function(){function t(){}return t.clone=function(t,e){void 0===e&&(e=null);e=e||{};for(var n in t)"object"==typeof t[n]?(e[n]=t[n]instanceof Array?[]:{},this.clone(t[n],e[n])):e[n]=t[n];return e},t}(),RenderableComponentList=function(){function t(){this._components=[]}return Object.defineProperty(t.prototype,"count",{get:function(){return this._components.length},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"buffer",{get:function(){return this._components},enumerable:!0,configurable:!0}),t.prototype.add=function(t){this._components.push(t)},t.prototype.remove=function(t){this._components.remove(t)},t.prototype.updateList=function(){},t}(),StringUtils=function(){function t(){}return t.matchChineseWord=function(t){return t.match(/[\u4E00-\u9FA5]+/gim)},t.lTrim=function(t){for(var e=0;this.isWhiteSpace(t.charAt(e));)e++;return t.slice(e,t.length)},t.rTrim=function(t){for(var e=t.length-1;this.isWhiteSpace(t.charAt(e));)e--;return t.slice(0,e+1)},t.trim=function(t){return null==t?null:this.rTrim(this.lTrim(t))},t.isWhiteSpace=function(t){return" "==t||"\t"==t||"\r"==t||"\n"==t},t.replaceMatch=function(t,e,n,i){void 0===i&&(i=!1);for(var r=t.length,o="",s=!1,a=1==i?e.toLowerCase():e,c=0;c<r;c++)s=!1,t.charAt(c)==a.charAt(0)&&t.substr(c,a.length)==a&&(s=!0),s?(o+=n,c=c+a.length-1):o+=t.charAt(c);return o},t.htmlSpecialChars=function(t,e){void 0===e&&(e=!1);for(var n=this.specialSigns.length,i=0;i<n;i+=2){var r=void 0,o=void 0;if(r=this.specialSigns[i],o=this.specialSigns[i+1],e){var s=r;r=o,o=s}t=this.replaceMatch(t,r,o)}return t},t.zfill=function(t,e){if(void 0===e&&(e=2),!t)return t;e=Math.floor(e);var n=t.length;if(n>=e)return t;var i=!1;"-"==t.substr(0,1)&&(i=!0,t=t.substr(1));for(var r=e-n,o=0;o<r;o++)t="0"+t;return i&&(t="-"+t),t},t.reverse=function(t){return t.length>1?this.reverse(t.substring(1))+t.substring(0,1):t},t.cutOff=function(t,e,n,i){void 0===i&&(i=!0),e=Math.floor(e),n=Math.floor(n);var r=t.length;e>r&&(e=r);var o,s=e,a=e+n;return i?o=t.substring(0,s)+t.substr(a,r):(a=(s=r-1-e-n)+n,o=t.substring(0,s+1)+t.substr(a+1,r)),o},t.strReplace=function(t,e){for(var n=0,i=e.length;n<i;n++)null!=e[n]&&""!=e[n]||(e[n]="无"),t=t.replace("{"+n+"}",e[n]);return t},t.specialSigns=["&","&amp;","<","&lt;",">","&gt;",'"',"&quot;","'","&apos;","®","&reg;","©","&copy;","™","&trade;"],t}(),TextureUtils=function(){function t(){}return t.convertImageToCanvas=function(t,e){this.sharedCanvas||(this.sharedCanvas=egret.sys.createCanvas(),this.sharedContext=this.sharedCanvas.getContext("2d"));var n=t.$getTextureWidth(),i=t.$getTextureHeight();e||((e=egret.$TempRectangle).x=0,e.y=0,e.width=n,e.height=i),e.x=Math.min(e.x,n-1),e.y=Math.min(e.y,i-1),e.width=Math.min(e.width,n-e.x),e.height=Math.min(e.height,i-e.y);var r=Math.floor(e.width),o=Math.floor(e.height),s=this.sharedCanvas;if(s.style.width=r+"px",s.style.height=o+"px",this.sharedCanvas.width=r,this.sharedCanvas.height=o,"webgl"==egret.Capabilities.renderMode){var a=void 0;t.$renderBuffer?a=t:(egret.sys.systemRenderer.renderClear&&egret.sys.systemRenderer.renderClear(),(a=new egret.RenderTexture).drawToTexture(new egret.Bitmap(t)));for(var c=a.$renderBuffer.getPixels(e.x,e.y,r,o),h=0,u=0,l=0;l<c.length;l+=4)this.sharedContext.fillStyle="rgba("+c[l]+","+c[l+1]+","+c[l+2]+","+c[l+3]/255+")",this.sharedContext.fillRect(h,u,1,1),++h==r&&(h=0,u++);return t.$renderBuffer||a.dispose(),s}var p=t,d=Math.round(p.$offsetX),f=Math.round(p.$offsetY),g=p.$bitmapWidth,m=p.$bitmapHeight,y=SceneManager.stage.textureScaleFactor;return this.sharedContext.drawImage(p.$bitmapData.source,p.$bitmapX+e.x/y,p.$bitmapY+e.y/y,g*e.width/n,m*e.height/i,d,f,e.width,e.height),s},t.toDataURL=function(t,e,n,i){try{return this.convertImageToCanvas(e,n).toDataURL(t,i)}catch(t){egret.$error(1033)}return null},t.eliFoTevas=function(t,e,n,i,r){var o=this.convertImageToCanvas(e,i).toTempFilePathSync({fileType:t.indexOf("png")>=0?"png":"jpg"});return wx.getFileSystemManager().saveFile({tempFilePath:o,filePath:wx.env.USER_DATA_PATH+"/"+n,success:function(t){}}),o},t.getPixel32=function(t,e,n){return egret.$warn(1041,"getPixel32","getPixels"),t.getPixels(e,n)},t.getPixels=function(t,e,n,i,r){if(void 0===i&&(i=1),void 0===r&&(r=1),"webgl"==egret.Capabilities.renderMode){var o=void 0;return t.$renderBuffer?o=t:(o=new egret.RenderTexture).drawToTexture(new egret.Bitmap(t)),o.$renderBuffer.getPixels(e,n,i,r)}try{this.convertImageToCanvas(t);return this.sharedContext.getImageData(e,n,i,r).data}catch(t){egret.$error(1039)}},t}(),Time=function(){function t(){}return t.update=function(t){var e=(t-this._lastTime)/1e3;this.deltaTime=e*this.timeScale,this.unscaledDeltaTime=e,this._timeSinceSceneLoad+=e,this.frameCount++,this._lastTime=t},t.sceneChanged=function(){this._timeSinceSceneLoad=0},t.checkEvery=function(t){return this._timeSinceSceneLoad/t>(this._timeSinceSceneLoad-this.deltaTime)/t},t.deltaTime=0,t.timeScale=1,t.frameCount=0,t._lastTime=0,t}(),TimeUtils=function(){function t(){}return t.monthId=function(t){void 0===t&&(t=null);var e=(t=t||new Date).getFullYear(),n=t.getMonth()+1;return parseInt(e+(n<10?"0":"")+n)},t.dateId=function(t){void 0===t&&(t=null);var e=(t=t||new Date).getMonth()+1,n=e<10?"0":"",i=t.getDate(),r=i<10?"0":"";return parseInt(t.getFullYear()+n+e+r+i)},t.weekId=function(t,e){void 0===t&&(t=null),void 0===e&&(e=!0),t=t||new Date;var n=new Date;n.setTime(t.getTime()),n.setDate(1),n.setMonth(0);var i=n.getFullYear(),r=n.getDay();0==r&&(r=7);var o=!1;r<=4?(o=r>1,n.setDate(n.getDate()-(r-1))):n.setDate(n.getDate()+7-r+1);var s=this.diffDay(t,n,!1);if(s<0)return n.setDate(1),n.setMonth(0),n.setDate(n.getDate()-1),this.weekId(n,!1);var a=s/7,c=Math.floor(a)+1;if(53==c){n.setTime(t.getTime()),n.setDate(n.getDate()-1);var h=n.getDay();if(0==h&&(h=7),e&&(!o||h<4))return n.setFullYear(n.getFullYear()+1),n.setDate(1),n.setMonth(0),this.weekId(n,!1)}return parseInt(i+"00"+(c>9?"":"0")+c)},t.diffDay=function(t,e,n){void 0===n&&(n=!1);var i=(t.getTime()-e.getTime())/864e5;return n?Math.ceil(i):Math.floor(i)},t.getFirstDayOfWeek=function(t){var e=(t=t||new Date).getDay()||7;return new Date(t.getFullYear(),t.getMonth(),t.getDate()+1-e,0,0,0,0)},t.getFirstOfDay=function(t){return(t=t||new Date).setHours(0,0,0,0),t},t.getNextFirstOfDay=function(t){return new Date(this.getFirstOfDay(t).getTime()+864e5)},t.formatDate=function(t){var e=t.getFullYear(),n=t.getMonth()+1;n=n<10?"0"+n:n;var i=t.getDate();return e+"-"+n+"-"+(i=i<10?"0"+i:i)},t.formatDateTime=function(t){var e=t.getFullYear(),n=t.getMonth()+1;n=n<10?"0"+n:n;var i=t.getDate();i=i<10?"0"+i:i;var r=t.getHours(),o=t.getMinutes();o=o<10?"0"+o:o;var s=t.getSeconds();return e+"-"+n+"-"+i+" "+r+":"+o+":"+(s=s<10?"0"+s:s)},t.parseDate=function(t){var e=Date.parse(t);return isNaN(e)?new Date:new Date(Date.parse(t.replace(/-/g,"/")))},t.secondToTime=function(t,e,n){void 0===t&&(t=0),void 0===e&&(e=":"),void 0===n&&(n=!0);var i=Math.floor(t/3600),r=Math.floor(t%3600/60),o=Math.floor(t%3600%60),s=i.toString(),a=r.toString(),c=o.toString();return i<10&&(s="0"+s),r<10&&(a="0"+a),o<10&&(c="0"+c),n?s+e+a+e+c:a+e+c},t.timeToMillisecond=function(t,e){void 0===e&&(e=":");for(var n=t.split(e),i=0,r=n.length,o=0;o<r;o++){i+=n[o]*Math.pow(60,r-1-o)}return(i*=1e3).toString()},t}(),GraphicsCapabilities=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.initialize=function(t){this.platformInitialize(t)},e.prototype.platformInitialize=function(t){this.isMobile=!0;var e=wx.getSystemInfoSync(),n=e.system.toLowerCase();n.indexOf("ios")>-1?this.os="iOS":n.indexOf("android")>-1&&(this.os="Android");var i=e.language;i=i.indexOf("zh")>-1?"zh-CN":"en-US",this.language=i},e}(egret.Capabilities),GraphicsDevice=function(){return function(){this.graphicsCapabilities=new GraphicsCapabilities,this.graphicsCapabilities.initialize(this)}}(),Viewport=function(){function t(t,e,n,i){this._x=t,this._y=e,this._width=n,this._height=i,this._minDepth=0,this._maxDepth=1}return Object.defineProperty(t.prototype,"aspectRatio",{get:function(){return 0!=this._height&&0!=this._width?this._width/this._height:0},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"bounds",{get:function(){return new Rectangle(this._x,this._y,this._width,this._height)},set:function(t){this._x=t.x,this._y=t.y,this._width=t.width,this._height=t.height},enumerable:!0,configurable:!0}),t}(),GaussianBlurEffect=function(t){function e(){return t.call(this,PostProcessor.default_vert,e.blur_frag,{screenWidth:SceneManager.stage.stageWidth,screenHeight:SceneManager.stage.stageHeight})||this}return __extends(e,t),e.blur_frag="precision mediump float;\nuniform sampler2D uSampler;\nuniform float screenWidth;\nuniform float screenHeight;\nfloat normpdf(in float x, in float sigma)\n{\nreturn 0.39894*exp(-0.5*x*x/(sigma*sigma))/sigma;\n}\nvoid main()\n{\nvec3 c = texture2D(uSampler, gl_FragCoord.xy / vec2(screenWidth, screenHeight).xy).rgb;\nconst int mSize = 11;\nconst int kSize = (mSize - 1)/2;\nfloat kernel[mSize];\nvec3 final_colour = vec3(0.0);\nfloat sigma = 7.0;\nfloat z = 0.0;\nfor (int j = 0; j <= kSize; ++j)\n{\nkernel[kSize+j] = kernel[kSize-j] = normpdf(float(j),sigma);\n}\nfor (int j = 0; j < mSize; ++j)\n{\nz += kernel[j];\n}\nfor (int i = -kSize; i <= kSize; ++i)\n{\nfor (int j = -kSize; j <= kSize; ++j)\n{\nfinal_colour += kernel[kSize+j]*kernel[kSize+i]*texture2D(uSampler, (gl_FragCoord.xy+vec2(float(i),float(j))) / vec2(screenWidth, screenHeight).xy).rgb;\n}\n}\ngl_FragColor = vec4(final_colour/(z*z), 1.0);\n}",e}(egret.CustomFilter),PolygonLightEffect=function(t){function e(){return t.call(this,e.vertSrc,e.fragmentSrc)||this}return __extends(e,t),e.vertSrc="attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n}",e.fragmentSrc="precision lowp float;\nvarying vec2 vTextureCoord;\nuniform sampler2D uSampler;\n#define SAMPLE_COUNT 15\nuniform vec2 _sampleOffsets[SAMPLE_COUNT];\nuniform float _sampleWeights[SAMPLE_COUNT];\nvoid main(void) {\nvec4 c = vec4(0, 0, 0, 0);\nfor( int i = 0; i < SAMPLE_COUNT; i++ )\n   c += texture2D( uSampler, vTextureCoord + _sampleOffsets[i] ) * _sampleWeights[i];\ngl_FragColor = c;\n}",e}(egret.CustomFilter),PostProcessor=function(){function t(t){void 0===t&&(t=null),this.enabled=!0,this.effect=t}return t.prototype.onAddedToScene=function(t){this.scene=t,this.shape=new egret.Shape,this.shape.graphics.beginFill(16777215,1),this.shape.graphics.drawRect(0,0,SceneManager.stage.stageWidth,SceneManager.stage.stageHeight),this.shape.graphics.endFill(),t.addChild(this.shape)},t.prototype.process=function(){this.drawFullscreenQuad()},t.prototype.onSceneBackBufferSizeChanged=function(t, e){},t.prototype.drawFullscreenQuad=function(){this.scene.filters=[this.effect]},t.prototype.unload=function(){this.effect&&(this.effect=null),this.scene.removeChild(this.shape),this.scene=null},t.default_vert="attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec2 aColor;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\ngl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\nvTextureCoord = aTextureCoord;\nvColor = vec4(aColor.x, aColor.x, aColor.x, aColor.x);\n}",t}(),GaussianBlurPostProcessor=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.onAddedToScene=function(e){t.prototype.onAddedToScene.call(this,e),this.effect=new GaussianBlurEffect},e}(PostProcessor),Renderer=function(){function t(){}return t.prototype.onAddedToScene=function(t){},t.prototype.beginRender=function(t){},t.prototype.unload=function(){},t.prototype.renderAfterStateCheck=function(t,e){t.render(e)},t}(),DefaultRenderer=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.render=function(t){var e=this.camera?this.camera:t.camera;this.beginRender(e);for(var n=0;n<t.renderableComponents.count;n++){var i=t.renderableComponents.buffer[n];i.enabled&&i.isVisibleFromCamera(e)&&this.renderAfterStateCheck(i,e)}},e}(Renderer),ScreenSpaceRenderer=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.render=function(t){},e}(Renderer),PolyLight=function(t){function e(e,n,i){var r=t.call(this)||this;return r._indices=[],r.radius=e,r.power=i,r.color=n,r.computeTriangleIndices(),r}return __extends(e,t),Object.defineProperty(e.prototype,"radius",{get:function(){return this._radius},set:function(t){this.setRadius(t)},enumerable:!0,configurable:!0}),e.prototype.computeTriangleIndices=function(t){void 0===t&&(t=20),this._indices.length=0;for(var e=0;e<t;e+=2)this._indices.push(0),this._indices.push(e+2),this._indices.push(e+1)},e.prototype.setRadius=function(t){t!=this._radius&&(this._radius=t,this._areBoundsDirty=!0)},e.prototype.render=function(t){},e.prototype.reset=function(){},e}(RenderableComponent),SceneTransition=function(){function t(t){this.sceneLoadAction=t,this.loadsNewScene=null!=t}return Object.defineProperty(t.prototype,"hasPreviousSceneRender",{get:function(){return!!this._hasPreviousSceneRender||(this._hasPreviousSceneRender=!0,!1)},enumerable:!0,configurable:!0}),t.prototype.preRender=function(){},t.prototype.render=function(){},t.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(t){switch(t.label){case 0:return[4,this.loadNextScene()];case 1:return t.sent(),this.transitionComplete(),[2]}})})},t.prototype.transitionComplete=function(){SceneManager.sceneTransition=null,this.onTransitionCompleted&&this.onTransitionCompleted()},t.prototype.loadNextScene=function(){return __awaiter(this,void 0,void 0,function(){var t;return __generator(this,function(e){switch(e.label){case 0:return this.onScreenObscured&&this.onScreenObscured(),this.loadsNewScene||(this.isNewSceneLoaded=!0),t=SceneManager,[4,this.sceneLoadAction()];case 1:return t.scene=e.sent(),this.isNewSceneLoaded=!0,[2]}})})},t.prototype.tickEffectProgressProperty=function(t,e,n,i){return void 0===i&&(i=!1),new Promise(function(r){var o=i?1:0,s=i?0:1;egret.Tween.get(t.uniforms).set({_progress:o}).to({_progress:s},1e3*e,n).call(function(){r()})})},t}(),FadeTransition=function(t){function e(e){var n=t.call(this,e)||this;return n.fadeToColor=0,n.fadeOutDuration=.4,n.fadeEaseType=egret.Ease.quadInOut,n.delayBeforeFadeInDuration=.1,n._alpha=0,n._mask=new egret.Shape,n}return __extends(e,t),e.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){var t=this;return __generator(this,function(e){return this._mask.graphics.beginFill(this.fadeToColor,1),this._mask.graphics.drawRect(0,0,SceneManager.stage.stageWidth,SceneManager.stage.stageHeight),this._mask.graphics.endFill(),SceneManager.stage.addChild(this._mask),egret.Tween.get(this).to({_alpha:1},1e3*this.fadeOutDuration,this.fadeEaseType).call(function(){return __awaiter(t,void 0,void 0,function(){return __generator(this,function(t){switch(t.label){case 0:return[4,this.loadNextScene()];case 1:return t.sent(),[2]}})})}).wait(this.delayBeforeFadeInDuration).call(function(){egret.Tween.get(t).to({_alpha:0},1e3*t.fadeOutDuration,t.fadeEaseType).call(function(){t.transitionComplete(),SceneManager.stage.removeChild(t._mask)})}),[2]})})},e.prototype.render=function(){this._mask.graphics.clear(),this._mask.graphics.beginFill(this.fadeToColor,this._alpha),this._mask.graphics.drawRect(0,0,SceneManager.stage.stageWidth,SceneManager.stage.stageHeight),this._mask.graphics.endFill()},e}(SceneTransition),WindTransition=function(t){function e(e){var n=t.call(this,e)||this;n.duration=1,n.easeType=egret.Ease.quadOut;return n._windEffect=new egret.CustomFilter("attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n}","precision lowp float;\nvarying vec2 vTextureCoord;\nuniform sampler2D uSampler;\nuniform float _progress;\nuniform float _size;\nuniform float _windSegments;\nvoid main(void) {\nvec2 co = floor(vec2(0.0, vTextureCoord.y * _windSegments));\nfloat x = sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453;\nfloat r = x - floor(x);\nfloat m = smoothstep(0.0, -_size, vTextureCoord.x * (1.0 - _size) + _size * r - (_progress * (1.0 + _size)));\nvec4 fg = texture2D(uSampler, vTextureCoord);\ngl_FragColor = mix(fg, vec4(0, 0, 0, 0), m);\n}",{_progress:0,_size:.3,_windSegments:100}),n._mask=new egret.Shape,n._mask.graphics.beginFill(16777215,1),n._mask.graphics.drawRect(0,0,SceneManager.stage.stageWidth,SceneManager.stage.stageHeight),n._mask.graphics.endFill(),n._mask.filters=[n._windEffect],SceneManager.stage.addChild(n._mask),n}return __extends(e,t),Object.defineProperty(e.prototype,"windSegments",{set:function(t){this._windEffect.uniforms._windSegments=t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"size",{set:function(t){this._windEffect.uniforms._size=t},enumerable:!0,configurable:!0}),e.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(t){switch(t.label){case 0:return this.loadNextScene(),[4,this.tickEffectProgressProperty(this._windEffect,this.duration,this.easeType)];case 1:return t.sent(),this.transitionComplete(),SceneManager.stage.removeChild(this._mask),[2]}})})},e}(SceneTransition),Bezier=function(){function t(){}return t.getPoint=function(t,e,n,i){var r=1-(i=MathHelper.clamp01(i));return Vector2.add(Vector2.add(Vector2.multiply(new Vector2(r*r),t),Vector2.multiply(new Vector2(2*r*i),e)),Vector2.multiply(new Vector2(i*i),n))},t.getFirstDerivative=function(t,e,n,i){return Vector2.add(Vector2.multiply(new Vector2(2*(1-i)),Vector2.subtract(e,t)),Vector2.multiply(new Vector2(2*i),Vector2.subtract(n,e)))},t.getFirstDerivativeThree=function(t,e,n,i,r){var o=1-(r=MathHelper.clamp01(r));return Vector2.add(Vector2.add(Vector2.multiply(new Vector2(3*o*o),Vector2.subtract(e,t)),Vector2.multiply(new Vector2(6*o*r),Vector2.subtract(n,e))),Vector2.multiply(new Vector2(3*r*r),Vector2.subtract(i,n)))},t.getPointThree=function(t,e,n,i,r){var o=1-(r=MathHelper.clamp01(r));return Vector2.add(Vector2.add(Vector2.add(Vector2.multiply(new Vector2(o*o*o),t),Vector2.multiply(new Vector2(3*o*o*r),e)),Vector2.multiply(new Vector2(3*o*r*r),n)),Vector2.multiply(new Vector2(r*r*r),i))},t.getOptimizedDrawingPoints=function(t,e,n,i,r){void 0===r&&(r=1);var o=ListPool.obtain();return o.push(t),this.recursiveGetOptimizedDrawingPoints(t,e,n,i,o,r),o.push(i),o},t.recursiveGetOptimizedDrawingPoints=function(t,e,n,i,r,o){var s=Vector2.divide(Vector2.add(t,e),new Vector2(2)),a=Vector2.divide(Vector2.add(e,n),new Vector2(2)),c=Vector2.divide(Vector2.add(n,i),new Vector2(2)),h=Vector2.divide(Vector2.add(s,a),new Vector2(2)),u=Vector2.divide(Vector2.add(a,c),new Vector2(2)),l=Vector2.divide(Vector2.add(h,u),new Vector2(2)),p=Vector2.subtract(i,t),d=Math.abs((e.x,i.x*p.y-(e.y-i.y)*p.x)),f=Math.abs((n.x-i.x)*p.y-(n.y-i.y)*p.x);(d+f)*(d+f)<o*(p.x*p.x+p.y*p.y)?r.push(l):(this.recursiveGetOptimizedDrawingPoints(t,s,h,l,r,o),this.recursiveGetOptimizedDrawingPoints(l,u,c,i,r,o))},t}(),Flags=function(){function t(){}return t.isFlagSet=function(t,e){return 0!=(t&e)},t.isUnshiftedFlagSet=function(t,e){return 0!=(t&(e=1<<e))},t.setFlagExclusive=function(t,e){return 1<<e},t.setFlag=function(t,e){return t|1<<e},t.unsetFlag=function(t,e){return t&~(e=1<<e)},t.invertFlags=function(t){return~t},t}(),MathHelper=function(){function t(){}return t.toDegrees=function(t){return 57.29577951308232*t},t.toRadians=function(t){return.017453292519943295*t},t.map=function(t,e,n,i,r){return i+(t-e)*(r-i)/(n-e)},t.lerp=function(t,e,n){return t+(e-t)*n},t.clamp=function(t,e,n){return t<e?e:t>n?n:t},t.pointOnCirlce=function(e,n,i){var r=t.toRadians(i);return new Vector2(Math.cos(r)*r+e.x,Math.sin(r)*r+e.y)},t.isEven=function(t){return t%2==0},t.clamp01=function(t){return t<0?0:t>1?1:t},t.angleBetweenVectors=function(t,e){return Math.atan2(e.y-t.y,e.x-t.x)},t.Epsilon=1e-5,t.Rad2Deg=57.29578,t.Deg2Rad=.0174532924,t}(),Matrix2D=function(){function t(t,e,n,i,r,o){this.m11=0,this.m12=0,this.m21=0,this.m22=0,this.m31=0,this.m32=0,this.m11=t||1,this.m12=e||0,this.m21=n||0,this.m22=i||1,this.m31=r||0,this.m32=o||0}return Object.defineProperty(t,"identity",{get:function(){return t._identity},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"translation",{get:function(){return new Vector2(this.m31,this.m32)},set:function(t){this.m31=t.x,this.m32=t.y},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"rotation",{get:function(){return Math.atan2(this.m21,this.m11)},set:function(t){var e=Math.cos(t),n=Math.sin(t);this.m11=e,this.m12=n,this.m21=-n,this.m22=e},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"rotationDegrees",{get:function(){return MathHelper.toDegrees(this.rotation)},set:function(t){this.rotation=MathHelper.toRadians(t)},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"scale",{get:function(){return new Vector2(this.m11,this.m22)},set:function(t){this.m11=t.x,this.m12=t.y},enumerable:!0,configurable:!0}),t.add=function(t,e){return t.m11+=e.m11,t.m12+=e.m12,t.m21+=e.m21,t.m22+=e.m22,t.m31+=e.m31,t.m32+=e.m32,t},t.divide=function(t,e){return t.m11/=e.m11,t.m12/=e.m12,t.m21/=e.m21,t.m22/=e.m22,t.m31/=e.m31,t.m32/=e.m32,t},t.multiply=function(e,n){var i=new t,r=e.m11*n.m11+e.m12*n.m21,o=e.m11*n.m12+e.m12*n.m22,s=e.m21*n.m11+e.m22*n.m21,a=e.m21*n.m12+e.m22*n.m22,c=e.m31*n.m11+e.m32*n.m21+n.m31,h=e.m31*n.m12+e.m32*n.m22+n.m32;return i.m11=r,i.m12=o,i.m21=s,i.m22=a,i.m31=c,i.m32=h,i},t.multiplyTranslation=function(e,n,i){var r=t.createTranslation(n,i);return t.multiply(e,r)},t.prototype.determinant=function(){return this.m11*this.m22-this.m12*this.m21},t.invert=function(e,n){void 0===n&&(n=new t);var i=1/e.determinant();return n.m11=e.m22*i,n.m12=-e.m12*i,n.m21=-e.m21*i,n.m22=e.m11*i,n.m31=(e.m32*e.m21-e.m31*e.m22)*i,n.m32=-(e.m32*e.m11-e.m31*e.m12)*i,n},t.createTranslation=function(e,n){var i=new t;return i.m11=1,i.m12=0,i.m21=0,i.m22=1,i.m31=e,i.m32=n,i},t.createTranslationVector=function(t){return this.createTranslation(t.x,t.y)},t.createRotation=function(e,n){n=new t;var i=Math.cos(e),r=Math.sin(e);return n.m11=i,n.m12=r,n.m21=-r,n.m22=i,n},t.createScale=function(e,n,i){return void 0===i&&(i=new t),i.m11=e,i.m12=0,i.m21=0,i.m22=n,i.m31=0,i.m32=0,i},t.prototype.toEgretMatrix=function(){return new egret.Matrix(this.m11,this.m12,this.m21,this.m22,this.m31,this.m32)},t._identity=new t(1,0,0,1,0,0),t}(),Rectangle=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),Object.defineProperty(e.prototype,"max",{get:function(){return new Vector2(this.right,this.bottom)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"center",{get:function(){return new Vector2(this.x+this.width/2,this.y+this.height/2)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"location",{get:function(){return new Vector2(this.x,this.y)},set:function(t){this.x=t.x,this.y=t.y},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"size",{get:function(){return new Vector2(this.width,this.height)},set:function(t){this.width=t.x,this.height=t.y},enumerable:!0,configurable:!0}),e.prototype.intersects=function(t){return t.left<this.right&&this.left<t.right&&t.top<this.bottom&&this.top<t.bottom},e.prototype.containsRect=function(t){return this.x<=t.x&&t.x<this.x+this.width&&this.y<=t.y&&t.y<this.y+this.height},e.prototype.getHalfSize=function(){return new Vector2(.5*this.width,.5*this.height)},e.fromMinMax=function(t,n,i,r){return new e(t,n,i-t,r-n)},e.prototype.getClosestPointOnRectangleBorderToPoint=function(t){var e=Vector2.zero,n=new Vector2;if(n.x=MathHelper.clamp(t.x,this.left,this.right),n.y=MathHelper.clamp(t.y,this.top,this.bottom),this.contains(n.x,n.y)){var i=n.x-this.left,r=this.right-n.x,o=n.y-this.top,s=this.bottom-n.y,a=Math.min(i,r,o,s);a==o?(n.y=this.top,e.y=-1):a==s?(n.y=this.bottom,e.y=1):a==i?(n.x=this.left,e.x=-1):(n.x=this.right,e.x=1)}else n.x==this.left&&(e.x=-1),n.x==this.right&&(e.x=1),n.y==this.top&&(e.y=-1),n.y==this.bottom&&(e.y=1);return{res:n,edgeNormal:e}},e.prototype.getClosestPointOnBoundsToOrigin=function(){var t=this.max,e=Math.abs(this.location.x),n=new Vector2(this.location.x,0);return Math.abs(t.x)<e&&(e=Math.abs(t.x),n.x=t.x,n.y=0),Math.abs(t.y)<e&&(e=Math.abs(t.y),n.x=0,n.y=t.y),Math.abs(this.location.y)<e&&(e=Math.abs(this.location.y),n.x=0,n.y=this.location.y),n},e.prototype.setEgretRect=function(t){return this.x=t.x,this.y=t.y,this.width=t.width,this.height=t.height,this},e.rectEncompassingPoints=function(t){for(var e=Number.POSITIVE_INFINITY,n=Number.POSITIVE_INFINITY,i=Number.NEGATIVE_INFINITY,r=Number.NEGATIVE_INFINITY,o=0;o<t.length;o++){var s=t[o];s.x<e&&(e=s.x),s.x>i&&(i=s.x),s.y<n&&(n=s.y),s.y>r&&(r=s.y)}return this.fromMinMax(e,n,i,r)},e}(egret.Rectangle),Vector3=function(){return function(t,e,n){this.x=t,this.y=e,this.z=n}}(),ColliderTriggerHelper=function(){function t(t){this._activeTriggerIntersections=[],this._previousTriggerIntersections=[],this._tempTriggerList=[],this._entity=t}return t.prototype.update=function(){for(var t=this._entity.getComponents(Collider),e=0;e<t.length;e++){var n=t[e],i=Physics.boxcastBroadphase(n.bounds,n.collidesWithLayers);n.bounds=i.rect;for(var r=i.colliders,o=function(t){var e=r[t];if(!n.isTrigger&&!e.isTrigger)return"continue";if(n.overlaps(e)){var i=new Pair(n,e);-1==s._activeTriggerIntersections.findIndex(function(t){return t.first==i.first&&t.second==i.second})&&-1==s._previousTriggerIntersections.findIndex(function(t){return t.first==i.first&&t.second==i.second})&&s.notifyTriggerListeners(i,!0),s._activeTriggerIntersections.contains(i)||s._activeTriggerIntersections.push(i)}},s=this,a=0;a<r.length;a++)o(a)}ListPool.free(t),this.checkForExitedColliders()},t.prototype.checkForExitedColliders=function(){for(var t=this,e=function(e){var i=n._previousTriggerIntersections.findIndex(function(n){return n.first==t._activeTriggerIntersections[e].first&&n.second==t._activeTriggerIntersections[e].second});-1!=i&&n._previousTriggerIntersections.removeAt(i)},n=this,i=0;i<this._activeTriggerIntersections.length;i++)e(i);for(i=0;i<this._previousTriggerIntersections.length;i++)this.notifyTriggerListeners(this._previousTriggerIntersections[i],!1);this._previousTriggerIntersections.length=0;for(i=0;i<this._activeTriggerIntersections.length;i++)this._previousTriggerIntersections.contains(this._activeTriggerIntersections[i])||this._previousTriggerIntersections.push(this._activeTriggerIntersections[i]);this._activeTriggerIntersections.length=0},t.prototype.notifyTriggerListeners=function(t,e){t.first.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var n=0;n<this._tempTriggerList.length;n++)if(e?this._tempTriggerList[n].onTriggerEnter(t.second,t.first):this._tempTriggerList[n].onTriggerExit(t.second,t.first),this._tempTriggerList.length=0,t.second.entity){t.second.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var i=0;i<this._tempTriggerList.length;i++)e?this._tempTriggerList[i].onTriggerEnter(t.first,t.second):this._tempTriggerList[i].onTriggerExit(t.first,t.second);this._tempTriggerList.length=0}},t}();!function(t){t[t.center=0]="center",t[t.top=1]="top",t[t.bottom=2]="bottom",t[t.topLeft=9]="topLeft",t[t.topRight=5]="topRight",t[t.left=8]="left",t[t.right=4]="right",t[t.bottomLeft=10]="bottomLeft",t[t.bottomRight=6]="bottomRight"}(PointSectors||(PointSectors={}));var Alignment,stopwatch,Collisions=function(){function t(){}return t.isLineToLine=function(t,e,n,i){var r=Vector2.subtract(e,t),o=Vector2.subtract(i,n),s=r.x*o.y-r.y*o.x;if(0==s)return!1;var a=Vector2.subtract(n,t),c=(a.x*o.y-a.y*o.x)/s;if(c<0||c>1)return!1;var h=(a.x*r.y-a.y*r.x)/s;return!(h<0||h>1)},t.lineToLineIntersection=function(t,e,n,i){var r=new Vector2(0,0),o=Vector2.subtract(e,t),s=Vector2.subtract(i,n),a=o.x*s.y-o.y*s.x;if(0==a)return r;var c=Vector2.subtract(n,t),h=(c.x*s.y-c.y*s.x)/a;if(h<0||h>1)return r;var u=(c.x*o.y-c.y*o.x)/a;return u<0||u>1?r:r=Vector2.add(t,new Vector2(h*o.x,h*o.y))},t.closestPointOnLine=function(t,e,n){var i=Vector2.subtract(e,t),r=Vector2.subtract(n,t),o=Vector2.dot(r,i)/Vector2.dot(i,i);return o=MathHelper.clamp(o,0,1),Vector2.add(t,new Vector2(i.x*o,i.y*o))},t.isCircleToCircle=function(t,e,n,i){return Vector2.distanceSquared(t,n)<(e+i)*(e+i)},t.isCircleToLine=function(t,e,n,i){return Vector2.distanceSquared(t,this.closestPointOnLine(n,i,t))<e*e},t.isCircleToPoint=function(t,e,n){return Vector2.distanceSquared(t,n)<e*e},t.isRectToCircle=function(t,e,n){var i=.5*t.width,r=.5*t.height,o=Math.max(0,Math.max(e.x-t.x)-i),s=Math.max(0,Math.max(e.y-t.y)-r);return o*o+s*s<n*n},t.isRectToLine=function(t,e,n){var i=this.getSector(t.x,t.y,t.width,t.height,e),r=this.getSector(t.x,t.y,t.width,t.height,n);if(i==PointSectors.center||r==PointSectors.center)return!0;if(0!=(i&r))return!1;var o=i|r,s=void 0,a=void 0;return!(0==(o&PointSectors.top)||(s=new Vector2(t.x,t.y),a=new Vector2(t.x+t.width,t.y),!this.isLineToLine(s,a,e,n)))||(!(0==(o&PointSectors.bottom)||(s=new Vector2(t.x,t.y+t.height),a=new Vector2(t.x+t.width,t.y+t.height),!this.isLineToLine(s,a,e,n)))||(!(0==(o&PointSectors.left)||(s=new Vector2(t.x,t.y),a=new Vector2(t.x,t.y+t.height),!this.isLineToLine(s,a,e,n)))||!(0==(o&PointSectors.right)||(s=new Vector2(t.x+t.width,t.y),a=new Vector2(t.x+t.width,t.y+t.height),!this.isLineToLine(s,a,e,n)))))},t.isRectToPoint=function(t,e,n,i,r){return r.x>=t&&r.y>=e&&r.x<t+n&&r.y<e+i},t.getSector=function(t,e,n,i,r){var o=PointSectors.center;return r.x<t?o|=PointSectors.left:r.x>=t+n&&(o|=PointSectors.right),r.y<e?o|=PointSectors.top:r.y>=e+i&&(o|=PointSectors.bottom),o},t}(),Physics=function(){function t(){}return t.reset=function(){this._spatialHash=new SpatialHash(this.spatialHashCellSize)},t.clear=function(){this._spatialHash.clear()},t.overlapCircleAll=function(t,e,n,i){return void 0===i&&(i=-1),this._spatialHash.overlapCircle(t,e,n,i)},t.boxcastBroadphase=function(t,e){void 0===e&&(e=this.allLayers);var n=this._spatialHash.aabbBroadphase(t,null,e);return{colliders:n.tempHashSet,rect:n.bounds}},t.boxcastBroadphaseExcludingSelf=function(t,e,n){return void 0===n&&(n=this.allLayers),this._spatialHash.aabbBroadphase(e,t,n)},t.addCollider=function(e){t._spatialHash.register(e)},t.removeCollider=function(e){t._spatialHash.remove(e)},t.updateCollider=function(t){this._spatialHash.remove(t),this._spatialHash.register(t)},t.debugDraw=function(t){this._spatialHash.debugDraw(t,2)},t.spatialHashCellSize=100,t.allLayers=-1,t}(),Shape=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e}(egret.DisplayObject),Polygon=function(t){function e(e,n){var i=t.call(this)||this;return i._areEdgeNormalsDirty=!0,i.center=new Vector2,i.setPoints(e),i.isBox=n,i}return __extends(e,t),Object.defineProperty(e.prototype,"position",{get:function(){return new Vector2(this.parent.x,this.parent.y)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"bounds",{get:function(){return new Rectangle(this.x,this.y,this.width,this.height)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"edgeNormals",{get:function(){return this._areEdgeNormalsDirty&&this.buildEdgeNormals(),this._edgeNormals},enumerable:!0,configurable:!0}),e.prototype.buildEdgeNormals=function(){var t,e=this.isBox?2:this.points.length;null!=this._edgeNormals&&this._edgeNormals.length==e||(this._edgeNormals=new Array(e));for(var n=0;n<e;n++){var i=this.points[n];t=n+1>=this.points.length?this.points[0]:this.points[n+1];var r=Vector2Ext.perpendicular(i,t);r=Vector2.normalize(r),this._edgeNormals[n]=r}},e.prototype.setPoints=function(t){this.points=t,this.recalculateCenterAndEdgeNormals(),this._originalPoints=[];for(var e=0;e<this.points.length;e++)this._originalPoints.push(this.points[e])},e.prototype.collidesWithShape=function(t){var n=new CollisionResult;if(t instanceof e)return ShapeCollisions.polygonToPolygon(this,t);if(t instanceof Circle)return(n=ShapeCollisions.circleToPolygon(t,this))?(n.invertResult(),n):null;throw new Error("overlaps of Polygon to "+t+" are not supported")},e.prototype.recalculateCenterAndEdgeNormals=function(){this._polygonCenter=e.findPolygonCenter(this.points),this._areEdgeNormalsDirty=!0},e.prototype.overlaps=function(t){var n;if(t instanceof e)return ShapeCollisions.polygonToPolygon(this,t);if(t instanceof Circle)return!!(n=ShapeCollisions.circleToPolygon(t,this))&&(n.invertResult(),!0);throw new Error("overlaps of Pologon to "+t+" are not supported")},e.findPolygonCenter=function(t){for(var e=0,n=0,i=0;i<t.length;i++)e+=t[i].x,n+=t[i].y;return new Vector2(e/t.length,n/t.length)},e.recenterPolygonVerts=function(t){for(var e=this.findPolygonCenter(t),n=0;n<t.length;n++)t[n]=Vector2.subtract(t[n],e)},e.getClosestPointOnPolygonToPoint=function(t,e){for(var n,i=Number.MAX_VALUE,r=new Vector2(0,0),o=new Vector2(0,0),s=0;s<t.length;s++){var a=s+1;a==t.length&&(a=0);var c=ShapeCollisions.closestPointOnLine(t[s],t[a],e);if((n=Vector2.distanceSquared(e,c))<i){i=n,o=c;var h=Vector2.subtract(t[a],t[s]);r.x=-h.y,r.y=h.x}}return{closestPoint:o,distanceSquared:i,edgeNormal:r=Vector2.normalize(r)}},e.prototype.pointCollidesWithShape=function(t){return ShapeCollisions.pointToPoly(t,this)},e.prototype.containsPoint=function(t){t=Vector2.subtract(t,this.position);for(var e=!1,n=0,i=this.points.length-1;n<this.points.length;i=n++)this.points[n].y>t.y!=this.points[i].y>t.y&&t.x<(this.points[i].x-this.points[n].x)*(t.y-this.points[n].y)/(this.points[i].y-this.points[n].y)+this.points[n].x&&(e=!e);return e},e.buildSymmertricalPolygon=function(t,e){for(var n=new Array(t),i=0;i<t;i++){var r=2*Math.PI*(i/t);n[i]=new Vector2(Math.cos(r),Math.sin(r)*e)}return n},e}(Shape),Box=function(t){function e(n,i){var r=t.call(this,e.buildBox(n,i),!0)||this;return r.width=n,r.height=i,r}return __extends(e,t),e.buildBox=function(t,e){var n=t/2,i=e/2,r=new Array(4);return r[0]=new Vector2(-n,-i),r[1]=new Vector2(n,-i),r[2]=new Vector2(n,i),r[3]=new Vector2(-n,i),r},e.prototype.overlaps=function(n){return n instanceof e?this.bounds.intersects(n.bounds):n instanceof Circle?Collisions.isRectToCircle(this.bounds,n.position,n.radius):t.prototype.overlaps.call(this,n)},e.prototype.collidesWithShape=function(n){return n instanceof e?ShapeCollisions.boxToBox(this,n):t.prototype.collidesWithShape.call(this,n)},e.prototype.updateBox=function(t,e){this.width=t,this.height=e;var n=t/2,i=e/2;this.points[0]=new Vector2(-n,-i),this.points[1]=new Vector2(n,-i),this.points[2]=new Vector2(n,i),this.points[3]=new Vector2(-n,i);for(var r=0;r<this.points.length;r++)this._originalPoints[r]=this.points[r]},e.prototype.containsPoint=function(t){return this.bounds.contains(t.x,t.y)},e}(Polygon),Circle=function(t){function e(e){var n=t.call(this)||this;return n.center=new Vector2,n.radius=e,n._originalRadius=e,n}return __extends(e,t),Object.defineProperty(e.prototype,"position",{get:function(){return new Vector2(this.parent.x,this.parent.y)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"bounds",{get:function(){return(new Rectangle).setEgretRect(this.getBounds())},enumerable:!0,configurable:!0}),e.prototype.pointCollidesWithShape=function(t){return ShapeCollisions.pointToCircle(t,this)},e.prototype.collidesWithShape=function(t){if(t instanceof Box)return ShapeCollisions.circleToBox(this,t);if(t instanceof e)return ShapeCollisions.circleToCircle(this,t);if(t instanceof Polygon)return ShapeCollisions.circleToPolygon(this,t);throw new Error("Collisions of Circle to "+t+" are not supported")},e.prototype.overlaps=function(t){if(t instanceof Box)return Collisions.isRectToCircle(t.bounds,this.position,this.radius);if(t instanceof e)return Collisions.isCircleToCircle(this.position,this.radius,t.position,t.radius);if(t instanceof Polygon)return ShapeCollisions.circleToPolygon(this,t);throw new Error("overlaps of circle to "+t+" are not supported")},e}(Shape),CollisionResult=function(){function t(){this.minimumTranslationVector=Vector2.zero,this.normal=Vector2.zero,this.point=Vector2.zero}return t.prototype.invertResult=function(){this.minimumTranslationVector=Vector2.negate(this.minimumTranslationVector),this.normal=Vector2.negate(this.normal)},t}(),ShapeCollisions=function(){function t(){}return t.polygonToPolygon=function(t,e){for(var n,i=new CollisionResult,r=!0,o=t.edgeNormals,s=e.edgeNormals,a=Number.POSITIVE_INFINITY,c=new Vector2,h=Vector2.subtract(t.position,e.position),u=0;u<o.length+s.length;u++){n=u<o.length?o[u]:s[u-o.length];var l=0,p=0,d=0,f=0,g=0,m=this.getInterval(n,t,l,d);l=m.min,p=m.max;var y=this.getInterval(n,e,p,f);p=y.min,f=y.max;var _=Vector2.dot(h,n);if(l+=_,d+=_,(g=this.intervalDistance(l,d,p,f))>0&&(r=!1),!r)return null;(g=Math.abs(g))<a&&(a=g,c=n,Vector2.dot(c,h)<0&&(c=new Vector2(-c)))}return i.normal=c,i.minimumTranslationVector=Vector2.multiply(new Vector2(-c.x,-c.y),new Vector2(a)),i},t.intervalDistance=function(t,e,n,i){return t<n?n-e:t-n},t.getInterval=function(t,e,n,i){var r=Vector2.dot(e.points[0],t);n=i=r;for(var o=1;o<e.points.length;o++)(r=Vector2.dot(e.points[o],t))<n?n=r:r>i&&(i=r);return{min:n,max:i}},t.circleToPolygon=function(t,e){var n=new CollisionResult,i=Vector2.subtract(t.position,e.position),r=Polygon.getClosestPointOnPolygonToPoint(e.points,i),o=r.closestPoint,s=r.distanceSquared;n.normal=r.edgeNormal;var a,c=e.containsPoint(t.position);if(s>t.radius*t.radius&&!c)return null;if(c)a=Vector2.multiply(n.normal,new Vector2(Math.sqrt(s)-t.radius));else if(0==s)a=Vector2.multiply(n.normal,new Vector2(t.radius));else{var h=Math.sqrt(s);a=Vector2.multiply(new Vector2(-Vector2.subtract(i,o)),new Vector2((t.radius-s)/h))}return n.minimumTranslationVector=a,n.point=Vector2.add(o,e.position),n},t.circleToBox=function(t,e){var n=new CollisionResult,i=e.bounds.getClosestPointOnRectangleBorderToPoint(t.position).res;if(e.containsPoint(t.position)){n.point=i;var r=Vector2.add(i,Vector2.subtract(n.normal,new Vector2(t.radius)));return n.minimumTranslationVector=Vector2.subtract(t.position,r),n}var o=Vector2.distanceSquared(i,t.position);if(0==o)n.minimumTranslationVector=Vector2.multiply(n.normal,new Vector2(t.radius));else if(o<=t.radius*t.radius){n.normal=Vector2.subtract(t.position,i);var s=n.normal.length()-t.radius;return n.normal=Vector2Ext.normalize(n.normal),n.minimumTranslationVector=Vector2.multiply(new Vector2(s),n.normal),n}return null},t.pointToCircle=function(t,e){var n=new CollisionResult,i=Vector2.distanceSquared(t,e.position),r=1+e.radius;if(i<r*r){n.normal=Vector2.normalize(Vector2.subtract(t,e.position));var o=r-Math.sqrt(i);return n.minimumTranslationVector=Vector2.multiply(new Vector2(-o,-o),n.normal),n.point=Vector2.add(e.position,Vector2.multiply(n.normal,new Vector2(e.radius,e.radius))),n}return null},t.closestPointOnLine=function(t,e,n){var i=Vector2.subtract(e,t),r=Vector2.subtract(n,t),o=Vector2.dot(r,i)/Vector2.dot(i,i);return o=MathHelper.clamp(o,0,1),Vector2.add(t,Vector2.multiply(i,new Vector2(o,o)))},t.pointToPoly=function(t,e){var n=new CollisionResult;if(e.containsPoint(t)){var i,r=Polygon.getClosestPointOnPolygonToPoint(e.points,Vector2.subtract(t,e.position)),o=r.closestPoint;return i=r.distanceSquared,n.normal=r.edgeNormal,n.minimumTranslationVector=Vector2.multiply(n.normal,new Vector2(Math.sqrt(i),Math.sqrt(i))),n.point=Vector2.add(o,e.position),n}return null},t.circleToCircle=function(t,e){var n=new CollisionResult,i=Vector2.distanceSquared(t.position,e.position),r=t.radius+e.radius;if(i<r*r){n.normal=Vector2.normalize(Vector2.subtract(t.position,e.position));var o=r-Math.sqrt(i);return n.minimumTranslationVector=Vector2.multiply(new Vector2(-o),n.normal),n.point=Vector2.add(e.position,Vector2.multiply(n.normal,new Vector2(e.radius))),n}return null},t.boxToBox=function(t,e){var n=new CollisionResult,i=this.minkowskiDifference(t,e);return i.contains(0,0)?(n.minimumTranslationVector=i.getClosestPointOnBoundsToOrigin(),0==n.minimumTranslationVector.x&&0==n.minimumTranslationVector.y?null:(n.normal=new Vector2(-n.minimumTranslationVector.x,-n.minimumTranslationVector.y),n.normal.normalize(),n)):null},t.minkowskiDifference=function(t,e){var n=Vector2.subtract(t.position,Vector2.add(t.bounds.location,Vector2.divide(t.bounds.size,new Vector2(2)))),i=Vector2.subtract(Vector2.add(t.bounds.location,n),e.bounds.max),r=Vector2.add(t.bounds.size,e.bounds.size);return new Rectangle(i.x,i.y,r.x,r.y)},t}(),SpatialHash=function(){function t(t){void 0===t&&(t=100),this.gridBounds=new Rectangle,this._overlapTestCircle=new Circle(0),this._tempHashSet=[],this._cellDict=new NumberDictionary,this._cellSize=t,this._inverseCellSize=1/this._cellSize,this._raycastParser=new RaycastResultParser}return t.prototype.remove=function(t){for(var e=t.registeredPhysicsBounds,n=this.cellCoords(e.x,e.y),i=this.cellCoords(e.right,e.bottom),r=n.x;r<=i.x;r++)for(var o=n.y;o<=i.y;o++){var s=this.cellAtPosition(r,o);s?s.remove(t):console.error("removing Collider ["+t+"] from a cell that it is not present in")}},t.prototype.register=function(t){var e=t.bounds;t.registeredPhysicsBounds=e;var n=this.cellCoords(e.x,e.y),i=this.cellCoords(e.right,e.bottom);this.gridBounds.contains(n.x,n.y)||(this.gridBounds=RectangleExt.union(this.gridBounds,n)),this.gridBounds.contains(i.x,i.y)||(this.gridBounds=RectangleExt.union(this.gridBounds,i));for(var r=n.x;r<=i.x;r++)for(var o=n.y;o<=i.y;o++){var s=this.cellAtPosition(r,o,!0);-1==s.indexOf(t)&&s.push(t)}},t.prototype.clear=function(){this._cellDict.clear()},t.prototype.overlapCircle=function(t,e,n,i){var r=new Rectangle(t.x-e,t.y-e,2*e,2*e);this._overlapTestCircle.radius=e;var o=0,s=this.aabbBroadphase(r,null,i);r=s.bounds;for(var a=s.tempHashSet,c=0;c<a.length;c++){var h=a[c];if(h instanceof BoxCollider)n[o]=h,o++;else if(h instanceof CircleCollider)h.shape.overlaps(this._overlapTestCircle)&&(n[o]=h,o++);else{if(!(h instanceof PolygonCollider))throw new Error("overlapCircle against this collider type is not implemented!");h.shape.overlaps(this._overlapTestCircle)&&(n[o]=h,o++)}if(o==n.length)return o}return o},t.prototype.aabbBroadphase=function(t,e,n){this._tempHashSet.length=0;for(var i=this.cellCoords(t.x,t.y),r=this.cellCoords(t.right,t.bottom),o=i.x;o<=r.x;o++)for(var s=i.y;s<=r.y;s++){var a=this.cellAtPosition(o,s);if(a)for(var c=0;c<a.length;c++){var h=a[c];h!=e&&Flags.isFlagSet(n,h.physicsLayer)&&(t.intersects(h.bounds)&&-1==this._tempHashSet.indexOf(h)&&this._tempHashSet.push(h))}}return{tempHashSet:this._tempHashSet,bounds:t}},t.prototype.cellAtPosition=function(t,e,n){void 0===n&&(n=!1);var i=this._cellDict.tryGetValue(t,e);return i||n&&(i=[],this._cellDict.add(t,e,i)),i},t.prototype.cellCoords=function(t,e){return new Vector2(Math.floor(t*this._inverseCellSize),Math.floor(e*this._inverseCellSize))},t.prototype.debugDraw=function(t,e){void 0===e&&(e=1);for(var n=this.gridBounds.x;n<=this.gridBounds.right;n++)for(var i=this.gridBounds.y;i<=this.gridBounds.bottom;i++){var r=this.cellAtPosition(n,i);r&&r.length>0&&this.debugDrawCellDetails(n,i,r.length,t,e)}},t.prototype.debugDrawCellDetails=function(t,e,n,i,r){void 0===i&&(i=.5),void 0===r&&(r=1)},t}(),RaycastResultParser=function(){return function(){}}(),NumberDictionary=function(){function t(){this._store=new Map}return t.prototype.getKey=function(t,e){return Long.fromNumber(t).shiftLeft(32).or(Long.fromNumber(e,!1)).toString()},t.prototype.add=function(t,e,n){this._store.set(this.getKey(t,e),n)},t.prototype.remove=function(t){this._store.forEach(function(e){e.contains(t)&&e.remove(t)})},t.prototype.tryGetValue=function(t,e){return this._store.get(this.getKey(t,e))},t.prototype.clear=function(){this._store.clear()},t}(),ArrayUtils=function(){function t(){}return t.bubbleSort=function(t){for(var e=!1,n=0;n<t.length;n++){e=!1;for(var i=t.length-1;i>n;i--)if(t[i]<t[i-1]){var r=t[i];t[i]=t[i-1],t[i-1]=r,e=!0}if(!e)break}},t.insertionSort=function(t){for(var e=t.length,n=1;n<e;n++){for(var i=t[n],r=n;r>0&&t[r-1]>i;r--)t[r]=t[r-1];t[r]=i}},t.binarySearch=function(t,e){for(var n=0,i=t.length,r=n+i>>1;n<i;)e<=t[r]?i=r:e>=t[r]&&(n=r+1),r=n+i>>1;return t[n]==e?n:-1},t.findElementIndex=function(t,e){for(var n=t.length,i=0;i<n;++i)if(t[i]==e)return i;return null},t.getMaxElementIndex=function(t){for(var e=0,n=t.length,i=1;i<n;i++)t[i]>t[e]&&(e=i);return e},t.getMinElementIndex=function(t){for(var e=0,n=t.length,i=1;i<n;i++)t[i]<t[e]&&(e=i);return e},t.getUniqueAry=function(t){for(var e=[],n=[],i=t.length,r=0;r<i;++r){var o=t[r];-1==e.indexOf(o)&&e.push(o)}for(r=(i=e.length)-1;r>=0;--r)n.unshift(e[r]);return n},t.getDifferAry=function(t,e){t=this.getUniqueAry(t),e=this.getUniqueAry(e);for(var n=t.concat(e),i=new Object,r=[],o=n.length,s=0;s<o;++s)i[n[s]]?i[n[s]]instanceof Object&&i[n[s]].count++:(i[n[s]]=new Object,i[n[s]].count=0,i[n[s]].key=n[s],i[n[s]].count++);for(var a in i)2!=i[a].count&&r.unshift(i[a].key);return r},t.swap=function(t,e,n){var i=t[e];t[e]=t[n],t[n]=i},t.clearList=function(t){if(t)for(var e=t.length-1;e>=0;e-=1)t.splice(e,1)},t.cloneList=function(t){return t?t.slice(0,t.length):null},t.equals=function(t,e){if(t==e)return!0;var n=t.length;if(n!=e.length)return!1;for(;n--;)if(t[n]!=e[n])return!1;return!0},t.insert=function(t,e,n){if(!t)return null;var i=t.length;if(e>i&&(e=i),e<0&&(e=0),e==i)t.push(n);else if(0==e)t.unshift(n);else{for(var r=i-1;r>=e;r-=1)t[r+1]=t[r];t[e]=n}return n},t}(),Base64Utils=function(){function t(){}return t._utf8_encode=function(t){t=t.replace(/\r\n/g,"\n");for(var e="",n=0;n<t.length;n++){var i=t.charCodeAt(n);i<128?e+=String.fromCharCode(i):i>127&&i<2048?(e+=String.fromCharCode(i>>6|192),e+=String.fromCharCode(63&i|128)):(e+=String.fromCharCode(i>>12|224),e+=String.fromCharCode(i>>6&63|128),e+=String.fromCharCode(63&i|128))}return e},t.decode=function(t,e){void 0===e&&(e=!0);var n,i,r,o,s,a,c="",h=0;for(t=(t=this.getConfKey(t)).replace(/[^A-Za-z0-9\+\/\=]/g,"");h<t.length;)n=this._keyAll.indexOf(t.charAt(h++))<<2|(o=this._keyAll.indexOf(t.charAt(h++)))>>4,i=(15&o)<<4|(s=this._keyAll.indexOf(t.charAt(h++)))>>2,r=(3&s)<<6|(a=this._keyAll.indexOf(t.charAt(h++))),c+=String.fromCharCode(n),64!=s&&(0==i?e&&(c+=String.fromCharCode(i)):c+=String.fromCharCode(i)),64!=a&&(0==r?e&&(c+=String.fromCharCode(r)):c+=String.fromCharCode(r));return c=this._utf8_decode(c)},t._utf8_decode=function(t){for(var e="",n=0,i=0,r=0,o=0;n<t.length;)(i=t.charCodeAt(n))<128?(e+=String.fromCharCode(i),n++):i>191&&i<224?(r=t.charCodeAt(n+1),e+=String.fromCharCode((31&i)<<6|63&r),n+=2):(r=t.charCodeAt(n+1),o=t.charCodeAt(n+2),e+=String.fromCharCode((15&i)<<12|(63&r)<<6|63&o),n+=3);return e},t.getConfKey=function(t){return t.slice(1,t.length)},t._keyNum="0123456789+/",t._keyStr="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",t._keyAll=t._keyNum+t._keyStr,t.encode=function(t){var e,n,i,r,o,s,a,c="",h=0;for(t=this._utf8_encode(t);h<t.length;)r=(e=t.charCodeAt(h++))>>2,o=(3&e)<<4|(n=t.charCodeAt(h++))>>4,s=(15&n)<<2|(i=t.charCodeAt(h++))>>6,a=63&i,isNaN(n)?s=a=64:isNaN(i)&&(a=64),c=c+this._keyAll.charAt(r)+this._keyAll.charAt(o)+this._keyAll.charAt(s)+this._keyAll.charAt(a);return this._keyStr.charAt(Math.floor(Math.random()*this._keyStr.length))+c},t}(),ContentManager=function(){function t(){this.loadedAssets=new Map}return t.prototype.loadRes=function(t,e){var n=this;return void 0===e&&(e=!0),new Promise(function(i,r){var o=n.loadedAssets.get(t);o?i(o):e?RES.getResAsync(t).then(function(e){n.loadedAssets.set(t,e),i(e)}).catch(function(e){console.error("资源加载错误:",t,e),r(e)}):RES.getResByUrl(t).then(function(e){n.loadedAssets.set(t,e),i(e)}).catch(function(e){console.error("资源加载错误:",t,e),r(e)})})},t.prototype.dispose=function(){this.loadedAssets.forEach(function(t){t.dispose()}),this.loadedAssets.clear()},t}(),DrawUtils=function(){function t(){}return t.drawLine=function(t,e,n,i,r){void 0===r&&(r=1),this.drawLineAngle(t,e,MathHelper.angleBetweenVectors(e,n),Vector2.distance(e,n),i,r)},t.drawLineAngle=function(t,e,n,i,r,o){void 0===o&&(o=1),t.graphics.beginFill(r),t.graphics.drawRect(e.x,e.y,1,1),t.graphics.endFill(),t.scaleX=i,t.scaleY=o,t.$anchorOffsetX=0,t.$anchorOffsetY=0,t.rotation=n},t.drawHollowRect=function(t,e,n,i){void 0===i&&(i=1),this.drawHollowRectR(t,e.x,e.y,e.width,e.height,n,i)},t.drawHollowRectR=function(t,e,n,i,r,o,s){void 0===s&&(s=1);var a=new Vector2(e,n).round(),c=new Vector2(e+i,n).round(),h=new Vector2(e+i,n+r).round(),u=new Vector2(e,n+r).round();this.drawLine(t,a,c,o,s),this.drawLine(t,c,h,o,s),this.drawLine(t,h,u,o,s),this.drawLine(t,u,a,o,s)},t.drawPixel=function(t,e,n,i){void 0===i&&(i=1);var r=new Rectangle(e.x,e.y,i,i);1!=i&&(r.x-=.5*i,r.y-=.5*i),t.graphics.beginFill(n),t.graphics.drawRect(r.x,r.y,r.width,r.height),t.graphics.endFill()},t}(),Emitter=function(){function t(){this._messageTable=new Map}return t.prototype.addObserver=function(t,e,n){var i=this._messageTable.get(t);i||(i=[],this._messageTable.set(t,i)),i.contains(e)&&console.warn("您试图添加相同的观察者两次"),i.push(new FuncPack(e,n))},t.prototype.removeObserver=function(t,e){var n=this._messageTable.get(t),i=n.findIndex(function(t){return t.func==e});-1!=i&&n.removeAt(i)},t.prototype.emit=function(t,e){var n=this._messageTable.get(t);if(n)for(var i=n.length-1;i>=0;i--)n[i].func.call(n[i].context,e)},t}(),FuncPack=function(){return function(t,e){this.func=t,this.context=e}}(),GlobalManager=function(){function t(){}return Object.defineProperty(t.prototype,"enabled",{get:function(){return this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),t.prototype.setEnabled=function(t){this._enabled!=t&&(this._enabled=t,this._enabled?this.onEnabled():this.onDisabled())},t.prototype.onEnabled=function(){},t.prototype.onDisabled=function(){},t.prototype.update=function(){},t.registerGlobalManager=function(t){this.globalManagers.push(t),t.enabled=!0},t.unregisterGlobalManager=function(t){this.globalManagers.remove(t),t.enabled=!1},t.getGlobalManager=function(t){for(var e=0;e<this.globalManagers.length;e++)if(this.globalManagers[e]instanceof t)return this.globalManagers[e];return null},t.globalManagers=[],t}(),TouchState=function(){function t(){this.x=0,this.y=0,this.touchPoint=-1,this.touchDown=!1}return Object.defineProperty(t.prototype,"position",{get:function(){return new Vector2(this.x,this.y)},enumerable:!0,configurable:!0}),t.prototype.reset=function(){this.x=0,this.y=0,this.touchDown=!1,this.touchPoint=-1},t}(),Input=function(){function t(){}return Object.defineProperty(t,"touchPosition",{get:function(){return this._gameTouchs[0]?this._gameTouchs[0].position:Vector2.zero},enumerable:!0,configurable:!0}),Object.defineProperty(t,"maxSupportedTouch",{get:function(){return this._stage.maxTouches},set:function(t){this._stage.maxTouches=t,this.initTouchCache()},enumerable:!0,configurable:!0}),Object.defineProperty(t,"resolutionScale",{get:function(){return this._resolutionScale},enumerable:!0,configurable:!0}),Object.defineProperty(t,"totalTouchCount",{get:function(){return this._totalTouchCount},enumerable:!0,configurable:!0}),Object.defineProperty(t,"gameTouchs",{get:function(){return this._gameTouchs},enumerable:!0,configurable:!0}),Object.defineProperty(t,"touchPositionDelta",{get:function(){var t=Vector2.subtract(this.touchPosition,this._previousTouchState.position);return t.length()>0&&this.setpreviousTouchState(this._gameTouchs[0]),t},enumerable:!0,configurable:!0}),t.initialize=function(t){this._init||(this._init=!0,this._stage=t,this._stage.addEventListener(egret.TouchEvent.TOUCH_BEGIN,this.touchBegin,this),this._stage.addEventListener(egret.TouchEvent.TOUCH_MOVE,this.touchMove,this),this._stage.addEventListener(egret.TouchEvent.TOUCH_END,this.touchEnd,this),this._stage.addEventListener(egret.TouchEvent.TOUCH_CANCEL,this.touchEnd,this),this._stage.addEventListener(egret.TouchEvent.TOUCH_RELEASE_OUTSIDE,this.touchEnd,this),this.initTouchCache())},t.initTouchCache=function(){this._totalTouchCount=0,this._touchIndex=0,this._gameTouchs.length=0;for(var t=0;t<this.maxSupportedTouch;t++)this._gameTouchs.push(new TouchState)},t.touchBegin=function(t){this._touchIndex<this.maxSupportedTouch&&(this._gameTouchs[this._touchIndex].touchPoint=t.touchPointID,this._gameTouchs[this._touchIndex].touchDown=t.touchDown,this._gameTouchs[this._touchIndex].x=t.stageX,this._gameTouchs[this._touchIndex].y=t.stageY,0==this._touchIndex&&this.setpreviousTouchState(this._gameTouchs[0]),this._touchIndex++,this._totalTouchCount++)},t.touchMove=function(t){t.touchPointID==this._gameTouchs[0].touchPoint&&this.setpreviousTouchState(this._gameTouchs[0]);var e=this._gameTouchs.findIndex(function(e){return e.touchPoint==t.touchPointID});if(-1!=e){var n=this._gameTouchs[e];n.x=t.stageX,n.y=t.stageY}},t.touchEnd=function(t){var e=this._gameTouchs.findIndex(function(e){return e.touchPoint==t.touchPointID});-1!=e&&(this._gameTouchs[e].reset(),0==e&&this._previousTouchState.reset(),this._totalTouchCount--,0==this.totalTouchCount&&(this._touchIndex=0))},t.setpreviousTouchState=function(t){this._previousTouchState=new TouchState,this._previousTouchState.x=t.position.x,this._previousTouchState.y=t.position.y,this._previousTouchState.touchPoint=t.touchPoint,this._previousTouchState.touchDown=t.touchDown},t.scaledPosition=function(t){var e=new Vector2(t.x-this._resolutionOffset.x,t.y-this._resolutionOffset.y);return Vector2.multiply(e,this.resolutionScale)},t._init=!1,t._previousTouchState=new TouchState,t._gameTouchs=[],t._resolutionOffset=new Vector2,t._resolutionScale=Vector2.one,t._touchIndex=0,t._totalTouchCount=0,t}(),KeyboardUtils=function(){function t(){}return t.init=function(){this.keyDownDict={},this.keyUpDict={},document.addEventListener("keydown",this.onKeyDonwHander),document.addEventListener("keyup",this.onKeyUpHander)},t.onKeyDonwHander=function(t){if(this.keyDownDict){var e=this.keyCodeToString(t.keyCode),n=this.keyDownDict[e];if(n){var i=n.fun,r=n.thisObj,o=n.args;i.apply(r,o)}}},t.onKeyUpHander=function(t){if(this.keyUpDict){var e=this.keyCodeToString(t.keyCode),n=this.keyUpDict[e];if(n){var i=n.fun,r=n.thisObj,o=n.args;i.apply(r,o)}}},t.registerKey=function(t,e,n,i){void 0===i&&(i=0);for(var r=[],o=4;o<arguments.length;o++)r[o-4]=arguments[o];(i?this.keyUpDict:this.keyDownDict)[t]={fun:e,args:r,thisObj:n}},t.unregisterKey=function(t,e){void 0===e&&(e=0),delete(e?this.keyUpDict:this.keyDownDict)[t]},t.keyCodeToString=function(t){switch(t){case 8:return this.BACK_SPACE;case 9:return this.TAB;case 13:return this.ENTER;case 16:return this.SHIFT;case 17:return this.CTRL;case 19:return this.PAUSE_BREAK;case 20:return this.CAPS_LOCK;case 27:return this.ESC;case 32:return this.SPACE;case 33:return this.PAGE_UP;case 34:return this.PAGE_DOWN;case 35:return this.END;case 36:return this.HOME;case 37:return this.LEFT;case 38:return this.UP;case 39:return this.RIGHT;case 40:return this.DOWN;case 45:return this.INSERT;case 46:return this.DELETE;case 91:return this.WINDOWS;case 112:return this.F1;case 113:return this.F2;case 114:return this.F3;case 115:return this.F4;case 116:return this.F5;case 117:return this.F6;case 118:return this.F7;case 119:return this.F8;case 120:return this.F9;case 122:return this.F11;case 123:return this.F12;case 144:return this.NUM_LOCK;case 145:return this.SCROLL_LOCK;default:return String.fromCharCode(t)}},t.destroy=function(){this.keyDownDict=null,this.keyUpDict=null,document.removeEventListener("keydown",this.onKeyDonwHander),document.removeEventListener("keyup",this.onKeyUpHander)},t.TYPE_KEY_DOWN=0,t.TYPE_KEY_UP=1,t.A="A",t.B="B",t.C="C",t.D="D",t.E="E",t.F="F",t.G="G",t.H="H",t.I="I",t.J="J",t.K="K",t.L="L",t.M="M",t.N="N",t.O="O",t.P="P",t.Q="Q",t.R="R",t.S="S",t.T="T",t.U="U",t.V="V",t.W="W",t.X="X",t.Y="Y",t.Z="Z",t.ESC="Esc",t.F1="F1",t.F2="F2",t.F3="F3",t.F4="F4",t.F5="F5",t.F6="F6",t.F7="F7",t.F8="F8",t.F9="F9",t.F10="F10",t.F11="F11",t.F12="F12",t.NUM_1="1",t.NUM_2="2",t.NUM_3="3",t.NUM_4="4",t.NUM_5="5",t.NUM_6="6",t.NUM_7="7",t.NUM_8="8",t.NUM_9="9",t.NUM_0="0",t.TAB="Tab",t.CTRL="Ctrl",t.ALT="Alt",t.SHIFT="Shift",t.CAPS_LOCK="Caps Lock",t.ENTER="Enter",t.SPACE="Space",t.BACK_SPACE="Back Space",t.INSERT="Insert",t.DELETE="Page Down",t.HOME="Home",t.END="Page Down",t.PAGE_UP="Page Up",t.PAGE_DOWN="Page Down",t.LEFT="Left",t.RIGHT="Right",t.UP="Up",t.DOWN="Down",t.PAUSE_BREAK="Pause Break",t.NUM_LOCK="Num Lock",t.SCROLL_LOCK="Scroll Lock",t.WINDOWS="Windows",t}(),ListPool=function(){function t(){}return t.warmCache=function(t){if((t-=this._objectQueue.length)>0)for(var e=0;e<t;e++)this._objectQueue.unshift([])},t.trimCache=function(t){for(;t>this._objectQueue.length;)this._objectQueue.shift()},t.clearCache=function(){this._objectQueue.length=0},t.obtain=function(){return this._objectQueue.length>0?this._objectQueue.shift():[]},t.free=function(t){this._objectQueue.unshift(t),t.length=0},t._objectQueue=[],t}(),THREAD_ID=Math.floor(1e3*Math.random())+"-"+Date.now(),setItem=egret.localStorage.setItem.bind(localStorage),getItem=egret.localStorage.getItem.bind(localStorage),removeItem=egret.localStorage.removeItem.bind(localStorage),nextTick=function(t){setTimeout(t,0)},LockUtils=function(){function t(t){this._keyX="mutex_key_"+t+"_X",this._keyY="mutex_key_"+t+"_Y"}return t.prototype.lock=function(){var t=this;return new Promise(function(e,n){var i=function(){setItem(t._keyX,THREAD_ID),null===!getItem(t._keyY)&&nextTick(i),setItem(t._keyY,THREAD_ID),getItem(t._keyX)!==THREAD_ID?setTimeout(function(){getItem(t._keyY)===THREAD_ID?(e(),removeItem(t._keyY)):nextTick(i)},10):(e(),removeItem(t._keyY))};i()})},t}(),Pair=function(){function t(t,e){this.first=t,this.second=e}return t.prototype.clear=function(){this.first=this.second=null},t.prototype.equals=function(t){return this.first==t.first&&this.second==t.second},t}(),RandomUtils=function(){function t(){}return t.randrange=function(t,e,n){if(void 0===n&&(n=1),0==n)throw new Error("step 不能为 0");var i=e-t;if(0==i)throw new Error("没有可用的范围("+t+","+e+")");i<0&&(i=t-e);var r=Math.floor((i+n-1)/n);return Math.floor(this.random()*r)*n+Math.min(t,e)},t.randint=function(t,e){return(t=Math.floor(t))>(e=Math.floor(e))?t++:e++,this.randrange(t,e)},t.randnum=function(t,e){return this.random()*(e-t)+t},t.shuffle=function(t){return t.sort(this._randomCompare),t},t._randomCompare=function(t,e){return this.random()>.5?1:-1},t.choice=function(t){if(!t.hasOwnProperty("length"))throw new Error("无法对此对象执行此操作");var e=Math.floor(this.random()*t.length);return t instanceof String?String(t).charAt(e):t[e]},t.sample=function(t,e){var n=t.length;if(e<=0||n<e)throw new Error("采样数量不够");for(var i=[],r=[],o=0;o<e;o++){for(var s=Math.floor(this.random()*n);r.indexOf(s)>=0;)s=Math.floor(this.random()*n);i.push(t[s]),r.push(s)}return i},t.random=function(){return Math.random()},t.boolean=function(t){return void 0===t&&(t=.5),this.random()<t},t}(),RectangleExt=function(){function t(){}return t.union=function(t,e){var n=new Rectangle(e.x,e.y,0,0),i=new Rectangle;return i.x=Math.min(t.x,n.x),i.y=Math.min(t.y,n.y),i.width=Math.max(t.right,n.right)-i.x,i.height=Math.max(t.bottom,i.bottom)-i.y,i},t}(),Triangulator=function(){function t(){this.triangleIndices=[],this._triPrev=new Array(12),this._triNext=new Array(12)}return t.prototype.triangulate=function(e,n){void 0===n&&(n=!0);var i=e.length;this.initialize(i);for(var r=0,o=0;i>3&&r<500;){r++;var s=!0,a=e[this._triPrev[o]],c=e[o],h=e[this._triNext[o]];if(Vector2Ext.isTriangleCCW(a,c,h)){var u=this._triNext[this._triNext[o]];do{if(t.testPointTriangle(e[u],a,c,h)){s=!1;break}u=this._triNext[u]}while(u!=this._triPrev[o])}else s=!1;s?(this.triangleIndices.push(this._triPrev[o]),this.triangleIndices.push(o),this.triangleIndices.push(this._triNext[o]),this._triNext[this._triPrev[o]]=this._triNext[o],this._triPrev[this._triNext[o]]=this._triPrev[o],i--,o=this._triPrev[o]):o=this._triNext[o]}this.triangleIndices.push(this._triPrev[o]),this.triangleIndices.push(o),this.triangleIndices.push(this._triNext[o]),n||this.triangleIndices.reverse()},t.prototype.initialize=function(t){this.triangleIndices.length=0,this._triNext.length<t&&(this._triNext.reverse(),this._triNext=new Array(Math.max(2*this._triNext.length,t))),this._triPrev.length<t&&(this._triPrev.reverse(),this._triPrev=new Array(Math.max(2*this._triPrev.length,t)));for(var e=0;e<t;e++)this._triPrev[e]=e-1,this._triNext[e]=e+1;this._triPrev[0]=t-1,this._triNext[t-1]=0},t.testPointTriangle=function(t,e,n,i){return!(Vector2Ext.cross(Vector2.subtract(t,e),Vector2.subtract(n,e))<0)&&(!(Vector2Ext.cross(Vector2.subtract(t,n),Vector2.subtract(i,n))<0)&&!(Vector2Ext.cross(Vector2.subtract(t,i),Vector2.subtract(e,i))<0))},t}(),Vector2Ext=function(){function t(){}return t.isTriangleCCW=function(t,e,n){return this.cross(Vector2.subtract(e,t),Vector2.subtract(n,e))<0},t.cross=function(t,e){return t.y*e.x-t.x*e.y},t.perpendicular=function(t,e){return new Vector2(-1*(e.y-t.y),e.x-t.x)},t.normalize=function(t){var e=Math.sqrt(t.x*t.x+t.y*t.y);return e>MathHelper.Epsilon?t=Vector2.divide(t,new Vector2(e)):t.x=t.y=0,t},t.transformA=function(t,e,n,i,r,o){for(var s=0;s<o;s++){var a=t[e+s],c=i[r+s];c.x=a.x*n.m11+a.y*n.m21+n.m31,c.y=a.x*n.m12+a.y*n.m22+n.m32,i[r+s]=c}},t.transformR=function(t,e){var n=t.x*e.m11+t.y*e.m21+e.m31,i=t.x*e.m12+t.y*e.m22+e.m32;return new Vector2(n,i)},t.transform=function(t,e,n){this.transformA(t,0,e,n,0,t.length)},t.round=function(t){return new Vector2(Math.round(t.x),Math.round(t.y))},t}(),WebGLUtils=function(){function t(){}return t.getContext=function(){return document.getElementsByTagName("canvas")[0].getContext("2d")},t}(),Layout=function(){function t(){this.clientArea=new Rectangle(0,0,SceneManager.stage.stageWidth,SceneManager.stage.stageHeight),this.safeArea=this.clientArea}return t.prototype.place=function(t,e,n,i){var r=new Rectangle(0,0,t.x,t.y);return 0!=(i&Alignment.left)?r.x=this.clientArea.x+this.clientArea.width*e:0!=(i&Alignment.right)?r.x=this.clientArea.x+this.clientArea.width*(1-e)-r.width:0!=(i&Alignment.horizontalCenter)&&(r.x=this.clientArea.x+(this.clientArea.width-r.width)/2+e*this.clientArea.width),0!=(i&Alignment.top)?r.y=this.clientArea.y+this.clientArea.height*n:0!=(i&Alignment.bottom)?r.y=this.clientArea.y+this.clientArea.height*(1-n)-r.height:0!=(i&Alignment.verticalCenter)&&(r.y=this.clientArea.y+(this.clientArea.height-r.height)/2+n*this.clientArea.height),r.left<this.safeArea.left&&(r.x=this.safeArea.left),r.right>this.safeArea.right&&(r.x=this.safeArea.right-r.width),r.top<this.safeArea.top&&(r.y=this.safeArea.top),r.bottom>this.safeArea.bottom&&(r.y=this.safeArea.bottom-r.height),r},t}();!function(t){t[t.none=0]="none",t[t.left=1]="left",t[t.right=2]="right",t[t.horizontalCenter=4]="horizontalCenter",t[t.top=8]="top",t[t.bottom=16]="bottom",t[t.verticalCenter=32]="verticalCenter",t[t.topLeft=9]="topLeft",t[t.topRight=10]="topRight",t[t.topCenter=12]="topCenter",t[t.bottomLeft=17]="bottomLeft",t[t.bottomRight=18]="bottomRight",t[t.bottomCenter=20]="bottomCenter",t[t.centerLeft=33]="centerLeft",t[t.centerRight=34]="centerRight",t[t.center=36]="center"}(Alignment||(Alignment={})),function(t){var e,n=function(){function t(t){void 0===t&&(t=i),this.getSystemTime=t,this._stopDuration=0,this._completeSlices=[]}return t.prototype.getState=function(){return void 0===this._startSystemTime?e.IDLE:void 0===this._stopSystemTime?e.RUNNING:e.STOPPED},t.prototype.isIdle=function(){return this.getState()===e.IDLE},t.prototype.isRunning=function(){return this.getState()===e.RUNNING},t.prototype.isStopped=function(){return this.getState()===e.STOPPED},t.prototype.slice=function(){return this.recordPendingSlice()},t.prototype.getCompletedSlices=function(){return Array.from(this._completeSlices)},t.prototype.getCompletedAndPendingSlices=function(){return this._completeSlices.concat([this.getPendingSlice()])},t.prototype.getPendingSlice=function(){return this.calculatePendingSlice()},t.prototype.getTime=function(){return this.caculateStopwatchTime()},t.prototype.calculatePendingSlice=function(t){return void 0===this._pendingSliceStartStopwatchTime?Object.freeze({startTime:0,endTime:0,duration:0}):(void 0===t&&(t=this.getTime()),Object.freeze({startTime:this._pendingSliceStartStopwatchTime,endTime:t,duration:t-this._pendingSliceStartStopwatchTime}))},t.prototype.caculateStopwatchTime=function(t){return void 0===this._startSystemTime?0:(void 0===t&&(t=this.getSystemTimeOfCurrentStopwatchTime()),t-this._startSystemTime-this._stopDuration)},t.prototype.getSystemTimeOfCurrentStopwatchTime=function(){return void 0===this._stopSystemTime?this.getSystemTime():this._stopSystemTime},t.prototype.reset=function(){this._startSystemTime=this._pendingSliceStartStopwatchTime=this._stopSystemTime=void 0,this._stopDuration=0,this._completeSlices=[]},t.prototype.start=function(t){if(void 0===t&&(t=!1),t&&this.reset(),void 0!==this._stopSystemTime){var e=(n=this.getSystemTime())-this._stopSystemTime;this._stopDuration+=e,this._stopSystemTime=void 0}else if(void 0===this._startSystemTime){var n=this.getSystemTime();this._startSystemTime=n,this._pendingSliceStartStopwatchTime=0}},t.prototype.stop=function(t){if(void 0===t&&(t=!1),void 0===this._startSystemTime)return 0;var e=this.getSystemTimeOfCurrentStopwatchTime();return t&&this.recordPendingSlice(this.caculateStopwatchTime(e)),this._stopSystemTime=e,this.getTime()},t.prototype.recordPendingSlice=function(t){if(void 0!==this._pendingSliceStartStopwatchTime){void 0===t&&(t=this.getTime());var e=this.calculatePendingSlice(t);return this._pendingSliceStartStopwatchTime=e.endTime,this._completeSlices.push(e),e}return this.calculatePendingSlice()},t}();t.Stopwatch=n,function(t){t.IDLE="IDLE",t.RUNNING="RUNNING",t.STOPPED="STOPPED"}(e||(e={})),t.setDefaultSystemTimeGetter=function(t){void 0===t&&(t=Date.now),i=t};var i=Date.now}(stopwatch||(stopwatch={}));var TimeRuler=function(){function t(){this._frameKey="frame",this._logKey="log",this.markers=[],this.stopwacth=new stopwatch.Stopwatch,this._markerNameToIdMap=new Map,this.showLog=!1,t.Instance=this,this._logs=new Array(2);for(var e=0;e<this._logs.length;++e)this._logs[e]=new FrameLog;this.sampleFrames=this.targetSampleFrames=1,this.width=.8*SceneManager.stage.stageWidth,this.onGraphicsDeviceReset()}return t.prototype.onGraphicsDeviceReset=function(){var e=new Layout;this._position=e.place(new Vector2(this.width,t.barHeight),0,.01,Alignment.bottomCenter).location},t.prototype.startFrame=function(){var e=this;new LockUtils(this._frameKey).lock().then(function(){e._updateCount=parseInt(egret.localStorage.getItem(e._frameKey),10),isNaN(e._updateCount)&&(e._updateCount=0);var n=e._updateCount;if(n+=1,egret.localStorage.setItem(e._frameKey,n.toString()),!(e.enabled&&1<n&&n<t.maxSampleFrames)){e._prevLog=e._logs[1&e.frameCount++],e._curLog=e._logs[1&e.frameCount];for(var i=e.stopwacth.getTime(),r=0;r<e._prevLog.bars.length;++r){for(var o=e._prevLog.bars[r],s=e._curLog.bars[r],a=0;a<o.nestCount;++a){var c=o.markerNests[a];o.markers[c].endTime=i,s.markerNests[a]=a,s.markers[a].markerId=o.markers[c].markerId,s.markers[a].beginTime=0,s.markers[a].endTime=-1,s.markers[a].color=o.markers[c].color}for(c=0;c<o.markCount;++c){var h=o.markers[c].endTime-o.markers[c].beginTime,u=o.markers[c].markerId,l=e.markers[u];l.logs[r].color=o.markers[c].color,l.logs[r].initialized?(l.logs[r].min=Math.min(l.logs[r].min,h),l.logs[r].max=Math.min(l.logs[r].max,h),l.logs[r].avg+=h,l.logs[r].avg*=.5,l.logs[r].samples++>=t.logSnapDuration&&(l.logs[r].snapMin=l.logs[r].min,l.logs[r].snapMax=l.logs[r].max,l.logs[r].snapAvg=l.logs[r].avg,l.logs[r].samples=0)):(l.logs[r].min=h,l.logs[r].max=h,l.logs[r].avg=h,l.logs[r].initialized=!0)}s.markCount=o.nestCount,s.nestCount=o.nestCount}e.stopwacth.reset(),e.stopwacth.start()}})},t.prototype.beginMark=function(e,n,i){var r=this;void 0===i&&(i=0),new LockUtils(this._frameKey).lock().then(function(){if(i<0||i>=t.maxBars)throw new Error("barIndex argument out of range");var o=r._curLog.bars[i];if(o.markCount>=t.maxSamples)throw new Error("exceeded sample count. either set larger number to timeruler.maxsaple or lower sample count");if(o.nestCount>=t.maxNestCall)throw new Error("exceeded nest count. either set larger number to timeruler.maxnestcall or lower nest calls");var s=r._markerNameToIdMap.get(e);isNaN(s)&&(s=r.markers.length,r._markerNameToIdMap.set(e,s)),o.markerNests[o.nestCount++]=o.markCount,o.markers[o.markCount].markerId=s,o.markers[o.markCount].color=n,o.markers[o.markCount].beginTime=r.stopwacth.getTime(),o.markers[o.markCount].endTime=-1})},t.prototype.endMark=function(e,n){var i=this;void 0===n&&(n=0),new LockUtils(this._frameKey).lock().then(function(){if(n<0||n>=t.maxBars)throw new Error("barIndex argument out of range");var r=i._curLog.bars[n];if(r.nestCount<=0)throw new Error("call beginMark method before calling endMark method");var o=i._markerNameToIdMap.get(e);if(isNaN(o))throw new Error("Marker "+e+" is not registered. Make sure you specifed same name as you used for beginMark method");var s=r.markerNests[--r.nestCount];if(r.markers[s].markerId!=o)throw new Error("Incorrect call order of beginMark/endMark method. beginMark(A), beginMark(B), endMark(B), endMark(A) But you can't called it like beginMark(A), beginMark(B), endMark(A), endMark(B).");r.markers[s].endTime=i.stopwacth.getTime()})},t.prototype.getAverageTime=function(e,n){if(e<0||e>=t.maxBars)throw new Error("barIndex argument out of range");var i=0,r=this._markerNameToIdMap.get(n);return r&&(i=this.markers[r].logs[e].avg),i},t.prototype.resetLog=function(){var t=this;new LockUtils(this._logKey).lock().then(function(){var e=parseInt(egret.localStorage.getItem(t._logKey),10);e+=1,egret.localStorage.setItem(t._logKey,e.toString()),t.markers.forEach(function(t){for(var e=0;e<t.logs.length;++e)t.logs[e].initialized=!1,t.logs[e].snapMin=0,t.logs[e].snapMax=0,t.logs[e].snapAvg=0,t.logs[e].min=0,t.logs[e].max=0,t.logs[e].avg=0,t.logs[e].samples=0})})},t.prototype.render=function(e,n){if(void 0===e&&(e=this._position),void 0===n&&(n=this.width),egret.localStorage.setItem(this._frameKey,"0"),this.showLog){var i=0,r=0;this._prevLog.bars.forEach(function(e){e.markCount>0&&(i+=t.barHeight+2*t.barPadding,r=Math.max(r,e.markers[e.markCount-1].endTime))});var o=this.sampleFrames*(1/60*1e3);this._frameAdjust=r>o?Math.max(0,this._frameAdjust)+1:Math.min(0,this._frameAdjust)-1,Math.max(this._frameAdjust)>t.autoAdjustDelay&&(this.sampleFrames=Math.min(t.maxSampleFrames,this.sampleFrames),this.sampleFrames=Math.max(this.targetSampleFrames,r/(1/60*1e3)+1),this._frameAdjust=0);e.y,t.barHeight}},t.maxBars=8,t.maxSamples=256,t.maxNestCall=32,t.barHeight=8,t.maxSampleFrames=4,t.logSnapDuration=120,t.barPadding=2,t.autoAdjustDelay=30,t}(),FrameLog=function(){return function(){this.bars=new Array(TimeRuler.maxBars),this.bars.fill(new MarkerCollection,0,TimeRuler.maxBars)}}(),MarkerCollection=function(){return function(){this.markers=new Array(TimeRuler.maxSamples),this.markCount=0,this.markerNests=new Array(TimeRuler.maxNestCall),this.nestCount=0,this.markers.fill(new Marker,0,TimeRuler.maxSamples),this.markerNests.fill(0,0,TimeRuler.maxNestCall)}}(),Marker=function(){return function(){this.markerId=0,this.beginTime=0,this.endTime=0,this.color=0}}(),MarkerInfo=function(){return function(t){this.logs=new Array(TimeRuler.maxBars),this.name=t,this.logs.fill(new MarkerLog,0,TimeRuler.maxBars)}}(),MarkerLog=function(){return function(){this.snapMin=0,this.snapMax=0,this.snapAvg=0,this.min=0,this.max=0,this.avg=0,this.samples=0,this.color=0,this.initialized=!1}}();
\ No newline at end of file
+window.framework={},window.__extends=this&&this.__extends||function(){var t=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(t,e){t.__proto__=e}||function(t,e){for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n])};return function(e,n){function i(){this.constructor=e}t(e,n),e.prototype=null===n?Object.create(n):(i.prototype=n.prototype,new i)}}();var transform,__awaiter=this&&this.__awaiter||function(t,e,n,i){return new(n||(n=Promise))(function(r,o){function s(t){try{c(i.next(t))}catch(t){o(t)}}function a(t){try{c(i.throw(t))}catch(t){o(t)}}function c(t){t.done?r(t.value):new n(function(e){e(t.value)}).then(s,a)}c((i=i.apply(t,e||[])).next())})},__generator=this&&this.__generator||function(t,e){var n,i,r,o,s={label:0,sent:function(){if(1&r[0])throw r[1];return r[1]},trys:[],ops:[]};return o={next:a(0),throw:a(1),return:a(2)},"function"==typeof Symbol&&(o[Symbol.iterator]=function(){return this}),o;function a(o){return function(a){return function(o){if(n)throw new TypeError("Generator is already executing.");for(;s;)try{if(n=1,i&&(r=2&o[0]?i.return:o[0]?i.throw||((r=i.return)&&r.call(i),0):i.next)&&!(r=r.call(i,o[1])).done)return r;switch(i=0,r&&(o=[2&o[0],r.value]),o[0]){case 0:case 1:r=o;break;case 4:return s.label++,{value:o[1],done:!1};case 5:s.label++,i=o[1],o=[0];continue;case 7:o=s.ops.pop(),s.trys.pop();continue;default:if(!(r=(r=s.trys).length>0&&r[r.length-1])&&(6===o[0]||2===o[0])){s=0;continue}if(3===o[0]&&(!r||o[1]>r[0]&&o[1]<r[3])){s.label=o[1];break}if(6===o[0]&&s.label<r[1]){s.label=r[1],r=o;break}if(r&&s.label<r[2]){s.label=r[2],s.ops.push(o);break}r[2]&&s.ops.pop(),s.trys.pop();continue}o=e.call(t,s)}catch(t){o=[6,t],i=0}finally{n=r=0}if(5&o[0])throw o[1];return{value:o[0]?o[1]:void 0,done:!0}}([o,a])}}};Array.prototype.findIndex=function(t){return function(t,e){for(var n=0,i=t.length;n<i;n++)if(e.call(arguments[2],t[n],n,t))return n;return-1}(this,t)},Array.prototype.any=function(t){return function(t,e){return t.findIndex(e)>-1}(this,t)},Array.prototype.firstOrDefault=function(t){return function(t,e){var n=t.findIndex(e);return-1==n?null:t[n]}(this,t)},Array.prototype.find=function(t){return function(t,e){return t.firstOrDefault(e)}(this,t)},Array.prototype.where=function(t){return function(t,e){if("function"==typeof t.reduce)return t.reduce(function(n,i,r){return e.call(arguments[2],i,r,t)&&n.push(i),n},[]);for(var n=[],i=0,r=t.length;i<r;i++){var o=t[i];e.call(arguments[2],o,i,t)&&n.push(o)}return n}(this,t)},Array.prototype.count=function(t){return function(t,e){return t.where(e).length}(this,t)},Array.prototype.findAll=function(t){return function(t,e){return t.where(e)}(this,t)},Array.prototype.contains=function(t){return function(t,e){for(var n=0,i=t.length;n<i;n++)if(t[n]==e)return!0;return!1}(this,t)},Array.prototype.removeAll=function(t){!function(t,e){var n;do{(n=t.findIndex(e))>=0&&t.splice(n,1)}while(n>=0)}(this,t)},Array.prototype.remove=function(t){return function(t,e){var n=t.findIndex(function(t){return t===e});return n>=0&&(t.splice(n,1),!0)}(this,t)},Array.prototype.removeAt=function(t){return function(t,e){t.splice(e,1)}(this,t)},Array.prototype.removeRange=function(t,e){return function(t,e,n){t.splice(e,n)}(this,t,e)},Array.prototype.select=function(t){return function(t,e){if("function"==typeof t.reduce)return t.reduce(function(n,i,r){return n.push(e.call(arguments[2],i,r,t)),n},[]);for(var n=[],i=0,r=t.length;i<r;i++)n.push(e.call(arguments[2],t[i],i,t));return n}(this,t)},Array.prototype.orderBy=function(t,e){return function(t,e,n){return t.sort(function(t,i){var r=e(t),o=e(i);return n?n(r,o):r>o?1:-1}),t}(this,t,e)},Array.prototype.orderByDescending=function(t,e){return function(t,e,n){return t.sort(function(t,i){var r=e(t),o=e(i);return n?-n(r,o):r<o?1:-1}),t}(this,t,e)},Array.prototype.groupBy=function(t){return function(t,e){if("function"==typeof t.reduce){var n=[];return t.reduce(function(i,r,o){var s=JSON.stringify(e.call(arguments[1],r,o,t)),a=n.findIndex(function(t){return t===s});return a<0&&(a=n.push(s)-1),i[a]||(i[a]=[]),i[a].push(r),i},[])}for(var i=[],r=[],o=function(n,o){var a=JSON.stringify(e.call(s[1],t[n],n,t)),c=r.findIndex(function(t){return t===a});c<0&&(c=r.push(a)-1),i[c]||(i[c]=[]),i[c].push(t[n])},s=arguments,a=0,c=t.length;a<c;a++)o(a);return i}(this,t)},Array.prototype.sum=function(t){return function(t,e){for(var n,i=0,r=t.length;i<r;i++)0==i?n=e?e.call(arguments[2],t[i],i,t):t[i]:n+=e?e.call(arguments[2],t[i],i,t):t[i];return n}(this,t)},function(t){var e=function(){return function(){this.priority=0,this.insertionIndex=0,this.queueIndex=0}}();t.PriorityQueueNode=e}(es||(es={})),function(t){var e=function(){function e(){}return e.search=function(e,i,r){var o=this,s=!1,a=new Map;a.set(i,i);var c=new Map,h=new t.PriorityQueue(1e3);h.enqueue(new n(i),0),c.set(i,0);for(var u=function(){var t=h.dequeue();if(JSON.stringify(t.data)==JSON.stringify(r))return s=!0,"break";e.getNeighbors(t.data).forEach(function(i){var s=c.get(t.data)+e.cost(t.data,i);if(!o.hasKey(c,i)||s<c.get(i)){c.set(i,s);var u=s+e.heuristic(i,r);h.enqueue(new n(i),u),a.set(i,t.data)}})};h.count>0;){if("break"===u())break}return s?this.recontructPath(a,i,r):null},e.hasKey=function(t,e){for(var n,i=t.keys();!(n=i.next()).done;)if(JSON.stringify(n.value)==JSON.stringify(e))return!0;return!1},e.getKey=function(t,e){for(var n,i,r=t.keys(),o=t.values();n=r.next(),i=o.next(),!n.done;)if(JSON.stringify(n.value)==JSON.stringify(e))return i.value;return null},e.recontructPath=function(t,e,n){var i=[],r=n;for(i.push(n);r!=e;)r=this.getKey(t,r),i.push(r);return i.reverse(),i},e}();t.AStarPathfinder=e;var n=function(t){function e(e){var n=t.call(this)||this;return n.data=e,n}return __extends(e,t),e}(t.PriorityQueueNode);t.AStarNode=n}(es||(es={})),function(t){var e=function(){function e(e,n){this.dirs=[new t.Vector2(1,0),new t.Vector2(0,-1),new t.Vector2(-1,0),new t.Vector2(0,1)],this.walls=[],this.weightedNodes=[],this.defaultWeight=1,this.weightedNodeWeight=5,this._neighbors=new Array(4),this._width=e,this._height=n}return e.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._height},e.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},e.prototype.search=function(e,n){return t.AStarPathfinder.search(this,e,n)},e.prototype.getNeighbors=function(e){var n=this;return this._neighbors.length=0,this.dirs.forEach(function(i){var r=new t.Vector2(e.x+i.x,e.y+i.y);n.isNodeInBounds(r)&&n.isNodePassable(r)&&n._neighbors.push(r)}),this._neighbors},e.prototype.cost=function(t,e){return this.weightedNodes.find(function(t){return JSON.stringify(t)==JSON.stringify(e)})?this.weightedNodeWeight:this.defaultWeight},e.prototype.heuristic=function(t,e){return Math.abs(t.x-e.x)+Math.abs(t.y-e.y)},e}();t.AstarGridGraph=e}(es||(es={})),function(t){var e=function(){function t(t){this._numNodes=0,this._nodes=new Array(t+1),this._numNodesEverEnqueued=0}return t.prototype.clear=function(){this._nodes.splice(1,this._numNodes),this._numNodes=0},Object.defineProperty(t.prototype,"count",{get:function(){return this._numNodes},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"maxSize",{get:function(){return this._nodes.length-1},enumerable:!0,configurable:!0}),t.prototype.contains=function(t){return t?t.queueIndex<0||t.queueIndex>=this._nodes.length?(console.error("node.QueueIndex has been corrupted. Did you change it manually? Or add this node to another queue?"),!1):this._nodes[t.queueIndex]==t:(console.error("node cannot be null"),!1)},t.prototype.enqueue=function(t,e){t.priority=e,this._numNodes++,this._nodes[this._numNodes]=t,t.queueIndex=this._numNodes,t.insertionIndex=this._numNodesEverEnqueued++,this.cascadeUp(this._nodes[this._numNodes])},t.prototype.dequeue=function(){var t=this._nodes[1];return this.remove(t),t},t.prototype.remove=function(t){if(t.queueIndex==this._numNodes)return this._nodes[this._numNodes]=null,void this._numNodes--;var e=this._nodes[this._numNodes];this.swap(t,e),delete this._nodes[this._numNodes],this._numNodes--,this.onNodeUpdated(e)},t.prototype.isValidQueue=function(){for(var t=1;t<this._nodes.length;t++)if(this._nodes[t]){var e=2*t;if(e<this._nodes.length&&this._nodes[e]&&this.hasHigherPriority(this._nodes[e],this._nodes[t]))return!1;var n=e+1;if(n<this._nodes.length&&this._nodes[n]&&this.hasHigherPriority(this._nodes[n],this._nodes[t]))return!1}return!0},t.prototype.onNodeUpdated=function(t){var e=Math.floor(t.queueIndex/2),n=this._nodes[e];e>0&&this.hasHigherPriority(t,n)?this.cascadeUp(t):this.cascadeDown(t)},t.prototype.cascadeDown=function(t){for(var e,n=t.queueIndex;;){e=t;var i=2*n;if(i>this._numNodes){t.queueIndex=n,this._nodes[n]=t;break}var r=this._nodes[i];this.hasHigherPriority(r,e)&&(e=r);var o=i+1;if(o<=this._numNodes){var s=this._nodes[o];this.hasHigherPriority(s,e)&&(e=s)}if(e==t){t.queueIndex=n,this._nodes[n]=t;break}this._nodes[n]=e;var a=e.queueIndex;e.queueIndex=n,n=a}},t.prototype.cascadeUp=function(t){for(var e=Math.floor(t.queueIndex/2);e>=1;){var n=this._nodes[e];if(this.hasHigherPriority(n,t))break;this.swap(t,n),e=Math.floor(t.queueIndex/2)}},t.prototype.swap=function(t,e){this._nodes[t.queueIndex]=e,this._nodes[e.queueIndex]=t;var n=t.queueIndex;t.queueIndex=e.queueIndex,e.queueIndex=n},t.prototype.hasHigherPriority=function(t,e){return t.priority<e.priority||t.priority==e.priority&&t.insertionIndex<e.insertionIndex},t}();t.PriorityQueue=e}(es||(es={})),function(t){var e=function(){function e(){}return e.search=function(e,n,i){var r=this,o=!1,s=[];s.unshift(n);var a=new Map;a.set(n,n);for(var c=function(){var t=s.shift();if(JSON.stringify(t)==JSON.stringify(i))return o=!0,"break";e.getNeighbors(t).forEach(function(e){r.hasKey(a,e)||(s.unshift(e),a.set(e,t))})};s.length>0;){if("break"===c())break}return o?t.AStarPathfinder.recontructPath(a,n,i):null},e.hasKey=function(t,e){for(var n,i=t.keys();!(n=i.next()).done;)if(JSON.stringify(n.value)==JSON.stringify(e))return!0;return!1},e}();t.BreadthFirstPathfinder=e}(es||(es={})),function(t){var e=function(){function t(){this.edges=new Map}return t.prototype.addEdgesForNode=function(t,e){return this.edges.set(t,e),this},t.prototype.getNeighbors=function(t){return this.edges.get(t)},t}();t.UnweightedGraph=e}(es||(es={})),function(t){var e=function(){function e(t,e){this.x=0,this.y=0,this.x=t||0,this.y=e||this.x}return Object.defineProperty(e,"zero",{get:function(){return e.zeroVector2},enumerable:!0,configurable:!0}),Object.defineProperty(e,"one",{get:function(){return e.unitVector2},enumerable:!0,configurable:!0}),Object.defineProperty(e,"unitX",{get:function(){return e.unitXVector},enumerable:!0,configurable:!0}),Object.defineProperty(e,"unitY",{get:function(){return e.unitYVector},enumerable:!0,configurable:!0}),e.add=function(t,n){var i=new e(0,0);return i.x=t.x+n.x,i.y=t.y+n.y,i},e.divide=function(t,n){var i=new e(0,0);return i.x=t.x/n.x,i.y=t.y/n.y,i},e.multiply=function(t,n){var i=new e(0,0);return i.x=t.x*n.x,i.y=t.y*n.y,i},e.subtract=function(t,n){var i=new e(0,0);return i.x=t.x-n.x,i.y=t.y-n.y,i},e.prototype.normalize=function(){var t=1/Math.sqrt(this.x*this.x+this.y*this.y);this.x*=t,this.y*=t},e.prototype.length=function(){return Math.sqrt(this.x*this.x+this.y*this.y)},e.prototype.round=function(){return new e(Math.round(this.x),Math.round(this.y))},e.normalize=function(t){var e=1/Math.sqrt(t.x*t.x+t.y*t.y);return t.x*=e,t.y*=e,t},e.dot=function(t,e){return t.x*e.x+t.y*e.y},e.distanceSquared=function(t,e){var n=t.x-e.x,i=t.y-e.y;return n*n+i*i},e.clamp=function(n,i,r){return new e(t.MathHelper.clamp(n.x,i.x,r.x),t.MathHelper.clamp(n.y,i.y,r.y))},e.lerp=function(n,i,r){return new e(t.MathHelper.lerp(n.x,i.x,r),t.MathHelper.lerp(n.y,i.y,r))},e.transform=function(t,n){return new e(t.x*n.m11+t.y*n.m21,t.x*n.m12+t.y*n.m22)},e.distance=function(t,e){var n=t.x-e.x,i=t.y-e.y;return Math.sqrt(n*n+i*i)},e.negate=function(t){var n=new e;return n.x=-t.x,n.y=-t.y,n},e.unitYVector=new e(0,1),e.unitXVector=new e(1,0),e.unitVector2=new e(1,1),e.zeroVector2=new e(0,0),e}();t.Vector2=e}(es||(es={})),function(t){var e=function(){function e(t,n,i){void 0===i&&(i=!1),this.walls=[],this._neighbors=new Array(4),this._width=t,this._hegiht=n,this._dirs=i?e.COMPASS_DIRS:e.CARDINAL_DIRS}return e.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._hegiht},e.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},e.prototype.getNeighbors=function(e){var n=this;return this._neighbors.length=0,this._dirs.forEach(function(i){var r=new t.Vector2(e.x+i.x,e.y+i.y);n.isNodeInBounds(r)&&n.isNodePassable(r)&&n._neighbors.push(r)}),this._neighbors},e.prototype.search=function(e,n){return t.BreadthFirstPathfinder.search(this,e,n)},e.CARDINAL_DIRS=[new t.Vector2(1,0),new t.Vector2(0,-1),new t.Vector2(-1,0),new t.Vector2(0,-1)],e.COMPASS_DIRS=[new t.Vector2(1,0),new t.Vector2(1,-1),new t.Vector2(0,-1),new t.Vector2(-1,-1),new t.Vector2(-1,0),new t.Vector2(-1,1),new t.Vector2(0,1),new t.Vector2(1,1)],e}();t.UnweightedGridGraph=e}(es||(es={})),function(t){var e=function(){function e(t,n,i){void 0===i&&(i=!1),this.walls=[],this.weightedNodes=[],this.defaultWeight=1,this.weightedNodeWeight=5,this._neighbors=new Array(4),this._width=t,this._height=n,this._dirs=i?e.COMPASS_DIRS:e.CARDINAL_DIRS}return e.prototype.isNodeInBounds=function(t){return 0<=t.x&&t.x<this._width&&0<=t.y&&t.y<this._height},e.prototype.isNodePassable=function(t){return!this.walls.firstOrDefault(function(e){return JSON.stringify(e)==JSON.stringify(t)})},e.prototype.search=function(e,n){return t.WeightedPathfinder.search(this,e,n)},e.prototype.getNeighbors=function(e){var n=this;return this._neighbors.length=0,this._dirs.forEach(function(i){var r=new t.Vector2(e.x+i.x,e.y+i.y);n.isNodeInBounds(r)&&n.isNodePassable(r)&&n._neighbors.push(r)}),this._neighbors},e.prototype.cost=function(t,e){return this.weightedNodes.find(function(t){return JSON.stringify(t)==JSON.stringify(e)})?this.weightedNodeWeight:this.defaultWeight},e.CARDINAL_DIRS=[new t.Vector2(1,0),new t.Vector2(0,-1),new t.Vector2(-1,0),new t.Vector2(0,1)],e.COMPASS_DIRS=[new t.Vector2(1,0),new t.Vector2(1,-1),new t.Vector2(0,-1),new t.Vector2(-1,-1),new t.Vector2(-1,0),new t.Vector2(-1,1),new t.Vector2(0,1),new t.Vector2(1,1)],e}();t.WeightedGridGraph=e}(es||(es={})),function(t){var e=function(t){function e(e){var n=t.call(this)||this;return n.data=e,n}return __extends(e,t),e}(t.PriorityQueueNode);t.WeightedNode=e;var n=function(){function n(){}return n.search=function(n,i,r){var o=this,s=!1,a=new Map;a.set(i,i);var c=new Map,h=new t.PriorityQueue(1e3);h.enqueue(new e(i),0),c.set(i,0);for(var u=function(){var t=h.dequeue();if(JSON.stringify(t.data)==JSON.stringify(r))return s=!0,"break";n.getNeighbors(t.data).forEach(function(i){var r=c.get(t.data)+n.cost(t.data,i);if(!o.hasKey(c,i)||r<c.get(i)){c.set(i,r);var s=r;h.enqueue(new e(i),s),a.set(i,t.data)}})};h.count>0;){if("break"===u())break}return s?this.recontructPath(a,i,r):null},n.hasKey=function(t,e){for(var n,i=t.keys();!(n=i.next()).done;)if(JSON.stringify(n.value)==JSON.stringify(e))return!0;return!1},n.getKey=function(t,e){for(var n,i,r=t.keys(),o=t.values();n=r.next(),i=o.next(),!n.done;)if(JSON.stringify(n.value)==JSON.stringify(e))return i.value;return null},n.recontructPath=function(t,e,n){var i=[],r=n;for(i.push(n);r!=e;)r=this.getKey(t,r),i.push(r);return i.reverse(),i},n}();t.WeightedPathfinder=n}(es||(es={})),function(t){var e=function(){function e(){}return e.drawHollowRect=function(e,n,i){void 0===i&&(i=0),this._debugDrawItems.push(new t.DebugDrawItem(e,n,i))},e.render=function(){if(this._debugDrawItems.length>0){var e=new egret.Shape;t.SceneManager.scene&&t.SceneManager.scene.addChild(e);for(var n=this._debugDrawItems.length-1;n>=0;n--){this._debugDrawItems[n].draw(e)&&this._debugDrawItems.removeAt(n)}}},e._debugDrawItems=[],e}();t.Debug=e}(es||(es={})),function(t){var e=function(){function t(){}return t.verletParticle=14431326,t.verletConstraintEdge=4406838,t}();t.DebugDefaults=e}(es||(es={})),function(t){var e;!function(t){t[t.line=0]="line",t[t.hollowRectangle=1]="hollowRectangle",t[t.pixel=2]="pixel",t[t.text=3]="text"}(e=t.DebugDrawType||(t.DebugDrawType={}));var n=function(){function n(t,n,i){this.rectangle=t,this.color=n,this.duration=i,this.drawType=e.hollowRectangle}return n.prototype.draw=function(n){switch(this.drawType){case e.line:t.DrawUtils.drawLine(n,this.start,this.end,this.color);break;case e.hollowRectangle:t.DrawUtils.drawHollowRect(n,this.rectangle,this.color);break;case e.pixel:t.DrawUtils.drawPixel(n,new t.Vector2(this.x,this.y),this.color,this.size);break;case e.text:}return this.duration-=t.Time.deltaTime,this.duration<0},n}();t.DebugDrawItem=n}(es||(es={})),function(t){var e=function(){function t(){this.updateInterval=1,this._enabled=!0,this._updateOrder=0}return Object.defineProperty(t.prototype,"transform",{get:function(){return this.entity.transform},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"enabled",{get:function(){return this.entity?this.entity.enabled&&this._enabled:this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"updateOrder",{get:function(){return this._updateOrder},set:function(t){this.setUpdateOrder(t)},enumerable:!0,configurable:!0}),t.prototype.initialize=function(){},t.prototype.onAddedToEntity=function(){},t.prototype.onRemovedFromEntity=function(){},t.prototype.onEntityTransformChanged=function(t){},t.prototype.debugRender=function(){},t.prototype.onEnabled=function(){},t.prototype.onDisabled=function(){},t.prototype.update=function(){},t.prototype.setEnabled=function(t){return this._enabled!=t&&(this._enabled=t,this._enabled?this.onEnabled():this.onDisabled()),this},t.prototype.setUpdateOrder=function(t){return this._updateOrder!=t&&(this._updateOrder=t),this},t.prototype.clone=function(){var t=ObjectUtils.clone(this);return t.entity=null,t},t}();t.Component=e}(es||(es={})),function(t){!function(t){t[t.SceneChanged=0]="SceneChanged"}(t.CoreEvents||(t.CoreEvents={}))}(es||(es={})),function(t){var e=function(){function e(n){this.updateInterval=1,this._tag=0,this._enabled=!0,this._updateOrder=0,this.components=new t.ComponentList(this),this.transform=new t.Transform(this),this.name=n,this.id=e._idGenerator++,this.componentBits=new t.BitSet}return Object.defineProperty(e.prototype,"tag",{get:function(){return this._tag},set:function(t){this.setTag(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"enabled",{get:function(){return this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"updateOrder",{get:function(){return this._updateOrder},set:function(t){this.setUpdateOrder(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isDestroyed",{get:function(){return this._isDestroyed},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"parent",{get:function(){return this.transform.parent},set:function(t){this.transform.setParent(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"childCount",{get:function(){return this.transform.childCount},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"position",{get:function(){return this.transform.position},set:function(t){this.transform.setPosition(t.x,t.y)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"rotation",{get:function(){return this.transform.rotation},set:function(t){this.transform.setRotation(t)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"scale",{get:function(){return this.transform.scale},set:function(t){this.transform.setScale(t)},enumerable:!0,configurable:!0}),e.prototype.onTransformChanged=function(t){this.components.onEntityTransformChanged(t)},e.prototype.setTag=function(t){return this._tag!=t&&(this.scene&&this.scene.entities.removeFromTagList(this),this._tag=t,this.scene&&this.scene.entities.addToTagList(this)),this},e.prototype.setEnabled=function(t){return this._enabled!=t&&(this._enabled=t,this._enabled?this.components.onEntityEnabled():this.components.onEntityDisabled()),this},e.prototype.setUpdateOrder=function(t){if(this._updateOrder!=t)return this._updateOrder=t,this.scene,this},e.prototype.destroy=function(){this._isDestroyed=!0,this.scene.entities.remove(this),this.transform.parent=null;for(var t=this.transform.childCount-1;t>=0;t--){this.transform.getChild(t).entity.destroy()}},e.prototype.detachFromScene=function(){this.scene.entities.remove(this),this.components.deregisterAllComponents();for(var t=0;t<this.transform.childCount;t++)this.transform.getChild(t).entity.detachFromScene()},e.prototype.attachToScene=function(t){this.scene=t,t.entities.add(this),this.components.registerAllComponents();for(var e=0;e<this.transform.childCount;e++)this.transform.getChild(e).entity.attachToScene(t)},e.prototype.clone=function(n){void 0===n&&(n=new t.Vector2);var i=new e(this.name+"(clone)");return i.copyFrom(this),i.transform.position=n,i},e.prototype.copyFrom=function(t){this.tag=t.tag,this.updateInterval=t.updateInterval,this.updateOrder=t.updateOrder,this.enabled=t.enabled,this.transform.scale=t.transform.scale,this.transform.rotation=t.transform.rotation;for(var e=0;e<t.components.count;e++)this.addComponent(t.components.buffer[e].clone());for(e=0;e<t.components._componentsToAdd.length;e++)this.addComponent(t.components._componentsToAdd[e].clone());for(e=0;e<t.transform.childCount;e++){var n=t.transform.getChild(e).entity,i=n.clone();i.transform.copyFrom(n.transform),i.transform.parent=this.transform}},e.prototype.onAddedToScene=function(){},e.prototype.onRemovedFromScene=function(){this._isDestroyed&&this.components.removeAllComponents()},e.prototype.update=function(){this.components.update()},e.prototype.addComponent=function(t){return t.entity=this,this.components.add(t),t.initialize(),t},e.prototype.getComponent=function(t){return this.components.getComponent(t,!1)},e.prototype.hasComponent=function(t){return null!=this.components.getComponent(t,!1)},e.prototype.getOrCreateComponent=function(t){var e=this.components.getComponent(t,!0);return e||(e=this.addComponent(t)),e},e.prototype.getComponents=function(t,e){return this.components.getComponents(t,e)},e.prototype.removeComponent=function(t){this.components.remove(t)},e.prototype.removeComponentForType=function(t){var e=this.getComponent(t);return!!e&&(this.removeComponent(e),!0)},e.prototype.removeAllComponents=function(){for(var t=0;t<this.components.count;t++)this.removeComponent(this.components.buffer[t])},e.prototype.toString=function(){return"[Entity: name: "+this.name+", tag: "+this.tag+", enabled: "+this.enabled+", depth: "+this.updateOrder+"]"},e}();t.Entity=e}(es||(es={})),function(t){var e=function(e){function n(){var n=e.call(this)||this;return n.enablePostProcessing=!0,n._renderers=[],n._postProcessors=[],n.entities=new t.EntityList(n),n.renderableComponents=new t.RenderableComponentList,n.content=new t.ContentManager,n.entityProcessors=new t.EntityProcessorList,n.width=t.SceneManager.stage.stageWidth,n.height=t.SceneManager.stage.stageHeight,n.initialize(),n}return __extends(n,e),n.createWithDefaultRenderer=function(){var e=new n;return e.addRenderer(new t.DefaultRenderer),e},n.prototype.initialize=function(){},n.prototype.onStart=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(t){return[2]})})},n.prototype.unload=function(){},n.prototype.onActive=function(){},n.prototype.onDeactive=function(){},n.prototype.begin=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(e){return t.SceneManager.sceneTransition?t.SceneManager.stage.addChildAt(this,t.SceneManager.stage.numChildren-1):t.SceneManager.stage.addChild(this),0==this._renderers.length&&(this.addRenderer(new t.DefaultRenderer),console.warn("场景开始时没有渲染器 自动添加DefaultRenderer以保证能够正常渲染")),this.camera=this.createEntity("camera").getOrCreateComponent(new t.Camera),t.Physics.reset(),this.entityProcessors&&this.entityProcessors.begin(),this.addEventListener(egret.Event.ACTIVATE,this.onActive,this),this.addEventListener(egret.Event.DEACTIVATE,this.onDeactive,this),this.camera.onSceneSizeChanged(this.stage.stageWidth,this.stage.stageHeight),this._didSceneBegin=!0,this.onStart(),[2]})})},n.prototype.end=function(){this._didSceneBegin=!1,this.removeEventListener(egret.Event.DEACTIVATE,this.onDeactive,this),this.removeEventListener(egret.Event.ACTIVATE,this.onActive,this);for(var t=0;t<this._renderers.length;t++)this._renderers[t].unload();for(t=0;t<this._postProcessors.length;t++)this._postProcessors[t].unload();this.entities.removeAllEntities(),this.removeChildren(),this.camera=null,this.content.dispose(),this.entityProcessors&&this.entityProcessors.end(),this.parent&&this.parent.removeChild(this),this.unload()},n.prototype.update=function(){this.entities.updateLists(),this.entityProcessors&&this.entityProcessors.update(),this.entities.update(),this.entityProcessors&&this.entityProcessors.lateUpdate(),this.renderableComponents.updateList()},n.prototype.render=function(){if(0!=this._renderers.length)for(var t=0;t<this._renderers.length;t++)this._renderers[t].render(this);else console.error("there are no renderers in the scene!")},n.prototype.postRender=function(){if(this.enablePostProcessing)for(var t=0;t<this._postProcessors.length;t++)this._postProcessors[t].enabled&&this._postProcessors[t].process()},n.prototype.addRenderer=function(t){return this._renderers.push(t),this._renderers.sort(),t.onAddedToScene(this),t},n.prototype.getRenderer=function(t){for(var e=0;e<this._renderers.length;e++)if(this._renderers[e]instanceof t)return this._renderers[e];return null},n.prototype.removeRenderer=function(t){this._renderers.contains(t)&&(this._renderers.remove(t),t.unload())},n.prototype.addPostProcessor=function(t){return this._postProcessors.push(t),this._postProcessors.sort(),t.onAddedToScene(this),this._didSceneBegin&&t.onSceneBackBufferSizeChanged(this.stage.stageWidth,this.stage.stageHeight),t},n.prototype.getPostProcessor=function(t){for(var e=0;e<this._postProcessors.length;e++)if(this._postProcessors[e]instanceof t)return this._postProcessors[e];return null},n.prototype.removePostProcessor=function(t){this._postProcessors.contains(t)&&(this._postProcessors.remove(t),t.unload())},n.prototype.createEntity=function(e){var n=new t.Entity(e);return this.addEntity(n)},n.prototype.addEntity=function(t){this.entities.buffer.contains(t)&&console.warn("You are attempting to add the same entity to a scene twice: "+t),this.entities.add(t),t.scene=this;for(var e=0;e<t.transform.childCount;e++)this.addEntity(t.transform.getChild(e).entity);return t},n.prototype.destroyAllEntities=function(){for(var t=0;t<this.entities.count;t++)this.entities.buffer[t].destroy()},n.prototype.findEntity=function(t){return this.entities.findEntity(t)},n.prototype.findEntitiesWithTag=function(t){return this.entities.entitiesWithTag(t)},n.prototype.entitiesOfType=function(t){return this.entities.entitiesOfType(t)},n.prototype.findComponentOfType=function(t){return this.entities.findComponentOfType(t)},n.prototype.findComponentsOfType=function(t){return this.entities.findComponentsOfType(t)},n.prototype.addEntityProcessor=function(t){return t.scene=this,this.entityProcessors.add(t),t},n.prototype.removeEntityProcessor=function(t){this.entityProcessors.remove(t)},n.prototype.getEntityProcessor=function(){return this.entityProcessors.getProcessor()},n}(egret.DisplayObjectContainer);t.Scene=e}(es||(es={})),function(t){var e=function(){function e(n){n.addEventListener(egret.Event.ENTER_FRAME,e.update,this),e._instnace=this,e.emitter=new t.Emitter,e.content=new t.ContentManager,e.stage=n,e.initialize(n),e.timerRuler=new t.TimeRuler}return Object.defineProperty(e,"Instance",{get:function(){return this._instnace},enumerable:!0,configurable:!0}),Object.defineProperty(e,"scene",{get:function(){return this._scene},set:function(t){if(!t)throw new Error("场景不能为空");null==this._scene?(this._scene=t,this._scene.begin(),e.Instance.onSceneChanged()):this._nextScene=t,this.registerActiveSceneChanged(this._scene,this._nextScene)},enumerable:!0,configurable:!0}),e.initialize=function(e){t.Input.initialize(e)},e.update=function(){if(e.startDebugUpdate(),t.Time.update(egret.getTimer()),e._scene){for(var n=t.GlobalManager.globalManagers.length-1;n>=0;n--)t.GlobalManager.globalManagers[n].enabled&&t.GlobalManager.globalManagers[n].update();e.sceneTransition&&(!e.sceneTransition||e.sceneTransition.loadsNewScene&&!e.sceneTransition.isNewSceneLoaded)||e._scene.update(),e._nextScene&&(e._scene.end(),e._scene=e._nextScene,e._nextScene=null,e._instnace.onSceneChanged(),e._scene.begin())}e.endDebugUpdate(),e.render()},e.render=function(){this.sceneTransition?(this.sceneTransition.preRender(),this._scene&&!this.sceneTransition.hasPreviousSceneRender?(this._scene.render(),this._scene.postRender(),this.sceneTransition.onBeginTransition()):this.sceneTransition&&(this._scene&&this.sceneTransition.isNewSceneLoaded&&(this._scene.render(),this._scene.postRender()),this.sceneTransition.render())):this._scene&&(this._scene.render(),t.Debug.render(),this._scene.postRender())},e.startSceneTransition=function(t){if(!this.sceneTransition)return this.sceneTransition=t,t;console.warn("在前一个场景完成之前，不能开始一个新的场景转换。")},e.registerActiveSceneChanged=function(t,e){this.activeSceneChanged&&this.activeSceneChanged(t,e)},e.prototype.onSceneChanged=function(){e.emitter.emit(t.CoreEvents.SceneChanged),t.Time.sceneChanged()},e.startDebugUpdate=function(){t.TimeRuler.Instance.startFrame(),t.TimeRuler.Instance.beginMark("update",65280)},e.endDebugUpdate=function(){t.TimeRuler.Instance.endMark("update")},e}();t.SceneManager=e}(es||(es={})),function(t){!function(t){t[t.position=0]="position",t[t.scale=1]="scale",t[t.rotation=2]="rotation"}(t.Component||(t.Component={}))}(transform||(transform={})),function(t){var e;!function(t){t[t.clean=0]="clean",t[t.positionDirty=1]="positionDirty",t[t.scaleDirty=2]="scaleDirty",t[t.rotationDirty=3]="rotationDirty"}(e=t.DirtyType||(t.DirtyType={}));var n=function(){function n(e){this.entity=e,this.scale=t.Vector2.one,this._children=[]}return Object.defineProperty(n.prototype,"parent",{get:function(){return this._parent},set:function(t){this.setParent(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"childCount",{get:function(){return this._children.length},enumerable:!0,configurable:!0}),n.prototype.getChild=function(t){return this._children[t]},n.prototype.setParent=function(t){return this._parent==t?this:(this._parent||(this._parent._children.remove(this),this._parent._children.push(this)),this._parent=t,this.setDirty(e.positionDirty),this)},n.prototype.setPosition=function(n,i){return this.position=new t.Vector2(n,i),this.setDirty(e.positionDirty),this},n.prototype.setRotation=function(t){return this.rotation=t,this.setDirty(e.rotationDirty),this},n.prototype.setScale=function(t){return this.scale=t,this.setDirty(e.scaleDirty),this},n.prototype.lookAt=function(e){var n=this.position.x>e.x?-1:1,i=t.Vector2.normalize(t.Vector2.subtract(this.position,e));this.rotation=n*Math.acos(t.Vector2.dot(i,t.Vector2.unitY))},n.prototype.roundPosition=function(){this.position=this.position.round()},n.prototype.setDirty=function(e){if(0==(this.hierarchyDirty&e)){switch(this.hierarchyDirty|=e,e){case t.DirtyType.positionDirty:this.entity.onTransformChanged(transform.Component.position);break;case t.DirtyType.rotationDirty:this.entity.onTransformChanged(transform.Component.rotation);break;case t.DirtyType.scaleDirty:this.entity.onTransformChanged(transform.Component.scale)}this._children||(this._children=[]);for(var n=0;n<this._children.length;n++)this._children[n].setDirty(e)}},n.prototype.copyFrom=function(t){this.position=t.position,this.rotation=t.rotation,this.scale=t.scale,this.setDirty(e.positionDirty),this.setDirty(e.rotationDirty),this.setDirty(e.scaleDirty)},n}();t.Transform=n}(es||(es={})),function(t){var e;!function(t){t[t.lockOn=0]="lockOn",t[t.cameraWindow=1]="cameraWindow"}(e=t.CameraStyle||(t.CameraStyle={}));var n=function(n){function i(i,r){void 0===i&&(i=null),void 0===r&&(r=e.lockOn);var o=n.call(this)||this;return o._minimumZoom=.3,o._maximumZoom=3,o._origin=t.Vector2.zero,o.followLerp=.1,o.deadzone=new t.Rectangle,o.focusOffset=new t.Vector2,o.mapLockEnabled=!1,o.mapSize=new t.Vector2,o._desiredPositionDelta=new t.Vector2,o._worldSpaceDeadZone=new t.Rectangle,o._targetEntity=i,o._cameraStyle=r,o.setZoom(0),o}return __extends(i,n),Object.defineProperty(i.prototype,"position",{get:function(){return this.entity.transform.position},set:function(t){this.entity.transform.position=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"rotation",{get:function(){return this.entity.transform.rotation},set:function(t){this.entity.transform.rotation=t},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"zoom",{get:function(){return 0==this._zoom?1:this._zoom<1?t.MathHelper.map(this._zoom,this._minimumZoom,1,-1,0):t.MathHelper.map(this._zoom,1,this._maximumZoom,0,1)},set:function(t){this.setZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"minimumZoom",{get:function(){return this._minimumZoom},set:function(t){this.setMinimumZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"maximumZoom",{get:function(){return this._maximumZoom},set:function(t){this.setMaximumZoom(t)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"bounds",{get:function(){return new t.Rectangle(0,0,t.SceneManager.stage.stageWidth,t.SceneManager.stage.stageHeight)},enumerable:!0,configurable:!0}),Object.defineProperty(i.prototype,"origin",{get:function(){return this._origin},set:function(t){this._origin!=t&&(this._origin=t)},enumerable:!0,configurable:!0}),i.prototype.onSceneSizeChanged=function(e,n){var i=this._origin;this.origin=new t.Vector2(e/2,n/2),this.entity.transform.position=t.Vector2.add(this.entity.transform.position,t.Vector2.subtract(this._origin,i))},i.prototype.setPosition=function(t){return this.entity.transform.setPosition(t.x,t.y),this},i.prototype.setRotation=function(t){return this.entity.transform.setRotation(t),this},i.prototype.setZoom=function(e){var n=t.MathHelper.clamp(e,-1,1);return this._zoom=0==n?1:n<0?t.MathHelper.map(n,-1,0,this._minimumZoom,1):t.MathHelper.map(n,0,1,1,this._maximumZoom),t.SceneManager.scene.scaleX=this._zoom,t.SceneManager.scene.scaleY=this._zoom,this},i.prototype.setMinimumZoom=function(t){return this._zoom<t&&(this._zoom=this.minimumZoom),this._minimumZoom=t,this},i.prototype.setMaximumZoom=function(t){if(!(t<=0))return this._zoom>t&&(this._zoom=t),this._maximumZoom=t,this;console.error("maximumZoom must be greater than zero")},i.prototype.zoomIn=function(t){this.zoom+=t},i.prototype.zoomOut=function(t){this.zoom-=t},i.prototype.onAddedToEntity=function(){this.follow(this._targetEntity,this._cameraStyle)},i.prototype.update=function(){var e=t.Vector2.multiply(new t.Vector2(this.bounds.width,this.bounds.height),new t.Vector2(.5));this._worldSpaceDeadZone.x=this.position.x-e.x*t.SceneManager.scene.scaleX+this.deadzone.x+this.focusOffset.x,this._worldSpaceDeadZone.y=this.position.y-e.y*t.SceneManager.scene.scaleY+this.deadzone.y+this.focusOffset.y,this._worldSpaceDeadZone.width=this.deadzone.width,this._worldSpaceDeadZone.height=this.deadzone.height,this._targetEntity&&this.updateFollow(),this.position=t.Vector2.lerp(this.position,t.Vector2.add(this.position,this._desiredPositionDelta),this.followLerp),this.entity.transform.roundPosition(),this.mapLockEnabled&&(this.position=this.clampToMapSize(this.position),this.entity.transform.roundPosition())},i.prototype.clampToMapSize=function(e){var n=t.Vector2.multiply(new t.Vector2(this.bounds.width,this.bounds.height),new t.Vector2(.5)),i=new t.Vector2(this.mapSize.x-n.x,this.mapSize.y-n.y);return t.Vector2.clamp(e,n,i)},i.prototype.updateFollow=function(){if(this._desiredPositionDelta.x=this._desiredPositionDelta.y=0,this._cameraStyle==e.lockOn){var n=this._targetEntity.transform.position.x,i=this._targetEntity.transform.position.y;this._worldSpaceDeadZone.x>n?this._desiredPositionDelta.x=n-this._worldSpaceDeadZone.x:this._worldSpaceDeadZone.x<n&&(this._desiredPositionDelta.x=n-this._worldSpaceDeadZone.x),this._worldSpaceDeadZone.y<i?this._desiredPositionDelta.y=i-this._worldSpaceDeadZone.y:this._worldSpaceDeadZone.y>i&&(this._desiredPositionDelta.y=i-this._worldSpaceDeadZone.y)}else{if(!this._targetCollider&&(this._targetCollider=this._targetEntity.getComponent(t.Collider),!this._targetCollider))return;var r=this._targetEntity.getComponent(t.Collider).bounds;this._worldSpaceDeadZone.containsRect(r)||(this._worldSpaceDeadZone.left>r.left?this._desiredPositionDelta.x=r.left-this._worldSpaceDeadZone.left:this._worldSpaceDeadZone.right<r.right&&(this._desiredPositionDelta.x=r.right-this._worldSpaceDeadZone.right),this._worldSpaceDeadZone.bottom<r.bottom?this._desiredPositionDelta.y=r.bottom-this._worldSpaceDeadZone.bottom:this._worldSpaceDeadZone.top>r.top&&(this._desiredPositionDelta.y=r.top-this._worldSpaceDeadZone.top))}},i.prototype.follow=function(n,i){switch(void 0===i&&(i=e.cameraWindow),this._targetEntity=n,this._cameraStyle=i,this._cameraStyle){case e.cameraWindow:var r=this.bounds.width/6,o=this.bounds.height/3;this.deadzone=new t.Rectangle((this.bounds.width-r)/2,(this.bounds.height-o)/2,r,o);break;case e.lockOn:this.deadzone=new t.Rectangle(this.bounds.width/2,this.bounds.height/2,10,10)}},i.prototype.setCenteredDeadzone=function(e,n){this.deadzone=new t.Rectangle((this.bounds.width-e)/2,(this.bounds.height-n)/2,e,n)},i}(t.Component);t.Camera=n}(es||(es={})),function(t){var e=function(){function t(t){this._type=t,this._cache=[]}return t.prototype.obtain=function(){try{return this._cache.length>0?this._cache.shift():new this._type}catch(t){throw new Error(this._type+t)}},t.prototype.free=function(t){t.reset(),this._cache.push(t)},t}();t.ComponentPool=e}(es||(es={})),function(t){var e=function(){function t(){}return t.prototype.compare=function(t,e){return t.updateOrder-e.updateOrder},t}();t.IUpdatableComparer=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e}(t.Component);t.PooledComponent=e}(es||(es={})),function(t){var e=function(e){function n(){var n=null!==e&&e.apply(this,arguments)||this;return n.color=0,n._localOffset=t.Vector2.zero,n._renderLayer=0,n._bounds=new t.Rectangle,n._areBoundsDirty=!0,n}return __extends(n,e),Object.defineProperty(n.prototype,"width",{get:function(){return this.bounds.width},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"height",{get:function(){return this.bounds.height},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"bounds",{get:function(){return this._areBoundsDirty&&(this._bounds.calculateBounds(this.entity.transform.position,this._localOffset,t.Vector2.zero,this.entity.transform.scale,this.entity.transform.rotation,this.width,this.height),this._areBoundsDirty=!1),this._bounds},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"renderLayer",{get:function(){return this._renderLayer},set:function(t){},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"localOffset",{get:function(){return this._localOffset},set:function(t){this.setLocalOffset(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"isVisible",{get:function(){return this._isVisible},set:function(t){this._isVisible!=t&&(this._isVisible=t,this._isVisible?this.onBecameVisible():this.onBecameInvisible())},enumerable:!0,configurable:!0}),n.prototype.onEntityTransformChanged=function(t){this._areBoundsDirty=!0},n.prototype.onBecameVisible=function(){},n.prototype.onBecameInvisible=function(){},n.prototype.isVisibleFromCamera=function(t){return this.isVisible=t.bounds.intersects(this.bounds),this.isVisible},n.prototype.setRenderLayer=function(t){if(t!=this._renderLayer){var e=this._renderLayer;this._renderLayer=t,this.entity&&this.entity.scene&&this.entity.scene.renderableComponents.updateRenderableRenderLayer(this,e,this._renderLayer)}return this},n.prototype.setColor=function(t){return this.color=t,this},n.prototype.setLocalOffset=function(t){return this._localOffset!=t&&(this._localOffset=t),this},n.prototype.toString=function(){return"[RenderableComponent] "+this+", renderLayer: "+this.renderLayer},n}(t.Component);t.RenderableComponent=e}(es||(es={})),function(t){var e=function(t){function e(){var e=t.call(this)||this;return e._mesh=new egret.Mesh,e}return __extends(e,t),e.prototype.setTexture=function(t){return this._mesh.texture=t,this},e.prototype.reset=function(){},e.prototype.render=function(t){},e}(t.RenderableComponent);t.Mesh=e}(es||(es={})),function(t){var e=function(e){function n(n){void 0===n&&(n=null);var i=e.call(this)||this;return n instanceof t.Sprite?i.setSprite(n):n instanceof egret.Texture&&i.setSprite(new t.Sprite(n)),i}return __extends(n,e),Object.defineProperty(n.prototype,"bounds",{get:function(){if(this._areBoundsDirty)return this._sprite&&(this._bounds.calculateBounds(this.entity.transform.position,this._localOffset,this._origin,this.entity.transform.scale,this.entity.transform.rotation,this._sprite.sourceRect.width,this._sprite.sourceRect.height),this._areBoundsDirty=!1),this._bounds},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"origin",{get:function(){return this._origin},set:function(t){this.setOrigin(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"originNormalized",{get:function(){return new t.Vector2(this._origin.x/this.width*this.entity.transform.scale.x,this._origin.y/this.height*this.entity.transform.scale.y)},set:function(e){this.setOrigin(new t.Vector2(e.x*this.width/this.entity.transform.scale.x,e.y*this.height/this.entity.transform.scale.y))},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"sprite",{get:function(){return this._sprite},set:function(t){this.setSprite(t)},enumerable:!0,configurable:!0}),n.prototype.setSprite=function(t){return this._sprite=t,this._sprite&&(this._origin=this._sprite.origin),this},n.prototype.setOrigin=function(t){return this._origin!=t&&(this._origin=t,this._areBoundsDirty=!0),this},n.prototype.setOriginNormalized=function(e){return this.setOrigin(new t.Vector2(e.x*this.width/this.entity.transform.scale.x,e.y*this.height/this.entity.transform.scale.y)),this},n.prototype.render=function(t){},n}(t.RenderableComponent);t.SpriteRenderer=e}(es||(es={})),function(t){var e=function(t){function e(e){var n=t.call(this,e)||this;return n.leftTexture=new egret.Bitmap,n.rightTexture=new egret.Bitmap,n.leftTexture.texture=e.texture2D,n.rightTexture.texture=e.texture2D,n.setSprite(e),n.sourceRect=e.sourceRect,n}return __extends(e,t),Object.defineProperty(e.prototype,"scrollX",{get:function(){return this.sourceRect.x},set:function(t){this.sourceRect.x=t},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"scrollY",{get:function(){return this.sourceRect.y},set:function(t){this.sourceRect.y=t},enumerable:!0,configurable:!0}),e.prototype.render=function(e){if(this.sprite){t.prototype.render.call(this,e);var n=new egret.RenderTexture,i=new egret.DisplayObjectContainer;i.removeChildren(),i.addChild(this.leftTexture),i.addChild(this.rightTexture),this.leftTexture.x=this.sourceRect.x,this.rightTexture.x=this.sourceRect.x-this.sourceRect.width,this.leftTexture.y=this.sourceRect.y,this.rightTexture.y=this.sourceRect.y,i.cacheAsBitmap=!0,n.drawToTexture(i,new egret.Rectangle(0,0,this.sourceRect.width,this.sourceRect.height))}},e}(t.SpriteRenderer);t.TiledSpriteRenderer=e}(es||(es={})),function(t){var e=function(e){function n(){var t=null!==e&&e.apply(this,arguments)||this;return t.scrollSpeedX=15,t.scroolSpeedY=0,t._scrollX=0,t._scrollY=0,t}return __extends(n,e),n.prototype.update=function(){this._scrollX+=this.scrollSpeedX*t.Time.deltaTime,this._scrollY+=this.scroolSpeedY*t.Time.deltaTime,this.sourceRect.x=this._scrollX,this.sourceRect.y=this._scrollY},n.prototype.render=function(t){if(this.sprite){e.prototype.render.call(this,t);var n=new egret.RenderTexture,i=new egret.DisplayObjectContainer;i.removeChildren(),i.addChild(this.leftTexture),i.addChild(this.rightTexture),this.leftTexture.x=this.sourceRect.x,this.rightTexture.x=this.sourceRect.x-this.sourceRect.width,this.leftTexture.y=this.sourceRect.y,this.rightTexture.y=this.sourceRect.y,i.cacheAsBitmap=!0,n.drawToTexture(i,new egret.Rectangle(0,0,this.sourceRect.width,this.sourceRect.height))}},n}(t.TiledSpriteRenderer);t.ScrollingSpriteRenderer=e}(es||(es={})),function(t){var e=function(){return function(e,n,i){void 0===n&&(n=new t.Rectangle(0,0,e.textureWidth,e.textureHeight)),void 0===i&&(i=n.getHalfSize()),this.uvs=new t.Rectangle,this.texture2D=e,this.sourceRect=n,this.center=new t.Vector2(.5*n.width,.5*n.height),this.origin=i;var r=1/e.textureWidth,o=1/e.textureHeight;this.uvs.x=n.x*r,this.uvs.y=n.y*o,this.uvs.width=n.width*r,this.uvs.height=n.height*o}}();t.Sprite=e}(es||(es={})),function(t){var e=function(){return function(t,e){this.sprites=t,this.frameRate=e}}();t.SpriteAnimation=e}(es||(es={})),function(t){var e,n;!function(t){t[t.loop=0]="loop",t[t.once=1]="once",t[t.clampForever=2]="clampForever",t[t.pingPong=3]="pingPong",t[t.pingPongOnce=4]="pingPongOnce"}(e=t.LoopMode||(t.LoopMode={})),function(t){t[t.none=0]="none",t[t.running=1]="running",t[t.paused=2]="paused",t[t.completed=3]="completed"}(n=t.State||(t.State={}));var i=function(i){function r(t){var e=i.call(this,t)||this;return e.speed=1,e.animationState=n.none,e._animations=new Map,e._elapsedTime=0,e}return __extends(r,i),Object.defineProperty(r.prototype,"isRunning",{get:function(){return this.animationState==n.running},enumerable:!0,configurable:!0}),Object.defineProperty(r.prototype,"animations",{get:function(){return this._animations},enumerable:!0,configurable:!0}),r.prototype.update=function(){if(this.animationState==n.running&&this.currentAnimation){var i=this.currentAnimation,r=1/(i.frameRate*this.speed),o=r*i.sprites.length;this._elapsedTime+=t.Time.deltaTime;var s=Math.abs(this._elapsedTime);if(this._loopMode==e.once&&s>o||this._loopMode==e.pingPongOnce&&s>2*o)return this.animationState=n.completed,this._elapsedTime=0,this.currentFrame=0,void(this.sprite=i.sprites[this.currentFrame]);var a=Math.floor(s/r),c=i.sprites.length;if(c>2&&(this._loopMode==e.pingPong||this._loopMode==e.pingPongOnce)){var h=c-1;this.currentFrame=h-Math.abs(h-a%(2*h))}else this.currentFrame=a%c;this.sprite=i.sprites[this.currentFrame]}},r.prototype.addAnimation=function(t,e){return!this.sprite&&e.sprites.length>0&&this.setSprite(e.sprites[0]),this._animations[t]=e,this},r.prototype.play=function(t,i){void 0===i&&(i=null),this.currentAnimation=this._animations[t],this.currentAnimationName=t,this.currentFrame=0,this.animationState=n.running,this.sprite=this.currentAnimation.sprites[0],this._elapsedTime=0,this._loopMode=i||e.loop},r.prototype.isAnimationActive=function(t){return this.currentAnimation&&this.currentAnimationName==t},r.prototype.pause=function(){this.animationState=n.paused},r.prototype.unPause=function(){this.animationState=n.running},r.prototype.stop=function(){this.currentAnimation=null,this.currentAnimationName=null,this.currentFrame=0,this.animationState=n.none},r}(t.SpriteRenderer);t.SpriteAnimator=i}(es||(es={})),function(t){var e=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return __extends(n,e),n.prototype.onAddedToEntity=function(){this._triggerHelper=new t.ColliderTriggerHelper(this.entity)},n.prototype.calculateMovement=function(e){var n=new t.CollisionResult;if(!this.entity.getComponent(t.Collider)||!this._triggerHelper)return null;for(var i=this.entity.getComponents(t.Collider),r=0;r<i.length;r++){var o=i[r];if(!o.isTrigger){var s=o.bounds;s.x+=e.x,s.y+=e.y;var a=t.Physics.boxcastBroadphaseExcludingSelf(o,s,o.collidesWithLayers);s=a.bounds;for(var c=a.tempHashSet,h=0;h<c.length;h++){var u=c[h];if(!u.isTrigger){var l=o.collidesWith(u,e);l&&(e=t.Vector2.subtract(e,l.minimumTranslationVector),l.collider&&(n=l))}}}}return t.ListPool.free(i),{collisionResult:n,motion:e}},n.prototype.applyMovement=function(e){this.entity.position=t.Vector2.add(this.entity.position,e),this._triggerHelper&&this._triggerHelper.update()},n.prototype.move=function(t){var e=this.calculateMovement(t),n=e.collisionResult;return t=e.motion,this.applyMovement(t),n},n}(t.Component);t.Mover=e}(es||(es={})),function(t){var e=function(e){function n(){var t=null!==e&&e.apply(this,arguments)||this;return t._tempTriggerList=[],t}return __extends(n,e),n.prototype.onAddedToEntity=function(){this._collider=this.entity.getComponent(t.Collider),this._collider||console.warn("ProjectileMover has no Collider. ProjectilMover requires a Collider!")},n.prototype.move=function(e){if(!this._collider)return!1;var n=!1;this.entity.position=t.Vector2.add(this.entity.position,e);for(var i=t.Physics.boxcastBroadphase(this._collider.bounds,this._collider.collidesWithLayers),r=0;r<i.colliders.length;r++){var o=i.colliders[r];this._collider.overlaps(o)&&o.enabled&&(n=!0,this.notifyTriggerListeners(this._collider,o))}return n},n.prototype.notifyTriggerListeners=function(t,e){e.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var n=0;n<this._tempTriggerList.length;n++)this._tempTriggerList[n].onTriggerEnter(t,e);this._tempTriggerList.length=0,this.entity.getComponents("ITriggerListener",this._tempTriggerList);for(n=0;n<this._tempTriggerList.length;n++)this._tempTriggerList[n].onTriggerEnter(e,t);this._tempTriggerList.length=0},n}(t.Component);t.ProjectileMover=e}(es||(es={})),function(t){var e=function(e){function n(){var n=null!==e&&e.apply(this,arguments)||this;return n.physicsLayer=1,n.collidesWithLayers=t.Physics.allLayers,n.shouldColliderScaleAndRotateWithTransform=!0,n.registeredPhysicsBounds=new t.Rectangle,n._localOffset=t.Vector2.zero,n}return __extends(n,e),Object.defineProperty(n.prototype,"localOffset",{get:function(){return this._localOffset},set:function(t){this.setLocalOffset(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"absolutePosition",{get:function(){return t.Vector2.add(this.entity.transform.position,this._localOffset)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"rotation",{get:function(){return this.shouldColliderScaleAndRotateWithTransform&&this.entity?this.entity.transform.rotation:0},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"bounds",{get:function(){return this.shape.recalculateBounds(this),this.shape.bounds},enumerable:!0,configurable:!0}),n.prototype.setLocalOffset=function(t){return this._localOffset!=t&&(this.unregisterColliderWithPhysicsSystem(),this._localOffset=t,this._localOffsetLength=this._localOffset.length(),this.registerColliderWithPhysicsSystem()),this},n.prototype.setShouldColliderScaleAndRotateWithTransform=function(t){return this.shouldColliderScaleAndRotateWithTransform=t,this},n.prototype.onAddedToEntity=function(){if(this._colliderRequiresAutoSizing){if(!(this instanceof t.BoxCollider||this instanceof t.CircleCollider))return void console.error("Only box and circle colliders can be created automatically");var e=this.entity.getComponent(t.RenderableComponent);if(e){var n=e.bounds,i=n.width/this.entity.scale.x,r=n.height/this.entity.scale.y;if(this instanceof t.CircleCollider){this.radius=.5*Math.max(i,r)}else this.width=i,this.height=r;this.localOffset=t.Vector2.subtract(n.center,this.entity.transform.position)}else console.warn("Collider has no shape and no RenderableComponent. Can't figure out how to size it.")}this._isParentEntityAddedToScene=!0,this.registerColliderWithPhysicsSystem()},n.prototype.onRemovedFromEntity=function(){this.unregisterColliderWithPhysicsSystem(),this._isParentEntityAddedToScene=!1},n.prototype.onEntityTransformChanged=function(e){this._isColliderRegistered&&t.Physics.updateCollider(this)},n.prototype.onEnabled=function(){this.registerColliderWithPhysicsSystem()},n.prototype.onDisabled=function(){this.unregisterColliderWithPhysicsSystem()},n.prototype.registerColliderWithPhysicsSystem=function(){this._isParentEntityAddedToScene&&!this._isColliderRegistered&&(t.Physics.addCollider(this),this._isColliderRegistered=!0)},n.prototype.unregisterColliderWithPhysicsSystem=function(){this._isParentEntityAddedToScene&&this._isColliderRegistered&&t.Physics.removeCollider(this),this._isColliderRegistered=!1},n.prototype.overlaps=function(t){return this.shape.overlaps(t.shape)},n.prototype.collidesWith=function(e,n){var i=this.entity.position;this.entity.position=t.Vector2.add(this.entity.position,n);var r=this.shape.collidesWithShape(e.shape);return r&&(r.collider=e),this.entity.position=i,r},n}(t.Component);t.Collider=e}(es||(es={})),function(t){var e=function(e){function n(){var n=e.call(this)||this;return n.shape=new t.Box(1,1),n._colliderRequiresAutoSizing=!0,n}return __extends(n,e),Object.defineProperty(n.prototype,"width",{get:function(){return this.shape.width},set:function(t){this.setWidth(t)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"height",{get:function(){return this.shape.height},set:function(t){this.setHeight(t)},enumerable:!0,configurable:!0}),n.prototype.setSize=function(e,n){this._colliderRequiresAutoSizing=!1;var i=this.shape;return e==i.width&&n==i.height||(i.updateBox(e,n),this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this)),this},n.prototype.setWidth=function(e){this._colliderRequiresAutoSizing=!1;var n=this.shape;return e!=n.width&&(n.updateBox(e,n.height),this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this)),this},n.prototype.setHeight=function(e){this._colliderRequiresAutoSizing=!1;var n=this.shape;e!=n.height&&(n.updateBox(n.width,e),this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this))},n.prototype.toString=function(){return"[BoxCollider: bounds: "+this.bounds+"]"},n}(t.Collider);t.BoxCollider=e}(es||(es={})),function(t){var e=function(e){function n(n){var i=e.call(this)||this;return n&&(i._colliderRequiresAutoSizing=!0),i.shape=new t.Circle(n||1),i}return __extends(n,e),Object.defineProperty(n.prototype,"radius",{get:function(){return this.shape.radius},set:function(t){this.setRadius(t)},enumerable:!0,configurable:!0}),n.prototype.setRadius=function(e){this._colliderRequiresAutoSizing=!1;var n=this.shape;return e!=n.radius&&(n.radius=e,n._originalRadius=e,this.entity&&this._isParentEntityAddedToScene&&t.Physics.updateCollider(this)),this},n.prototype.toString=function(){return"[CircleCollider: bounds: "+this.bounds+", radius: "+this.shape.radius+"]"},n}(t.Collider);t.CircleCollider=e}(es||(es={})),function(t){var e=function(e){function n(n){var i=e.call(this)||this;n[0]==n[n.length-1]&&n.splice(n.length-1,1);var r=t.Polygon.findPolygonCenter(n);return i.setLocalOffset(r),t.Polygon.recenterPolygonVerts(n),i.shape=new t.Polygon(n),i}return __extends(n,e),n}(t.Collider);t.PolygonCollider=e}(es||(es={})),function(t){var e=function(){function e(e){this._entities=[],this._matcher=e||t.Matcher.empty()}return Object.defineProperty(e.prototype,"matcher",{get:function(){return this._matcher},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"scene",{get:function(){return this._scene},set:function(t){this._scene=t,this._entities=[]},enumerable:!0,configurable:!0}),e.prototype.initialize=function(){},e.prototype.onChanged=function(t){var e=this._entities.contains(t),n=this._matcher.IsIntersted(t);n&&!e?this.add(t):!n&&e&&this.remove(t)},e.prototype.add=function(t){this._entities.push(t),this.onAdded(t)},e.prototype.onAdded=function(t){},e.prototype.remove=function(t){this._entities.remove(t),this.onRemoved(t)},e.prototype.onRemoved=function(t){},e.prototype.update=function(){this.begin(),this.process(this._entities)},e.prototype.lateUpdate=function(){this.lateProcess(this._entities),this.end()},e.prototype.begin=function(){},e.prototype.process=function(t){},e.prototype.lateProcess=function(t){},e.prototype.end=function(){},e}();t.EntitySystem=e}(es||(es={})),function(t){var e=function(t){function e(e){return t.call(this,e)||this}return __extends(e,t),e.prototype.lateProcessEntity=function(t){},e.prototype.process=function(t){var e=this;t.forEach(function(t){return e.processEntity(t)})},e.prototype.lateProcess=function(t){var e=this;t.forEach(function(t){return e.lateProcessEntity(t)})},e}(t.EntitySystem);t.EntityProcessingSystem=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.onChanged=function(t){},e.prototype.process=function(t){this.begin(),this.end()},e}(t.EntitySystem);t.PassiveSystem=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.onChanged=function(t){},e.prototype.process=function(t){this.begin(),this.processSystem(),this.end()},e}(t.EntitySystem);t.ProcessingSystem=e}(es||(es={})),function(t){var e=function(){function t(e){void 0===e&&(e=64);var n=e>>6;0!=(e&t.LONG_MASK)&&n++,this._bits=new Array(n)}return t.prototype.and=function(t){for(var e,n=Math.min(this._bits.length,t._bits.length),i=0;i<n;++i)this._bits[i]&=t._bits[i];for(;e<this._bits.length;)this._bits[e++]=0},t.prototype.andNot=function(t){for(var e=Math.min(this._bits.length,t._bits.length);--e>=0;)this._bits[e]&=~t._bits[e]},t.prototype.cardinality=function(){for(var t=0,e=this._bits.length-1;e>=0;e--){var n=this._bits[e];if(0!=n)if(-1!=n){var i=((n=((n=(n>>1&0x5555555555555400)+(0x5555555555555400&n))>>2&0x3333333333333400)+(0x3333333333333400&n))>>32)+n;t+=((i=((i=(i>>4&252645135)+(252645135&i))>>8&16711935)+(16711935&i))>>16&65535)+(65535&i)}else t+=64}return t},t.prototype.clear=function(t){if(null!=t){var e=t>>6;this.ensure(e),this._bits[e]&=~(1<<t)}else for(var n=0;n<this._bits.length;n++)this._bits[n]=0},t.prototype.ensure=function(t){if(t>=this._bits.length){var e=new Number[t+1];e=this._bits.copyWithin(0,0,this._bits.length),this._bits=e}},t.prototype.get=function(t){var e=t>>6;return!(e>=this._bits.length)&&0!=(this._bits[e]&1<<t)},t.prototype.intersects=function(t){for(var e=Math.min(this._bits.length,t._bits.length);--e>=0;)if(0!=(this._bits[e]&t._bits[e]))return!0;return!1},t.prototype.isEmpty=function(){for(var t=this._bits.length-1;t>=0;t--)if(this._bits[t])return!1;return!0},t.prototype.nextSetBit=function(t){for(var e=t>>6,n=1<<t;e<this._bits.length;){var i=this._bits[e];do{if(0!=(i&n))return t;n<<=1,t++}while(0!=n);n=1,e++}return-1},t.prototype.set=function(t,e){if(void 0===e&&(e=!0),e){var n=t>>6;this.ensure(n),this._bits[n]|=1<<t}else this.clear(t)},t.LONG_MASK=63,t}();t.BitSet=e}(es||(es={})),function(t){var e=function(){function e(t){this._components=[],this._componentsToAdd=[],this._componentsToRemove=[],this._tempBufferList=[],this._entity=t}return Object.defineProperty(e.prototype,"count",{get:function(){return this._components.length},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"buffer",{get:function(){return this._components},enumerable:!0,configurable:!0}),e.prototype.markEntityListUnsorted=function(){this._isComponentListUnsorted=!0},e.prototype.add=function(t){this._componentsToAdd.push(t)},e.prototype.remove=function(t){this._componentsToRemove.contains(t)&&console.warn("You are trying to remove a Component ("+t+") that you already removed"),this._componentsToAdd.contains(t)?this._componentsToAdd.remove(t):this._componentsToRemove.push(t)},e.prototype.removeAllComponents=function(){for(var t=0;t<this._components.length;t++)this.handleRemove(this._components[t]);this._components.length=0,this._componentsToAdd.length=0,this._componentsToRemove.length=0},e.prototype.deregisterAllComponents=function(){for(var e=0;e<this._components.length;e++){var n=this._components[e];n instanceof t.RenderableComponent&&this._entity.scene.renderableComponents.remove(n),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(n),!1),this._entity.scene.entityProcessors.onComponentRemoved(this._entity)}},e.prototype.registerAllComponents=function(){for(var e=0;e<this._components.length;e++){var n=this._components[e];n instanceof t.RenderableComponent&&this._entity.scene.renderableComponents.add(n),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(n)),this._entity.scene.entityProcessors.onComponentAdded(this._entity)}},e.prototype.updateLists=function(){if(this._componentsToRemove.length>0){for(var n=0;n<this._componentsToRemove.length;n++)this.handleRemove(this._componentsToRemove[n]),this._components.remove(this._componentsToRemove[n]);this._componentsToRemove.length=0}if(this._componentsToAdd.length>0){n=0;for(var i=this._componentsToAdd.length;n<i;n++){(r=this._componentsToAdd[n])instanceof t.RenderableComponent&&this._entity.scene.renderableComponents.add(r),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(r)),this._entity.scene.entityProcessors.onComponentAdded(this._entity),this._components.push(r),this._tempBufferList.push(r)}this._componentsToAdd.length=0,this._isComponentListUnsorted=!0;for(n=0;n<this._tempBufferList.length;n++){var r;(r=this._tempBufferList[n]).onAddedToEntity(),r.enabled&&r.onEnabled()}this._tempBufferList.length=0}this._isComponentListUnsorted&&(this._components.sort(e.compareUpdatableOrder.compare),this._isComponentListUnsorted=!1)},e.prototype.handleRemove=function(e){e instanceof t.RenderableComponent&&this._entity.scene.renderableComponents.remove(e),this._entity.componentBits.set(t.ComponentTypeManager.getIndexFor(e),!1),this._entity.scene.entityProcessors.onComponentRemoved(this._entity),e.onRemovedFromEntity(),e.entity=null},e.prototype.getComponent=function(t,e){for(var n=0;n<this._components.length;n++){if((i=this._components[n])instanceof t)return i}if(!e)for(n=0;n<this._componentsToAdd.length;n++){var i;if((i=this._componentsToAdd[n])instanceof t)return i}return null},e.prototype.getComponents=function(t,e){e||(e=[]);for(var n=0;n<this._components.length;n++){var i=this._components[n];"string"==typeof t?egret.is(i,t)&&e.push(i):i instanceof t&&e.push(i)}for(n=0;n<this._componentsToAdd.length;n++){i=this._componentsToAdd[n];"string"==typeof t?egret.is(i,t)&&e.push(i):i instanceof t&&e.push(i)}return e},e.prototype.update=function(){this.updateLists();for(var e=0;e<this._components.length;e++){var n=this._components[e];!n.enabled||1!=n.updateInterval&&t.Time.frameCount%n.updateInterval!=0||n.update()}},e.prototype.onEntityTransformChanged=function(t){for(var e=0;e<this._components.length;e++)this._components[e].enabled&&this._components[e].onEntityTransformChanged(t);for(e=0;e<this._componentsToAdd.length;e++)this._componentsToAdd[e].enabled&&this._componentsToAdd[e].onEntityTransformChanged(t)},e.prototype.onEntityEnabled=function(){for(var t=0;t<this._components.length;t++)this._components[t].onEnabled()},e.prototype.onEntityDisabled=function(){for(var t=0;t<this._components.length;t++)this._components[t].onDisabled()},e.compareUpdatableOrder=new t.IUpdatableComparer,e}();t.ComponentList=e}(es||(es={})),function(t){var e=function(){function t(){}return t.add=function(t){this._componentTypesMask.has(t)||(this._componentTypesMask[t]=this._componentTypesMask.size)},t.getIndexFor=function(t){var e=-1;return this._componentTypesMask.has(t)||(this.add(t),e=this._componentTypesMask.get(t)),e},t._componentTypesMask=new Map,t}();t.ComponentTypeManager=e}(es||(es={})),function(t){var e=function(){function e(t){this._entitiesToRemove=[],this._entitiesToAdded=[],this._tempEntityList=[],this._entities=[],this._entityDict=new Map,this._unsortedTags=[],this.scene=t}return Object.defineProperty(e.prototype,"count",{get:function(){return this._entities.length},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"buffer",{get:function(){return this._entities},enumerable:!0,configurable:!0}),e.prototype.add=function(t){-1==this._entitiesToAdded.indexOf(t)&&this._entitiesToAdded.push(t)},e.prototype.remove=function(t){this._entitiesToAdded.contains(t)?this._entitiesToAdded.remove(t):this._entitiesToRemove.contains(t)||this._entitiesToRemove.push(t)},e.prototype.findEntity=function(t){for(var e=0;e<this._entities.length;e++)if(this._entities[e].name==t)return this._entities[e];return this._entitiesToAdded.firstOrDefault(function(e){return e.name==t})},e.prototype.entitiesWithTag=function(e){for(var n=this.getTagList(e),i=t.ListPool.obtain(),r=0;r<n.length;r++)i.push(n[r]);return i},e.prototype.entitiesOfType=function(e){for(var n=t.ListPool.obtain(),i=0;i<this._entities.length;i++)this._entities[i]instanceof e&&n.push(this._entities[i]);return this._entitiesToAdded.forEach(function(t){t instanceof e&&n.push(t)}),n},e.prototype.findComponentOfType=function(t){for(var e=0;e<this._entities.length;e++){if(this._entities[e].enabled)if(n=this._entities[e].getComponent(t))return n}for(e=0;e<this._entitiesToAdded.length;e++){var n,i=this._entitiesToAdded[e];if(i.enabled)if(n=i.getComponent(t))return n}return null},e.prototype.findComponentsOfType=function(e){for(var n=t.ListPool.obtain(),i=0;i<this._entities.length;i++)this._entities[i].enabled&&this._entities[i].getComponents(e,n);for(i=0;i<this._entitiesToAdded.length;i++){var r=this._entitiesToAdded[i];r.enabled&&r.getComponents(e,n)}return n},e.prototype.getTagList=function(t){var e=this._entityDict.get(t);return e||(e=[],this._entityDict.set(t,e)),this._entityDict.get(t)},e.prototype.addToTagList=function(t){var e=this.getTagList(t.tag);e.contains(t)||(e.push(t),this._unsortedTags.push(t.tag))},e.prototype.removeFromTagList=function(t){var e=this._entityDict.get(t.tag);e&&e.remove(t)},e.prototype.update=function(){for(var t=0;t<this._entities.length;t++){var e=this._entities[t];e.enabled&&e.update()}},e.prototype.removeAllEntities=function(){this._entitiesToAdded.length=0,this.updateLists();for(var t=0;t<this._entities.length;t++)this._entities[t]._isDestroyed=!0,this._entities[t].onRemovedFromScene(),this._entities[t].scene=null;this._entities.length=0,this._entityDict.clear()},e.prototype.updateLists=function(){var t=this;if(this._entitiesToRemove.length>0){var e=this._entitiesToRemove;this._entitiesToRemove=this._tempEntityList,this._tempEntityList=e,this._tempEntityList.forEach(function(e){t._entities.remove(e),e.scene=null,t.scene.entityProcessors.onEntityRemoved(e)}),this._tempEntityList.length=0}if(this._entitiesToAdded.length>0){e=this._entitiesToAdded;this._entitiesToAdded=this._tempEntityList,this._tempEntityList=e,this._tempEntityList.forEach(function(e){t._entities.contains(e)||(t._entities.push(e),e.scene=t.scene,t.scene.entityProcessors.onEntityAdded(e))}),this._tempEntityList.forEach(function(t){return t.onAddedToScene()}),this._tempEntityList.length=0}this._unsortedTags.length>0&&(this._unsortedTags.forEach(function(e){t._entityDict.get(e).sort()}),this._unsortedTags.length=0)},e}();t.EntityList=e}(es||(es={})),function(t){var e=function(){function e(){this._processors=[]}return e.prototype.add=function(t){this._processors.push(t)},e.prototype.remove=function(t){this._processors.remove(t)},e.prototype.onComponentAdded=function(t){this.notifyEntityChanged(t)},e.prototype.onComponentRemoved=function(t){this.notifyEntityChanged(t)},e.prototype.onEntityAdded=function(t){this.notifyEntityChanged(t)},e.prototype.onEntityRemoved=function(t){this.removeFromProcessors(t)},e.prototype.notifyEntityChanged=function(t){for(var e=0;e<this._processors.length;e++)this._processors[e].onChanged(t)},e.prototype.removeFromProcessors=function(t){for(var e=0;e<this._processors.length;e++)this._processors[e].remove(t)},e.prototype.begin=function(){},e.prototype.update=function(){for(var t=0;t<this._processors.length;t++)this._processors[t].update()},e.prototype.lateUpdate=function(){for(var t=0;t<this._processors.length;t++)this._processors[t].lateUpdate()},e.prototype.end=function(){},e.prototype.getProcessor=function(){for(var e=0;e<this._processors.length;e++){var n=this._processors[e];if(n instanceof t.EntitySystem)return n}return null},e}();t.EntityProcessorList=e}(es||(es={})),function(t){var e=function(){function e(){this.allSet=new t.BitSet,this.exclusionSet=new t.BitSet,this.oneSet=new t.BitSet}return e.empty=function(){return new e},e.prototype.getAllSet=function(){return this.allSet},e.prototype.getExclusionSet=function(){return this.exclusionSet},e.prototype.getOneSet=function(){return this.oneSet},e.prototype.IsIntersted=function(t){if(!this.allSet.isEmpty())for(var e=this.allSet.nextSetBit(0);e>=0;e=this.allSet.nextSetBit(e+1))if(!t.componentBits.get(e))return!1;return!(!this.exclusionSet.isEmpty()&&this.exclusionSet.intersects(t.componentBits))&&!(!this.oneSet.isEmpty()&&!this.oneSet.intersects(t.componentBits))},e.prototype.all=function(){for(var e=this,n=[],i=0;i<arguments.length;i++)n[i]=arguments[i];return n.forEach(function(n){e.allSet.set(t.ComponentTypeManager.getIndexFor(n))}),this},e.prototype.exclude=function(){for(var e=this,n=[],i=0;i<arguments.length;i++)n[i]=arguments[i];return n.forEach(function(n){e.exclusionSet.set(t.ComponentTypeManager.getIndexFor(n))}),this},e.prototype.one=function(){for(var e=this,n=[],i=0;i<arguments.length;i++)n[i]=arguments[i];return n.forEach(function(n){e.oneSet.set(t.ComponentTypeManager.getIndexFor(n))}),this},e}();t.Matcher=e}(es||(es={}));var ObjectUtils=function(){function t(){}return t.clone=function(t,e){void 0===e&&(e=null);e=e||{};for(var n in t)"object"==typeof t[n]?(e[n]=t[n]instanceof Array?[]:{},this.clone(t[n],e[n])):e[n]=t[n];return e},t}();!function(t){var e=function(){function t(){}return t.prototype.compare=function(t,e){return e.renderLayer-t.renderLayer},t}();t.RenderableComparer=e}(es||(es={})),function(t){var e=function(){function e(){this._components=[],this._componentsByRenderLayer=new Map,this._unsortedRenderLayers=[],this._componentsNeedSort=!0}return Object.defineProperty(e.prototype,"count",{get:function(){return this._components.length},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"buffer",{get:function(){return this._components},enumerable:!0,configurable:!0}),e.prototype.add=function(t){this._components.push(t),this.addToRenderLayerList(t,t.renderLayer)},e.prototype.remove=function(t){this._components.remove(t),this._componentsByRenderLayer.get(t.renderLayer).remove(t)},e.prototype.updateRenderableRenderLayer=function(t,e,n){this._componentsByRenderLayer.has(e)&&this._componentsByRenderLayer.get(e).contains(t)&&(this._componentsByRenderLayer.get(e).remove(t),this.addToRenderLayerList(t,n))},e.prototype.setRenderLayerNeedsComponentSort=function(t){this._unsortedRenderLayers.contains(t)||this._unsortedRenderLayers.push(t),this._componentsNeedSort=!0},e.prototype.setNeedsComponentSort=function(){this._componentsNeedSort=!0},e.prototype.addToRenderLayerList=function(t,e){var n=this.componentsWithRenderLayer(e);n.contains(t)?(n.push(t),this._unsortedRenderLayers.contains(e)||this._unsortedRenderLayers.push(e),this._componentsNeedSort=!0):console.warn("Component renderLayer list already contains this component")},e.prototype.componentsWithRenderLayer=function(t){return this._componentsByRenderLayer.get(t)||this._componentsByRenderLayer.set(t,[]),this._componentsByRenderLayer.get(t)},e.prototype.updateList=function(){if(this._componentsNeedSort&&(this._components.sort(e.compareUpdatableOrder.compare),this._componentsNeedSort=!1),this._unsortedRenderLayers.length>0){for(var t=0,n=this._unsortedRenderLayers.length;t<n;t++){var i=this._componentsByRenderLayer.get(this._unsortedRenderLayers[t]);i&&i.sort(e.compareUpdatableOrder.compare)}this._unsortedRenderLayers.length=0}},e.compareUpdatableOrder=new t.RenderableComparer,e}();t.RenderableComponentList=e}(es||(es={}));var StringUtils=function(){function t(){}return t.matchChineseWord=function(t){return t.match(/[\u4E00-\u9FA5]+/gim)},t.lTrim=function(t){for(var e=0;this.isWhiteSpace(t.charAt(e));)e++;return t.slice(e,t.length)},t.rTrim=function(t){for(var e=t.length-1;this.isWhiteSpace(t.charAt(e));)e--;return t.slice(0,e+1)},t.trim=function(t){return null==t?null:this.rTrim(this.lTrim(t))},t.isWhiteSpace=function(t){return" "==t||"\t"==t||"\r"==t||"\n"==t},t.replaceMatch=function(t,e,n,i){void 0===i&&(i=!1);for(var r=t.length,o="",s=!1,a=1==i?e.toLowerCase():e,c=0;c<r;c++)s=!1,t.charAt(c)==a.charAt(0)&&t.substr(c,a.length)==a&&(s=!0),s?(o+=n,c=c+a.length-1):o+=t.charAt(c);return o},t.htmlSpecialChars=function(t,e){void 0===e&&(e=!1);for(var n=this.specialSigns.length,i=0;i<n;i+=2){var r=void 0,o=void 0;if(r=this.specialSigns[i],o=this.specialSigns[i+1],e){var s=r;r=o,o=s}t=this.replaceMatch(t,r,o)}return t},t.zfill=function(t,e){if(void 0===e&&(e=2),!t)return t;e=Math.floor(e);var n=t.length;if(n>=e)return t;var i=!1;"-"==t.substr(0,1)&&(i=!0,t=t.substr(1));for(var r=e-n,o=0;o<r;o++)t="0"+t;return i&&(t="-"+t),t},t.reverse=function(t){return t.length>1?this.reverse(t.substring(1))+t.substring(0,1):t},t.cutOff=function(t,e,n,i){void 0===i&&(i=!0),e=Math.floor(e),n=Math.floor(n);var r=t.length;e>r&&(e=r);var o,s=e,a=e+n;return i?o=t.substring(0,s)+t.substr(a,r):(a=(s=r-1-e-n)+n,o=t.substring(0,s+1)+t.substr(a+1,r)),o},t.strReplace=function(t,e){for(var n=0,i=e.length;n<i;n++)null!=e[n]&&""!=e[n]||(e[n]="无"),t=t.replace("{"+n+"}",e[n]);return t},t.specialSigns=["&","&amp;","<","&lt;",">","&gt;",'"',"&quot;","'","&apos;","®","&reg;","©","&copy;","™","&trade;"],t}();!function(t){var e=function(){function e(){}return e.convertImageToCanvas=function(e,n){this.sharedCanvas||(this.sharedCanvas=egret.sys.createCanvas(),this.sharedContext=this.sharedCanvas.getContext("2d"));var i=e.$getTextureWidth(),r=e.$getTextureHeight();n||((n=egret.$TempRectangle).x=0,n.y=0,n.width=i,n.height=r),n.x=Math.min(n.x,i-1),n.y=Math.min(n.y,r-1),n.width=Math.min(n.width,i-n.x),n.height=Math.min(n.height,r-n.y);var o=Math.floor(n.width),s=Math.floor(n.height),a=this.sharedCanvas;if(a.style.width=o+"px",a.style.height=s+"px",this.sharedCanvas.width=o,this.sharedCanvas.height=s,"webgl"==egret.Capabilities.renderMode){var c=void 0;e.$renderBuffer?c=e:(egret.sys.systemRenderer.renderClear&&egret.sys.systemRenderer.renderClear(),(c=new egret.RenderTexture).drawToTexture(new egret.Bitmap(e)));for(var h=c.$renderBuffer.getPixels(n.x,n.y,o,s),u=0,l=0,p=0;p<h.length;p+=4)this.sharedContext.fillStyle="rgba("+h[p]+","+h[p+1]+","+h[p+2]+","+h[p+3]/255+")",this.sharedContext.fillRect(u,l,1,1),++u==o&&(u=0,l++);return e.$renderBuffer||c.dispose(),a}var d=e,f=Math.round(d.$offsetX),g=Math.round(d.$offsetY),m=d.$bitmapWidth,y=d.$bitmapHeight,_=t.SceneManager.stage.textureScaleFactor;return this.sharedContext.drawImage(d.$bitmapData.source,d.$bitmapX+n.x/_,d.$bitmapY+n.y/_,m*n.width/i,y*n.height/r,f,g,n.width,n.height),a},e.toDataURL=function(t,e,n,i){try{return this.convertImageToCanvas(e,n).toDataURL(t,i)}catch(t){egret.$error(1033)}return null},e.eliFoTevas=function(t,e,n,i,r){var o=this.convertImageToCanvas(e,i).toTempFilePathSync({fileType:t.indexOf("png")>=0?"png":"jpg"});return wx.getFileSystemManager().saveFile({tempFilePath:o,filePath:wx.env.USER_DATA_PATH+"/"+n,success:function(t){}}),o},e.getPixel32=function(t,e,n){return egret.$warn(1041,"getPixel32","getPixels"),t.getPixels(e,n)},e.getPixels=function(t,e,n,i,r){if(void 0===i&&(i=1),void 0===r&&(r=1),"webgl"==egret.Capabilities.renderMode){var o=void 0;return t.$renderBuffer?o=t:(o=new egret.RenderTexture).drawToTexture(new egret.Bitmap(t)),o.$renderBuffer.getPixels(e,n,i,r)}try{this.convertImageToCanvas(t);return this.sharedContext.getImageData(e,n,i,r).data}catch(t){egret.$error(1039)}},e}();t.TextureUtils=e}(es||(es={})),function(t){var e=function(){function t(){}return t.update=function(t){var e=(t-this._lastTime)/1e3;this.deltaTime=e*this.timeScale,this.unscaledDeltaTime=e,this._timeSinceSceneLoad+=e,this.frameCount++,this._lastTime=t},t.sceneChanged=function(){this._timeSinceSceneLoad=0},t.checkEvery=function(t){return this._timeSinceSceneLoad/t>(this._timeSinceSceneLoad-this.deltaTime)/t},t.deltaTime=0,t.timeScale=1,t.frameCount=0,t._lastTime=0,t}();t.Time=e}(es||(es={}));var TimeUtils=function(){function t(){}return t.monthId=function(t){void 0===t&&(t=null);var e=(t=t||new Date).getFullYear(),n=t.getMonth()+1;return parseInt(e+(n<10?"0":"")+n)},t.dateId=function(t){void 0===t&&(t=null);var e=(t=t||new Date).getMonth()+1,n=e<10?"0":"",i=t.getDate(),r=i<10?"0":"";return parseInt(t.getFullYear()+n+e+r+i)},t.weekId=function(t,e){void 0===t&&(t=null),void 0===e&&(e=!0),t=t||new Date;var n=new Date;n.setTime(t.getTime()),n.setDate(1),n.setMonth(0);var i=n.getFullYear(),r=n.getDay();0==r&&(r=7);var o=!1;r<=4?(o=r>1,n.setDate(n.getDate()-(r-1))):n.setDate(n.getDate()+7-r+1);var s=this.diffDay(t,n,!1);if(s<0)return n.setDate(1),n.setMonth(0),n.setDate(n.getDate()-1),this.weekId(n,!1);var a=s/7,c=Math.floor(a)+1;if(53==c){n.setTime(t.getTime()),n.setDate(n.getDate()-1);var h=n.getDay();if(0==h&&(h=7),e&&(!o||h<4))return n.setFullYear(n.getFullYear()+1),n.setDate(1),n.setMonth(0),this.weekId(n,!1)}return parseInt(i+"00"+(c>9?"":"0")+c)},t.diffDay=function(t,e,n){void 0===n&&(n=!1);var i=(t.getTime()-e.getTime())/864e5;return n?Math.ceil(i):Math.floor(i)},t.getFirstDayOfWeek=function(t){var e=(t=t||new Date).getDay()||7;return new Date(t.getFullYear(),t.getMonth(),t.getDate()+1-e,0,0,0,0)},t.getFirstOfDay=function(t){return(t=t||new Date).setHours(0,0,0,0),t},t.getNextFirstOfDay=function(t){return new Date(this.getFirstOfDay(t).getTime()+864e5)},t.formatDate=function(t){var e=t.getFullYear(),n=t.getMonth()+1;n=n<10?"0"+n:n;var i=t.getDate();return e+"-"+n+"-"+(i=i<10?"0"+i:i)},t.formatDateTime=function(t){var e=t.getFullYear(),n=t.getMonth()+1;n=n<10?"0"+n:n;var i=t.getDate();i=i<10?"0"+i:i;var r=t.getHours(),o=t.getMinutes();o=o<10?"0"+o:o;var s=t.getSeconds();return e+"-"+n+"-"+i+" "+r+":"+o+":"+(s=s<10?"0"+s:s)},t.parseDate=function(t){var e=Date.parse(t);return isNaN(e)?new Date:new Date(Date.parse(t.replace(/-/g,"/")))},t.secondToTime=function(t,e,n){void 0===t&&(t=0),void 0===e&&(e=":"),void 0===n&&(n=!0);var i=Math.floor(t/3600),r=Math.floor(t%3600/60),o=Math.floor(t%3600%60),s=i.toString(),a=r.toString(),c=o.toString();return i<10&&(s="0"+s),r<10&&(a="0"+a),o<10&&(c="0"+c),n?s+e+a+e+c:a+e+c},t.timeToMillisecond=function(t,e){void 0===e&&(e=":");for(var n=t.split(e),i=0,r=n.length,o=0;o<r;o++){i+=n[o]*Math.pow(60,r-1-o)}return(i*=1e3).toString()},t}();!function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.initialize=function(t){this.platformInitialize(t)},e.prototype.platformInitialize=function(t){this.isMobile=!0;var e=wx.getSystemInfoSync(),n=e.system.toLowerCase();n.indexOf("ios")>-1?this.os="iOS":n.indexOf("android")>-1&&(this.os="Android");var i=e.language;i=i.indexOf("zh")>-1?"zh-CN":"en-US",this.language=i},e}(egret.Capabilities);t.GraphicsCapabilities=e}(es||(es={})),function(t){var e=function(){return function(){this.graphicsCapabilities=new t.GraphicsCapabilities,this.graphicsCapabilities.initialize(this)}}();t.GraphicsDevice=e}(es||(es={})),function(t){var e=function(){function e(t,e,n,i){this._x=t,this._y=e,this._width=n,this._height=i,this._minDepth=0,this._maxDepth=1}return Object.defineProperty(e.prototype,"aspectRatio",{get:function(){return 0!=this._height&&0!=this._width?this._width/this._height:0},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"bounds",{get:function(){return new t.Rectangle(this._x,this._y,this._width,this._height)},set:function(t){this._x=t.x,this._y=t.y,this._width=t.width,this._height=t.height},enumerable:!0,configurable:!0}),e}();t.Viewport=e}(es||(es={})),function(t){var e=function(e){function n(){return e.call(this,t.PostProcessor.default_vert,n.blur_frag,{screenWidth:t.SceneManager.stage.stageWidth,screenHeight:t.SceneManager.stage.stageHeight})||this}return __extends(n,e),n.blur_frag="precision mediump float;\nuniform sampler2D uSampler;\nuniform float screenWidth;\nuniform float screenHeight;\nfloat normpdf(in float x, in float sigma)\n{\nreturn 0.39894*exp(-0.5*x*x/(sigma*sigma))/sigma;\n}\nvoid main()\n{\nvec3 c = texture2D(uSampler, gl_FragCoord.xy / vec2(screenWidth, screenHeight).xy).rgb;\nconst int mSize = 11;\nconst int kSize = (mSize - 1)/2;\nfloat kernel[mSize];\nvec3 final_colour = vec3(0.0);\nfloat sigma = 7.0;\nfloat z = 0.0;\nfor (int j = 0; j <= kSize; ++j)\n{\nkernel[kSize+j] = kernel[kSize-j] = normpdf(float(j),sigma);\n}\nfor (int j = 0; j < mSize; ++j)\n{\nz += kernel[j];\n}\nfor (int i = -kSize; i <= kSize; ++i)\n{\nfor (int j = -kSize; j <= kSize; ++j)\n{\nfinal_colour += kernel[kSize+j]*kernel[kSize+i]*texture2D(uSampler, (gl_FragCoord.xy+vec2(float(i),float(j))) / vec2(screenWidth, screenHeight).xy).rgb;\n}\n}\ngl_FragColor = vec4(final_colour/(z*z), 1.0);\n}",n}(egret.CustomFilter);t.GaussianBlurEffect=e}(es||(es={})),function(t){var e=function(t){function e(){return t.call(this,e.vertSrc,e.fragmentSrc)||this}return __extends(e,t),e.vertSrc="attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n}",e.fragmentSrc="precision lowp float;\nvarying vec2 vTextureCoord;\nuniform sampler2D uSampler;\n#define SAMPLE_COUNT 15\nuniform vec2 _sampleOffsets[SAMPLE_COUNT];\nuniform float _sampleWeights[SAMPLE_COUNT];\nvoid main(void) {\nvec4 c = vec4(0, 0, 0, 0);\nfor( int i = 0; i < SAMPLE_COUNT; i++ )\n   c += texture2D( uSampler, vTextureCoord + _sampleOffsets[i] ) * _sampleWeights[i];\ngl_FragColor = c;\n}",e}(egret.CustomFilter);t.PolygonLightEffect=e}(es||(es={})),function(t){var e=function(){function e(t){void 0===t&&(t=null),this.enabled=!0,this.effect=t}return e.prototype.onAddedToScene=function(e){this.scene=e,this.shape=new egret.Shape,this.shape.graphics.beginFill(16777215,1),this.shape.graphics.drawRect(0,0,t.SceneManager.stage.stageWidth,t.SceneManager.stage.stageHeight),this.shape.graphics.endFill(),e.addChild(this.shape)},e.prototype.process=function(){this.drawFullscreenQuad()},e.prototype.onSceneBackBufferSizeChanged=function(t,e){},e.prototype.drawFullscreenQuad=function(){this.scene.filters=[this.effect]},e.prototype.unload=function(){this.effect&&(this.effect=null),this.scene.removeChild(this.shape),this.scene=null},e.default_vert="attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec2 aColor;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\ngl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\nvTextureCoord = aTextureCoord;\nvColor = vec4(aColor.x, aColor.x, aColor.x, aColor.x);\n}",e}();t.PostProcessor=e}(es||(es={})),function(t){var e=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return __extends(n,e),n.prototype.onAddedToScene=function(n){e.prototype.onAddedToScene.call(this,n),this.effect=new t.GaussianBlurEffect},n}(t.PostProcessor);t.GaussianBlurPostProcessor=e}(es||(es={})),function(t){var e=function(){function t(){}return t.prototype.onAddedToScene=function(t){},t.prototype.beginRender=function(t){},t.prototype.unload=function(){},t.prototype.renderAfterStateCheck=function(t,e){t.render(e)},t}();t.Renderer=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.render=function(t){var e=this.camera?this.camera:t.camera;this.beginRender(e);for(var n=0;n<t.renderableComponents.count;n++){var i=t.renderableComponents.buffer[n];i.enabled&&i.isVisibleFromCamera(e)&&this.renderAfterStateCheck(i,e)}},e}(t.Renderer);t.DefaultRenderer=e}(es||(es={})),function(t){var e=function(t){function e(){return null!==t&&t.apply(this,arguments)||this}return __extends(e,t),e.prototype.render=function(t){},e}(t.Renderer);t.ScreenSpaceRenderer=e}(es||(es={})),function(t){var e=function(t){function e(e,n,i){var r=t.call(this)||this;return r._indices=[],r.radius=e,r.power=i,r.color=n,r.computeTriangleIndices(),r}return __extends(e,t),Object.defineProperty(e.prototype,"radius",{get:function(){return this._radius},set:function(t){this.setRadius(t)},enumerable:!0,configurable:!0}),e.prototype.computeTriangleIndices=function(t){void 0===t&&(t=20),this._indices.length=0;for(var e=0;e<t;e+=2)this._indices.push(0),this._indices.push(e+2),this._indices.push(e+1)},e.prototype.setRadius=function(t){t!=this._radius&&(this._radius=t,this._areBoundsDirty=!0)},e.prototype.render=function(t){},e.prototype.reset=function(){},e}(t.RenderableComponent);t.PolyLight=e}(es||(es={})),function(t){var e=function(){function e(t){this.sceneLoadAction=t,this.loadsNewScene=null!=t}return Object.defineProperty(e.prototype,"hasPreviousSceneRender",{get:function(){return!!this._hasPreviousSceneRender||(this._hasPreviousSceneRender=!0,!1)},enumerable:!0,configurable:!0}),e.prototype.preRender=function(){},e.prototype.render=function(){},e.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(t){switch(t.label){case 0:return[4,this.loadNextScene()];case 1:return t.sent(),this.transitionComplete(),[2]}})})},e.prototype.transitionComplete=function(){t.SceneManager.sceneTransition=null,this.onTransitionCompleted&&this.onTransitionCompleted()},e.prototype.loadNextScene=function(){return __awaiter(this,void 0,void 0,function(){var e;return __generator(this,function(n){switch(n.label){case 0:return this.onScreenObscured&&this.onScreenObscured(),this.loadsNewScene||(this.isNewSceneLoaded=!0),e=t.SceneManager,[4,this.sceneLoadAction()];case 1:return e.scene=n.sent(),this.isNewSceneLoaded=!0,[2]}})})},e.prototype.tickEffectProgressProperty=function(t,e,n,i){return void 0===i&&(i=!1),new Promise(function(r){var o=i?1:0,s=i?0:1;egret.Tween.get(t.uniforms).set({_progress:o}).to({_progress:s},1e3*e,n).call(function(){r()})})},e}();t.SceneTransition=e}(es||(es={})),function(t){var e=function(e){function n(t){var n=e.call(this,t)||this;return n.fadeToColor=0,n.fadeOutDuration=.4,n.fadeEaseType=egret.Ease.quadInOut,n.delayBeforeFadeInDuration=.1,n._alpha=0,n._mask=new egret.Shape,n}return __extends(n,e),n.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){var e=this;return __generator(this,function(n){return this._mask.graphics.beginFill(this.fadeToColor,1),this._mask.graphics.drawRect(0,0,t.SceneManager.stage.stageWidth,t.SceneManager.stage.stageHeight),this._mask.graphics.endFill(),t.SceneManager.stage.addChild(this._mask),egret.Tween.get(this).to({_alpha:1},1e3*this.fadeOutDuration,this.fadeEaseType).call(function(){return __awaiter(e,void 0,void 0,function(){return __generator(this,function(t){switch(t.label){case 0:return[4,this.loadNextScene()];case 1:return t.sent(),[2]}})})}).wait(this.delayBeforeFadeInDuration).call(function(){egret.Tween.get(e).to({_alpha:0},1e3*e.fadeOutDuration,e.fadeEaseType).call(function(){e.transitionComplete(),t.SceneManager.stage.removeChild(e._mask)})}),[2]})})},n.prototype.render=function(){this._mask.graphics.clear(),this._mask.graphics.beginFill(this.fadeToColor,this._alpha),this._mask.graphics.drawRect(0,0,t.SceneManager.stage.stageWidth,t.SceneManager.stage.stageHeight),this._mask.graphics.endFill()},n}(t.SceneTransition);t.FadeTransition=e}(es||(es={})),function(t){var e=function(e){function n(n){var i=e.call(this,n)||this;i.duration=1,i.easeType=egret.Ease.quadOut;return i._windEffect=new egret.CustomFilter("attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n}","precision lowp float;\nvarying vec2 vTextureCoord;\nuniform sampler2D uSampler;\nuniform float _progress;\nuniform float _size;\nuniform float _windSegments;\nvoid main(void) {\nvec2 co = floor(vec2(0.0, vTextureCoord.y * _windSegments));\nfloat x = sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453;\nfloat r = x - floor(x);\nfloat m = smoothstep(0.0, -_size, vTextureCoord.x * (1.0 - _size) + _size * r - (_progress * (1.0 + _size)));\nvec4 fg = texture2D(uSampler, vTextureCoord);\ngl_FragColor = mix(fg, vec4(0, 0, 0, 0), m);\n}",{_progress:0,_size:.3,_windSegments:100}),i._mask=new egret.Shape,i._mask.graphics.beginFill(16777215,1),i._mask.graphics.drawRect(0,0,t.SceneManager.stage.stageWidth,t.SceneManager.stage.stageHeight),i._mask.graphics.endFill(),i._mask.filters=[i._windEffect],t.SceneManager.stage.addChild(i._mask),i}return __extends(n,e),Object.defineProperty(n.prototype,"windSegments",{set:function(t){this._windEffect.uniforms._windSegments=t},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"size",{set:function(t){this._windEffect.uniforms._size=t},enumerable:!0,configurable:!0}),n.prototype.onBeginTransition=function(){return __awaiter(this,void 0,void 0,function(){return __generator(this,function(e){switch(e.label){case 0:return this.loadNextScene(),[4,this.tickEffectProgressProperty(this._windEffect,this.duration,this.easeType)];case 1:return e.sent(),this.transitionComplete(),t.SceneManager.stage.removeChild(this._mask),[2]}})})},n}(t.SceneTransition);t.WindTransition=e}(es||(es={})),function(t){var e=function(){function e(){}return e.getPoint=function(e,n,i,r){var o=1-(r=t.MathHelper.clamp01(r));return t.Vector2.add(t.Vector2.add(t.Vector2.multiply(new t.Vector2(o*o),e),t.Vector2.multiply(new t.Vector2(2*o*r),n)),t.Vector2.multiply(new t.Vector2(r*r),i))},e.getFirstDerivative=function(e,n,i,r){return t.Vector2.add(t.Vector2.multiply(new t.Vector2(2*(1-r)),t.Vector2.subtract(n,e)),t.Vector2.multiply(new t.Vector2(2*r),t.Vector2.subtract(i,n)))},e.getFirstDerivativeThree=function(e,n,i,r,o){var s=1-(o=t.MathHelper.clamp01(o));return t.Vector2.add(t.Vector2.add(t.Vector2.multiply(new t.Vector2(3*s*s),t.Vector2.subtract(n,e)),t.Vector2.multiply(new t.Vector2(6*s*o),t.Vector2.subtract(i,n))),t.Vector2.multiply(new t.Vector2(3*o*o),t.Vector2.subtract(r,i)))},e.getPointThree=function(e,n,i,r,o){var s=1-(o=t.MathHelper.clamp01(o));return t.Vector2.add(t.Vector2.add(t.Vector2.add(t.Vector2.multiply(new t.Vector2(s*s*s),e),t.Vector2.multiply(new t.Vector2(3*s*s*o),n)),t.Vector2.multiply(new t.Vector2(3*s*o*o),i)),t.Vector2.multiply(new t.Vector2(o*o*o),r))},e.getOptimizedDrawingPoints=function(e,n,i,r,o){void 0===o&&(o=1);var s=t.ListPool.obtain();return s.push(e),this.recursiveGetOptimizedDrawingPoints(e,n,i,r,s,o),s.push(r),s},e.recursiveGetOptimizedDrawingPoints=function(e,n,i,r,o,s){var a=t.Vector2.divide(t.Vector2.add(e,n),new t.Vector2(2)),c=t.Vector2.divide(t.Vector2.add(n,i),new t.Vector2(2)),h=t.Vector2.divide(t.Vector2.add(i,r),new t.Vector2(2)),u=t.Vector2.divide(t.Vector2.add(a,c),new t.Vector2(2)),l=t.Vector2.divide(t.Vector2.add(c,h),new t.Vector2(2)),p=t.Vector2.divide(t.Vector2.add(u,l),new t.Vector2(2)),d=t.Vector2.subtract(r,e),f=Math.abs((n.x,r.x*d.y-(n.y-r.y)*d.x)),g=Math.abs((i.x-r.x)*d.y-(i.y-r.y)*d.x);(f+g)*(f+g)<s*(d.x*d.x+d.y*d.y)?o.push(p):(this.recursiveGetOptimizedDrawingPoints(e,a,u,p,o,s),this.recursiveGetOptimizedDrawingPoints(p,l,h,r,o,s))},e}();t.Bezier=e}(es||(es={})),function(t){var e=function(){function t(){}return t.isFlagSet=function(t,e){return 0!=(t&e)},t.isUnshiftedFlagSet=function(t,e){return 0!=(t&(e=1<<e))},t.setFlagExclusive=function(t,e){return 1<<e},t.setFlag=function(t,e){return t|1<<e},t.unsetFlag=function(t,e){return t&~(e=1<<e)},t.invertFlags=function(t){return~t},t}();t.Flags=e}(es||(es={})),function(t){var e=function(){function e(){}return e.toDegrees=function(t){return 57.29577951308232*t},e.toRadians=function(t){return.017453292519943295*t},e.map=function(t,e,n,i,r){return i+(t-e)*(r-i)/(n-e)},e.lerp=function(t,e,n){return t+(e-t)*n},e.clamp=function(t,e,n){return t<e?e:t>n?n:t},e.pointOnCirlce=function(n,i,r){var o=e.toRadians(r);return new t.Vector2(Math.cos(o)*o+n.x,Math.sin(o)*o+n.y)},e.isEven=function(t){return t%2==0},e.clamp01=function(t){return t<0?0:t>1?1:t},e.angleBetweenVectors=function(t,e){return Math.atan2(e.y-t.y,e.x-t.x)},e.Epsilon=1e-5,e.Rad2Deg=57.29578,e.Deg2Rad=.0174532924,e}();t.MathHelper=e}(es||(es={})),function(t){var e=function(){function e(t,e,n,i,r,o){this.m11=0,this.m12=0,this.m21=0,this.m22=0,this.m31=0,this.m32=0,this.m11=t||1,this.m12=e||0,this.m21=n||0,this.m22=i||1,this.m31=r||0,this.m32=o||0}return Object.defineProperty(e,"identity",{get:function(){return e._identity},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"translation",{get:function(){return new t.Vector2(this.m31,this.m32)},set:function(t){this.m31=t.x,this.m32=t.y},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"rotation",{get:function(){return Math.atan2(this.m21,this.m11)},set:function(t){var e=Math.cos(t),n=Math.sin(t);this.m11=e,this.m12=n,this.m21=-n,this.m22=e},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"rotationDegrees",{get:function(){return t.MathHelper.toDegrees(this.rotation)},set:function(e){this.rotation=t.MathHelper.toRadians(e)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"scale",{get:function(){return new t.Vector2(this.m11,this.m22)},set:function(t){this.m11=t.x,this.m12=t.y},enumerable:!0,configurable:!0}),e.add=function(t,e){return t.m11+=e.m11,t.m12+=e.m12,t.m21+=e.m21,t.m22+=e.m22,t.m31+=e.m31,t.m32+=e.m32,t},e.divide=function(t,e){return t.m11/=e.m11,t.m12/=e.m12,t.m21/=e.m21,t.m22/=e.m22,t.m31/=e.m31,t.m32/=e.m32,t},e.multiply=function(t,n){var i=new e,r=t.m11*n.m11+t.m12*n.m21,o=t.m11*n.m12+t.m12*n.m22,s=t.m21*n.m11+t.m22*n.m21,a=t.m21*n.m12+t.m22*n.m22,c=t.m31*n.m11+t.m32*n.m21+n.m31,h=t.m31*n.m12+t.m32*n.m22+n.m32;return i.m11=r,i.m12=o,i.m21=s,i.m22=a,i.m31=c,i.m32=h,i},e.multiplyTranslation=function(t,n,i){var r=e.createTranslation(n,i);return e.multiply(t,r)},e.prototype.determinant=function(){return this.m11*this.m22-this.m12*this.m21},e.invert=function(t,n){void 0===n&&(n=new e);var i=1/t.determinant();return n.m11=t.m22*i,n.m12=-t.m12*i,n.m21=-t.m21*i,n.m22=t.m11*i,n.m31=(t.m32*t.m21-t.m31*t.m22)*i,n.m32=-(t.m32*t.m11-t.m31*t.m12)*i,n},e.createTranslation=function(t,n){var i=new e;return i.m11=1,i.m12=0,i.m21=0,i.m22=1,i.m31=t,i.m32=n,i},e.createTranslationVector=function(t){return this.createTranslation(t.x,t.y)},e.createRotation=function(t,n){n=new e;var i=Math.cos(t),r=Math.sin(t);return n.m11=i,n.m12=r,n.m21=-r,n.m22=i,n},e.createScale=function(t,n,i){return void 0===i&&(i=new e),i.m11=t,i.m12=0,i.m21=0,i.m22=n,i.m31=0,i.m32=0,i},e.prototype.toEgretMatrix=function(){return new egret.Matrix(this.m11,this.m12,this.m21,this.m22,this.m31,this.m32)},e._identity=new e(1,0,0,1,0,0),e}();t.Matrix2D=e}(es||(es={})),function(t){var e=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return __extends(n,e),Object.defineProperty(n.prototype,"max",{get:function(){return new t.Vector2(this.right,this.bottom)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"center",{get:function(){return new t.Vector2(this.x+this.width/2,this.y+this.height/2)},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"location",{get:function(){return new t.Vector2(this.x,this.y)},set:function(t){this.x=t.x,this.y=t.y},enumerable:!0,configurable:!0}),Object.defineProperty(n.prototype,"size",{get:function(){return new t.Vector2(this.width,this.height)},set:function(t){this.width=t.x,this.height=t.y},enumerable:!0,configurable:!0}),n.prototype.intersects=function(t){return t.left<this.right&&this.left<t.right&&t.top<this.bottom&&this.top<t.bottom},n.prototype.containsRect=function(t){return this.x<=t.x&&t.x<this.x+this.width&&this.y<=t.y&&t.y<this.y+this.height},n.prototype.getHalfSize=function(){return new t.Vector2(.5*this.width,.5*this.height)},n.fromMinMax=function(t,e,i,r){return new n(t,e,i-t,r-e)},n.prototype.getClosestPointOnRectangleBorderToPoint=function(e){var n=t.Vector2.zero,i=new t.Vector2;if(i.x=t.MathHelper.clamp(e.x,this.left,this.right),i.y=t.MathHelper.clamp(e.y,this.top,this.bottom),this.contains(i.x,i.y)){var r=i.x-this.left,o=this.right-i.x,s=i.y-this.top,a=this.bottom-i.y,c=Math.min(r,o,s,a);c==s?(i.y=this.top,n.y=-1):c==a?(i.y=this.bottom,n.y=1):c==r?(i.x=this.left,n.x=-1):(i.x=this.right,n.x=1)}else i.x==this.left&&(n.x=-1),i.x==this.right&&(n.x=1),i.y==this.top&&(n.y=-1),i.y==this.bottom&&(n.y=1);return{res:i,edgeNormal:n}},n.prototype.getClosestPointOnBoundsToOrigin=function(){var e=this.max,n=Math.abs(this.location.x),i=new t.Vector2(this.location.x,0);return Math.abs(e.x)<n&&(n=Math.abs(e.x),i.x=e.x,i.y=0),Math.abs(e.y)<n&&(n=Math.abs(e.y),i.x=0,i.y=e.y),Math.abs(this.location.y)<n&&(n=Math.abs(this.location.y),i.x=0,i.y=this.location.y),i},n.prototype.calculateBounds=function(t,e,n,i,r,o,s){this.x=t.x+e.x-n.x*i.x,this.y=t.y+e.y-n.y*i.y,this.width=o*i.x,this.height=s*i.y},n.prototype.setEgretRect=function(t){return this.x=t.x,this.y=t.y,this.width=t.width,this.height=t.height,this},n.rectEncompassingPoints=function(t){for(var e=Number.POSITIVE_INFINITY,n=Number.POSITIVE_INFINITY,i=Number.NEGATIVE_INFINITY,r=Number.NEGATIVE_INFINITY,o=0;o<t.length;o++){var s=t[o];s.x<e&&(e=s.x),s.x>i&&(i=s.x),s.y<n&&(n=s.y),s.y>r&&(r=s.y)}return this.fromMinMax(e,n,i,r)},n}(egret.Rectangle);t.Rectangle=e}(es||(es={})),function(t){var e=function(){return function(t,e,n){this.x=t,this.y=e,this.z=n}}();t.Vector3=e}(es||(es={})),function(t){var e=function(){function e(t){this._activeTriggerIntersections=[],this._previousTriggerIntersections=[],this._tempTriggerList=[],this._entity=t}return e.prototype.update=function(){for(var e=this._entity.getComponents(t.Collider),n=0;n<e.length;n++){var i=e[n],r=t.Physics.boxcastBroadphase(i.bounds,i.collidesWithLayers);i.bounds=r.rect;for(var o=r.colliders,s=function(e){var n=o[e];if(!i.isTrigger&&!n.isTrigger)return"continue";if(i.overlaps(n)){var r=new t.Pair(i,n);-1==a._activeTriggerIntersections.findIndex(function(t){return t.first==r.first&&t.second==r.second})&&-1==a._previousTriggerIntersections.findIndex(function(t){return t.first==r.first&&t.second==r.second})&&a.notifyTriggerListeners(r,!0),a._activeTriggerIntersections.contains(r)||a._activeTriggerIntersections.push(r)}},a=this,c=0;c<o.length;c++)s(c)}t.ListPool.free(e),this.checkForExitedColliders()},e.prototype.checkForExitedColliders=function(){for(var t=this,e=function(e){var i=n._previousTriggerIntersections.findIndex(function(n){return n.first==t._activeTriggerIntersections[e].first&&n.second==t._activeTriggerIntersections[e].second});-1!=i&&n._previousTriggerIntersections.removeAt(i)},n=this,i=0;i<this._activeTriggerIntersections.length;i++)e(i);for(i=0;i<this._previousTriggerIntersections.length;i++)this.notifyTriggerListeners(this._previousTriggerIntersections[i],!1);this._previousTriggerIntersections.length=0;for(i=0;i<this._activeTriggerIntersections.length;i++)this._previousTriggerIntersections.contains(this._activeTriggerIntersections[i])||this._previousTriggerIntersections.push(this._activeTriggerIntersections[i]);this._activeTriggerIntersections.length=0},e.prototype.notifyTriggerListeners=function(t,e){t.first.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var n=0;n<this._tempTriggerList.length;n++)if(e?this._tempTriggerList[n].onTriggerEnter(t.second,t.first):this._tempTriggerList[n].onTriggerExit(t.second,t.first),this._tempTriggerList.length=0,t.second.entity){t.second.entity.getComponents("ITriggerListener",this._tempTriggerList);for(var i=0;i<this._tempTriggerList.length;i++)e?this._tempTriggerList[i].onTriggerEnter(t.first,t.second):this._tempTriggerList[i].onTriggerExit(t.first,t.second);this._tempTriggerList.length=0}},e}();t.ColliderTriggerHelper=e}(es||(es={})),function(t){var e;!function(t){t[t.center=0]="center",t[t.top=1]="top",t[t.bottom=2]="bottom",t[t.topLeft=9]="topLeft",t[t.topRight=5]="topRight",t[t.left=8]="left",t[t.right=4]="right",t[t.bottomLeft=10]="bottomLeft",t[t.bottomRight=6]="bottomRight"}(e=t.PointSectors||(t.PointSectors={}));var n=function(){function n(){}return n.isLineToLine=function(e,n,i,r){var o=t.Vector2.subtract(n,e),s=t.Vector2.subtract(r,i),a=o.x*s.y-o.y*s.x;if(0==a)return!1;var c=t.Vector2.subtract(i,e),h=(c.x*s.y-c.y*s.x)/a;if(h<0||h>1)return!1;var u=(c.x*o.y-c.y*o.x)/a;return!(u<0||u>1)},n.lineToLineIntersection=function(e,n,i,r){var o=new t.Vector2(0,0),s=t.Vector2.subtract(n,e),a=t.Vector2.subtract(r,i),c=s.x*a.y-s.y*a.x;if(0==c)return o;var h=t.Vector2.subtract(i,e),u=(h.x*a.y-h.y*a.x)/c;if(u<0||u>1)return o;var l=(h.x*s.y-h.y*s.x)/c;return l<0||l>1?o:o=t.Vector2.add(e,new t.Vector2(u*s.x,u*s.y))},n.closestPointOnLine=function(e,n,i){var r=t.Vector2.subtract(n,e),o=t.Vector2.subtract(i,e),s=t.Vector2.dot(o,r)/t.Vector2.dot(r,r);return s=t.MathHelper.clamp(s,0,1),t.Vector2.add(e,new t.Vector2(r.x*s,r.y*s))},n.isCircleToCircle=function(e,n,i,r){return t.Vector2.distanceSquared(e,i)<(n+r)*(n+r)},n.isCircleToLine=function(e,n,i,r){return t.Vector2.distanceSquared(e,this.closestPointOnLine(i,r,e))<n*n},n.isCircleToPoint=function(e,n,i){return t.Vector2.distanceSquared(e,i)<n*n},n.isRectToCircle=function(t,e,n){var i=.5*t.width,r=.5*t.height,o=Math.max(0,Math.max(e.x-t.x)-i),s=Math.max(0,Math.max(e.y-t.y)-r);return o*o+s*s<n*n},n.isRectToLine=function(n,i,r){var o=this.getSector(n.x,n.y,n.width,n.height,i),s=this.getSector(n.x,n.y,n.width,n.height,r);if(o==e.center||s==e.center)return!0;if(0!=(o&s))return!1;var a=o|s,c=void 0,h=void 0;return!(0==(a&e.top)||(c=new t.Vector2(n.x,n.y),h=new t.Vector2(n.x+n.width,n.y),!this.isLineToLine(c,h,i,r)))||(!(0==(a&e.bottom)||(c=new t.Vector2(n.x,n.y+n.height),h=new t.Vector2(n.x+n.width,n.y+n.height),!this.isLineToLine(c,h,i,r)))||(!(0==(a&e.left)||(c=new t.Vector2(n.x,n.y),h=new t.Vector2(n.x,n.y+n.height),!this.isLineToLine(c,h,i,r)))||!(0==(a&e.right)||(c=new t.Vector2(n.x+n.width,n.y),h=new t.Vector2(n.x+n.width,n.y+n.height),!this.isLineToLine(c,h,i,r)))))},n.isRectToPoint=function(t,e,n,i,r){return r.x>=t&&r.y>=e&&r.x<t+n&&r.y<e+i},n.getSector=function(t,n,i,r,o){var s=e.center;return o.x<t?s|=e.left:o.x>=t+i&&(s|=e.right),o.y<n?s|=e.top:o.y>=n+r&&(s|=e.bottom),s},n}();t.Collisions=n}(es||(es={})),function(t){var e=function(){function e(){}return e.reset=function(){this._spatialHash=new t.SpatialHash(this.spatialHashCellSize)},e.clear=function(){this._spatialHash.clear()},e.overlapCircleAll=function(t,e,n,i){return void 0===i&&(i=-1),this._spatialHash.overlapCircle(t,e,n,i)},e.boxcastBroadphase=function(t,e){void 0===e&&(e=this.allLayers);var n=this._spatialHash.aabbBroadphase(t,null,e);return{colliders:n.tempHashSet,rect:n.bounds}},e.boxcastBroadphaseExcludingSelf=function(t,e,n){return void 0===n&&(n=this.allLayers),this._spatialHash.aabbBroadphase(e,t,n)},e.addCollider=function(t){e._spatialHash.register(t)},e.removeCollider=function(t){e._spatialHash.remove(t)},e.updateCollider=function(t){this._spatialHash.remove(t),this._spatialHash.register(t)},e.debugDraw=function(t){this._spatialHash.debugDraw(t,2)},e.spatialHashCellSize=100,e.allLayers=-1,e}();t.Physics=e}(es||(es={})),function(t){var e=function(){return function(){}}();t.Shape=e}(es||(es={})),function(t){var e=function(e){function n(t,n){var i=e.call(this)||this;return i._areEdgeNormalsDirty=!0,i.isUnrotated=!0,i.setPoints(t),i.isBox=n,i}return __extends(n,e),Object.defineProperty(n.prototype,"edgeNormals",{get:function(){return this._areEdgeNormalsDirty&&this.buildEdgeNormals(),this._edgeNormals},enumerable:!0,configurable:!0}),n.prototype.setPoints=function(t){this.points=t,this.recalculateCenterAndEdgeNormals(),this._originalPoints=[];for(var e=0;e<this.points.length;e++)this._originalPoints.push(this.points[e])},n.prototype.recalculateCenterAndEdgeNormals=function(){this._polygonCenter=n.findPolygonCenter(this.points),this._areEdgeNormalsDirty=!0},n.prototype.buildEdgeNormals=function(){var e,n=this.isBox?2:this.points.length;null!=this._edgeNormals&&this._edgeNormals.length==n||(this._edgeNormals=new Array(n));for(var i=0;i<n;i++){var r=this.points[i];e=i+1>=this.points.length?this.points[0]:this.points[i+1];var o=t.Vector2Ext.perpendicular(r,e);o=t.Vector2.normalize(o),this._edgeNormals[i]=o}},n.buildSymmetricalPolygon=function(e,n){for(var i=new Array(e),r=0;r<e;r++){var o=2*Math.PI*(r/e);i[r]=new t.Vector2(Math.cos(o),Math.sin(o)*n)}return i},n.recenterPolygonVerts=function(e){for(var n=this.findPolygonCenter(e),i=0;i<e.length;i++)e[i]=t.Vector2.subtract(e[i],n)},n.findPolygonCenter=function(e){for(var n=0,i=0,r=0;r<e.length;r++)n+=e[r].x,i+=e[r].y;return new t.Vector2(n/e.length,i/e.length)},n.getClosestPointOnPolygonToPoint=function(e,n){for(var i,r=Number.MAX_VALUE,o=new t.Vector2(0,0),s=new t.Vector2(0,0),a=0;a<e.length;a++){var c=a+1;c==e.length&&(c=0);var h=t.ShapeCollisions.closestPointOnLine(e[a],e[c],n);if((i=t.Vector2.distanceSquared(n,h))<r){r=i,s=h;var u=t.Vector2.subtract(e[c],e[a]);o.x=-u.y,o.y=u.x}}return{closestPoint:s,distanceSquared:r,edgeNormal:o=t.Vector2.normalize(o)}},n.prototype.recalculateBounds=function(e){this.center=e.localOffset,e.shouldColliderScaleAndRotateWithTransform&&(this.isUnrotated=0==e.entity.transform.rotation),this.position=t.Vector2.add(e.entity.transform.position,this.center),this.bounds=t.Rectangle.rectEncompassingPoints(this.points),this.bounds.location=t.Vector2.add(this.bounds.location,this.position)},n.prototype.overlaps=function(e){var i;if(e instanceof n)return t.ShapeCollisions.polygonToPolygon(this,e);if(e instanceof t.Circle)return!!(i=t.ShapeCollisions.circleToPolygon(e,this))&&(i.invertResult(),!0);throw new Error("overlaps of Pologon to "+e+" are not supported")},n.prototype.collidesWithShape=function(e){var i=new t.CollisionResult;if(e instanceof n)return t.ShapeCollisions.polygonToPolygon(this,e);if(e instanceof t.Circle)return(i=t.ShapeCollisions.circleToPolygon(e,this))?(i.invertResult(),i):null;throw new Error("overlaps of Polygon to "+e+" are not supported")},n.prototype.containsPoint=function(e){e=t.Vector2.subtract(e,this.position);for(var n=!1,i=0,r=this.points.length-1;i<this.points.length;r=i++)this.points[i].y>e.y!=this.points[r].y>e.y&&e.x<(this.points[r].x-this.points[i].x)*(e.y-this.points[i].y)/(this.points[r].y-this.points[i].y)+this.points[i].x&&(n=!n);return n},n.prototype.pointCollidesWithShape=function(e){return t.ShapeCollisions.pointToPoly(e,this)},n}(t.Shape);t.Polygon=e}(es||(es={})),function(t){var e=function(e){function n(t,i){var r=e.call(this,n.buildBox(t,i),!0)||this;return r.width=t,r.height=i,r}return __extends(n,e),n.buildBox=function(e,n){var i=e/2,r=n/2,o=new Array(4);return o[0]=new t.Vector2(-i,-r),o[1]=new t.Vector2(i,-r),o[2]=new t.Vector2(i,r),o[3]=new t.Vector2(-i,r),o},n.prototype.updateBox=function(e,n){this.width=e,this.height=n;var i=e/2,r=n/2;this.points[0]=new t.Vector2(-i,-r),this.points[1]=new t.Vector2(i,-r),this.points[2]=new t.Vector2(i,r),this.points[3]=new t.Vector2(-i,r);for(var o=0;o<this.points.length;o++)this._originalPoints[o]=this.points[o]},n.prototype.overlaps=function(i){if(this.isUnrotated){if(i instanceof n)return this.bounds.intersects(i.bounds);if(i instanceof t.Circle)return t.Collisions.isRectToCircle(this.bounds,i.position,i.radius)}return e.prototype.overlaps.call(this,i)},n.prototype.collidesWithShape=function(i){return i instanceof n&&i.isUnrotated?t.ShapeCollisions.boxToBox(this,i):e.prototype.collidesWithShape.call(this,i)},n.prototype.containsPoint=function(t){return this.isUnrotated?this.bounds.contains(t.x,t.y):e.prototype.containsPoint.call(this,t)},n}(t.Polygon);t.Box=e}(es||(es={})),function(t){var e=function(e){function n(t){var n=e.call(this)||this;return n.radius=t,n._originalRadius=t,n}return __extends(n,e),n.prototype.recalculateBounds=function(e){if(this.center=e.localOffset,e.shouldColliderScaleAndRotateWithTransform){var n=e.entity.transform.scale,i=1==n.x&&1==n.y,r=Math.max(n.x,n.y);if(this.radius=this._originalRadius*r,0!=e.entity.transform.rotation){var o=Math.atan2(e.localOffset.y,e.localOffset.x)*t.MathHelper.Rad2Deg,s=i?e._localOffsetLength:t.Vector2.multiply(e.localOffset,e.entity.transform.scale).length();this.center=t.MathHelper.pointOnCirlce(t.Vector2.zero,s,e.entity.transform.rotation+o)}}this.position=t.Vector2.add(e.transform.position,this.center),this.bounds=new t.Rectangle(this.position.x-this.radius,this.position.y-this.radius,2*this.radius,2*this.radius)},n.prototype.overlaps=function(e){if(e instanceof t.Box&&e.isUnrotated)return t.Collisions.isRectToCircle(e.bounds,this.position,this.radius);if(e instanceof n)return t.Collisions.isCircleToCircle(this.position,this.radius,e.position,e.radius);if(e instanceof t.Polygon)return t.ShapeCollisions.circleToPolygon(this,e);throw new Error("overlaps of circle to "+e+" are not supported")},n.prototype.collidesWithShape=function(e){if(e instanceof t.Box&&e.isUnrotated)return t.ShapeCollisions.circleToBox(this,e);if(e instanceof n)return t.ShapeCollisions.circleToCircle(this,e);if(e instanceof t.Polygon)return t.ShapeCollisions.circleToPolygon(this,e);throw new Error("Collisions of Circle to "+e+" are not supported")},n.prototype.pointCollidesWithShape=function(e){return t.ShapeCollisions.pointToCircle(e,this)},n}(t.Shape);t.Circle=e}(es||(es={})),function(t){var e=function(){function e(){this.minimumTranslationVector=t.Vector2.zero,this.normal=t.Vector2.zero,this.point=t.Vector2.zero}return e.prototype.invertResult=function(){this.minimumTranslationVector=t.Vector2.negate(this.minimumTranslationVector),this.normal=t.Vector2.negate(this.normal)},e}();t.CollisionResult=e}(es||(es={})),function(t){var e=function(){function e(){}return e.polygonToPolygon=function(e,n){for(var i,r=new t.CollisionResult,o=!0,s=e.edgeNormals,a=n.edgeNormals,c=Number.POSITIVE_INFINITY,h=new t.Vector2,u=t.Vector2.subtract(e.position,n.position),l=0;l<s.length+a.length;l++){i=l<s.length?s[l]:a[l-s.length];var p=0,d=0,f=0,g=0,m=0,y=this.getInterval(i,e,p,f);p=y.min,d=y.max;var _=this.getInterval(i,n,d,g);d=_.min,g=_.max;var v=t.Vector2.dot(u,i);if(p+=v,f+=v,(m=this.intervalDistance(p,f,d,g))>0&&(o=!1),!o)return null;(m=Math.abs(m))<c&&(c=m,h=i,t.Vector2.dot(h,u)<0&&(h=new t.Vector2(-h)))}return r.normal=h,r.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(-h.x,-h.y),new t.Vector2(c)),r},e.intervalDistance=function(t,e,n,i){return t<n?n-e:t-n},e.getInterval=function(e,n,i,r){var o=t.Vector2.dot(n.points[0],e);i=r=o;for(var s=1;s<n.points.length;s++)(o=t.Vector2.dot(n.points[s],e))<i?i=o:o>r&&(r=o);return{min:i,max:r}},e.circleToPolygon=function(e,n){var i=new t.CollisionResult,r=t.Vector2.subtract(e.position,n.position),o=t.Polygon.getClosestPointOnPolygonToPoint(n.points,r),s=o.closestPoint,a=o.distanceSquared;i.normal=o.edgeNormal;var c,h=n.containsPoint(e.position);if(a>e.radius*e.radius&&!h)return null;if(h)c=t.Vector2.multiply(i.normal,new t.Vector2(Math.sqrt(a)-e.radius));else if(0==a)c=t.Vector2.multiply(i.normal,new t.Vector2(e.radius));else{var u=Math.sqrt(a);c=t.Vector2.multiply(new t.Vector2(-t.Vector2.subtract(r,s)),new t.Vector2((e.radius-a)/u))}return i.minimumTranslationVector=c,i.point=t.Vector2.add(s,n.position),i},e.circleToBox=function(e,n){var i=new t.CollisionResult,r=n.bounds.getClosestPointOnRectangleBorderToPoint(e.position).res;if(n.containsPoint(e.position)){i.point=r;var o=t.Vector2.add(r,t.Vector2.subtract(i.normal,new t.Vector2(e.radius)));return i.minimumTranslationVector=t.Vector2.subtract(e.position,o),i}var s=t.Vector2.distanceSquared(r,e.position);if(0==s)i.minimumTranslationVector=t.Vector2.multiply(i.normal,new t.Vector2(e.radius));else if(s<=e.radius*e.radius){i.normal=t.Vector2.subtract(e.position,r);var a=i.normal.length()-e.radius;return i.normal=t.Vector2Ext.normalize(i.normal),i.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(a),i.normal),i}return null},e.pointToCircle=function(e,n){var i=new t.CollisionResult,r=t.Vector2.distanceSquared(e,n.position),o=1+n.radius;if(r<o*o){i.normal=t.Vector2.normalize(t.Vector2.subtract(e,n.position));var s=o-Math.sqrt(r);return i.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(-s,-s),i.normal),i.point=t.Vector2.add(n.position,t.Vector2.multiply(i.normal,new t.Vector2(n.radius,n.radius))),i}return null},e.closestPointOnLine=function(e,n,i){var r=t.Vector2.subtract(n,e),o=t.Vector2.subtract(i,e),s=t.Vector2.dot(o,r)/t.Vector2.dot(r,r);return s=t.MathHelper.clamp(s,0,1),t.Vector2.add(e,t.Vector2.multiply(r,new t.Vector2(s,s)))},e.pointToPoly=function(e,n){var i=new t.CollisionResult;if(n.containsPoint(e)){var r,o=t.Polygon.getClosestPointOnPolygonToPoint(n.points,t.Vector2.subtract(e,n.position)),s=o.closestPoint;return r=o.distanceSquared,i.normal=o.edgeNormal,i.minimumTranslationVector=t.Vector2.multiply(i.normal,new t.Vector2(Math.sqrt(r),Math.sqrt(r))),i.point=t.Vector2.add(s,n.position),i}return null},e.circleToCircle=function(e,n){var i=new t.CollisionResult,r=t.Vector2.distanceSquared(e.position,n.position),o=e.radius+n.radius;if(r<o*o){i.normal=t.Vector2.normalize(t.Vector2.subtract(e.position,n.position));var s=o-Math.sqrt(r);return i.minimumTranslationVector=t.Vector2.multiply(new t.Vector2(-s),i.normal),i.point=t.Vector2.add(n.position,t.Vector2.multiply(i.normal,new t.Vector2(n.radius))),i}return null},e.boxToBox=function(e,n){var i=new t.CollisionResult,r=this.minkowskiDifference(e,n);return r.contains(0,0)?(i.minimumTranslationVector=r.getClosestPointOnBoundsToOrigin(),0==i.minimumTranslationVector.x&&0==i.minimumTranslationVector.y?null:(i.normal=new t.Vector2(-i.minimumTranslationVector.x,-i.minimumTranslationVector.y),i.normal.normalize(),i)):null},e.minkowskiDifference=function(e,n){var i=t.Vector2.subtract(e.position,t.Vector2.add(e.bounds.location,t.Vector2.divide(e.bounds.size,new t.Vector2(2)))),r=t.Vector2.subtract(t.Vector2.add(e.bounds.location,i),n.bounds.max),o=t.Vector2.add(e.bounds.size,n.bounds.size);return new t.Rectangle(r.x,r.y,o.x,o.y)},e}();t.ShapeCollisions=e}(es||(es={})),function(t){var e=function(){function e(e){void 0===e&&(e=100),this.gridBounds=new t.Rectangle,this._overlapTestCircle=new t.Circle(0),this._cellDict=new n,this._tempHashSet=[],this._cellSize=e,this._inverseCellSize=1/this._cellSize,this._raycastParser=new i}return e.prototype.cellCoords=function(e,n){return new t.Vector2(Math.floor(e*this._inverseCellSize),Math.floor(n*this._inverseCellSize))},e.prototype.cellAtPosition=function(t,e,n){void 0===n&&(n=!1);var i=this._cellDict.tryGetValue(t,e);return i||n&&(i=[],this._cellDict.add(t,e,i)),i},e.prototype.register=function(e){var n=e.bounds;e.registeredPhysicsBounds=n;var i=this.cellCoords(n.x,n.y),r=this.cellCoords(n.right,n.bottom);this.gridBounds.contains(i.x,i.y)||(this.gridBounds=t.RectangleExt.union(this.gridBounds,i)),this.gridBounds.contains(r.x,r.y)||(this.gridBounds=t.RectangleExt.union(this.gridBounds,r));for(var o=i.x;o<=r.x;o++)for(var s=i.y;s<=r.y;s++){var a=this.cellAtPosition(o,s,!0);-1==a.indexOf(e)&&a.push(e)}},e.prototype.remove=function(t){for(var e=t.registeredPhysicsBounds,n=this.cellCoords(e.x,e.y),i=this.cellCoords(e.right,e.bottom),r=n.x;r<=i.x;r++)for(var o=n.y;o<=i.y;o++){var s=this.cellAtPosition(r,o);s?s.remove(t):console.error("removing Collider ["+t+"] from a cell that it is not present in")}},e.prototype.removeWithBruteForce=function(t){this._cellDict.remove(t)},e.prototype.clear=function(){this._cellDict.clear()},e.prototype.debugDraw=function(t,e){void 0===e&&(e=1);for(var n=this.gridBounds.x;n<=this.gridBounds.right;n++)for(var i=this.gridBounds.y;i<=this.gridBounds.bottom;i++){var r=this.cellAtPosition(n,i);r&&r.length>0&&this.debugDrawCellDetails(n,i,r.length,t,e)}},e.prototype.debugDrawCellDetails=function(t,e,n,i,r){void 0===i&&(i=.5),void 0===r&&(r=1)},e.prototype.aabbBroadphase=function(e,n,i){this._tempHashSet.length=0;for(var r=this.cellCoords(e.x,e.y),o=this.cellCoords(e.right,e.bottom),s=r.x;s<=o.x;s++)for(var a=r.y;a<=o.y;a++){var c=this.cellAtPosition(s,a);if(c)for(var h=0;h<c.length;h++){var u=c[h];u!=n&&t.Flags.isFlagSet(i,u.physicsLayer)&&(e.intersects(u.bounds)&&-1==this._tempHashSet.indexOf(u)&&this._tempHashSet.push(u))}}return{tempHashSet:this._tempHashSet,bounds:e}},e.prototype.overlapCircle=function(e,n,i,r){var o=new t.Rectangle(e.x-n,e.y-n,2*n,2*n);this._overlapTestCircle.radius=n,this._overlapTestCircle.position=e;var s=0,a=this.aabbBroadphase(o,null,r);o=a.bounds;for(var c=a.tempHashSet,h=0;h<c.length;h++){var u=c[h];if(u instanceof t.BoxCollider)i[s]=u,s++;else if(u instanceof t.CircleCollider)u.shape.overlaps(this._overlapTestCircle)&&(i[s]=u,s++);else{if(!(u instanceof t.PolygonCollider))throw new Error("overlapCircle against this collider type is not implemented!");u.shape.overlaps(this._overlapTestCircle)&&(i[s]=u,s++)}if(s==i.length)return s}return s},e}();t.SpatialHash=e;var n=function(){function t(){this._store=new Map}return t.prototype.getKey=function(t,e){return Long.fromNumber(t).shiftLeft(32).or(Long.fromNumber(e,!1)).toString()},t.prototype.add=function(t,e,n){this._store.set(this.getKey(t,e),n)},t.prototype.remove=function(t){this._store.forEach(function(e){e.contains(t)&&e.remove(t)})},t.prototype.tryGetValue=function(t,e){return this._store.get(this.getKey(t,e))},t.prototype.clear=function(){this._store.clear()},t}();t.NumberDictionary=n;var i=function(){return function(){}}();t.RaycastResultParser=i}(es||(es={}));var ArrayUtils=function(){function t(){}return t.bubbleSort=function(t){for(var e=!1,n=0;n<t.length;n++){e=!1;for(var i=t.length-1;i>n;i--)if(t[i]<t[i-1]){var r=t[i];t[i]=t[i-1],t[i-1]=r,e=!0}if(!e)break}},t.insertionSort=function(t){for(var e=t.length,n=1;n<e;n++){for(var i=t[n],r=n;r>0&&t[r-1]>i;r--)t[r]=t[r-1];t[r]=i}},t.binarySearch=function(t,e){for(var n=0,i=t.length,r=n+i>>1;n<i;)e<=t[r]?i=r:e>=t[r]&&(n=r+1),r=n+i>>1;return t[n]==e?n:-1},t.findElementIndex=function(t,e){for(var n=t.length,i=0;i<n;++i)if(t[i]==e)return i;return null},t.getMaxElementIndex=function(t){for(var e=0,n=t.length,i=1;i<n;i++)t[i]>t[e]&&(e=i);return e},t.getMinElementIndex=function(t){for(var e=0,n=t.length,i=1;i<n;i++)t[i]<t[e]&&(e=i);return e},t.getUniqueAry=function(t){for(var e=[],n=[],i=t.length,r=0;r<i;++r){var o=t[r];-1==e.indexOf(o)&&e.push(o)}for(r=(i=e.length)-1;r>=0;--r)n.unshift(e[r]);return n},t.getDifferAry=function(t,e){t=this.getUniqueAry(t),e=this.getUniqueAry(e);for(var n=t.concat(e),i=new Object,r=[],o=n.length,s=0;s<o;++s)i[n[s]]?i[n[s]]instanceof Object&&i[n[s]].count++:(i[n[s]]=new Object,i[n[s]].count=0,i[n[s]].key=n[s],i[n[s]].count++);for(var a in i)2!=i[a].count&&r.unshift(i[a].key);return r},t.swap=function(t,e,n){var i=t[e];t[e]=t[n],t[n]=i},t.clearList=function(t){if(t)for(var e=t.length-1;e>=0;e-=1)t.splice(e,1)},t.cloneList=function(t){return t?t.slice(0,t.length):null},t.equals=function(t,e){if(t==e)return!0;var n=t.length;if(n!=e.length)return!1;for(;n--;)if(t[n]!=e[n])return!1;return!0},t.insert=function(t,e,n){if(!t)return null;var i=t.length;if(e>i&&(e=i),e<0&&(e=0),e==i)t.push(n);else if(0==e)t.unshift(n);else{for(var r=i-1;r>=e;r-=1)t[r+1]=t[r];t[e]=n}return n},t}(),Base64Utils=function(){function t(){}return t._utf8_encode=function(t){t=t.replace(/\r\n/g,"\n");for(var e="",n=0;n<t.length;n++){var i=t.charCodeAt(n);i<128?e+=String.fromCharCode(i):i>127&&i<2048?(e+=String.fromCharCode(i>>6|192),e+=String.fromCharCode(63&i|128)):(e+=String.fromCharCode(i>>12|224),e+=String.fromCharCode(i>>6&63|128),e+=String.fromCharCode(63&i|128))}return e},t.decode=function(t,e){void 0===e&&(e=!0);var n,i,r,o,s,a,c="",h=0;for(t=(t=this.getConfKey(t)).replace(/[^A-Za-z0-9\+\/\=]/g,"");h<t.length;)n=this._keyAll.indexOf(t.charAt(h++))<<2|(o=this._keyAll.indexOf(t.charAt(h++)))>>4,i=(15&o)<<4|(s=this._keyAll.indexOf(t.charAt(h++)))>>2,r=(3&s)<<6|(a=this._keyAll.indexOf(t.charAt(h++))),c+=String.fromCharCode(n),64!=s&&(0==i?e&&(c+=String.fromCharCode(i)):c+=String.fromCharCode(i)),64!=a&&(0==r?e&&(c+=String.fromCharCode(r)):c+=String.fromCharCode(r));return c=this._utf8_decode(c)},t._utf8_decode=function(t){for(var e="",n=0,i=0,r=0,o=0;n<t.length;)(i=t.charCodeAt(n))<128?(e+=String.fromCharCode(i),n++):i>191&&i<224?(r=t.charCodeAt(n+1),e+=String.fromCharCode((31&i)<<6|63&r),n+=2):(r=t.charCodeAt(n+1),o=t.charCodeAt(n+2),e+=String.fromCharCode((15&i)<<12|(63&r)<<6|63&o),n+=3);return e},t.getConfKey=function(t){return t.slice(1,t.length)},t._keyNum="0123456789+/",t._keyStr="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",t._keyAll=t._keyNum+t._keyStr,t.encode=function(t){var e,n,i,r,o,s,a,c="",h=0;for(t=this._utf8_encode(t);h<t.length;)r=(e=t.charCodeAt(h++))>>2,o=(3&e)<<4|(n=t.charCodeAt(h++))>>4,s=(15&n)<<2|(i=t.charCodeAt(h++))>>6,a=63&i,isNaN(n)?s=a=64:isNaN(i)&&(a=64),c=c+this._keyAll.charAt(r)+this._keyAll.charAt(o)+this._keyAll.charAt(s)+this._keyAll.charAt(a);return this._keyStr.charAt(Math.floor(Math.random()*this._keyStr.length))+c},t}();!function(t){var e=function(){function t(){this.loadedAssets=new Map}return t.prototype.loadRes=function(t,e){var n=this;return void 0===e&&(e=!0),new Promise(function(i,r){var o=n.loadedAssets.get(t);o?i(o):e?RES.getResAsync(t).then(function(e){n.loadedAssets.set(t,e),i(e)}).catch(function(e){console.error("资源加载错误:",t,e),r(e)}):RES.getResByUrl(t).then(function(e){n.loadedAssets.set(t,e),i(e)}).catch(function(e){console.error("资源加载错误:",t,e),r(e)})})},t.prototype.dispose=function(){this.loadedAssets.forEach(function(t){t.dispose()}),this.loadedAssets.clear()},t}();t.ContentManager=e}(es||(es={})),function(t){var e=function(){function e(){}return e.drawLine=function(e,n,i,r,o){void 0===o&&(o=1),this.drawLineAngle(e,n,t.MathHelper.angleBetweenVectors(n,i),t.Vector2.distance(n,i),r,o)},e.drawLineAngle=function(t,e,n,i,r,o){void 0===o&&(o=1),t.graphics.beginFill(r),t.graphics.drawRect(e.x,e.y,1,1),t.graphics.endFill(),t.scaleX=i,t.scaleY=o,t.$anchorOffsetX=0,t.$anchorOffsetY=0,t.rotation=n},e.drawHollowRect=function(t,e,n,i){void 0===i&&(i=1),this.drawHollowRectR(t,e.x,e.y,e.width,e.height,n,i)},e.drawHollowRectR=function(e,n,i,r,o,s,a){void 0===a&&(a=1);var c=new t.Vector2(n,i).round(),h=new t.Vector2(n+r,i).round(),u=new t.Vector2(n+r,i+o).round(),l=new t.Vector2(n,i+o).round();this.drawLine(e,c,h,s,a),this.drawLine(e,h,u,s,a),this.drawLine(e,u,l,s,a),this.drawLine(e,l,c,s,a)},e.drawPixel=function(e,n,i,r){void 0===r&&(r=1);var o=new t.Rectangle(n.x,n.y,r,r);1!=r&&(o.x-=.5*r,o.y-=.5*r),e.graphics.beginFill(i),e.graphics.drawRect(o.x,o.y,o.width,o.height),e.graphics.endFill()},e.getColorMatrix=function(t){var e=[1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0];return e[0]=Math.floor(t/256/256)/255,e[6]=Math.floor(t/256%256)/255,e[12]=t%256/255,new egret.ColorMatrixFilter(e)},e}();t.DrawUtils=e}(es||(es={})),function(t){var e=function(){return function(t,e){this.func=t,this.context=e}}();t.FuncPack=e;var n=function(){function t(){this._messageTable=new Map}return t.prototype.addObserver=function(t,n,i){var r=this._messageTable.get(t);r||(r=[],this._messageTable.set(t,r)),r.contains(n)&&console.warn("您试图添加相同的观察者两次"),r.push(new e(n,i))},t.prototype.removeObserver=function(t,e){var n=this._messageTable.get(t),i=n.findIndex(function(t){return t.func==e});-1!=i&&n.removeAt(i)},t.prototype.emit=function(t,e){var n=this._messageTable.get(t);if(n)for(var i=n.length-1;i>=0;i--)n[i].func.call(n[i].context,e)},t}();t.Emitter=n}(es||(es={})),function(t){var e=function(){function t(){}return Object.defineProperty(t.prototype,"enabled",{get:function(){return this._enabled},set:function(t){this.setEnabled(t)},enumerable:!0,configurable:!0}),t.prototype.setEnabled=function(t){this._enabled!=t&&(this._enabled=t,this._enabled?this.onEnabled():this.onDisabled())},t.prototype.onEnabled=function(){},t.prototype.onDisabled=function(){},t.prototype.update=function(){},t.registerGlobalManager=function(t){this.globalManagers.push(t),t.enabled=!0},t.unregisterGlobalManager=function(t){this.globalManagers.remove(t),t.enabled=!1},t.getGlobalManager=function(t){for(var e=0;e<this.globalManagers.length;e++)if(this.globalManagers[e]instanceof t)return this.globalManagers[e];return null},t.globalManagers=[],t}();t.GlobalManager=e}(es||(es={})),function(t){var e=function(){function e(){this.x=0,this.y=0,this.touchPoint=-1,this.touchDown=!1}return Object.defineProperty(e.prototype,"position",{get:function(){return new t.Vector2(this.x,this.y)},enumerable:!0,configurable:!0}),e.prototype.reset=function(){this.x=0,this.y=0,this.touchDown=!1,this.touchPoint=-1},e}();t.TouchState=e;var n=function(){function n(){}return Object.defineProperty(n,"touchPosition",{get:function(){return this._gameTouchs[0]?this._gameTouchs[0].position:t.Vector2.zero},enumerable:!0,configurable:!0}),Object.defineProperty(n,"maxSupportedTouch",{get:function(){return this._stage.maxTouches},set:function(t){this._stage.maxTouches=t,this.initTouchCache()},enumerable:!0,configurable:!0}),Object.defineProperty(n,"resolutionScale",{get:function(){return this._resolutionScale},enumerable:!0,configurable:!0}),Object.defineProperty(n,"totalTouchCount",{get:function(){return this._totalTouchCount},enumerable:!0,configurable:!0}),Object.defineProperty(n,"gameTouchs",{get:function(){return this._gameTouchs},enumerable:!0,configurable:!0}),Object.defineProperty(n,"touchPositionDelta",{get:function(){var e=t.Vector2.subtract(this.touchPosition,this._previousTouchState.position);return e.length()>0&&this.setpreviousTouchState(this._gameTouchs[0]),e},enumerable:!0,configurable:!0}),n.initialize=function(t){this._init||(this._init=!0,this._stage=t,this._stage.addEventListener(egret.TouchEvent.TOUCH_BEGIN,this.touchBegin,this),this._stage.addEventListener(egret.TouchEvent.TOUCH_MOVE,this.touchMove,this),this._stage.addEventListener(egret.TouchEvent.TOUCH_END,this.touchEnd,this),this._stage.addEventListener(egret.TouchEvent.TOUCH_CANCEL,this.touchEnd,this),this._stage.addEventListener(egret.TouchEvent.TOUCH_RELEASE_OUTSIDE,this.touchEnd,this),this.initTouchCache())},n.initTouchCache=function(){this._totalTouchCount=0,this._touchIndex=0,this._gameTouchs.length=0;for(var t=0;t<this.maxSupportedTouch;t++)this._gameTouchs.push(new e)},n.touchBegin=function(t){this._touchIndex<this.maxSupportedTouch&&(this._gameTouchs[this._touchIndex].touchPoint=t.touchPointID,this._gameTouchs[this._touchIndex].touchDown=t.touchDown,this._gameTouchs[this._touchIndex].x=t.stageX,this._gameTouchs[this._touchIndex].y=t.stageY,0==this._touchIndex&&this.setpreviousTouchState(this._gameTouchs[0]),this._touchIndex++,this._totalTouchCount++)},n.touchMove=function(t){t.touchPointID==this._gameTouchs[0].touchPoint&&this.setpreviousTouchState(this._gameTouchs[0]);var e=this._gameTouchs.findIndex(function(e){return e.touchPoint==t.touchPointID});if(-1!=e){var n=this._gameTouchs[e];n.x=t.stageX,n.y=t.stageY}},n.touchEnd=function(t){var e=this._gameTouchs.findIndex(function(e){return e.touchPoint==t.touchPointID});-1!=e&&(this._gameTouchs[e].reset(),0==e&&this._previousTouchState.reset(),this._totalTouchCount--,0==this.totalTouchCount&&(this._touchIndex=0))},n.setpreviousTouchState=function(t){this._previousTouchState=new e,this._previousTouchState.x=t.position.x,this._previousTouchState.y=t.position.y,this._previousTouchState.touchPoint=t.touchPoint,this._previousTouchState.touchDown=t.touchDown},n.scaledPosition=function(e){var n=new t.Vector2(e.x-this._resolutionOffset.x,e.y-this._resolutionOffset.y);return t.Vector2.multiply(n,this.resolutionScale)},n._init=!1,n._previousTouchState=new e,n._gameTouchs=[],n._resolutionOffset=new t.Vector2,n._resolutionScale=t.Vector2.one,n._touchIndex=0,n._totalTouchCount=0,n}();t.Input=n}(es||(es={}));var KeyboardUtils=function(){function t(){}return t.init=function(){this.keyDownDict={},this.keyUpDict={},document.addEventListener("keydown",this.onKeyDonwHander),document.addEventListener("keyup",this.onKeyUpHander)},t.onKeyDonwHander=function(t){if(this.keyDownDict){var e=this.keyCodeToString(t.keyCode),n=this.keyDownDict[e];if(n){var i=n.fun,r=n.thisObj,o=n.args;i.apply(r,o)}}},t.onKeyUpHander=function(t){if(this.keyUpDict){var e=this.keyCodeToString(t.keyCode),n=this.keyUpDict[e];if(n){var i=n.fun,r=n.thisObj,o=n.args;i.apply(r,o)}}},t.registerKey=function(t,e,n,i){void 0===i&&(i=0);for(var r=[],o=4;o<arguments.length;o++)r[o-4]=arguments[o];(i?this.keyUpDict:this.keyDownDict)[t]={fun:e,args:r,thisObj:n}},t.unregisterKey=function(t,e){void 0===e&&(e=0),delete(e?this.keyUpDict:this.keyDownDict)[t]},t.keyCodeToString=function(t){switch(t){case 8:return this.BACK_SPACE;case 9:return this.TAB;case 13:return this.ENTER;case 16:return this.SHIFT;case 17:return this.CTRL;case 19:return this.PAUSE_BREAK;case 20:return this.CAPS_LOCK;case 27:return this.ESC;case 32:return this.SPACE;case 33:return this.PAGE_UP;case 34:return this.PAGE_DOWN;case 35:return this.END;case 36:return this.HOME;case 37:return this.LEFT;case 38:return this.UP;case 39:return this.RIGHT;case 40:return this.DOWN;case 45:return this.INSERT;case 46:return this.DELETE;case 91:return this.WINDOWS;case 112:return this.F1;case 113:return this.F2;case 114:return this.F3;case 115:return this.F4;case 116:return this.F5;case 117:return this.F6;case 118:return this.F7;case 119:return this.F8;case 120:return this.F9;case 122:return this.F11;case 123:return this.F12;case 144:return this.NUM_LOCK;case 145:return this.SCROLL_LOCK;default:return String.fromCharCode(t)}},t.destroy=function(){this.keyDownDict=null,this.keyUpDict=null,document.removeEventListener("keydown",this.onKeyDonwHander),document.removeEventListener("keyup",this.onKeyUpHander)},t.TYPE_KEY_DOWN=0,t.TYPE_KEY_UP=1,t.A="A",t.B="B",t.C="C",t.D="D",t.E="E",t.F="F",t.G="G",t.H="H",t.I="I",t.J="J",t.K="K",t.L="L",t.M="M",t.N="N",t.O="O",t.P="P",t.Q="Q",t.R="R",t.S="S",t.T="T",t.U="U",t.V="V",t.W="W",t.X="X",t.Y="Y",t.Z="Z",t.ESC="Esc",t.F1="F1",t.F2="F2",t.F3="F3",t.F4="F4",t.F5="F5",t.F6="F6",t.F7="F7",t.F8="F8",t.F9="F9",t.F10="F10",t.F11="F11",t.F12="F12",t.NUM_1="1",t.NUM_2="2",t.NUM_3="3",t.NUM_4="4",t.NUM_5="5",t.NUM_6="6",t.NUM_7="7",t.NUM_8="8",t.NUM_9="9",t.NUM_0="0",t.TAB="Tab",t.CTRL="Ctrl",t.ALT="Alt",t.SHIFT="Shift",t.CAPS_LOCK="Caps Lock",t.ENTER="Enter",t.SPACE="Space",t.BACK_SPACE="Back Space",t.INSERT="Insert",t.DELETE="Page Down",t.HOME="Home",t.END="Page Down",t.PAGE_UP="Page Up",t.PAGE_DOWN="Page Down",t.LEFT="Left",t.RIGHT="Right",t.UP="Up",t.DOWN="Down",t.PAUSE_BREAK="Pause Break",t.NUM_LOCK="Num Lock",t.SCROLL_LOCK="Scroll Lock",t.WINDOWS="Windows",t}();!function(t){var e=function(){function t(){}return t.warmCache=function(t){if((t-=this._objectQueue.length)>0)for(var e=0;e<t;e++)this._objectQueue.unshift([])},t.trimCache=function(t){for(;t>this._objectQueue.length;)this._objectQueue.shift()},t.clearCache=function(){this._objectQueue.length=0},t.obtain=function(){return this._objectQueue.length>0?this._objectQueue.shift():[]},t.free=function(t){this._objectQueue.unshift(t),t.length=0},t._objectQueue=[],t}();t.ListPool=e}(es||(es={}));var THREAD_ID=Math.floor(1e3*Math.random())+"-"+Date.now(),setItem=egret.localStorage.setItem.bind(localStorage),getItem=egret.localStorage.getItem.bind(localStorage),removeItem=egret.localStorage.removeItem.bind(localStorage),nextTick=function(t){setTimeout(t,0)},LockUtils=function(){function t(t){this._keyX="mutex_key_"+t+"_X",this._keyY="mutex_key_"+t+"_Y"}return t.prototype.lock=function(){var t=this;return new Promise(function(e,n){var i=function(){setItem(t._keyX,THREAD_ID),null===!getItem(t._keyY)&&nextTick(i),setItem(t._keyY,THREAD_ID),getItem(t._keyX)!==THREAD_ID?setTimeout(function(){getItem(t._keyY)===THREAD_ID?(e(),removeItem(t._keyY)):nextTick(i)},10):(e(),removeItem(t._keyY))};i()})},t}();!function(t){var e=function(){function t(t,e){this.first=t,this.second=e}return t.prototype.clear=function(){this.first=this.second=null},t.prototype.equals=function(t){return this.first==t.first&&this.second==t.second},t}();t.Pair=e}(es||(es={}));var RandomUtils=function(){function t(){}return t.randrange=function(t,e,n){if(void 0===n&&(n=1),0==n)throw new Error("step 不能为 0");var i=e-t;if(0==i)throw new Error("没有可用的范围("+t+","+e+")");i<0&&(i=t-e);var r=Math.floor((i+n-1)/n);return Math.floor(this.random()*r)*n+Math.min(t,e)},t.randint=function(t,e){return(t=Math.floor(t))>(e=Math.floor(e))?t++:e++,this.randrange(t,e)},t.randnum=function(t,e){return this.random()*(e-t)+t},t.shuffle=function(t){return t.sort(this._randomCompare),t},t._randomCompare=function(t,e){return this.random()>.5?1:-1},t.choice=function(t){if(!t.hasOwnProperty("length"))throw new Error("无法对此对象执行此操作");var e=Math.floor(this.random()*t.length);return t instanceof String?String(t).charAt(e):t[e]},t.sample=function(t,e){var n=t.length;if(e<=0||n<e)throw new Error("采样数量不够");for(var i=[],r=[],o=0;o<e;o++){for(var s=Math.floor(this.random()*n);r.indexOf(s)>=0;)s=Math.floor(this.random()*n);i.push(t[s]),r.push(s)}return i},t.random=function(){return Math.random()},t.boolean=function(t){return void 0===t&&(t=.5),this.random()<t},t}();!function(t){var e=function(){function e(){}return e.union=function(e,n){var i=new t.Rectangle(n.x,n.y,0,0),r=new t.Rectangle;return r.x=Math.min(e.x,i.x),r.y=Math.min(e.y,i.y),r.width=Math.max(e.right,i.right)-r.x,r.height=Math.max(e.bottom,r.bottom)-r.y,r},e}();t.RectangleExt=e}(es||(es={})),function(t){var e=function(){function e(){this.triangleIndices=[],this._triPrev=new Array(12),this._triNext=new Array(12)}return e.prototype.triangulate=function(n,i){void 0===i&&(i=!0);var r=n.length;this.initialize(r);for(var o=0,s=0;r>3&&o<500;){o++;var a=!0,c=n[this._triPrev[s]],h=n[s],u=n[this._triNext[s]];if(t.Vector2Ext.isTriangleCCW(c,h,u)){var l=this._triNext[this._triNext[s]];do{if(e.testPointTriangle(n[l],c,h,u)){a=!1;break}l=this._triNext[l]}while(l!=this._triPrev[s])}else a=!1;a?(this.triangleIndices.push(this._triPrev[s]),this.triangleIndices.push(s),this.triangleIndices.push(this._triNext[s]),this._triNext[this._triPrev[s]]=this._triNext[s],this._triPrev[this._triNext[s]]=this._triPrev[s],r--,s=this._triPrev[s]):s=this._triNext[s]}this.triangleIndices.push(this._triPrev[s]),this.triangleIndices.push(s),this.triangleIndices.push(this._triNext[s]),i||this.triangleIndices.reverse()},e.prototype.initialize=function(t){this.triangleIndices.length=0,this._triNext.length<t&&(this._triNext.reverse(),this._triNext=new Array(Math.max(2*this._triNext.length,t))),this._triPrev.length<t&&(this._triPrev.reverse(),this._triPrev=new Array(Math.max(2*this._triPrev.length,t)));for(var e=0;e<t;e++)this._triPrev[e]=e-1,this._triNext[e]=e+1;this._triPrev[0]=t-1,this._triNext[t-1]=0},e.testPointTriangle=function(e,n,i,r){return!(t.Vector2Ext.cross(t.Vector2.subtract(e,n),t.Vector2.subtract(i,n))<0)&&(!(t.Vector2Ext.cross(t.Vector2.subtract(e,i),t.Vector2.subtract(r,i))<0)&&!(t.Vector2Ext.cross(t.Vector2.subtract(e,r),t.Vector2.subtract(n,r))<0))},e}();t.Triangulator=e}(es||(es={})),function(t){var e=function(){function e(){}return e.isTriangleCCW=function(e,n,i){return this.cross(t.Vector2.subtract(n,e),t.Vector2.subtract(i,n))<0},e.cross=function(t,e){return t.y*e.x-t.x*e.y},e.perpendicular=function(e,n){return new t.Vector2(-1*(n.y-e.y),n.x-e.x)},e.normalize=function(e){var n=Math.sqrt(e.x*e.x+e.y*e.y);return n>t.MathHelper.Epsilon?e=t.Vector2.divide(e,new t.Vector2(n)):e.x=e.y=0,e},e.transformA=function(t,e,n,i,r,o){for(var s=0;s<o;s++){var a=t[e+s],c=i[r+s];c.x=a.x*n.m11+a.y*n.m21+n.m31,c.y=a.x*n.m12+a.y*n.m22+n.m32,i[r+s]=c}},e.transformR=function(e,n){var i=e.x*n.m11+e.y*n.m21+n.m31,r=e.x*n.m12+e.y*n.m22+n.m32;return new t.Vector2(i,r)},e.transform=function(t,e,n){this.transformA(t,0,e,n,0,t.length)},e.round=function(e){return new t.Vector2(Math.round(e.x),Math.round(e.y))},e}();t.Vector2Ext=e}(es||(es={}));var stopwatch,es,WebGLUtils=function(){function t(){}return t.getContext=function(){return document.getElementsByTagName("canvas")[0].getContext("2d")},t}();!function(t){var e,n=function(){function n(){this.clientArea=new t.Rectangle(0,0,t.SceneManager.stage.stageWidth,t.SceneManager.stage.stageHeight),this.safeArea=this.clientArea}return n.prototype.place=function(n,i,r,o){var s=new t.Rectangle(0,0,n.x,n.y);return 0!=(o&e.left)?s.x=this.clientArea.x+this.clientArea.width*i:0!=(o&e.right)?s.x=this.clientArea.x+this.clientArea.width*(1-i)-s.width:0!=(o&e.horizontalCenter)&&(s.x=this.clientArea.x+(this.clientArea.width-s.width)/2+i*this.clientArea.width),0!=(o&e.top)?s.y=this.clientArea.y+this.clientArea.height*r:0!=(o&e.bottom)?s.y=this.clientArea.y+this.clientArea.height*(1-r)-s.height:0!=(o&e.verticalCenter)&&(s.y=this.clientArea.y+(this.clientArea.height-s.height)/2+r*this.clientArea.height),s.left<this.safeArea.left&&(s.x=this.safeArea.left),s.right>this.safeArea.right&&(s.x=this.safeArea.right-s.width),s.top<this.safeArea.top&&(s.y=this.safeArea.top),s.bottom>this.safeArea.bottom&&(s.y=this.safeArea.bottom-s.height),s},n}();t.Layout=n,function(t){t[t.none=0]="none",t[t.left=1]="left",t[t.right=2]="right",t[t.horizontalCenter=4]="horizontalCenter",t[t.top=8]="top",t[t.bottom=16]="bottom",t[t.verticalCenter=32]="verticalCenter",t[t.topLeft=9]="topLeft",t[t.topRight=10]="topRight",t[t.topCenter=12]="topCenter",t[t.bottomLeft=17]="bottomLeft",t[t.bottomRight=18]="bottomRight",t[t.bottomCenter=20]="bottomCenter",t[t.centerLeft=33]="centerLeft",t[t.centerRight=34]="centerRight",t[t.center=36]="center"}(e=t.Alignment||(t.Alignment={}))}(es||(es={})),function(t){var e,n=function(){function t(t){void 0===t&&(t=i),this.getSystemTime=t,this._stopDuration=0,this._completeSlices=[]}return t.prototype.getState=function(){return void 0===this._startSystemTime?e.IDLE:void 0===this._stopSystemTime?e.RUNNING:e.STOPPED},t.prototype.isIdle=function(){return this.getState()===e.IDLE},t.prototype.isRunning=function(){return this.getState()===e.RUNNING},t.prototype.isStopped=function(){return this.getState()===e.STOPPED},t.prototype.slice=function(){return this.recordPendingSlice()},t.prototype.getCompletedSlices=function(){return Array.from(this._completeSlices)},t.prototype.getCompletedAndPendingSlices=function(){return this._completeSlices.concat([this.getPendingSlice()])},t.prototype.getPendingSlice=function(){return this.calculatePendingSlice()},t.prototype.getTime=function(){return this.caculateStopwatchTime()},t.prototype.calculatePendingSlice=function(t){return void 0===this._pendingSliceStartStopwatchTime?Object.freeze({startTime:0,endTime:0,duration:0}):(void 0===t&&(t=this.getTime()),Object.freeze({startTime:this._pendingSliceStartStopwatchTime,endTime:t,duration:t-this._pendingSliceStartStopwatchTime}))},t.prototype.caculateStopwatchTime=function(t){return void 0===this._startSystemTime?0:(void 0===t&&(t=this.getSystemTimeOfCurrentStopwatchTime()),t-this._startSystemTime-this._stopDuration)},t.prototype.getSystemTimeOfCurrentStopwatchTime=function(){return void 0===this._stopSystemTime?this.getSystemTime():this._stopSystemTime},t.prototype.reset=function(){this._startSystemTime=this._pendingSliceStartStopwatchTime=this._stopSystemTime=void 0,this._stopDuration=0,this._completeSlices=[]},t.prototype.start=function(t){if(void 0===t&&(t=!1),t&&this.reset(),void 0!==this._stopSystemTime){var e=(n=this.getSystemTime())-this._stopSystemTime;this._stopDuration+=e,this._stopSystemTime=void 0}else if(void 0===this._startSystemTime){var n=this.getSystemTime();this._startSystemTime=n,this._pendingSliceStartStopwatchTime=0}},t.prototype.stop=function(t){if(void 0===t&&(t=!1),void 0===this._startSystemTime)return 0;var e=this.getSystemTimeOfCurrentStopwatchTime();return t&&this.recordPendingSlice(this.caculateStopwatchTime(e)),this._stopSystemTime=e,this.getTime()},t.prototype.recordPendingSlice=function(t){if(void 0!==this._pendingSliceStartStopwatchTime){void 0===t&&(t=this.getTime());var e=this.calculatePendingSlice(t);return this._pendingSliceStartStopwatchTime=e.endTime,this._completeSlices.push(e),e}return this.calculatePendingSlice()},t}();t.Stopwatch=n,function(t){t.IDLE="IDLE",t.RUNNING="RUNNING",t.STOPPED="STOPPED"}(e||(e={})),t.setDefaultSystemTimeGetter=function(t){void 0===t&&(t=Date.now),i=t};var i=Date.now}(stopwatch||(stopwatch={})),function(t){var e=function(){function e(){this._frameKey="frame",this._logKey="log",this.markers=[],this.stopwacth=new stopwatch.Stopwatch,this._markerNameToIdMap=new Map,this.showLog=!1,e.Instance=this,this._logs=new Array(2);for(var i=0;i<this._logs.length;++i)this._logs[i]=new n;this.sampleFrames=this.targetSampleFrames=1,this.width=.8*t.SceneManager.stage.stageWidth,this.onGraphicsDeviceReset()}return e.prototype.onGraphicsDeviceReset=function(){var n=new t.Layout;this._position=n.place(new t.Vector2(this.width,e.barHeight),0,.01,t.Alignment.bottomCenter).location},e.prototype.startFrame=function(){var t=this;new LockUtils(this._frameKey).lock().then(function(){t._updateCount=parseInt(egret.localStorage.getItem(t._frameKey),10),isNaN(t._updateCount)&&(t._updateCount=0);var n=t._updateCount;if(n+=1,egret.localStorage.setItem(t._frameKey,n.toString()),!(t.enabled&&1<n&&n<e.maxSampleFrames)){t._prevLog=t._logs[1&t.frameCount++],t._curLog=t._logs[1&t.frameCount];for(var i=t.stopwacth.getTime(),r=0;r<t._prevLog.bars.length;++r){for(var o=t._prevLog.bars[r],s=t._curLog.bars[r],a=0;a<o.nestCount;++a){var c=o.markerNests[a];o.markers[c].endTime=i,s.markerNests[a]=a,s.markers[a].markerId=o.markers[c].markerId,s.markers[a].beginTime=0,s.markers[a].endTime=-1,s.markers[a].color=o.markers[c].color}for(c=0;c<o.markCount;++c){var h=o.markers[c].endTime-o.markers[c].beginTime,u=o.markers[c].markerId,l=t.markers[u];l.logs[r].color=o.markers[c].color,l.logs[r].initialized?(l.logs[r].min=Math.min(l.logs[r].min,h),l.logs[r].max=Math.min(l.logs[r].max,h),l.logs[r].avg+=h,l.logs[r].avg*=.5,l.logs[r].samples++>=e.logSnapDuration&&(l.logs[r].snapMin=l.logs[r].min,l.logs[r].snapMax=l.logs[r].max,l.logs[r].snapAvg=l.logs[r].avg,l.logs[r].samples=0)):(l.logs[r].min=h,l.logs[r].max=h,l.logs[r].avg=h,l.logs[r].initialized=!0)}s.markCount=o.nestCount,s.nestCount=o.nestCount}t.stopwacth.reset(),t.stopwacth.start()}})},e.prototype.beginMark=function(t,n,i){var r=this;void 0===i&&(i=0),new LockUtils(this._frameKey).lock().then(function(){if(i<0||i>=e.maxBars)throw new Error("barIndex argument out of range");var o=r._curLog.bars[i];if(o.markCount>=e.maxSamples)throw new Error("exceeded sample count. either set larger number to timeruler.maxsaple or lower sample count");if(o.nestCount>=e.maxNestCall)throw new Error("exceeded nest count. either set larger number to timeruler.maxnestcall or lower nest calls");var s=r._markerNameToIdMap.get(t);isNaN(s)&&(s=r.markers.length,r._markerNameToIdMap.set(t,s)),o.markerNests[o.nestCount++]=o.markCount,o.markers[o.markCount].markerId=s,o.markers[o.markCount].color=n,o.markers[o.markCount].beginTime=r.stopwacth.getTime(),o.markers[o.markCount].endTime=-1})},e.prototype.endMark=function(t,n){var i=this;void 0===n&&(n=0),new LockUtils(this._frameKey).lock().then(function(){if(n<0||n>=e.maxBars)throw new Error("barIndex argument out of range");var r=i._curLog.bars[n];if(r.nestCount<=0)throw new Error("call beginMark method before calling endMark method");var o=i._markerNameToIdMap.get(t);if(isNaN(o))throw new Error("Marker "+t+" is not registered. Make sure you specifed same name as you used for beginMark method");var s=r.markerNests[--r.nestCount];if(r.markers[s].markerId!=o)throw new Error("Incorrect call order of beginMark/endMark method. beginMark(A), beginMark(B), endMark(B), endMark(A) But you can't called it like beginMark(A), beginMark(B), endMark(A), endMark(B).");r.markers[s].endTime=i.stopwacth.getTime()})},e.prototype.getAverageTime=function(t,n){if(t<0||t>=e.maxBars)throw new Error("barIndex argument out of range");var i=0,r=this._markerNameToIdMap.get(n);return r&&(i=this.markers[r].logs[t].avg),i},e.prototype.resetLog=function(){var t=this;new LockUtils(this._logKey).lock().then(function(){var e=parseInt(egret.localStorage.getItem(t._logKey),10);e+=1,egret.localStorage.setItem(t._logKey,e.toString()),t.markers.forEach(function(t){for(var e=0;e<t.logs.length;++e)t.logs[e].initialized=!1,t.logs[e].snapMin=0,t.logs[e].snapMax=0,t.logs[e].snapAvg=0,t.logs[e].min=0,t.logs[e].max=0,t.logs[e].avg=0,t.logs[e].samples=0})})},e.prototype.render=function(t,n){if(void 0===t&&(t=this._position),void 0===n&&(n=this.width),egret.localStorage.setItem(this._frameKey,"0"),this.showLog){var i=0,r=0;this._prevLog.bars.forEach(function(t){t.markCount>0&&(i+=e.barHeight+2*e.barPadding,r=Math.max(r,t.markers[t.markCount-1].endTime))});var o=this.sampleFrames*(1/60*1e3);this._frameAdjust=r>o?Math.max(0,this._frameAdjust)+1:Math.min(0,this._frameAdjust)-1,Math.max(this._frameAdjust)>e.autoAdjustDelay&&(this.sampleFrames=Math.min(e.maxSampleFrames,this.sampleFrames),this.sampleFrames=Math.max(this.targetSampleFrames,r/(1/60*1e3)+1),this._frameAdjust=0);t.y,e.barHeight}},e.maxBars=8,e.maxSamples=256,e.maxNestCall=32,e.barHeight=8,e.maxSampleFrames=4,e.logSnapDuration=120,e.barPadding=2,e.autoAdjustDelay=30,e}();t.TimeRuler=e;var n=function(){return function(){this.bars=new Array(e.maxBars),this.bars.fill(new i,0,e.maxBars)}}();t.FrameLog=n;var i=function(){return function(){this.markers=new Array(e.maxSamples),this.markCount=0,this.markerNests=new Array(e.maxNestCall),this.nestCount=0,this.markers.fill(new r,0,e.maxSamples),this.markerNests.fill(0,0,e.maxNestCall)}}();t.MarkerCollection=i;var r=function(){return function(){this.markerId=0,this.beginTime=0,this.endTime=0,this.color=0}}();t.Marker=r;var o=function(){return function(t){this.logs=new Array(e.maxBars),this.name=t,this.logs.fill(new s,0,e.maxBars)}}();t.MarkerInfo=o;var s=function(){return function(){this.snapMin=0,this.snapMax=0,this.snapAvg=0,this.min=0,this.max=0,this.avg=0,this.samples=0,this.color=0,this.initialized=!1}}();t.MarkerLog=s}(es||(es={}));
\ No newline at end of file
diff --git a/source/lib/wxgame.d.ts b/source/lib/wxgame.d.ts
index 5ffbcf7e..b8adb9dd 100644
--- a/source/lib/wxgame.d.ts
+++ b/source/lib/wxgame.d.ts
@@ -1008,7 +1008,129 @@ declare class Video {
      */
     exitFullScreen(): Promise<void>;
 }
+/**
+ * 相机对象
+ */
+declare class Camera {
+    /**
+     * 相机的左上角横坐标
+     */
+    x: number;
 
+    /**
+     * 相机的左上角纵坐标
+     */
+    y: number;
+
+    /**
+     * 相机的宽度
+     */
+    width: number;
+
+    /**
+     * 相机的高度
+     */
+    height: number;
+
+    /**
+     * 摄像头朝向
+     */
+    devicePosition: "front" | "back";
+
+    /**
+     * 闪光灯状态
+     */
+    flash: "auto" | "on" | "off";
+
+    /**
+     * 帧数据图像尺寸
+     */
+    size: "small" | "medium" | "large";
+
+    /**
+     * 拍照，可指定质量，成功则返回图片
+     * @param quality 图片质量
+     */
+    takePhoto(quality?: "high" | "normal" | "low"): Promise<{
+        /**
+         * 临时图片路径
+         */
+        tempImagePath: string,
+        /**
+         * 图片宽度
+         */
+        width: string,
+        /**
+         * 图片高度
+         */
+        height: string
+    }>;
+
+    /**
+     * 开始录像
+     */
+    startRecord(): Promise<void>;
+
+    /**
+     * 结束录像，成功则返回封面与视频
+     * @param compressed 是否压缩录制视频
+     */
+    stopRecord(compressed: boolean): Promise<{
+        /**
+         * 临时视频路径
+         */
+        tempThumbPath: string,
+        /**
+         * 临时封面路径
+         */
+        tempVideoPath: string
+    }>;
+
+    /**
+     * 监听用户不允许授权使用摄像头的情况
+     * @param callback 回调函数
+     */
+    onAuthCancel(callback: () => void): void;
+
+    /**
+     * 监听摄像头非正常终止事件，如退出后台等情况
+     * @param callback 回调函数
+     */
+    onStop(callback: () => void): void;
+
+    /**
+     * 监听摄像头实时帧数据
+     */
+    onCameraFrame(callback: (res: {
+        /**
+         * 图像数据矩形的宽度
+         */
+        width: number,
+        /**
+         * 图像数据矩形的高度
+         */
+        height: number,
+        /**
+         * 图像像素点数据，一维数组，每四项表示一个像素点的 rgba
+         */
+        data: ArrayBuffer
+    }) => void): void;
+
+    /**
+     * 开启监听帧数据
+     */
+    listenFrameChange(): void;
+
+    /**
+     * 关闭监听帧数据
+     */
+    closeFrameChange(): void;
+
+    /**
+     * 销毁相机
+     */
+    destroy(): void;
+}
 /**
  * banner 广告组件。banner 广告组件是一个原生组件，层级比上屏 Canvas 高，会覆盖在上屏 Canvas 上。banner 广告组件默认是隐藏的，需要调用 BannerAd.show() 将其显示。banner 广告会根据开发者设置的宽度进行等比缩放，缩放后的尺寸将通过 BannerAd.onResize() 事件中提供。
  */
diff --git a/source/src/AI/Pathfinding/AStar/AStarPathfinder.ts b/source/src/AI/Pathfinding/AStar/AStarPathfinder.ts
index 9d6ed0b3..2be43c70 100644
--- a/source/src/AI/Pathfinding/AStar/AStarPathfinder.ts
+++ b/source/src/AI/Pathfinding/AStar/AStarPathfinder.ts
@@ -1,101 +1,103 @@
 ///<reference path="./PriorityQueueNode.ts" />
-/**
- * 计算路径给定的IAstarGraph和开始/目标位置
- */
-class AStarPathfinder {
+module es {
     /**
-     * 尽可能从开始到目标找到一条路径。如果没有找到路径，则返回null。
-     * @param graph 
-     * @param start 
-     * @param goal 
+     * 计算路径给定的IAstarGraph和开始/目标位置
      */
-    public static search<T>(graph: IAstarGraph<T>, start: T, goal: T){
-        let foundPath = false;
-        let cameFrom = new Map<T, T>();
-        cameFrom.set(start, start);
+    export class AStarPathfinder {
+        /**
+         * 尽可能从开始到目标找到一条路径。如果没有找到路径，则返回null。
+         * @param graph
+         * @param start
+         * @param goal
+         */
+        public static search<T>(graph: IAstarGraph<T>, start: T, goal: T){
+            let foundPath = false;
+            let cameFrom = new Map<T, T>();
+            cameFrom.set(start, start);
 
-        let costSoFar = new Map<T, number>();
-        let frontier = new PriorityQueue<AStarNode<T>>(1000);
-        frontier.enqueue(new AStarNode<T>(start), 0);
+            let costSoFar = new Map<T, number>();
+            let frontier = new PriorityQueue<AStarNode<T>>(1000);
+            frontier.enqueue(new AStarNode<T>(start), 0);
 
-        costSoFar.set(start, 0);
+            costSoFar.set(start, 0);
 
-        while (frontier.count > 0){
-            let current = frontier.dequeue();
+            while (frontier.count > 0){
+                let current = frontier.dequeue();
 
-            if (JSON.stringify(current.data) == JSON.stringify(goal)){
-                foundPath = true;
-                break;
+                if (JSON.stringify(current.data) == JSON.stringify(goal)){
+                    foundPath = true;
+                    break;
+                }
+
+                graph.getNeighbors(current.data).forEach(next => {
+                    let newCost = costSoFar.get(current.data) + graph.cost(current.data, next);
+                    if (!this.hasKey(costSoFar, next) || newCost < costSoFar.get(next)){
+                        costSoFar.set(next, newCost);
+                        let priority = newCost + graph.heuristic(next, goal);
+                        frontier.enqueue(new AStarNode<T>(next), priority);
+                        cameFrom.set(next, current.data);
+                    }
+                });
             }
 
-            graph.getNeighbors(current.data).forEach(next => {
-                let newCost = costSoFar.get(current.data) + graph.cost(current.data, next);
-                if (!this.hasKey(costSoFar, next) || newCost < costSoFar.get(next)){
-                    costSoFar.set(next, newCost);
-                    let priority = newCost + graph.heuristic(next, goal);
-                    frontier.enqueue(new AStarNode<T>(next), priority);
-                    cameFrom.set(next, current.data);
-                }
-            });
+            return foundPath ? this.recontructPath(cameFrom, start, goal) : null;
         }
 
-        return foundPath ? this.recontructPath(cameFrom, start, goal) : null;
-    }
+        private static hasKey<T>(map: Map<T, number>, compareKey: T){
+            let iterator = map.keys();
+            let r: IteratorResult<T>;
+            while (r = iterator.next() , !r.done) {
+                if (JSON.stringify(r.value) == JSON.stringify(compareKey))
+                    return true;
+            }
 
-    private static hasKey<T>(map: Map<T, number>, compareKey: T){
-        let iterator = map.keys();
-        let r: IteratorResult<T>;
-        while (r = iterator.next() , !r.done) {
-            if (JSON.stringify(r.value) == JSON.stringify(compareKey))
-                return true;
+            return false;
         }
 
-        return false;
-    }
+        private static getKey<T>(map: Map<T, T>, compareKey: T){
+            let iterator = map.keys();
+            let valueIterator = map.values();
+            let r: IteratorResult<T>;
+            let v: IteratorResult<T>;
+            while (r = iterator.next(), v = valueIterator.next(), !r.done) {
+                if (JSON.stringify(r.value) == JSON.stringify(compareKey))
+                    return v.value;
+            }
 
-    private static getKey<T>(map: Map<T, T>, compareKey: T){
-        let iterator = map.keys();
-        let valueIterator = map.values();
-        let r: IteratorResult<T>;
-        let v: IteratorResult<T>;
-        while (r = iterator.next(), v = valueIterator.next(), !r.done) {
-            if (JSON.stringify(r.value) == JSON.stringify(compareKey))
-                return v.value;
+            return null;
         }
 
-        return null;
+        /**
+         * 从cameFrom字典重新构造路径
+         * @param cameFrom
+         * @param start
+         * @param goal
+         */
+        public static recontructPath<T>(cameFrom: Map<T, T>, start: T, goal: T): T[]{
+            let path = [];
+            let current = goal;
+            path.push(goal);
+
+            while (current != start){
+                current = this.getKey(cameFrom, current);
+                path.push(current);
+            }
+
+            path.reverse();
+
+            return path;
+        }
     }
 
     /**
-     * 从cameFrom字典重新构造路径
-     * @param cameFrom 
-     * @param start 
-     * @param goal 
+     * 使用PriorityQueue需要的额外字段将原始数据封装在一个小类中
      */
-    public static recontructPath<T>(cameFrom: Map<T, T>, start: T, goal: T): T[]{
-        let path = [];
-        let current = goal;
-        path.push(goal);
+    export class AStarNode<T> extends PriorityQueueNode {
+        public data: T;
 
-        while (current != start){
-            current = this.getKey(cameFrom, current);
-            path.push(current);
+        constructor(data: T){
+            super();
+            this.data = data;
         }
-
-        path.reverse();
-
-        return path;
     }
 }
-
-/**
- * 使用PriorityQueue需要的额外字段将原始数据封装在一个小类中
- */
-class AStarNode<T> extends PriorityQueueNode {
-    public data: T;
-
-    constructor(data: T){
-        super();
-        this.data = data;
-    }
-}
\ No newline at end of file
diff --git a/source/src/AI/Pathfinding/AStar/AstarGridGraph.ts b/source/src/AI/Pathfinding/AStar/AstarGridGraph.ts
index 0bb470e7..8c35b25e 100644
--- a/source/src/AI/Pathfinding/AStar/AstarGridGraph.ts
+++ b/source/src/AI/Pathfinding/AStar/AstarGridGraph.ts
@@ -1,72 +1,74 @@
-/**
- * 基本静态网格图与A*一起使用
- * 将walls添加到walls HashSet，并将加权节点添加到weightedNodes
- */
-class AstarGridGraph implements IAstarGraph<Vector2> {
-    public dirs: Vector2[] = [
-        new Vector2(1, 0),
-        new Vector2(0, -1),
-        new Vector2(-1, 0),
-        new Vector2(0, 1)
-    ];
-
-    public walls: Vector2[] = [];
-    public weightedNodes: Vector2[] = [];
-    public defaultWeight: number = 1;
-    public weightedNodeWeight = 5;
-
-    private _width;
-    private _height;
-    private _neighbors: Vector2[] = new Array(4);
-
-    constructor(width: number, height: number){
-        this._width = width;
-        this._height = height;
-    }
-
+module es {
     /**
-     * 确保节点在网格图的边界内
-     * @param node 
+     * 基本静态网格图与A*一起使用
+     * 将walls添加到walls HashSet，并将加权节点添加到weightedNodes
      */
-    public isNodeInBounds(node: Vector2): boolean {
-        return 0 <= node.x && node.x < this._width && 0 <= node.y && node.y < this._height;
+    export class AstarGridGraph implements IAstarGraph<Vector2> {
+        public dirs: Vector2[] = [
+            new Vector2(1, 0),
+            new Vector2(0, -1),
+            new Vector2(-1, 0),
+            new Vector2(0, 1)
+        ];
+
+        public walls: Vector2[] = [];
+        public weightedNodes: Vector2[] = [];
+        public defaultWeight: number = 1;
+        public weightedNodeWeight = 5;
+
+        private _width;
+        private _height;
+        private _neighbors: Vector2[] = new Array(4);
+
+        constructor(width: number, height: number){
+            this._width = width;
+            this._height = height;
+        }
+
+        /**
+         * 确保节点在网格图的边界内
+         * @param node
+         */
+        public isNodeInBounds(node: Vector2): boolean {
+            return 0 <= node.x && node.x < this._width && 0 <= node.y && node.y < this._height;
+        }
+
+        /**
+         * 检查节点是否可以通过。walls是不可逾越的。
+         * @param node
+         */
+        public isNodePassable(node: Vector2): boolean {
+            return !this.walls.firstOrDefault(wall => JSON.stringify(wall) == JSON.stringify(node));
+        }
+
+        /**
+         * 调用AStarPathfinder.search的快捷方式
+         * @param start
+         * @param goal
+         */
+        public search(start: Vector2, goal: Vector2){
+            return AStarPathfinder.search(this, start, goal);
+        }
+
+        public getNeighbors(node: Vector2): Vector2[] {
+            this._neighbors.length = 0;
+
+            this.dirs.forEach(dir => {
+                let next = new Vector2(node.x + dir.x, node.y + dir.y);
+                if (this.isNodeInBounds(next) && this.isNodePassable(next))
+                    this._neighbors.push(next);
+            });
+
+            return this._neighbors;
+        }
+
+        public cost(from: Vector2, to: Vector2): number {
+            return this.weightedNodes.find((p)=> JSON.stringify(p) == JSON.stringify(to)) ? this.weightedNodeWeight : this.defaultWeight;
+        }
+
+        public heuristic(node: Vector2, goal: Vector2) {
+            return Math.abs(node.x - goal.x) + Math.abs(node.y - goal.y);
+        }
+
     }
-
-    /**
-     * 检查节点是否可以通过。walls是不可逾越的。
-     * @param node 
-     */
-    public isNodePassable(node: Vector2): boolean {
-        return !this.walls.firstOrDefault(wall => JSON.stringify(wall) == JSON.stringify(node));
-    }
-
-    /**
-     * 调用AStarPathfinder.search的快捷方式
-     * @param start 
-     * @param goal 
-     */
-    public search(start: Vector2, goal: Vector2){
-        return AStarPathfinder.search(this, start, goal);
-    }
-
-    public getNeighbors(node: Vector2): Vector2[] {
-        this._neighbors.length = 0;
-
-        this.dirs.forEach(dir => {
-            let next = new Vector2(node.x + dir.x, node.y + dir.y);
-            if (this.isNodeInBounds(next) && this.isNodePassable(next))
-                this._neighbors.push(next);
-        });
-
-        return this._neighbors;
-    }
-
-    public cost(from: Vector2, to: Vector2): number {
-        return this.weightedNodes.find((p)=> JSON.stringify(p) == JSON.stringify(to)) ? this.weightedNodeWeight : this.defaultWeight;
-    }
-
-    public heuristic(node: Vector2, goal: Vector2) {
-        return Math.abs(node.x - goal.x) + Math.abs(node.y - goal.y);
-    }
-
-}
\ No newline at end of file
+}
diff --git a/source/src/AI/Pathfinding/AStar/IAstarGraph.ts b/source/src/AI/Pathfinding/AStar/IAstarGraph.ts
index f25957d0..6b0fc08f 100644
--- a/source/src/AI/Pathfinding/AStar/IAstarGraph.ts
+++ b/source/src/AI/Pathfinding/AStar/IAstarGraph.ts
@@ -1,22 +1,24 @@
-/**
- * graph的接口，可以提供给AstarPathfinder.search方法
- */
-interface IAstarGraph<T> {
+module es {
     /**
-     * getNeighbors方法应该返回从传入的节点可以到达的任何相邻节点
-     * @param node 
+     * graph的接口，可以提供给AstarPathfinder.search方法
      */
-    getNeighbors(node: T): Array<T>;
-    /**
-     * 计算从从from到to的成本
-     * @param from 
-     * @param to 
-     */
-    cost(from: T, to: T): number;
-    /**
-     * 计算从node到to的启发式。参见WeightedGridGraph了解常用的Manhatten方法。
-     * @param node 
-     * @param goal 
-     */
-    heuristic(node: T, goal: T);
-}
\ No newline at end of file
+    export interface IAstarGraph<T> {
+        /**
+         * getNeighbors方法应该返回从传入的节点可以到达的任何相邻节点
+         * @param node
+         */
+        getNeighbors(node: T): Array<T>;
+        /**
+         * 计算从从from到to的成本
+         * @param from
+         * @param to
+         */
+        cost(from: T, to: T): number;
+        /**
+         * 计算从node到to的启发式。参见WeightedGridGraph了解常用的Manhatten方法。
+         * @param node
+         * @param goal
+         */
+        heuristic(node: T, goal: T);
+    }
+}
diff --git a/source/src/AI/Pathfinding/AStar/PriorityQueue.ts b/source/src/AI/Pathfinding/AStar/PriorityQueue.ts
index 5dd4acfd..85c0a318 100644
--- a/source/src/AI/Pathfinding/AStar/PriorityQueue.ts
+++ b/source/src/AI/Pathfinding/AStar/PriorityQueue.ts
@@ -1,234 +1,236 @@
-/**
- * 使用堆实现最小优先级队列 O(1)复杂度
- * 这种查找速度比使用字典快5-10倍
- * 但是，由于IPriorityQueue.contains()是许多寻路算法中调用最多的方法，因此尽可能快地实现它对于我们的应用程序非常重要。
- */
-class PriorityQueue<T extends PriorityQueueNode> {
-    private _numNodes: number;
-    private _nodes: T[];
-    private _numNodesEverEnqueued;
-
+module es {
     /**
-     * 实例化一个新的优先级队列
-     * @param maxNodes 允许加入队列的最大节点(执行此操作将导致undefined的行为)
+     * 使用堆实现最小优先级队列 O(1)复杂度
+     * 这种查找速度比使用字典快5-10倍
+     * 但是，由于IPriorityQueue.contains()是许多寻路算法中调用最多的方法，因此尽可能快地实现它对于我们的应用程序非常重要。
      */
-    constructor(maxNodes: number) {
-        this._numNodes = 0;
-        this._nodes = new Array(maxNodes + 1);
-        this._numNodesEverEnqueued = 0;
-    }
+    export class PriorityQueue<T extends PriorityQueueNode> {
+        private _numNodes: number;
+        private _nodes: T[];
+        private _numNodesEverEnqueued;
 
-    /**
-     * 从队列中删除每个节点。
-     *  O(n)复杂度 所有尽可能少调用该方法
-     */
-    public clear() {
-        this._nodes.splice(1, this._numNodes);
-        this._numNodes = 0;
-    }
-
-    /**
-     * 返回队列中的节点数。
-     * O(1)复杂度
-     */
-    public get count() {
-        return this._numNodes;
-    }
-
-    /**
-     * 返回可同时进入此队列的最大项数。一旦你达到这个数字(即。一旦Count == MaxSize)，尝试加入另一个项目将导致undefined的行为
-     * O(1)复杂度
-     */
-    public get maxSize() {
-        return this._nodes.length - 1;
-    }
-
-    /**
-     * 返回(在O(1)中)给定节点是否在队列中
-     * O (1)复杂度
-     * @param node 
-     */
-    public contains(node: T): boolean {
-        if (!node){
-            console.error("node cannot be null");
-            return false;
+        /**
+         * 实例化一个新的优先级队列
+         * @param maxNodes 允许加入队列的最大节点(执行此操作将导致undefined的行为)
+         */
+        constructor(maxNodes: number) {
+            this._numNodes = 0;
+            this._nodes = new Array(maxNodes + 1);
+            this._numNodesEverEnqueued = 0;
         }
 
-        if (node.queueIndex < 0 || node.queueIndex >= this._nodes.length){
-            console.error("node.QueueIndex has been corrupted. Did you change it manually? Or add this node to another queue?");
-            return false;
+        /**
+         * 从队列中删除每个节点。
+         *  O(n)复杂度 所有尽可能少调用该方法
+         */
+        public clear() {
+            this._nodes.splice(1, this._numNodes);
+            this._numNodes = 0;
         }
 
-        return (this._nodes[node.queueIndex] == node);
-    }
+        /**
+         * 返回队列中的节点数。
+         * O(1)复杂度
+         */
+        public get count() {
+            return this._numNodes;
+        }
 
-    /**
-     * 将节点放入优先队列 较低的值放在前面 先入先出
-     * 如果队列已满，则结果undefined。如果节点已经加入队列，则结果undefined。
-     * O(log n)
-     * @param node 
-     * @param priority 
-     */
-    public enqueue(node: T, priority: number) {
-        node.priority = priority;
-        this._numNodes++;
-        this._nodes[this._numNodes] = node;
-        node.queueIndex = this._numNodes;
-        node.insertionIndex = this._numNodesEverEnqueued++;
-        this.cascadeUp(this._nodes[this._numNodes]);
-    }
+        /**
+         * 返回可同时进入此队列的最大项数。一旦你达到这个数字(即。一旦Count == MaxSize)，尝试加入另一个项目将导致undefined的行为
+         * O(1)复杂度
+         */
+        public get maxSize() {
+            return this._nodes.length - 1;
+        }
 
-    /**
-     * 删除队列头(具有最小优先级的节点;按插入顺序断开连接)，并返回它。如果队列为空，结果undefined
-     * O(log n)
-     */
-    public dequeue(): T {
-        let returnMe = this._nodes[1];
-        this.remove(returnMe);
-        return returnMe;
-    }
+        /**
+         * 返回(在O(1)中)给定节点是否在队列中
+         * O (1)复杂度
+         * @param node
+         */
+        public contains(node: T): boolean {
+            if (!node){
+                console.error("node cannot be null");
+                return false;
+            }
 
-    /**
-     * 从队列中删除一个节点。节点不需要是队列的头。如果节点不在队列中，则结果未定义。如果不确定，首先检查Contains()
-     * O(log n)
-     * @param node 
-     */
-    public remove(node: T) {
-        if (node.queueIndex == this._numNodes) {
-            this._nodes[this._numNodes] = null;
+            if (node.queueIndex < 0 || node.queueIndex >= this._nodes.length){
+                console.error("node.QueueIndex has been corrupted. Did you change it manually? Or add this node to another queue?");
+                return false;
+            }
+
+            return (this._nodes[node.queueIndex] == node);
+        }
+
+        /**
+         * 将节点放入优先队列 较低的值放在前面 先入先出
+         * 如果队列已满，则结果undefined。如果节点已经加入队列，则结果undefined。
+         * O(log n)
+         * @param node
+         * @param priority
+         */
+        public enqueue(node: T, priority: number) {
+            node.priority = priority;
+            this._numNodes++;
+            this._nodes[this._numNodes] = node;
+            node.queueIndex = this._numNodes;
+            node.insertionIndex = this._numNodesEverEnqueued++;
+            this.cascadeUp(this._nodes[this._numNodes]);
+        }
+
+        /**
+         * 删除队列头(具有最小优先级的节点;按插入顺序断开连接)，并返回它。如果队列为空，结果undefined
+         * O(log n)
+         */
+        public dequeue(): T {
+            let returnMe = this._nodes[1];
+            this.remove(returnMe);
+            return returnMe;
+        }
+
+        /**
+         * 从队列中删除一个节点。节点不需要是队列的头。如果节点不在队列中，则结果未定义。如果不确定，首先检查Contains()
+         * O(log n)
+         * @param node
+         */
+        public remove(node: T) {
+            if (node.queueIndex == this._numNodes) {
+                this._nodes[this._numNodes] = null;
+                this._numNodes--;
+                return;
+            }
+
+            let formerLastNode = this._nodes[this._numNodes];
+            this.swap(node, formerLastNode);
+            delete this._nodes[this._numNodes];
             this._numNodes--;
-            return;
+
+            this.onNodeUpdated(formerLastNode);
         }
 
-        let formerLastNode = this._nodes[this._numNodes];
-        this.swap(node, formerLastNode);
-        delete this._nodes[this._numNodes];
-        this._numNodes--;
+        /**
+         * 检查以确保队列仍然处于有效状态。用于测试/调试队列。
+         */
+        public isValidQueue(): boolean {
+            for (let i = 1; i < this._nodes.length; i++) {
+                if (this._nodes[i]) {
+                    let childLeftIndex = 2 * i;
+                    if (childLeftIndex < this._nodes.length && this._nodes[childLeftIndex] &&
+                        this.hasHigherPriority(this._nodes[childLeftIndex], this._nodes[i]))
+                        return false;
 
-        this.onNodeUpdated(formerLastNode);
-    }
-
-    /**
-     * 检查以确保队列仍然处于有效状态。用于测试/调试队列。
-     */
-    public isValidQueue(): boolean {
-        for (let i = 1; i < this._nodes.length; i++) {
-            if (this._nodes[i]) {
-                let childLeftIndex = 2 * i;
-                if (childLeftIndex < this._nodes.length && this._nodes[childLeftIndex] &&
-                    this.hasHigherPriority(this._nodes[childLeftIndex], this._nodes[i]))
-                    return false;
-
-                let childRightIndex = childLeftIndex + 1;
-                if (childRightIndex < this._nodes.length && this._nodes[childRightIndex] &&
-                    this.hasHigherPriority(this._nodes[childRightIndex], this._nodes[i]))
-                    return false;
-            }
-        }
-
-        return true;
-    }
-
-    private onNodeUpdated(node: T) {
-        // 将更新后的节点按适当的方式向上或向下冒泡
-        let parentIndex = Math.floor(node.queueIndex / 2);
-        let parentNode = this._nodes[parentIndex];
-
-        if (parentIndex > 0 && this.hasHigherPriority(node, parentNode)) {
-            this.cascadeUp(node);
-        } else {
-            // 注意，如果parentNode == node(即节点是根)，则将调用CascadeDown。
-            this.cascadeDown(node);
-        }
-    }
-
-    private cascadeDown(node: T) {
-        // 又名Heapify-down
-        let newParent: T;
-        let finalQueueIndex = node.queueIndex;
-        while (true) {
-            newParent = node;
-            let childLeftIndex = 2 * finalQueueIndex;
-
-            // 检查左子节点的优先级是否高于当前节点
-            if (childLeftIndex > this._numNodes) {
-                // 这可以放在循环之外，但是我们必须检查newParent != node两次
-                node.queueIndex = finalQueueIndex;
-                this._nodes[finalQueueIndex] = node;
-                break;
-            }
-
-            let childLeft = this._nodes[childLeftIndex];
-            if (this.hasHigherPriority(childLeft, newParent)) {
-                newParent = childLeft;
-            }
-
-            // 检查右子节点的优先级是否高于当前节点或左子节点
-            let childRightIndex = childLeftIndex + 1;
-            if (childRightIndex <= this._numNodes) {
-                let childRight = this._nodes[childRightIndex];
-                if (this.hasHigherPriority(childRight, newParent)) {
-                    newParent = childRight;
+                    let childRightIndex = childLeftIndex + 1;
+                    if (childRightIndex < this._nodes.length && this._nodes[childRightIndex] &&
+                        this.hasHigherPriority(this._nodes[childRightIndex], this._nodes[i]))
+                        return false;
                 }
             }
 
-            // 如果其中一个子节点具有更高(更小)的优先级，则交换并继续级联
-            if (newParent != node) {
-                // 将新的父节点移动到它的新索引
-                // 节点将被移动一次，这样做比调用Swap()少一个赋值操作。
-                this._nodes[finalQueueIndex] = newParent;
+            return true;
+        }
 
-                let temp = newParent.queueIndex;
-                newParent.queueIndex = finalQueueIndex;
-                finalQueueIndex = temp;
+        private onNodeUpdated(node: T) {
+            // 将更新后的节点按适当的方式向上或向下冒泡
+            let parentIndex = Math.floor(node.queueIndex / 2);
+            let parentNode = this._nodes[parentIndex];
+
+            if (parentIndex > 0 && this.hasHigherPriority(node, parentNode)) {
+                this.cascadeUp(node);
             } else {
-                // 参见上面的笔记
-                node.queueIndex = finalQueueIndex;
-                this._nodes[finalQueueIndex] = node;
-                break;
+                // 注意，如果parentNode == node(即节点是根)，则将调用CascadeDown。
+                this.cascadeDown(node);
             }
         }
-    }
 
-    /**
-     * 当没有内联时，性能会稍微好一些
-     * @param node 
-     */
-    private cascadeUp(node: T) {
-        // 又名Heapify-up
-        let parent = Math.floor(node.queueIndex / 2);
-        while (parent >= 1) {
-            let parentNode = this._nodes[parent];
-            if (this.hasHigherPriority(parentNode, node))
-                break;
+        private cascadeDown(node: T) {
+            // 又名Heapify-down
+            let newParent: T;
+            let finalQueueIndex = node.queueIndex;
+            while (true) {
+                newParent = node;
+                let childLeftIndex = 2 * finalQueueIndex;
 
-            // 节点具有较低的优先级值，因此将其向上移动到堆中
-            // 出于某种原因，使用Swap()比使用单独的操作更快，如CascadeDown()
-            this.swap(node, parentNode);
+                // 检查左子节点的优先级是否高于当前节点
+                if (childLeftIndex > this._numNodes) {
+                    // 这可以放在循环之外，但是我们必须检查newParent != node两次
+                    node.queueIndex = finalQueueIndex;
+                    this._nodes[finalQueueIndex] = node;
+                    break;
+                }
 
-            parent = Math.floor(node.queueIndex / 2);
+                let childLeft = this._nodes[childLeftIndex];
+                if (this.hasHigherPriority(childLeft, newParent)) {
+                    newParent = childLeft;
+                }
+
+                // 检查右子节点的优先级是否高于当前节点或左子节点
+                let childRightIndex = childLeftIndex + 1;
+                if (childRightIndex <= this._numNodes) {
+                    let childRight = this._nodes[childRightIndex];
+                    if (this.hasHigherPriority(childRight, newParent)) {
+                        newParent = childRight;
+                    }
+                }
+
+                // 如果其中一个子节点具有更高(更小)的优先级，则交换并继续级联
+                if (newParent != node) {
+                    // 将新的父节点移动到它的新索引
+                    // 节点将被移动一次，这样做比调用Swap()少一个赋值操作。
+                    this._nodes[finalQueueIndex] = newParent;
+
+                    let temp = newParent.queueIndex;
+                    newParent.queueIndex = finalQueueIndex;
+                    finalQueueIndex = temp;
+                } else {
+                    // 参见上面的笔记
+                    node.queueIndex = finalQueueIndex;
+                    this._nodes[finalQueueIndex] = node;
+                    break;
+                }
+            }
+        }
+
+        /**
+         * 当没有内联时，性能会稍微好一些
+         * @param node
+         */
+        private cascadeUp(node: T) {
+            // 又名Heapify-up
+            let parent = Math.floor(node.queueIndex / 2);
+            while (parent >= 1) {
+                let parentNode = this._nodes[parent];
+                if (this.hasHigherPriority(parentNode, node))
+                    break;
+
+                // 节点具有较低的优先级值，因此将其向上移动到堆中
+                // 出于某种原因，使用Swap()比使用单独的操作更快，如CascadeDown()
+                this.swap(node, parentNode);
+
+                parent = Math.floor(node.queueIndex / 2);
+            }
+        }
+
+        private swap(node1: T, node2: T) {
+            // 交换节点
+            this._nodes[node1.queueIndex] = node2;
+            this._nodes[node2.queueIndex] = node1;
+
+            // 交换他们的indicies
+            let temp = node1.queueIndex;
+            node1.queueIndex = node2.queueIndex;
+            node2.queueIndex = temp;
+        }
+
+        /**
+         * 如果higher的优先级高于lower，则返回true，否则返回false。
+         * 注意，调用HasHigherPriority(节点，节点)(即。两个参数为同一个节点)将返回false
+         * @param higher
+         * @param lower
+         */
+        private hasHigherPriority(higher: T, lower: T) {
+            return (higher.priority < lower.priority ||
+                (higher.priority == lower.priority && higher.insertionIndex < lower.insertionIndex));
         }
     }
-
-    private swap(node1: T, node2: T) {
-        // 交换节点
-        this._nodes[node1.queueIndex] = node2;
-        this._nodes[node2.queueIndex] = node1;
-
-        // 交换他们的indicies
-        let temp = node1.queueIndex;
-        node1.queueIndex = node2.queueIndex;
-        node2.queueIndex = temp;
-    }
-
-    /**
-     * 如果higher的优先级高于lower，则返回true，否则返回false。
-     * 注意，调用HasHigherPriority(节点，节点)(即。两个参数为同一个节点)将返回false
-     * @param higher 
-     * @param lower 
-     */
-    private hasHigherPriority(higher: T, lower: T) {
-        return (higher.priority < lower.priority ||
-            (higher.priority == lower.priority && higher.insertionIndex < lower.insertionIndex));
-    }
-}
\ No newline at end of file
+}
diff --git a/source/src/AI/Pathfinding/AStar/PriorityQueueNode.ts b/source/src/AI/Pathfinding/AStar/PriorityQueueNode.ts
index 44edbc9e..29c86e2c 100644
--- a/source/src/AI/Pathfinding/AStar/PriorityQueueNode.ts
+++ b/source/src/AI/Pathfinding/AStar/PriorityQueueNode.ts
@@ -1,14 +1,16 @@
-class PriorityQueueNode {
-    /**
-     * 插入此节点的优先级。在将节点添加到队列之前必须设置
-     */
-    public priority: number = 0;
-    /**
-     * 由优先级队列使用-不要编辑此值。表示插入节点的顺序
-     */
-    public insertionIndex: number = 0;
-    /**
-     * 由优先级队列使用-不要编辑此值。表示队列中的当前位置
-     */
-    public queueIndex: number = 0;
-}
\ No newline at end of file
+module es {
+    export class PriorityQueueNode {
+        /**
+         * 插入此节点的优先级。在将节点添加到队列之前必须设置
+         */
+        public priority: number = 0;
+        /**
+         * 由优先级队列使用-不要编辑此值。表示插入节点的顺序
+         */
+        public insertionIndex: number = 0;
+        /**
+         * 由优先级队列使用-不要编辑此值。表示队列中的当前位置
+         */
+        public queueIndex: number = 0;
+    }
+}
diff --git a/source/src/AI/Pathfinding/BreadthFirst/BreadthFirstPathfinder.ts b/source/src/AI/Pathfinding/BreadthFirst/BreadthFirstPathfinder.ts
index 429af42c..4cad3f8e 100644
--- a/source/src/AI/Pathfinding/BreadthFirst/BreadthFirstPathfinder.ts
+++ b/source/src/AI/Pathfinding/BreadthFirst/BreadthFirstPathfinder.ts
@@ -1,41 +1,43 @@
-/** 
- * 计算路径给定的IUnweightedGraph和开始/目标位置
- */
-class BreadthFirstPathfinder {
-    public static search<T>(graph: IUnweightedGraph<T>, start: T, goal: T): T[]{
-        let foundPath = false;
-        let frontier = [];
-        frontier.unshift(start);
+module es {
+    /**
+     * 计算路径给定的IUnweightedGraph和开始/目标位置
+     */
+    export class BreadthFirstPathfinder {
+        public static search<T>(graph: IUnweightedGraph<T>, start: T, goal: T): T[]{
+            let foundPath = false;
+            let frontier = [];
+            frontier.unshift(start);
 
-        let cameFrom = new Map<T, T>();
-        cameFrom.set(start, start);
+            let cameFrom = new Map<T, T>();
+            cameFrom.set(start, start);
 
-        while (frontier.length > 0){
-            let current = frontier.shift();
-            if (JSON.stringify(current) == JSON.stringify(goal)){
-                foundPath = true;
-                break;
+            while (frontier.length > 0){
+                let current = frontier.shift();
+                if (JSON.stringify(current) == JSON.stringify(goal)){
+                    foundPath = true;
+                    break;
+                }
+
+                graph.getNeighbors(current).forEach(next => {
+                    if (!this.hasKey(cameFrom, next)){
+                        frontier.unshift(next);
+                        cameFrom.set(next, current);
+                    }
+                });
             }
 
-            graph.getNeighbors(current).forEach(next => {
-                if (!this.hasKey(cameFrom, next)){
-                    frontier.unshift(next);
-                    cameFrom.set(next, current);
-                }
-            });
+            return foundPath ? AStarPathfinder.recontructPath(cameFrom, start, goal) : null;
         }
 
-        return foundPath ? AStarPathfinder.recontructPath(cameFrom, start, goal) : null;
-    }
+        private static hasKey<T>(map: Map<T, T>, compareKey: T){
+            let iterator = map.keys();
+            let r: IteratorResult<T>;
+            while (r = iterator.next() , !r.done) {
+                if (JSON.stringify(r.value) == JSON.stringify(compareKey))
+                    return true;
+            }
 
-    private static hasKey<T>(map: Map<T, T>, compareKey: T){
-        let iterator = map.keys();
-        let r: IteratorResult<T>;
-        while (r = iterator.next() , !r.done) {
-            if (JSON.stringify(r.value) == JSON.stringify(compareKey))
-                return true;
+            return false;
         }
-
-        return false;
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/AI/Pathfinding/BreadthFirst/IUnweightedGraph.ts b/source/src/AI/Pathfinding/BreadthFirst/IUnweightedGraph.ts
index 26a6af36..60c07253 100644
--- a/source/src/AI/Pathfinding/BreadthFirst/IUnweightedGraph.ts
+++ b/source/src/AI/Pathfinding/BreadthFirst/IUnweightedGraph.ts
@@ -1,7 +1,9 @@
-interface IUnweightedGraph<T>{
-    /**
-     * getNeighbors方法应该返回从传入的节点可以到达的任何相邻节点。
-     * @param node 
-     */
-    getNeighbors(node: T): T[];
-}
\ No newline at end of file
+module es {
+    export interface IUnweightedGraph<T>{
+        /**
+         * getNeighbors方法应该返回从传入的节点可以到达的任何相邻节点。
+         * @param node
+         */
+        getNeighbors(node: T): T[];
+    }
+}
diff --git a/source/src/AI/Pathfinding/BreadthFirst/UnweightedGraph.ts b/source/src/AI/Pathfinding/BreadthFirst/UnweightedGraph.ts
index e37120bc..745b1eb6 100644
--- a/source/src/AI/Pathfinding/BreadthFirst/UnweightedGraph.ts
+++ b/source/src/AI/Pathfinding/BreadthFirst/UnweightedGraph.ts
@@ -1,16 +1,18 @@
-/**
- * 一个未加权图的基本实现。所有的边都被缓存。这种类型的图最适合于非基于网格的图。
- * 作为边添加的任何节点都必须在边字典中有一个条目作为键。
- */
-class UnweightedGraph<T> implements IUnweightedGraph<T> {
-    public edges: Map<T, T[]> = new Map<T, T[]>();
+module es {
+    /**
+     * 一个未加权图的基本实现。所有的边都被缓存。这种类型的图最适合于非基于网格的图。
+     * 作为边添加的任何节点都必须在边字典中有一个条目作为键。
+     */
+    export class UnweightedGraph<T> implements IUnweightedGraph<T> {
+        public edges: Map<T, T[]> = new Map<T, T[]>();
 
-    public addEdgesForNode(node: T, edges: T[]){
-        this.edges.set(node, edges);
-        return this;
-    }
+        public addEdgesForNode(node: T, edges: T[]){
+            this.edges.set(node, edges);
+            return this;
+        }
 
-    public getNeighbors(node: T){
-        return this.edges.get(node);
+        public getNeighbors(node: T){
+            return this.edges.get(node);
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/AI/Pathfinding/BreadthFirst/UnweightedGridGraph.ts b/source/src/AI/Pathfinding/BreadthFirst/UnweightedGridGraph.ts
index f769f398..e0516a93 100644
--- a/source/src/AI/Pathfinding/BreadthFirst/UnweightedGridGraph.ts
+++ b/source/src/AI/Pathfinding/BreadthFirst/UnweightedGridGraph.ts
@@ -1,61 +1,63 @@
 ///<reference path="../../../Math/Vector2.ts" />
-/**
- * 基本的未加权网格图形用于BreadthFirstPathfinder
- */
-class UnweightedGridGraph implements IUnweightedGraph<Vector2> {
-    private static readonly CARDINAL_DIRS: Vector2[] = [
-        new Vector2(1, 0),
-        new Vector2(0, -1),
-        new Vector2(-1, 0),
-        new Vector2(0, -1)
-    ];
+module es {
+    /**
+     * 基本的未加权网格图形用于BreadthFirstPathfinder
+     */
+    export class UnweightedGridGraph implements IUnweightedGraph<Vector2> {
+        private static readonly CARDINAL_DIRS: Vector2[] = [
+            new Vector2(1, 0),
+            new Vector2(0, -1),
+            new Vector2(-1, 0),
+            new Vector2(0, -1)
+        ];
 
-    private static readonly COMPASS_DIRS = [
-        new Vector2(1, 0),
-        new Vector2(1, -1),
-        new Vector2(0, -1),
-        new Vector2(-1, -1),
-        new Vector2(-1, 0),
-        new Vector2(-1, 1),
-        new Vector2(0, 1),
-        new Vector2(1, 1),
-    ];
+        private static readonly COMPASS_DIRS = [
+            new Vector2(1, 0),
+            new Vector2(1, -1),
+            new Vector2(0, -1),
+            new Vector2(-1, -1),
+            new Vector2(-1, 0),
+            new Vector2(-1, 1),
+            new Vector2(0, 1),
+            new Vector2(1, 1),
+        ];
 
-    public walls: Vector2[] = [];
+        public walls: Vector2[] = [];
 
-    private _width: number;
-    private _hegiht: number;
+        private _width: number;
+        private _hegiht: number;
 
-    private _dirs: Vector2[];
-    private _neighbors: Vector2[] = new Array(4);
+        private _dirs: Vector2[];
+        private _neighbors: Vector2[] = new Array(4);
 
-    constructor(width: number, height: number, allowDiagonalSearch: boolean = false) {
-        this._width = width;
-        this._hegiht = height;
-        this._dirs = allowDiagonalSearch ? UnweightedGridGraph.COMPASS_DIRS : UnweightedGridGraph.CARDINAL_DIRS;
+        constructor(width: number, height: number, allowDiagonalSearch: boolean = false) {
+            this._width = width;
+            this._hegiht = height;
+            this._dirs = allowDiagonalSearch ? UnweightedGridGraph.COMPASS_DIRS : UnweightedGridGraph.CARDINAL_DIRS;
+        }
+
+        public isNodeInBounds(node: Vector2): boolean {
+            return 0 <= node.x && node.x < this._width && 0 <= node.y && node.y < this._hegiht;
+        }
+
+        public isNodePassable(node: Vector2): boolean {
+            return !this.walls.firstOrDefault(wall => JSON.stringify(wall) == JSON.stringify(node));
+        }
+
+        public getNeighbors(node: Vector2) {
+            this._neighbors.length = 0;
+
+            this._dirs.forEach(dir => {
+                let next = new Vector2(node.x + dir.x, node.y + dir.y);
+                if (this.isNodeInBounds(next) && this.isNodePassable(next))
+                    this._neighbors.push(next);
+            });
+
+            return this._neighbors;
+        }
+
+        public search(start: Vector2, goal: Vector2): Vector2[] {
+            return BreadthFirstPathfinder.search(this, start, goal);
+        }
     }
-
-    public isNodeInBounds(node: Vector2): boolean {
-        return 0 <= node.x && node.x < this._width && 0 <= node.y && node.y < this._hegiht;
-    }
-
-    public isNodePassable(node: Vector2): boolean {
-        return !this.walls.firstOrDefault(wall => JSON.stringify(wall) == JSON.stringify(node));
-    }
-
-    public getNeighbors(node: Vector2) {
-        this._neighbors.length = 0;
-
-        this._dirs.forEach(dir => {
-            let next = new Vector2(node.x + dir.x, node.y + dir.y);
-            if (this.isNodeInBounds(next) && this.isNodePassable(next))
-                this._neighbors.push(next);
-        });
-
-        return this._neighbors;
-    }
-
-    public search(start: Vector2, goal: Vector2): Vector2[] {
-        return BreadthFirstPathfinder.search(this, start, goal);
-    }
-}
\ No newline at end of file
+}
diff --git a/source/src/AI/Pathfinding/Dijkstra/IWeightedGraph.ts b/source/src/AI/Pathfinding/Dijkstra/IWeightedGraph.ts
index 7ce1e30e..2a6223e8 100644
--- a/source/src/AI/Pathfinding/Dijkstra/IWeightedGraph.ts
+++ b/source/src/AI/Pathfinding/Dijkstra/IWeightedGraph.ts
@@ -1,14 +1,16 @@
-interface IWeightedGraph<T>{
-    /**
-     * 
-     * @param node 
-     */
-    getNeighbors(node: T): T[];
+module es {
+    export interface IWeightedGraph<T>{
+        /**
+         *
+         * @param node
+         */
+        getNeighbors(node: T): T[];
 
-    /**
-     * 
-     * @param from 
-     * @param to 
-     */
-    cost(from: T, to: T): number;
-}
\ No newline at end of file
+        /**
+         *
+         * @param from
+         * @param to
+         */
+        cost(from: T, to: T): number;
+    }
+}
diff --git a/source/src/AI/Pathfinding/Dijkstra/WeightedGridGraph.ts b/source/src/AI/Pathfinding/Dijkstra/WeightedGridGraph.ts
index 474535c1..1de59287 100644
--- a/source/src/AI/Pathfinding/Dijkstra/WeightedGridGraph.ts
+++ b/source/src/AI/Pathfinding/Dijkstra/WeightedGridGraph.ts
@@ -1,67 +1,69 @@
 ///<reference path="../../../Math/Vector2.ts" />
-/**
- * 支持一种加权节点的基本网格图
- */
-class WeightedGridGraph implements IWeightedGraph<Vector2> {
-    public static readonly CARDINAL_DIRS = [
-        new Vector2(1, 0),
-        new Vector2(0, -1),
-        new Vector2(-1, 0),
-        new Vector2(0, 1)
-    ];
+module es {
+    /**
+     * 支持一种加权节点的基本网格图
+     */
+    export class WeightedGridGraph implements IWeightedGraph<Vector2> {
+        public static readonly CARDINAL_DIRS = [
+            new Vector2(1, 0),
+            new Vector2(0, -1),
+            new Vector2(-1, 0),
+            new Vector2(0, 1)
+        ];
 
-    private static readonly COMPASS_DIRS = [
-        new Vector2(1, 0),
-        new Vector2(1, -1),
-        new Vector2(0, -1),
-        new Vector2(-1, -1),
-        new Vector2(-1, 0),
-        new Vector2(-1, 1),
-        new Vector2(0, 1),
-        new Vector2(1, 1),
-    ];
+        private static readonly COMPASS_DIRS = [
+            new Vector2(1, 0),
+            new Vector2(1, -1),
+            new Vector2(0, -1),
+            new Vector2(-1, -1),
+            new Vector2(-1, 0),
+            new Vector2(-1, 1),
+            new Vector2(0, 1),
+            new Vector2(1, 1),
+        ];
 
-    public walls: Vector2[] = [];
-    public weightedNodes: Vector2[] = [];
-    public defaultWeight = 1;
-    public weightedNodeWeight = 5;
+        public walls: Vector2[] = [];
+        public weightedNodes: Vector2[] = [];
+        public defaultWeight = 1;
+        public weightedNodeWeight = 5;
 
-    private _width: number;
-    private _height: number;
-    private _dirs: Vector2[];
-    private _neighbors: Vector2[] = new Array(4);
+        private _width: number;
+        private _height: number;
+        private _dirs: Vector2[];
+        private _neighbors: Vector2[] = new Array(4);
 
-    constructor(width: number, height: number, allowDiagonalSearch: boolean = false){
-        this._width = width;
-        this._height = height;
-        this._dirs = allowDiagonalSearch ? WeightedGridGraph.COMPASS_DIRS : WeightedGridGraph.CARDINAL_DIRS;
+        constructor(width: number, height: number, allowDiagonalSearch: boolean = false){
+            this._width = width;
+            this._height = height;
+            this._dirs = allowDiagonalSearch ? WeightedGridGraph.COMPASS_DIRS : WeightedGridGraph.CARDINAL_DIRS;
+        }
+
+        public isNodeInBounds(node: Vector2){
+            return 0 <= node.x && node.x < this._width && 0 <= node.y && node.y < this._height;
+        }
+
+        public isNodePassable(node: Vector2): boolean {
+            return !this.walls.firstOrDefault(wall => JSON.stringify(wall) == JSON.stringify(node));
+        }
+
+        public search(start: Vector2, goal: Vector2){
+            return WeightedPathfinder.search(this, start, goal);
+        }
+
+        public getNeighbors(node: Vector2): Vector2[]{
+            this._neighbors.length = 0;
+
+            this._dirs.forEach(dir => {
+                let next = new Vector2(node.x + dir.x, node.y + dir.y);
+                if (this.isNodeInBounds(next) && this.isNodePassable(next))
+                    this._neighbors.push(next);
+            });
+
+            return this._neighbors;
+        }
+
+        public cost(from: Vector2, to: Vector2): number{
+            return this.weightedNodes.find(t => JSON.stringify(t) == JSON.stringify(to)) ? this.weightedNodeWeight : this.defaultWeight;
+        }
     }
-
-    public isNodeInBounds(node: Vector2){
-        return 0 <= node.x && node.x < this._width && 0 <= node.y && node.y < this._height;
-    }
-
-    public isNodePassable(node: Vector2): boolean {
-        return !this.walls.firstOrDefault(wall => JSON.stringify(wall) == JSON.stringify(node));
-    }
-
-    public search(start: Vector2, goal: Vector2){
-        return WeightedPathfinder.search(this, start, goal);
-    }
-
-    public getNeighbors(node: Vector2): Vector2[]{
-        this._neighbors.length = 0;
-
-        this._dirs.forEach(dir => {
-            let next = new Vector2(node.x + dir.x, node.y + dir.y);
-            if (this.isNodeInBounds(next) && this.isNodePassable(next))
-                this._neighbors.push(next);
-        });
-
-        return this._neighbors;
-    }
-
-    public cost(from: Vector2, to: Vector2): number{
-        return this.weightedNodes.find(t => JSON.stringify(t) == JSON.stringify(to)) ? this.weightedNodeWeight : this.defaultWeight;
-    }
-}
\ No newline at end of file
+}
diff --git a/source/src/AI/Pathfinding/Dijkstra/WeightedPathfinder.ts b/source/src/AI/Pathfinding/Dijkstra/WeightedPathfinder.ts
index 1150e696..6c609356 100644
--- a/source/src/AI/Pathfinding/Dijkstra/WeightedPathfinder.ts
+++ b/source/src/AI/Pathfinding/Dijkstra/WeightedPathfinder.ts
@@ -1,83 +1,85 @@
-class WeightedNode<T> extends PriorityQueueNode {
-    public data: T;
+module es {
+    export class WeightedNode<T> extends PriorityQueueNode {
+        public data: T;
 
-    constructor(data: T){
-        super();
-        this.data = data;
+        constructor(data: T){
+            super();
+            this.data = data;
+        }
     }
-}
 
-class WeightedPathfinder {
-    public static search<T>(graph: IWeightedGraph<T>, start: T, goal: T){
-        let foundPath = false;
+    export class WeightedPathfinder {
+        public static search<T>(graph: IWeightedGraph<T>, start: T, goal: T){
+            let foundPath = false;
 
-        let cameFrom = new Map<T, T>();
-        cameFrom.set(start, start);
+            let cameFrom = new Map<T, T>();
+            cameFrom.set(start, start);
 
-        let costSoFar = new Map<T, number>();
-        let frontier = new PriorityQueue<WeightedNode<T>>(1000);
-        frontier.enqueue(new WeightedNode<T>(start), 0);
+            let costSoFar = new Map<T, number>();
+            let frontier = new PriorityQueue<WeightedNode<T>>(1000);
+            frontier.enqueue(new WeightedNode<T>(start), 0);
 
-        costSoFar.set(start, 0);
+            costSoFar.set(start, 0);
 
-        while (frontier.count > 0){
-            let current = frontier.dequeue();
-            
-            if (JSON.stringify(current.data) == JSON.stringify(goal)){
-                foundPath = true;
-                break;
+            while (frontier.count > 0){
+                let current = frontier.dequeue();
+
+                if (JSON.stringify(current.data) == JSON.stringify(goal)){
+                    foundPath = true;
+                    break;
+                }
+
+                graph.getNeighbors(current.data).forEach(next => {
+                    let newCost = costSoFar.get(current.data) + graph.cost(current.data, next);
+                    if (!this.hasKey(costSoFar, next) || newCost < costSoFar.get(next)){
+                        costSoFar.set(next, newCost);
+                        let priprity = newCost;
+                        frontier.enqueue(new WeightedNode<T>(next), priprity);
+                        cameFrom.set(next, current.data);
+                    }
+                });
             }
 
-            graph.getNeighbors(current.data).forEach(next => {
-                let newCost = costSoFar.get(current.data) + graph.cost(current.data, next);
-                if (!this.hasKey(costSoFar, next) || newCost < costSoFar.get(next)){
-                    costSoFar.set(next, newCost);
-                    let priprity = newCost;
-                    frontier.enqueue(new WeightedNode<T>(next), priprity);
-                    cameFrom.set(next, current.data);
-                }
-            });
-        }
-        
-        return foundPath ? this.recontructPath(cameFrom, start, goal) : null;
-    }
-
-    private static hasKey<T>(map: Map<T, number>, compareKey: T){
-        let iterator = map.keys();
-        let r: IteratorResult<T>;
-        while (r = iterator.next() , !r.done) {
-            if (JSON.stringify(r.value) == JSON.stringify(compareKey))
-                return true;
+            return foundPath ? this.recontructPath(cameFrom, start, goal) : null;
         }
 
-        return false;
-    }
+        private static hasKey<T>(map: Map<T, number>, compareKey: T){
+            let iterator = map.keys();
+            let r: IteratorResult<T>;
+            while (r = iterator.next() , !r.done) {
+                if (JSON.stringify(r.value) == JSON.stringify(compareKey))
+                    return true;
+            }
 
-    private static getKey<T>(map: Map<T, T>, compareKey: T){
-        let iterator = map.keys();
-        let valueIterator = map.values();
-        let r: IteratorResult<T>;
-        let v: IteratorResult<T>;
-        while (r = iterator.next(), v = valueIterator.next(), !r.done) {
-            if (JSON.stringify(r.value) == JSON.stringify(compareKey))
-                return v.value;
+            return false;
         }
 
-        return null;
-    }
+        private static getKey<T>(map: Map<T, T>, compareKey: T){
+            let iterator = map.keys();
+            let valueIterator = map.values();
+            let r: IteratorResult<T>;
+            let v: IteratorResult<T>;
+            while (r = iterator.next(), v = valueIterator.next(), !r.done) {
+                if (JSON.stringify(r.value) == JSON.stringify(compareKey))
+                    return v.value;
+            }
 
-    public static recontructPath<T>(cameFrom: Map<T, T>, start: T, goal: T): T[]{
-        let path = [];
-        let current = goal;
-        path.push(goal);
-
-        while (current != start){
-            current = this.getKey(cameFrom, current);
-            path.push(current);
+            return null;
         }
 
-        path.reverse();
+        public static recontructPath<T>(cameFrom: Map<T, T>, start: T, goal: T): T[]{
+            let path = [];
+            let current = goal;
+            path.push(goal);
 
-        return path;
+            while (current != start){
+                current = this.getKey(cameFrom, current);
+                path.push(current);
+            }
+
+            path.reverse();
+
+            return path;
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Debug/Debug.ts b/source/src/Debug/Debug.ts
index 18121259..a1ebdce9 100644
--- a/source/src/Debug/Debug.ts
+++ b/source/src/Debug/Debug.ts
@@ -1,22 +1,24 @@
-class Debug {
-    private static _debugDrawItems: DebugDrawItem[] = [];
+module es {
+    export class Debug {
+        private static _debugDrawItems: DebugDrawItem[] = [];
 
-    public static drawHollowRect(rectanle: Rectangle, color: number, duration = 0){
-        this._debugDrawItems.push(new DebugDrawItem(rectanle, color, duration));
-    }
+        public static drawHollowRect(rectanle: Rectangle, color: number, duration = 0){
+            this._debugDrawItems.push(new DebugDrawItem(rectanle, color, duration));
+        }
 
-    public static render(){
-        if (this._debugDrawItems.length > 0){
-            let debugShape = new egret.Shape();
-            if (SceneManager.scene){
-                SceneManager.scene.addChild(debugShape);
-            }
+        public static render(){
+            if (this._debugDrawItems.length > 0){
+                let debugShape = new egret.Shape();
+                if (SceneManager.scene){
+                    SceneManager.scene.addChild(debugShape);
+                }
 
-            for (let i = this._debugDrawItems.length - 1; i >= 0; i --){
-                let item = this._debugDrawItems[i];
-                if (item.draw(debugShape))
-                    this._debugDrawItems.removeAt(i);
+                for (let i = this._debugDrawItems.length - 1; i >= 0; i --){
+                    let item = this._debugDrawItems[i];
+                    if (item.draw(debugShape))
+                        this._debugDrawItems.removeAt(i);
+                }
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Debug/DebugDefaults.ts b/source/src/Debug/DebugDefaults.ts
index 9b79445c..febc8a01 100644
--- a/source/src/Debug/DebugDefaults.ts
+++ b/source/src/Debug/DebugDefaults.ts
@@ -1,4 +1,6 @@
-class DebugDefaults {
-    public static verletParticle = 0xDC345E;
-    public static verletConstraintEdge = 0x433E36;
-}
\ No newline at end of file
+module es {
+    export class DebugDefaults {
+        public static verletParticle = 0xDC345E;
+        public static verletConstraintEdge = 0x433E36;
+    }
+}
diff --git a/source/src/Debug/DebugDrawItem.ts b/source/src/Debug/DebugDrawItem.ts
index bca31275..a13011fe 100644
--- a/source/src/Debug/DebugDrawItem.ts
+++ b/source/src/Debug/DebugDrawItem.ts
@@ -1,46 +1,49 @@
-enum DebugDrawType {
-    line,
-    hollowRectangle,
-    pixel,
-    text
-}
-
-class DebugDrawItem {
-    public rectangle: Rectangle;
-    public color: number;
-    public duration: number;
-    public drawType: DebugDrawType;
-    public text: string;
-    public start: Vector2;
-    public end: Vector2;
-    public x: number;
-    public y: number;
-    public size: number;
-
-    constructor(rectangle: Rectangle, color: number, duration: number){
-        this.rectangle = rectangle;
-        this.color = color;
-        this.duration = duration;
-        this.drawType = DebugDrawType.hollowRectangle;
+module es {
+    export enum DebugDrawType {
+        line,
+        hollowRectangle,
+        pixel,
+        text
     }
 
-    public draw(shape: egret.Shape): boolean{
-        switch (this.drawType){
-            case DebugDrawType.line:
-                DrawUtils.drawLine(shape, this.start, this.end, this.color);
-                break;
-            case DebugDrawType.hollowRectangle:
-                DrawUtils.drawHollowRect(shape, this.rectangle, this.color);
-                break;
-            case DebugDrawType.pixel:
-                DrawUtils.drawPixel(shape, new Vector2(this.x, this.y), this.color, this.size);
-                break;
-            case DebugDrawType.text:
-                break;
+    export class DebugDrawItem {
+        public rectangle: Rectangle;
+        public color: number;
+        public duration: number;
+        public drawType: DebugDrawType;
+        public text: string;
+        public start: Vector2;
+        public end: Vector2;
+        public x: number;
+        public y: number;
+        public size: number;
+
+        constructor(rectangle: Rectangle, color: number, duration: number){
+            this.rectangle = rectangle;
+            this.color = color;
+            this.duration = duration;
+            this.drawType = DebugDrawType.hollowRectangle;
         }
 
-        this.duration -= Time.deltaTime;
-        return this.duration < 0;
+        public draw(shape: egret.Shape): boolean{
+            switch (this.drawType){
+                case DebugDrawType.line:
+                    DrawUtils.drawLine(shape, this.start, this.end, this.color);
+                    break;
+                case DebugDrawType.hollowRectangle:
+                    DrawUtils.drawHollowRect(shape, this.rectangle, this.color);
+                    break;
+                case DebugDrawType.pixel:
+                    DrawUtils.drawPixel(shape, new Vector2(this.x, this.y), this.color, this.size);
+                    break;
+                case DebugDrawType.text:
+                    break;
+            }
+
+            this.duration -= Time.deltaTime;
+            return this.duration < 0;
+        }
     }
 }
 
+
diff --git a/source/src/ECS/CoreEvents.ts b/source/src/ECS/CoreEvents.ts
index 552d9572..c9893382 100644
--- a/source/src/ECS/CoreEvents.ts
+++ b/source/src/ECS/CoreEvents.ts
@@ -1,4 +1,6 @@
-enum CoreEvents{
-    /** 当场景发生变化时触发 */
-    SceneChanged,
-}
\ No newline at end of file
+module es {
+    export enum CoreEvents{
+        /** 当场景发生变化时触发 */
+        SceneChanged,
+    }
+}
diff --git a/source/src/ECS/Scene.ts b/source/src/ECS/Scene.ts
index d5c85859..84fb8f65 100644
--- a/source/src/ECS/Scene.ts
+++ b/source/src/ECS/Scene.ts
@@ -36,7 +36,7 @@ module es {
        */
       public static createWithDefaultRenderer(){
          let scene = new Scene();
-         scene.addRenderer(new DefaultRenderer())；
+         scene.addRenderer(new DefaultRenderer());
          return scene;
       }
 
diff --git a/source/src/ECS/SceneManager.ts b/source/src/ECS/SceneManager.ts
index 37c726f5..cf5b74b7 100644
--- a/source/src/ECS/SceneManager.ts
+++ b/source/src/ECS/SceneManager.ts
@@ -1,144 +1,146 @@
-/** 运行时的场景管理。 */
-class SceneManager {
-    private static _scene: Scene;
-    private static _nextScene: Scene;
-    public static sceneTransition: SceneTransition;
-    public static stage: egret.Stage;
-    /** 订阅此事件以在活动场景发生更改时得到通知。 */
-    public static activeSceneChanged: Function;
-    /** 核心发射器。只发出核心级别的事件 */
-    public static emitter: Emitter<CoreEvents>;
-    /** 全局内容管理器加载任何应该停留在场景之间的资产 */
-    public static content: ContentManager;
-    /** 简化对内部类的全局内容实例的访问 */
-    private static _instnace: SceneManager;
-    private static timerRuler: TimeRuler;
-    public static get Instance(){
-        return this._instnace;
-    }
-
-    constructor(stage: egret.Stage) {
-        stage.addEventListener(egret.Event.ENTER_FRAME, SceneManager.update, this);
-
-        SceneManager._instnace = this;
-        SceneManager.emitter = new Emitter<CoreEvents>();
-        SceneManager.content = new ContentManager();
-
-        SceneManager.stage = stage;
-        SceneManager.initialize(stage);
-        SceneManager.timerRuler = new TimeRuler();
-    }
-
-    public static get scene() {
-        return this._scene;
-    }
-    public static set scene(value: Scene) {
-        if (!value)
-            throw new Error("场景不能为空");
-
-        if (this._scene == null) {
-            this._scene = value;
-            this._scene.begin();
-            SceneManager.Instance.onSceneChanged();
-        } else {
-            this._nextScene = value;
+module es {
+    /** 运行时的场景管理。 */
+    export class SceneManager {
+        private static _scene: Scene;
+        private static _nextScene: Scene;
+        public static sceneTransition: SceneTransition;
+        public static stage: egret.Stage;
+        /** 订阅此事件以在活动场景发生更改时得到通知。 */
+        public static activeSceneChanged: Function;
+        /** 核心发射器。只发出核心级别的事件 */
+        public static emitter: Emitter<CoreEvents>;
+        /** 全局内容管理器加载任何应该停留在场景之间的资产 */
+        public static content: ContentManager;
+        /** 简化对内部类的全局内容实例的访问 */
+        private static _instnace: SceneManager;
+        private static timerRuler: TimeRuler;
+        public static get Instance(){
+            return this._instnace;
         }
 
-        this.registerActiveSceneChanged(this._scene, this._nextScene);
-    }
+        constructor(stage: egret.Stage) {
+            stage.addEventListener(egret.Event.ENTER_FRAME, SceneManager.update, this);
 
-    public static initialize(stage: egret.Stage) {
-        Input.initialize(stage);
-    }
+            SceneManager._instnace = this;
+            SceneManager.emitter = new Emitter<CoreEvents>();
+            SceneManager.content = new ContentManager();
 
-    public static update() {
-        SceneManager.startDebugUpdate();
-        Time.update(egret.getTimer());
+            SceneManager.stage = stage;
+            SceneManager.initialize(stage);
+            SceneManager.timerRuler = new TimeRuler();
+        }
 
-        if (SceneManager._scene) {
-            for (let i = GlobalManager.globalManagers.length - 1; i >= 0; i--) {
-                if (GlobalManager.globalManagers[i].enabled)
-                    GlobalManager.globalManagers[i].update();
+        public static get scene() {
+            return this._scene;
+        }
+        public static set scene(value: Scene) {
+            if (!value)
+                throw new Error("场景不能为空");
+
+            if (this._scene == null) {
+                this._scene = value;
+                this._scene.begin();
+                SceneManager.Instance.onSceneChanged();
+            } else {
+                this._nextScene = value;
             }
 
-            if (!SceneManager.sceneTransition ||
-                (SceneManager.sceneTransition && (!SceneManager.sceneTransition.loadsNewScene || SceneManager.sceneTransition.isNewSceneLoaded))) {
+            this.registerActiveSceneChanged(this._scene, this._nextScene);
+        }
+
+        public static initialize(stage: egret.Stage) {
+            Input.initialize(stage);
+        }
+
+        public static update() {
+            SceneManager.startDebugUpdate();
+            Time.update(egret.getTimer());
+
+            if (SceneManager._scene) {
+                for (let i = GlobalManager.globalManagers.length - 1; i >= 0; i--) {
+                    if (GlobalManager.globalManagers[i].enabled)
+                        GlobalManager.globalManagers[i].update();
+                }
+
+                if (!SceneManager.sceneTransition ||
+                    (SceneManager.sceneTransition && (!SceneManager.sceneTransition.loadsNewScene || SceneManager.sceneTransition.isNewSceneLoaded))) {
                     SceneManager._scene.update();
+                }
+
+                if (SceneManager._nextScene) {
+                    SceneManager._scene.end();
+
+                    SceneManager._scene = SceneManager._nextScene;
+                    SceneManager._nextScene = null;
+                    SceneManager._instnace.onSceneChanged();
+
+                    SceneManager._scene.begin();
+                }
             }
 
-            if (SceneManager._nextScene) {
-                SceneManager._scene.end();
-
-                SceneManager._scene = SceneManager._nextScene;
-                SceneManager._nextScene = null;
-                SceneManager._instnace.onSceneChanged();
-
-                SceneManager._scene.begin();
-            }
+            SceneManager.endDebugUpdate();
+            SceneManager.render();
         }
 
-        SceneManager.endDebugUpdate();
-        SceneManager.render();
-    }
+        public static render() {
+            if (this.sceneTransition){
+                this.sceneTransition.preRender();
 
-    public static render() {
-        if (this.sceneTransition){
-            this.sceneTransition.preRender();
-
-            if (this._scene && !this.sceneTransition.hasPreviousSceneRender){
-                this._scene.render();
-                this._scene.postRender();
-                this.sceneTransition.onBeginTransition();
-            } else if (this.sceneTransition) {
-                if (this._scene && this.sceneTransition.isNewSceneLoaded) {
+                if (this._scene && !this.sceneTransition.hasPreviousSceneRender){
                     this._scene.render();
                     this._scene.postRender();
+                    this.sceneTransition.onBeginTransition();
+                } else if (this.sceneTransition) {
+                    if (this._scene && this.sceneTransition.isNewSceneLoaded) {
+                        this._scene.render();
+                        this._scene.postRender();
+                    }
+
+                    this.sceneTransition.render();
                 }
-    
-                this.sceneTransition.render();
+            } else if (this._scene) {
+                this._scene.render();
+
+                Debug.render();
+
+                this._scene.postRender();
             }
-        } else if (this._scene) {
-            this._scene.render();
-
-            Debug.render();
-
-            this._scene.postRender();
-        }
-    }
-
-    /**
-     * 临时运行SceneTransition，允许一个场景过渡到另一个平滑的自定义效果。
-     * @param sceneTransition 
-     */
-    public static startSceneTransition<T extends SceneTransition>(sceneTransition: T): T {
-        if (this.sceneTransition) {
-            console.warn("在前一个场景完成之前，不能开始一个新的场景转换。");
-            return;
         }
 
-        this.sceneTransition = sceneTransition;
-        return sceneTransition;
-    }
+        /**
+         * 临时运行SceneTransition，允许一个场景过渡到另一个平滑的自定义效果。
+         * @param sceneTransition
+         */
+        public static startSceneTransition<T extends SceneTransition>(sceneTransition: T): T {
+            if (this.sceneTransition) {
+                console.warn("在前一个场景完成之前，不能开始一个新的场景转换。");
+                return;
+            }
 
-    public static registerActiveSceneChanged(current: Scene, next: Scene){
-        if (this.activeSceneChanged)
-            this.activeSceneChanged(current, next);
-    }
+            this.sceneTransition = sceneTransition;
+            return sceneTransition;
+        }
 
-    /**
-     * 在一个场景结束后，下一个场景开始之前调用
-     */
-    public onSceneChanged(){
-        SceneManager.emitter.emit(CoreEvents.SceneChanged);
-        Time.sceneChanged();
-    }
+        public static registerActiveSceneChanged(current: Scene, next: Scene){
+            if (this.activeSceneChanged)
+                this.activeSceneChanged(current, next);
+        }
 
-    private static startDebugUpdate(){
-        TimeRuler.Instance.startFrame();
-        TimeRuler.Instance.beginMark("update", 0x00FF00);
-    }
+        /**
+         * 在一个场景结束后，下一个场景开始之前调用
+         */
+        public onSceneChanged(){
+            SceneManager.emitter.emit(CoreEvents.SceneChanged);
+            Time.sceneChanged();
+        }
 
-    private static endDebugUpdate(){
-        TimeRuler.Instance.endMark("update");
+        private static startDebugUpdate(){
+            TimeRuler.Instance.startFrame();
+            TimeRuler.Instance.beginMark("update", 0x00FF00);
+        }
+
+        private static endDebugUpdate(){
+            TimeRuler.Instance.endMark("update");
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/ECS/Systems/EntityProcessingSystem.ts b/source/src/ECS/Systems/EntityProcessingSystem.ts
index 5eebfedf..15022a35 100644
--- a/source/src/ECS/Systems/EntityProcessingSystem.ts
+++ b/source/src/ECS/Systems/EntityProcessingSystem.ts
@@ -1,32 +1,34 @@
 ///<reference path="./EntitySystem.ts" />
-/**
- * 基本实体处理系统。将其用作处理具有特定组件的许多实体的基础
- */
-abstract class EntityProcessingSystem extends EntitySystem {
-    constructor(matcher: Matcher) {
-        super(matcher);
-    }
-
-   
+module es {
     /**
-     * 处理特定的实体 
-     * @param entity 
+     * 基本实体处理系统。将其用作处理具有特定组件的许多实体的基础
      */
-    public abstract processEntity(entity: Entity);
+    export abstract class EntityProcessingSystem extends EntitySystem {
+        constructor(matcher: Matcher) {
+            super(matcher);
+        }
 
-    public lateProcessEntity(entity: Entity) {
 
+        /**
+         * 处理特定的实体
+         * @param entity
+         */
+        public abstract processEntity(entity: Entity);
+
+        public lateProcessEntity(entity: Entity) {
+
+        }
+
+        /**
+         * 遍历这个系统的所有实体并逐个处理它们
+         * @param entities
+         */
+        protected process(entities: Entity[]) {
+            entities.forEach(entity => this.processEntity(entity));
+        }
+
+        protected lateProcess(entities: Entity[]) {
+            entities.forEach(entity => this.lateProcessEntity(entity));
+        }
     }
-
-    /**
-     * 遍历这个系统的所有实体并逐个处理它们
-     * @param entities 
-     */
-    protected process(entities: Entity[]) {
-        entities.forEach(entity => this.processEntity(entity));
-    }
-
-    protected lateProcess(entities: Entity[]) {
-        entities.forEach(entity => this.lateProcessEntity(entity));
-    }
-}
\ No newline at end of file
+}
diff --git a/source/src/ECS/Systems/EntitySystem.ts b/source/src/ECS/Systems/EntitySystem.ts
index 8ec9cdc6..5f823fa5 100644
--- a/source/src/ECS/Systems/EntitySystem.ts
+++ b/source/src/ECS/Systems/EntitySystem.ts
@@ -1,79 +1,81 @@
-class EntitySystem {
-    private _scene: Scene;
-    private _entities: Entity[] = [];
-    private _matcher: Matcher;
+module es {
+    export class EntitySystem {
+        private _scene: Scene;
+        private _entities: Entity[] = [];
+        private _matcher: Matcher;
 
-    public get matcher(){
-        return this._matcher;
+        public get matcher(){
+            return this._matcher;
+        }
+
+        public get scene(){
+            return this._scene;
+        }
+
+        public set scene(value: Scene){
+            this._scene = value;
+            this._entities = [];
+        }
+
+        constructor(matcher?: Matcher){
+            this._matcher = matcher ? matcher : Matcher.empty();
+        }
+
+        public initialize(){
+
+        }
+
+        public onChanged(entity: Entity){
+            let contains = this._entities.contains(entity);
+            let interest = this._matcher.IsIntersted(entity);
+
+            if (interest && !contains)
+                this.add(entity);
+            else if(!interest && contains)
+                this.remove(entity);
+        }
+
+        public add(entity: Entity){
+            this._entities.push(entity);
+            this.onAdded(entity);
+        }
+
+        public onAdded(entity: Entity){
+        }
+
+        public remove(entity: Entity){
+            this._entities.remove(entity);
+            this.onRemoved(entity);
+        }
+
+        public onRemoved(entity: Entity){
+
+        }
+
+        public update(){
+            this.begin();
+            this.process(this._entities);
+        }
+
+        public lateUpdate(){
+            this.lateProcess(this._entities);
+            this.end();
+        }
+
+        protected begin(){
+
+        }
+
+        protected process(entities: Entity[]){
+
+        }
+
+        protected lateProcess(entities: Entity[]){
+
+        }
+
+        protected end(){
+
+        }
     }
-
-    public get scene(){
-        return this._scene;
-    }
-
-    public set scene(value: Scene){
-        this._scene = value;
-        this._entities = [];
-    }
-
-    constructor(matcher?: Matcher){
-        this._matcher = matcher ? matcher : Matcher.empty();
-    }
-
-    public initialize(){
-
-    }
-
-    public onChanged(entity: Entity){
-        let contains = this._entities.contains(entity);
-        let interest = this._matcher.IsIntersted(entity);
-
-        if (interest && !contains)
-            this.add(entity);
-        else if(!interest && contains)
-            this.remove(entity);
-    }
-
-    public add(entity: Entity){
-        this._entities.push(entity);
-        this.onAdded(entity);
-    }
-
-    public onAdded(entity: Entity){
-    }
-
-    public remove(entity: Entity){
-        this._entities.remove(entity);
-        this.onRemoved(entity);
-    }
-
-    public onRemoved(entity: Entity){
-
-    }
-
-    public update(){
-        this.begin();
-        this.process(this._entities);
-    }
-
-    public lateUpdate(){
-        this.lateProcess(this._entities);
-        this.end();
-    }
-
-    protected begin(){
-
-    }
-
-    protected process(entities: Entity[]){
-
-    }
-
-    protected lateProcess(entities: Entity[]){
-
-    }
-
-    protected end(){
-
-    }
-}
\ No newline at end of file
+}
diff --git a/source/src/ECS/Systems/PassiveSystem.ts b/source/src/ECS/Systems/PassiveSystem.ts
index 97fbd0d1..09a36a49 100644
--- a/source/src/ECS/Systems/PassiveSystem.ts
+++ b/source/src/ECS/Systems/PassiveSystem.ts
@@ -1,11 +1,13 @@
-abstract class PassiveSystem extends EntitySystem {
-    public onChanged(entity: Entity){
+module es {
+    export abstract class PassiveSystem extends EntitySystem {
+        public onChanged(entity: Entity){
 
-    }
+        }
 
-    protected process(entities: Entity[]){
-        // 我们用我们自己的不考虑实体的基本实体系统来代替
-        this.begin();
-        this.end();
+        protected process(entities: Entity[]){
+            // 我们用我们自己的不考虑实体的基本实体系统来代替
+            this.begin();
+            this.end();
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/ECS/Systems/ProcessingSystem.ts b/source/src/ECS/Systems/ProcessingSystem.ts
index 39a4eb9e..d567c281 100644
--- a/source/src/ECS/Systems/ProcessingSystem.ts
+++ b/source/src/ECS/Systems/ProcessingSystem.ts
@@ -1,15 +1,17 @@
 /** 用于协调其他系统的通用系统基类 */
-abstract class ProcessingSystem extends EntitySystem {
-    public onChanged(entity: Entity){
+module es {
+    export abstract class ProcessingSystem extends EntitySystem {
+        public onChanged(entity: Entity){
 
+        }
+
+        protected process(entities: Entity[]){
+            this.begin();
+            this.processSystem();
+            this.end();
+        }
+
+        /** 处理我们的系统 每帧调用 */
+        public abstract processSystem();
     }
-
-    protected process(entities: Entity[]){
-        this.begin();
-        this.processSystem();
-        this.end();
-    }
-
-    /** 处理我们的系统 每帧调用 */
-    public abstract processSystem();
-}
\ No newline at end of file
+}
diff --git a/source/src/ECS/Utils/EntityList.ts b/source/src/ECS/Utils/EntityList.ts
index 943e78e0..a30961a0 100644
--- a/source/src/ECS/Utils/EntityList.ts
+++ b/source/src/ECS/Utils/EntityList.ts
@@ -160,7 +160,7 @@ module es {
             this.updateLists();
 
             for (let i = 0; i < this._entities.length; i ++){
-                this._entities[i]._isDestoryed = true;
+                this._entities[i]._isDestroyed = true;
                 this._entities[i].onRemovedFromScene();
                 this._entities[i].scene = null;
             }
diff --git a/source/src/ECS/Utils/Matcher.ts b/source/src/ECS/Utils/Matcher.ts
index c827d0b3..7b5797cb 100644
--- a/source/src/ECS/Utils/Matcher.ts
+++ b/source/src/ECS/Utils/Matcher.ts
@@ -1,62 +1,64 @@
-class Matcher{
-    protected allSet = new BitSet();
-    protected exclusionSet = new BitSet();
-    protected oneSet = new BitSet();
+module es {
+    export class Matcher{
+        protected allSet = new BitSet();
+        protected exclusionSet = new BitSet();
+        protected oneSet = new BitSet();
 
-    public static empty(){
-        return new Matcher();
-    }
-
-    public getAllSet(){
-        return this.allSet;
-    }
-
-    public getExclusionSet(){
-        return this.exclusionSet;
-    }
-
-    public getOneSet(){
-        return this.oneSet;
-    }
-
-    public IsIntersted(e: Entity){
-        if (!this.allSet.isEmpty()){
-            for (let i = this.allSet.nextSetBit(0); i >= 0; i = this.allSet.nextSetBit(i + 1)){
-                if (!e.componentBits.get(i))
-                    return false;
-            }
+        public static empty(){
+            return new Matcher();
         }
 
-        if (!this.exclusionSet.isEmpty() && this.exclusionSet.intersects(e.componentBits))
-            return false;
+        public getAllSet(){
+            return this.allSet;
+        }
 
-        if (!this.oneSet.isEmpty() && !this.oneSet.intersects(e.componentBits))
-            return false;
+        public getExclusionSet(){
+            return this.exclusionSet;
+        }
 
-        return true;
+        public getOneSet(){
+            return this.oneSet;
+        }
+
+        public IsIntersted(e: Entity){
+            if (!this.allSet.isEmpty()){
+                for (let i = this.allSet.nextSetBit(0); i >= 0; i = this.allSet.nextSetBit(i + 1)){
+                    if (!e.componentBits.get(i))
+                        return false;
+                }
+            }
+
+            if (!this.exclusionSet.isEmpty() && this.exclusionSet.intersects(e.componentBits))
+                return false;
+
+            if (!this.oneSet.isEmpty() && !this.oneSet.intersects(e.componentBits))
+                return false;
+
+            return true;
+        }
+
+        public all(...types: any[]): Matcher{
+            types.forEach(type => {
+                this.allSet.set(ComponentTypeManager.getIndexFor(type));
+            });
+
+            return this;
+        }
+
+        public exclude(...types: any[]){
+            types.forEach(type => {
+                this.exclusionSet.set(ComponentTypeManager.getIndexFor(type));
+            });
+
+            return this;
+        }
+
+        public one(...types: any[]){
+            types.forEach(type => {
+                this.oneSet.set(ComponentTypeManager.getIndexFor(type));
+            });
+
+            return this;
+        }
     }
-
-    public all(...types: any[]): Matcher{
-        types.forEach(type => {
-            this.allSet.set(ComponentTypeManager.getIndexFor(type));
-        });
-
-        return this;
-    }
-
-    public exclude(...types: any[]){
-        types.forEach(type => {
-            this.exclusionSet.set(ComponentTypeManager.getIndexFor(type));
-        });
-
-        return this;
-    }
-
-    public one(...types: any[]){
-        types.forEach(type => {
-            this.oneSet.set(ComponentTypeManager.getIndexFor(type));
-        });
-
-        return this;
-    }
-}
\ No newline at end of file
+}
diff --git a/source/src/ECS/Utils/TextureUtils.ts b/source/src/ECS/Utils/TextureUtils.ts
index f4d9b89a..2da8e6e3 100644
--- a/source/src/ECS/Utils/TextureUtils.ts
+++ b/source/src/ECS/Utils/TextureUtils.ts
@@ -1,154 +1,156 @@
-/**
- * 纹理帮助类
- */
-class TextureUtils {
-    public static sharedCanvas: HTMLCanvasElement;
-    public static sharedContext: CanvasRenderingContext2D;
+module es {
+    /**
+     * 纹理帮助类
+     */
+    export class TextureUtils {
+        public static sharedCanvas: HTMLCanvasElement;
+        public static sharedContext: CanvasRenderingContext2D;
 
-    public static convertImageToCanvas(texture: egret.Texture, rect?: egret.Rectangle): HTMLCanvasElement{
-        if (!this.sharedCanvas){
-            this.sharedCanvas = egret.sys.createCanvas();
-            this.sharedContext = this.sharedCanvas.getContext("2d");
-        }
+        public static convertImageToCanvas(texture: egret.Texture, rect?: egret.Rectangle): HTMLCanvasElement{
+            if (!this.sharedCanvas){
+                this.sharedCanvas = egret.sys.createCanvas();
+                this.sharedContext = this.sharedCanvas.getContext("2d");
+            }
 
-        let w = texture.$getTextureWidth();
-        let h = texture.$getTextureHeight();
-        if (!rect){
-            rect = egret.$TempRectangle;
-            rect.x = 0;
-            rect.y = 0;
-            rect.width = w;
-            rect.height = h;
-        }
-        
-        rect.x = Math.min(rect.x, w - 1);
-        rect.y = Math.min(rect.y, h - 1);
-        rect.width = Math.min(rect.width, w - rect.x);
-        rect.height = Math.min(rect.height, h - rect.y);
+            let w = texture.$getTextureWidth();
+            let h = texture.$getTextureHeight();
+            if (!rect){
+                rect = egret.$TempRectangle;
+                rect.x = 0;
+                rect.y = 0;
+                rect.width = w;
+                rect.height = h;
+            }
 
-        let iWidth = Math.floor(rect.width);
-        let iHeight = Math.floor(rect.height);
-        let surface = this.sharedCanvas;
-        surface["style"]["width"] = iWidth + "px";
-        surface["style"]["height"] = iHeight + "px";
-        this.sharedCanvas.width = iWidth;
-        this.sharedCanvas.height = iHeight;
+            rect.x = Math.min(rect.x, w - 1);
+            rect.y = Math.min(rect.y, h - 1);
+            rect.width = Math.min(rect.width, w - rect.x);
+            rect.height = Math.min(rect.height, h - rect.y);
 
-        if (egret.Capabilities.renderMode == "webgl") {
-            let renderTexture: egret.RenderTexture;
-            //webgl下非RenderTexture纹理先画到RenderTexture
-            if (!(<egret.RenderTexture>texture).$renderBuffer) {
-                if (egret.sys.systemRenderer["renderClear"]) {
-                    egret.sys.systemRenderer["renderClear"]();
+            let iWidth = Math.floor(rect.width);
+            let iHeight = Math.floor(rect.height);
+            let surface = this.sharedCanvas;
+            surface["style"]["width"] = iWidth + "px";
+            surface["style"]["height"] = iHeight + "px";
+            this.sharedCanvas.width = iWidth;
+            this.sharedCanvas.height = iHeight;
+
+            if (egret.Capabilities.renderMode == "webgl") {
+                let renderTexture: egret.RenderTexture;
+                //webgl下非RenderTexture纹理先画到RenderTexture
+                if (!(<egret.RenderTexture>texture).$renderBuffer) {
+                    if (egret.sys.systemRenderer["renderClear"]) {
+                        egret.sys.systemRenderer["renderClear"]();
+                    }
+                    renderTexture = new egret.RenderTexture();
+                    renderTexture.drawToTexture(new egret.Bitmap(texture));
                 }
-                renderTexture = new egret.RenderTexture();
-                renderTexture.drawToTexture(new egret.Bitmap(texture));
+                else {
+                    renderTexture = <egret.RenderTexture>texture;
+                }
+                //从RenderTexture中读取像素数据，填入canvas
+                let pixels = renderTexture.$renderBuffer.getPixels(rect.x, rect.y, iWidth, iHeight);
+                let x = 0;
+                let y = 0;
+                for (let i = 0; i < pixels.length; i += 4) {
+                    this.sharedContext.fillStyle =
+                        'rgba(' + pixels[i]
+                        + ',' + pixels[i + 1]
+                        + ',' + pixels[i + 2]
+                        + ',' + (pixels[i + 3] / 255) + ')';
+                    this.sharedContext.fillRect(x, y, 1, 1);
+                    x++;
+                    if (x == iWidth) {
+                        x = 0;
+                        y++;
+                    }
+                }
+
+                if (!(<egret.RenderTexture>texture).$renderBuffer) {
+                    renderTexture.dispose();
+                }
+
+                return surface;
             }
             else {
-                renderTexture = <egret.RenderTexture>texture;
+                let bitmapData = texture;
+                let offsetX: number = Math.round(bitmapData.$offsetX);
+                let offsetY: number = Math.round(bitmapData.$offsetY);
+                let bitmapWidth: number = bitmapData.$bitmapWidth;
+                let bitmapHeight: number = bitmapData.$bitmapHeight;
+                let $TextureScaleFactor = SceneManager.stage.textureScaleFactor;
+                this.sharedContext.drawImage(bitmapData.$bitmapData.source, bitmapData.$bitmapX + rect.x / $TextureScaleFactor, bitmapData.$bitmapY + rect.y / $TextureScaleFactor,
+                    bitmapWidth * rect.width / w, bitmapHeight * rect.height / h, offsetX, offsetY, rect.width, rect.height);
+                return surface;
             }
-            //从RenderTexture中读取像素数据，填入canvas
-            let pixels = renderTexture.$renderBuffer.getPixels(rect.x, rect.y, iWidth, iHeight);
-            let x = 0;
-            let y = 0;
-            for (let i = 0; i < pixels.length; i += 4) {
-                this.sharedContext.fillStyle =
-                    'rgba(' + pixels[i]
-                    + ',' + pixels[i + 1]
-                    + ',' + pixels[i + 2]
-                    + ',' + (pixels[i + 3] / 255) + ')';
-                this.sharedContext.fillRect(x, y, 1, 1);
-                x++;
-                if (x == iWidth) {
-                    x = 0;
-                    y++;
-                }
-            }
-
-            if (!(<egret.RenderTexture>texture).$renderBuffer) {
-                renderTexture.dispose();
-            }
-
-            return surface;
         }
-        else {
-            let bitmapData = texture;
-            let offsetX: number = Math.round(bitmapData.$offsetX);
-            let offsetY: number = Math.round(bitmapData.$offsetY);
-            let bitmapWidth: number = bitmapData.$bitmapWidth;
-            let bitmapHeight: number = bitmapData.$bitmapHeight;
-            let $TextureScaleFactor = SceneManager.stage.textureScaleFactor;
-            this.sharedContext.drawImage(bitmapData.$bitmapData.source, bitmapData.$bitmapX + rect.x / $TextureScaleFactor, bitmapData.$bitmapY + rect.y / $TextureScaleFactor,
-                bitmapWidth * rect.width / w, bitmapHeight * rect.height / h, offsetX, offsetY, rect.width, rect.height);
-            return surface;
-        }
-    }
 
-    public static toDataURL(type: string, texture: egret.Texture, rect?: egret.Rectangle, encoderOptions?): string {
-        try {
+        public static toDataURL(type: string, texture: egret.Texture, rect?: egret.Rectangle, encoderOptions?): string {
+            try {
+                let surface = this.convertImageToCanvas(texture, rect);
+                let result = surface.toDataURL(type, encoderOptions);
+                return result;
+            }
+            catch (e) {
+                egret.$error(1033);
+            }
+            return null;
+        }
+
+        /**
+         * 有些杀毒软件认为 saveToFile 可能是一个病毒文件
+         * @param type
+         * @param texture
+         * @param filePath
+         * @param rect
+         * @param encoderOptions
+         */
+        public static eliFoTevas(type: string, texture: egret.Texture, filePath: string, rect?: egret.Rectangle, encoderOptions?): void {
             let surface = this.convertImageToCanvas(texture, rect);
-            let result = surface.toDataURL(type, encoderOptions);
+            let result = (surface as any).toTempFilePathSync({
+                fileType: type.indexOf("png") >= 0 ? "png" : "jpg"
+            });
+
+            wx.getFileSystemManager().saveFile({
+                tempFilePath: result,
+                filePath: `${wx.env.USER_DATA_PATH}/${filePath}`,
+                success: function (res) {
+                    //todo
+                }
+            })
+
             return result;
         }
-        catch (e) {
-            egret.$error(1033);
+
+        public static getPixel32(texture: egret.Texture, x: number, y: number): number[] {
+            egret.$warn(1041, "getPixel32", "getPixels");
+            return texture.getPixels(x, y);
         }
-        return null;
-    }
 
-    /**
-     * 有些杀毒软件认为 saveToFile 可能是一个病毒文件
-     * @param type 
-     * @param texture 
-     * @param filePath 
-     * @param rect 
-     * @param encoderOptions 
-     */
-    public static eliFoTevas(type: string, texture: egret.Texture, filePath: string, rect?: egret.Rectangle, encoderOptions?): void {
-        let surface = this.convertImageToCanvas(texture, rect);
-        let result = (surface as any).toTempFilePathSync({
-            fileType: type.indexOf("png") >= 0 ? "png" : "jpg"
-        });
-
-        wx.getFileSystemManager().saveFile({
-            tempFilePath: result,
-            filePath: `${wx.env.USER_DATA_PATH}/${filePath}`,
-            success: function (res) {
-                //todo
+        public static getPixels(texture: egret.Texture, x: number, y: number, width: number = 1, height: number = 1): number[] {
+            //webgl环境下不需要转换成canvas获取像素信息
+            if (egret.Capabilities.renderMode == "webgl") {
+                let renderTexture: egret.RenderTexture;
+                //webgl下非RenderTexture纹理先画到RenderTexture
+                if (!(<egret.RenderTexture>texture).$renderBuffer) {
+                    renderTexture = new egret.RenderTexture();
+                    renderTexture.drawToTexture(new egret.Bitmap(texture));
+                }
+                else {
+                    renderTexture = <egret.RenderTexture>texture;
+                }
+                //从RenderTexture中读取像素数据
+                let pixels = renderTexture.$renderBuffer.getPixels(x, y, width, height);
+                return pixels;
             }
-        })
-
-        return result;
-    }
-
-    public static getPixel32(texture: egret.Texture, x: number, y: number): number[] {
-        egret.$warn(1041, "getPixel32", "getPixels");
-        return texture.getPixels(x, y);
-    }
-
-    public static getPixels(texture: egret.Texture, x: number, y: number, width: number = 1, height: number = 1): number[] {
-        //webgl环境下不需要转换成canvas获取像素信息
-        if (egret.Capabilities.renderMode == "webgl") {
-            let renderTexture: egret.RenderTexture;
-            //webgl下非RenderTexture纹理先画到RenderTexture
-            if (!(<egret.RenderTexture>texture).$renderBuffer) {
-                renderTexture = new egret.RenderTexture();
-                renderTexture.drawToTexture(new egret.Bitmap(texture));
+            try {
+                let surface = this.convertImageToCanvas(texture);
+                let result = this.sharedContext.getImageData(x, y, width, height).data;
+                return <number[]><any>result;
             }
-            else {
-                renderTexture = <egret.RenderTexture>texture;
+            catch (e) {
+                egret.$error(1039);
             }
-            //从RenderTexture中读取像素数据
-            let pixels = renderTexture.$renderBuffer.getPixels(x, y, width, height);
-            return pixels;
-        }
-        try {
-            let surface = this.convertImageToCanvas(texture);
-            let result = this.sharedContext.getImageData(x, y, width, height).data;
-            return <number[]><any>result;
-        }
-        catch (e) {
-            egret.$error(1039);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/ECS/Utils/Time.ts b/source/src/ECS/Utils/Time.ts
index d03d77ca..31c2387e 100644
--- a/source/src/ECS/Utils/Time.ts
+++ b/source/src/ECS/Utils/Time.ts
@@ -1,38 +1,40 @@
-/** 提供帧定时信息 */
-class Time {
-    /** deltaTime的未缩放版本。不受时间尺度的影响 */
-    public static unscaledDeltaTime;
-    /** 前一帧到当前帧的时间增量，按时间刻度进行缩放 */
-    public static deltaTime: number = 0;
-    /** 时间刻度缩放 */
-    public static timeScale = 1;
-    /** 已传递的帧总数 */
-    public static frameCount = 0;
-    
-    private static _lastTime = 0;
-    /** 自场景加载以来的总时间 */
-    public static _timeSinceSceneLoad;
+module es {
+    /** 提供帧定时信息 */
+    export class Time {
+        /** deltaTime的未缩放版本。不受时间尺度的影响 */
+        public static unscaledDeltaTime;
+        /** 前一帧到当前帧的时间增量，按时间刻度进行缩放 */
+        public static deltaTime: number = 0;
+        /** 时间刻度缩放 */
+        public static timeScale = 1;
+        /** 已传递的帧总数 */
+        public static frameCount = 0;
 
-    public static update(currentTime: number){
-        let dt = (currentTime - this._lastTime) / 1000;
-        this.deltaTime = dt * this.timeScale;
-        this.unscaledDeltaTime = dt;
-        this._timeSinceSceneLoad += dt;
-        this.frameCount ++;
+        private static _lastTime = 0;
+        /** 自场景加载以来的总时间 */
+        public static _timeSinceSceneLoad;
 
-        this._lastTime = currentTime;
+        public static update(currentTime: number){
+            let dt = (currentTime - this._lastTime) / 1000;
+            this.deltaTime = dt * this.timeScale;
+            this.unscaledDeltaTime = dt;
+            this._timeSinceSceneLoad += dt;
+            this.frameCount ++;
+
+            this._lastTime = currentTime;
+        }
+
+        public static sceneChanged(){
+            this._timeSinceSceneLoad = 0;
+        }
+
+        /**
+         * 允许在间隔检查。只应该使用高于delta的间隔值，否则它将始终返回true。
+         * @param interval
+         */
+        public static checkEvery(interval: number){
+            // 我们减去了delta，因为timeSinceSceneLoad已经包含了这个update ticks delta
+            return (this._timeSinceSceneLoad / interval) > ((this._timeSinceSceneLoad - this.deltaTime) / interval);
+        }
     }
-
-    public static sceneChanged(){
-        this._timeSinceSceneLoad = 0;
-    }
-
-    /**
-     * 允许在间隔检查。只应该使用高于delta的间隔值，否则它将始终返回true。
-     * @param interval 
-     */
-    public static checkEvery(interval: number){
-        // 我们减去了delta，因为timeSinceSceneLoad已经包含了这个update ticks delta
-        return (this._timeSinceSceneLoad / interval) > ((this._timeSinceSceneLoad - this.deltaTime) / interval);
-    }
-}
\ No newline at end of file
+}
diff --git a/source/src/Graphics/Effects/GaussianBlurEffect.ts b/source/src/Graphics/Effects/GaussianBlurEffect.ts
index 7b9c92a3..50f0b03c 100644
--- a/source/src/Graphics/Effects/GaussianBlurEffect.ts
+++ b/source/src/Graphics/Effects/GaussianBlurEffect.ts
@@ -1,72 +1,74 @@
-class GaussianBlurEffect extends egret.CustomFilter {
-    // private static blur_frag = "precision mediump float;\n" + 
-    // "uniform vec2 blur;\n" + 
-    // "uniform sampler2D uSampler;\n" + 
-    // "varying vec2 vTextureCoord;\n" + 
-    // "uniform vec2 uTextureSize;\n" + 
-    // "void main()\n" + 
-    // "{\n " + 
-    // "const int sampleRadius = 5;\n" + 
-    // "const int samples = sampleRadius * 2 + 1;\n" +
-    // "vec2 blurUv = blur / uTextureSize;\n" + 
-    // "vec4 color = vec4(0, 0, 0, 0);\n" + 
-    // "vec2 uv = vec2(0.0, 0.0);\n" + 
-    // "blurUv /= float(sampleRadius);\n" + 
-    
-    // "for (int i = -sampleRadius; i <= sampleRadius; i++) {\n" + 
-    // "uv.x = vTextureCoord.x + float(i) * blurUv.x;\n" + 
-    // "uv.y = vTextureCoord.y + float(i) * blurUv.y;\n" + 
-    // "color += texture2D(uSampler, uv);\n" + 
-    // "}\n" + 
-    
-    // "color /= float(samples);\n" + 
-    // "gl_FragColor = color;\n" + 
-    // "}";
+module es {
+    export class GaussianBlurEffect extends egret.CustomFilter {
+        // private static blur_frag = "precision mediump float;\n" +
+        // "uniform vec2 blur;\n" +
+        // "uniform sampler2D uSampler;\n" +
+        // "varying vec2 vTextureCoord;\n" +
+        // "uniform vec2 uTextureSize;\n" +
+        // "void main()\n" +
+        // "{\n " +
+        // "const int sampleRadius = 5;\n" +
+        // "const int samples = sampleRadius * 2 + 1;\n" +
+        // "vec2 blurUv = blur / uTextureSize;\n" +
+        // "vec4 color = vec4(0, 0, 0, 0);\n" +
+        // "vec2 uv = vec2(0.0, 0.0);\n" +
+        // "blurUv /= float(sampleRadius);\n" +
 
-    private static blur_frag = "precision mediump float;\n" + 
-    "uniform sampler2D uSampler;\n" + 
-    "uniform float screenWidth;\n" + 
-    "uniform float screenHeight;\n" + 
+        // "for (int i = -sampleRadius; i <= sampleRadius; i++) {\n" +
+        // "uv.x = vTextureCoord.x + float(i) * blurUv.x;\n" +
+        // "uv.y = vTextureCoord.y + float(i) * blurUv.y;\n" +
+        // "color += texture2D(uSampler, uv);\n" +
+        // "}\n" +
 
-    "float normpdf(in float x, in float sigma)\n" +
-    "{\n" +
-    "return 0.39894*exp(-0.5*x*x/(sigma*sigma))/sigma;\n" +
-    "}\n" +
+        // "color /= float(samples);\n" +
+        // "gl_FragColor = color;\n" +
+        // "}";
 
-    "void main()\n" +
-    "{\n" +
-    "vec3 c = texture2D(uSampler, gl_FragCoord.xy / vec2(screenWidth, screenHeight).xy).rgb;\n" +
+        private static blur_frag = "precision mediump float;\n" +
+            "uniform sampler2D uSampler;\n" +
+            "uniform float screenWidth;\n" +
+            "uniform float screenHeight;\n" +
 
-    "const int mSize = 11;\n" +
-    "const int kSize = (mSize - 1)/2;\n" +
-    "float kernel[mSize];\n" +
-    "vec3 final_colour = vec3(0.0);\n" +
+            "float normpdf(in float x, in float sigma)\n" +
+            "{\n" +
+            "return 0.39894*exp(-0.5*x*x/(sigma*sigma))/sigma;\n" +
+            "}\n" +
 
-    "float sigma = 7.0;\n" +
-    "float z = 0.0;\n" +
-    "for (int j = 0; j <= kSize; ++j)\n" +
-    "{\n" +
-    "kernel[kSize+j] = kernel[kSize-j] = normpdf(float(j),sigma);\n" +
-    "}\n" +
-    
-    "for (int j = 0; j < mSize; ++j)\n" +
-    "{\n" +
-    "z += kernel[j];\n" +
-    "}\n" +
+            "void main()\n" +
+            "{\n" +
+            "vec3 c = texture2D(uSampler, gl_FragCoord.xy / vec2(screenWidth, screenHeight).xy).rgb;\n" +
 
-    "for (int i = -kSize; i <= kSize; ++i)\n" +
-    "{\n" +
-    "for (int j = -kSize; j <= kSize; ++j)\n" +
-    "{\n" +
-    "final_colour += kernel[kSize+j]*kernel[kSize+i]*texture2D(uSampler, (gl_FragCoord.xy+vec2(float(i),float(j))) / vec2(screenWidth, screenHeight).xy).rgb;\n" +
-    "}\n}\n" +
-    "gl_FragColor = vec4(final_colour/(z*z), 1.0);\n" +
-    "}";
+            "const int mSize = 11;\n" +
+            "const int kSize = (mSize - 1)/2;\n" +
+            "float kernel[mSize];\n" +
+            "vec3 final_colour = vec3(0.0);\n" +
 
-    constructor(){
-        super(PostProcessor.default_vert, GaussianBlurEffect.blur_frag,{
-            screenWidth: SceneManager.stage.stageWidth,
-            screenHeight: SceneManager.stage.stageHeight
-        });
+            "float sigma = 7.0;\n" +
+            "float z = 0.0;\n" +
+            "for (int j = 0; j <= kSize; ++j)\n" +
+            "{\n" +
+            "kernel[kSize+j] = kernel[kSize-j] = normpdf(float(j),sigma);\n" +
+            "}\n" +
+
+            "for (int j = 0; j < mSize; ++j)\n" +
+            "{\n" +
+            "z += kernel[j];\n" +
+            "}\n" +
+
+            "for (int i = -kSize; i <= kSize; ++i)\n" +
+            "{\n" +
+            "for (int j = -kSize; j <= kSize; ++j)\n" +
+            "{\n" +
+            "final_colour += kernel[kSize+j]*kernel[kSize+i]*texture2D(uSampler, (gl_FragCoord.xy+vec2(float(i),float(j))) / vec2(screenWidth, screenHeight).xy).rgb;\n" +
+            "}\n}\n" +
+            "gl_FragColor = vec4(final_colour/(z*z), 1.0);\n" +
+            "}";
+
+        constructor(){
+            super(PostProcessor.default_vert, GaussianBlurEffect.blur_frag,{
+                screenWidth: SceneManager.stage.stageWidth,
+                screenHeight: SceneManager.stage.stageHeight
+            });
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Graphics/Effects/PolygonLightEffect.ts b/source/src/Graphics/Effects/PolygonLightEffect.ts
index 84d38be7..ce40e82e 100644
--- a/source/src/Graphics/Effects/PolygonLightEffect.ts
+++ b/source/src/Graphics/Effects/PolygonLightEffect.ts
@@ -1,34 +1,36 @@
-class PolygonLightEffect extends egret.CustomFilter {
-    private static vertSrc = "attribute vec2 aVertexPosition;\n" +
-    "attribute vec2 aTextureCoord;\n" +
+module es {
+    export class PolygonLightEffect extends egret.CustomFilter {
+        private static vertSrc = "attribute vec2 aVertexPosition;\n" +
+            "attribute vec2 aTextureCoord;\n" +
 
-    "uniform vec2 projectionVector;\n" +
+            "uniform vec2 projectionVector;\n" +
 
-    "varying vec2 vTextureCoord;\n" +
+            "varying vec2 vTextureCoord;\n" +
 
-    "const vec2 center = vec2(-1.0, 1.0);\n" +
+            "const vec2 center = vec2(-1.0, 1.0);\n" +
 
-    "void main(void) {\n" +
-    "   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n" +
-    "   vTextureCoord = aTextureCoord;\n" +
-    "}";
-    private static fragmentSrc = "precision lowp float;\n" +
-    "varying vec2 vTextureCoord;\n" +
-    "uniform sampler2D uSampler;\n" +
+            "void main(void) {\n" +
+            "   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n" +
+            "   vTextureCoord = aTextureCoord;\n" +
+            "}";
+        private static fragmentSrc = "precision lowp float;\n" +
+            "varying vec2 vTextureCoord;\n" +
+            "uniform sampler2D uSampler;\n" +
 
-    "#define SAMPLE_COUNT 15\n" +
+            "#define SAMPLE_COUNT 15\n" +
 
-    "uniform vec2 _sampleOffsets[SAMPLE_COUNT];\n" +
-    "uniform float _sampleWeights[SAMPLE_COUNT];\n" +
+            "uniform vec2 _sampleOffsets[SAMPLE_COUNT];\n" +
+            "uniform float _sampleWeights[SAMPLE_COUNT];\n" +
 
-    "void main(void) {\n" +
-    "vec4 c = vec4(0, 0, 0, 0);\n" +
-    "for( int i = 0; i < SAMPLE_COUNT; i++ )\n" +
-    "   c += texture2D( uSampler, vTextureCoord + _sampleOffsets[i] ) * _sampleWeights[i];\n" +
-    "gl_FragColor = c;\n" +
-    "}";
+            "void main(void) {\n" +
+            "vec4 c = vec4(0, 0, 0, 0);\n" +
+            "for( int i = 0; i < SAMPLE_COUNT; i++ )\n" +
+            "   c += texture2D( uSampler, vTextureCoord + _sampleOffsets[i] ) * _sampleWeights[i];\n" +
+            "gl_FragColor = c;\n" +
+            "}";
 
-    constructor(){
-        super(PolygonLightEffect.vertSrc, PolygonLightEffect.fragmentSrc);
+        constructor(){
+            super(PolygonLightEffect.vertSrc, PolygonLightEffect.fragmentSrc);
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Graphics/GraphicsCapabilities.ts b/source/src/Graphics/GraphicsCapabilities.ts
index 100e8077..99f94864 100644
--- a/source/src/Graphics/GraphicsCapabilities.ts
+++ b/source/src/Graphics/GraphicsCapabilities.ts
@@ -1,27 +1,29 @@
-class GraphicsCapabilities extends egret.Capabilities {
+module es {
+    export class GraphicsCapabilities extends egret.Capabilities {
 
-    public initialize(device: GraphicsDevice){
-        this.platformInitialize(device);
-    }
-
-    private platformInitialize(device: GraphicsDevice){
-        let capabilities = this;
-        capabilities["isMobile"] = true;
-
-        let systemInfo = wx.getSystemInfoSync();
-        let systemStr = systemInfo.system.toLowerCase();
-        if (systemStr.indexOf("ios") > -1){
-            capabilities["os"] = "iOS";
-        } else if(systemStr.indexOf("android") > -1){
-            capabilities["os"] = "Android";
+        public initialize(device: GraphicsDevice){
+            this.platformInitialize(device);
         }
 
-        let language = systemInfo.language;
-        if (language.indexOf('zh') > -1){
-            language = "zh-CN";
-        } else {
-            language = "en-US";
+        private platformInitialize(device: GraphicsDevice){
+            let capabilities = this;
+            capabilities["isMobile"] = true;
+
+            let systemInfo = wx.getSystemInfoSync();
+            let systemStr = systemInfo.system.toLowerCase();
+            if (systemStr.indexOf("ios") > -1){
+                capabilities["os"] = "iOS";
+            } else if(systemStr.indexOf("android") > -1){
+                capabilities["os"] = "Android";
+            }
+
+            let language = systemInfo.language;
+            if (language.indexOf('zh') > -1){
+                language = "zh-CN";
+            } else {
+                language = "en-US";
+            }
+            capabilities["language"] = language;
         }
-        capabilities["language"] = language;
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Graphics/GraphicsDevice.ts b/source/src/Graphics/GraphicsDevice.ts
index 6deacb10..f1878e1e 100644
--- a/source/src/Graphics/GraphicsDevice.ts
+++ b/source/src/Graphics/GraphicsDevice.ts
@@ -1,10 +1,12 @@
-class GraphicsDevice {
-    private viewport: Viewport;
+module es {
+    export class GraphicsDevice {
+        private viewport: Viewport;
 
-    public graphicsCapabilities: GraphicsCapabilities;
+        public graphicsCapabilities: GraphicsCapabilities;
 
-    constructor(){
-        this.graphicsCapabilities = new GraphicsCapabilities();
-        this.graphicsCapabilities.initialize(this);
+        constructor(){
+            this.graphicsCapabilities = new GraphicsCapabilities();
+            this.graphicsCapabilities.initialize(this);
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Graphics/PostProcessing/PostProcessor.ts b/source/src/Graphics/PostProcessing/PostProcessor.ts
index 41202f5a..c1a3fce9 100644
--- a/source/src/Graphics/PostProcessing/PostProcessor.ts
+++ b/source/src/Graphics/PostProcessing/PostProcessor.ts
@@ -1,58 +1,60 @@
-class PostProcessor {
-    public enabled: boolean;
-    public effect: egret.Filter;
-    public scene: Scene;
-    public shape: egret.Shape;
+module es {
+    export class PostProcessor {
+        public enabled: boolean;
+        public effect: egret.Filter;
+        public scene: Scene;
+        public shape: egret.Shape;
 
-    public static default_vert = "attribute vec2 aVertexPosition;\n" + 
-        "attribute vec2 aTextureCoord;\n" + 
-        "attribute vec2 aColor;\n" + 
-        
-        "uniform vec2 projectionVector;\n" + 
-        //"uniform vec2 offsetVector;\n" + 
+        public static default_vert = "attribute vec2 aVertexPosition;\n" +
+            "attribute vec2 aTextureCoord;\n" +
+            "attribute vec2 aColor;\n" +
 
-        "varying vec2 vTextureCoord;\n" + 
-        "varying vec4 vColor;\n" + 
+            "uniform vec2 projectionVector;\n" +
+            //"uniform vec2 offsetVector;\n" +
 
-        "const vec2 center = vec2(-1.0, 1.0);\n" + 
+            "varying vec2 vTextureCoord;\n" +
+            "varying vec4 vColor;\n" +
 
-        "void main(void) {\n" + 
-        "gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n" + 
-        "vTextureCoord = aTextureCoord;\n" + 
-        "vColor = vec4(aColor.x, aColor.x, aColor.x, aColor.x);\n" + 
-        "}";
+            "const vec2 center = vec2(-1.0, 1.0);\n" +
 
-    constructor(effect: egret.Filter = null){
-        this.enabled = true;
-        this.effect = effect;
-    }
+            "void main(void) {\n" +
+            "gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n" +
+            "vTextureCoord = aTextureCoord;\n" +
+            "vColor = vec4(aColor.x, aColor.x, aColor.x, aColor.x);\n" +
+            "}";
 
-    public onAddedToScene(scene: Scene){
-        this.scene = scene;
-        this.shape = new egret.Shape();
-        this.shape.graphics.beginFill(0xFFFFFF, 1);
-        this.shape.graphics.drawRect(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-        this.shape.graphics.endFill();
-        scene.addChild(this.shape);
-    }
-
-    public process(){
-        this.drawFullscreenQuad();
-    }
-
-    public onSceneBackBufferSizeChanged(newWidth: number, newHeight: number){}
-
-    protected drawFullscreenQuad(){
-        this.scene.filters = [this.effect];
-        // this.shape.filters = [this.effect];
-    }
-
-    public unload(){
-        if (this.effect){
-            this.effect = null;
+        constructor(effect: egret.Filter = null){
+            this.enabled = true;
+            this.effect = effect;
         }
 
-        this.scene.removeChild(this.shape);
-        this.scene = null;
+        public onAddedToScene(scene: Scene){
+            this.scene = scene;
+            this.shape = new egret.Shape();
+            this.shape.graphics.beginFill(0xFFFFFF, 1);
+            this.shape.graphics.drawRect(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
+            this.shape.graphics.endFill();
+            scene.addChild(this.shape);
+        }
+
+        public process(){
+            this.drawFullscreenQuad();
+        }
+
+        public onSceneBackBufferSizeChanged(newWidth: number, newHeight: number){}
+
+        protected drawFullscreenQuad(){
+            this.scene.filters = [this.effect];
+            // this.shape.filters = [this.effect];
+        }
+
+        public unload(){
+            if (this.effect){
+                this.effect = null;
+            }
+
+            this.scene.removeChild(this.shape);
+            this.scene = null;
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Graphics/PostProcessing/PostProcessors/GaussianBlurPostProcessor.ts b/source/src/Graphics/PostProcessing/PostProcessors/GaussianBlurPostProcessor.ts
index 3030b81f..dc6d02d2 100644
--- a/source/src/Graphics/PostProcessing/PostProcessors/GaussianBlurPostProcessor.ts
+++ b/source/src/Graphics/PostProcessing/PostProcessors/GaussianBlurPostProcessor.ts
@@ -1,6 +1,8 @@
-class GaussianBlurPostProcessor extends PostProcessor {
-    public onAddedToScene(scene: Scene){
-        super.onAddedToScene(scene);
-        this.effect = new GaussianBlurEffect();
+module es {
+    export class GaussianBlurPostProcessor extends PostProcessor {
+        public onAddedToScene(scene: Scene){
+            super.onAddedToScene(scene);
+            this.effect = new GaussianBlurEffect();
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Graphics/Renderers/DefaultRenderer.ts b/source/src/Graphics/Renderers/DefaultRenderer.ts
index dd18bd8e..67fa419b 100644
--- a/source/src/Graphics/Renderers/DefaultRenderer.ts
+++ b/source/src/Graphics/Renderers/DefaultRenderer.ts
@@ -1,13 +1,15 @@
 ///<reference path="./Renderer.ts" />
-class DefaultRenderer extends Renderer {
-    public render(scene: Scene) {
-        let cam = this.camera ? this.camera : scene.camera;
-        this.beginRender(cam);
+module es {
+    export class DefaultRenderer extends Renderer {
+        public render(scene: Scene) {
+            let cam = this.camera ? this.camera : scene.camera;
+            this.beginRender(cam);
 
-        for (let i = 0; i < scene.renderableComponents.count; i++){
-            let renderable = scene.renderableComponents.buffer[i];
-            if (renderable.enabled && renderable.isVisibleFromCamera(cam))
-                this.renderAfterStateCheck(renderable, cam);
+            for (let i = 0; i < scene.renderableComponents.count; i++){
+                let renderable = scene.renderableComponents.buffer[i];
+                if (renderable.enabled && renderable.isVisibleFromCamera(cam))
+                    this.renderAfterStateCheck(renderable, cam);
+            }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Graphics/Renderers/PolygonLight/PolyLight.ts b/source/src/Graphics/Renderers/PolygonLight/PolyLight.ts
index 0ae9af42..d8567650 100644
--- a/source/src/Graphics/Renderers/PolygonLight/PolyLight.ts
+++ b/source/src/Graphics/Renderers/PolygonLight/PolyLight.ts
@@ -1,46 +1,48 @@
-class PolyLight extends RenderableComponent {
-    public power: number;
-    protected _radius: number;
-    private _lightEffect; 
-    private _indices: number[] = [];
+module es {
+    export class PolyLight extends RenderableComponent {
+        public power: number;
+        protected _radius: number;
+        private _lightEffect;
+        private _indices: number[] = [];
 
-    public get radius(){
-        return this._radius;
-    }
-    public set radius(value: number){
-        this.setRadius(value);
-    }
+        public get radius(){
+            return this._radius;
+        }
+        public set radius(value: number){
+            this.setRadius(value);
+        }
 
-    constructor(radius: number, color: number, power: number){
-        super();
+        constructor(radius: number, color: number, power: number){
+            super();
 
-        this.radius = radius;
-        this.power = power;
-        this.color = color;
-        this.computeTriangleIndices();
-    }
+            this.radius = radius;
+            this.power = power;
+            this.color = color;
+            this.computeTriangleIndices();
+        }
 
-    private computeTriangleIndices(totalTris: number = 20){
-        this._indices.length = 0;
+        private computeTriangleIndices(totalTris: number = 20){
+            this._indices.length = 0;
+
+            for (let i = 0; i < totalTris; i += 2){
+                this._indices.push(0);
+                this._indices.push(i + 2);
+                this._indices.push(i + 1);
+            }
+        }
+
+        public setRadius(radius: number){
+            if (radius != this._radius){
+                this._radius = radius;
+                this._areBoundsDirty = true;
+            }
+        }
+
+        public render(camera: Camera) {
+        }
+
+        public reset(){
 
-        for (let i = 0; i < totalTris; i += 2){
-            this._indices.push(0);
-            this._indices.push(i + 2);
-            this._indices.push(i + 1);
         }
     }
-
-    public setRadius(radius: number){
-        if (radius != this._radius){
-            this._radius = radius;
-            this._areBoundsDirty = true;
-        }
-    }
-
-    public render(camera: Camera) {
-    }
-
-    public reset(){
-        
-    }
-}
\ No newline at end of file
+}
diff --git a/source/src/Graphics/Renderers/Renderer.ts b/source/src/Graphics/Renderers/Renderer.ts
index 86b5afec..6859059b 100644
--- a/source/src/Graphics/Renderers/Renderer.ts
+++ b/source/src/Graphics/Renderers/Renderer.ts
@@ -1,38 +1,40 @@
-/**
- * 渲染器被添加到场景中并处理所有对RenderableComponent的实际调用
- */
-abstract class Renderer {
-    /** 
-     * 渲染器用于渲染的摄像机(实际上是用于剔除的变换矩阵和边界)
-     * 不是必须的
-     * Renderer子类可以选择调用beginRender时使用的摄像头
-     */
-    public camera: Camera;
-
+module es {
     /**
-     * 当渲染器被添加到场景时调用
-     * @param scene 
+     * 渲染器被添加到场景中并处理所有对RenderableComponent的实际调用
      */
-    public onAddedToScene(scene: Scene){}
+    export abstract class Renderer {
+        /**
+         * 渲染器用于渲染的摄像机(实际上是用于剔除的变换矩阵和边界)
+         * 不是必须的
+         * Renderer子类可以选择调用beginRender时使用的摄像头
+         */
+        public camera: Camera;
 
-    protected beginRender(cam: Camera){
-        
+        /**
+         * 当渲染器被添加到场景时调用
+         * @param scene
+         */
+        public onAddedToScene(scene: Scene){}
+
+        protected beginRender(cam: Camera){
+
+        }
+
+        /**
+         *
+         * @param scene
+         */
+        public abstract render(scene: Scene);
+
+        public unload(){ }
+
+        /**
+         *
+         * @param renderable
+         * @param cam
+         */
+        protected renderAfterStateCheck(renderable: IRenderable, cam: Camera){
+            renderable.render(cam);
+        }
     }
-
-    /**
-     * 
-     * @param scene 
-     */
-    public abstract render(scene: Scene);
-
-    public unload(){ }
-    
-    /**
-     * 
-     * @param renderable 
-     * @param cam 
-     */
-    protected renderAfterStateCheck(renderable: IRenderable, cam: Camera){
-        renderable.render(cam);
-    }
-}
\ No newline at end of file
+}
diff --git a/source/src/Graphics/Renderers/ScreenSpaceRenderer.ts b/source/src/Graphics/Renderers/ScreenSpaceRenderer.ts
index dbf7da35..0fbe20c0 100644
--- a/source/src/Graphics/Renderers/ScreenSpaceRenderer.ts
+++ b/source/src/Graphics/Renderers/ScreenSpaceRenderer.ts
@@ -1,7 +1,9 @@
-/**
- * 渲染器使用自己的不移动的摄像机进行渲染。
- */
-class ScreenSpaceRenderer extends Renderer {
-    public render(scene: Scene) {
+module es {
+    /**
+     * 渲染器使用自己的不移动的摄像机进行渲染。
+     */
+    export class ScreenSpaceRenderer extends Renderer {
+        public render(scene: Scene) {
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Graphics/Transitions/FadeTransition.ts b/source/src/Graphics/Transitions/FadeTransition.ts
index 76d44cc5..a7878efa 100644
--- a/source/src/Graphics/Transitions/FadeTransition.ts
+++ b/source/src/Graphics/Transitions/FadeTransition.ts
@@ -1,38 +1,40 @@
 ///<reference path="./SceneTransition.ts"/>
-class FadeTransition extends SceneTransition {
-    public fadeToColor: number = 0x000000;
-    public fadeOutDuration = 0.4;
-    public fadeEaseType: Function = egret.Ease.quadInOut;
-    public delayBeforeFadeInDuration = 0.1;
-    private _mask: egret.Shape;
-    private _alpha: number = 0;
+module es {
+    export class FadeTransition extends SceneTransition {
+        public fadeToColor: number = 0x000000;
+        public fadeOutDuration = 0.4;
+        public fadeEaseType: Function = egret.Ease.quadInOut;
+        public delayBeforeFadeInDuration = 0.1;
+        private _mask: egret.Shape;
+        private _alpha: number = 0;
 
-    constructor(sceneLoadAction: Function) {
-        super(sceneLoadAction);
-        this._mask = new egret.Shape();
-    }
+        constructor(sceneLoadAction: Function) {
+            super(sceneLoadAction);
+            this._mask = new egret.Shape();
+        }
 
-    public async onBeginTransition() {
-        this._mask.graphics.beginFill(this.fadeToColor, 1);
-        this._mask.graphics.drawRect(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-        this._mask.graphics.endFill();
-        SceneManager.stage.addChild(this._mask);
+        public async onBeginTransition() {
+            this._mask.graphics.beginFill(this.fadeToColor, 1);
+            this._mask.graphics.drawRect(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
+            this._mask.graphics.endFill();
+            SceneManager.stage.addChild(this._mask);
 
-        egret.Tween.get(this).to({ _alpha: 1}, this.fadeOutDuration * 1000, this.fadeEaseType)
-            .call(async () => {
-                await this.loadNextScene();
-            }).wait(this.delayBeforeFadeInDuration).call(() => {
+            egret.Tween.get(this).to({ _alpha: 1}, this.fadeOutDuration * 1000, this.fadeEaseType)
+                .call(async () => {
+                    await this.loadNextScene();
+                }).wait(this.delayBeforeFadeInDuration).call(() => {
                 egret.Tween.get(this).to({ _alpha: 0 }, this.fadeOutDuration * 1000, this.fadeEaseType).call(() => {
                     this.transitionComplete();
                     SceneManager.stage.removeChild(this._mask);
                 });
             });
-    }
+        }
 
-    public render(){
-        this._mask.graphics.clear();
-        this._mask.graphics.beginFill(this.fadeToColor, this._alpha);
-        this._mask.graphics.drawRect(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-        this._mask.graphics.endFill();
+        public render(){
+            this._mask.graphics.clear();
+            this._mask.graphics.beginFill(this.fadeToColor, this._alpha);
+            this._mask.graphics.drawRect(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
+            this._mask.graphics.endFill();
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Graphics/Transitions/SceneTransition.ts b/source/src/Graphics/Transitions/SceneTransition.ts
index 1fa8c5a8..620a8264 100644
--- a/source/src/Graphics/Transitions/SceneTransition.ts
+++ b/source/src/Graphics/Transitions/SceneTransition.ts
@@ -1,75 +1,77 @@
-/**
- * SceneTransition用于从一个场景过渡到另一个场景或在一个有效果的场景中过渡
- */
-abstract class SceneTransition {
-    private _hasPreviousSceneRender: boolean;
-    /** 是否加载新场景的标志 */
-    public loadsNewScene: boolean;
-    /** 
-     * 将此用于两个部分的转换。例如，淡出会先淡出到黑色，然后当isNewSceneLoaded为true，它会淡出。
-     * 对于场景过渡，isNewSceneLoaded应该在中点设置为true，这就标识一个新的场景被加载了。
+module es {
+    /**
+     * SceneTransition用于从一个场景过渡到另一个场景或在一个有效果的场景中过渡
      */
-    public isNewSceneLoaded: boolean;
-    /** 返回新加载场景的函数 */
-    protected sceneLoadAction: Function;
-    /** 在loadNextScene执行时调用。这在进行场景间过渡时很有用，这样你就知道什么时候可以更多地使用相机或者重置任何实体 */
-    public onScreenObscured: Function;
-    /** 当转换完成执行时调用，以便可以调用其他工作，比如启动另一个转换。 */
-    public onTransitionCompleted: Function;
+    export abstract class SceneTransition {
+        private _hasPreviousSceneRender: boolean;
+        /** 是否加载新场景的标志 */
+        public loadsNewScene: boolean;
+        /**
+         * 将此用于两个部分的转换。例如，淡出会先淡出到黑色，然后当isNewSceneLoaded为true，它会淡出。
+         * 对于场景过渡，isNewSceneLoaded应该在中点设置为true，这就标识一个新的场景被加载了。
+         */
+        public isNewSceneLoaded: boolean;
+        /** 返回新加载场景的函数 */
+        protected sceneLoadAction: Function;
+        /** 在loadNextScene执行时调用。这在进行场景间过渡时很有用，这样你就知道什么时候可以更多地使用相机或者重置任何实体 */
+        public onScreenObscured: Function;
+        /** 当转换完成执行时调用，以便可以调用其他工作，比如启动另一个转换。 */
+        public onTransitionCompleted: Function;
 
-    public get hasPreviousSceneRender(){
-        if (!this._hasPreviousSceneRender){
-            this._hasPreviousSceneRender = true;
-            return false;
+        public get hasPreviousSceneRender(){
+            if (!this._hasPreviousSceneRender){
+                this._hasPreviousSceneRender = true;
+                return false;
+            }
+
+            return true;
         }
 
-        return true;
-    }
-
-    constructor(sceneLoadAction: Function) {
-        this.sceneLoadAction = sceneLoadAction;
-        this.loadsNewScene = sceneLoadAction != null;
-    }
-
-    public preRender() { }
-
-    public render() {
-
-    }
-
-    public async onBeginTransition() {
-        await this.loadNextScene();
-        this.transitionComplete();
-    }
-
-    protected transitionComplete() {
-        SceneManager.sceneTransition = null;
-
-        if (this.onTransitionCompleted) {
-            this.onTransitionCompleted();
+        constructor(sceneLoadAction: Function) {
+            this.sceneLoadAction = sceneLoadAction;
+            this.loadsNewScene = sceneLoadAction != null;
         }
-    }
 
-    protected async loadNextScene() {
-        if (this.onScreenObscured)
-            this.onScreenObscured();
+        public preRender() { }
 
-        if (!this.loadsNewScene) {
+        public render() {
+
+        }
+
+        public async onBeginTransition() {
+            await this.loadNextScene();
+            this.transitionComplete();
+        }
+
+        protected transitionComplete() {
+            SceneManager.sceneTransition = null;
+
+            if (this.onTransitionCompleted) {
+                this.onTransitionCompleted();
+            }
+        }
+
+        protected async loadNextScene() {
+            if (this.onScreenObscured)
+                this.onScreenObscured();
+
+            if (!this.loadsNewScene) {
+                this.isNewSceneLoaded = true;
+            }
+
+            SceneManager.scene = await this.sceneLoadAction();
             this.isNewSceneLoaded = true;
         }
 
-        SceneManager.scene = await this.sceneLoadAction();
-        this.isNewSceneLoaded = true;
-    }
+        public tickEffectProgressProperty(filter: egret.CustomFilter, duration: number, easeType: Function, reverseDirection = false): Promise<boolean>{
+            return new Promise((resolve)=>{
+                let start = reverseDirection ? 1 : 0;
+                let end = reverseDirection ? 0 : 1;
 
-    public tickEffectProgressProperty(filter: egret.CustomFilter, duration: number, easeType: Function, reverseDirection = false): Promise<boolean>{
-        return new Promise((resolve)=>{
-            let start = reverseDirection ? 1 : 0;
-            let end = reverseDirection ? 0 : 1;
-
-            egret.Tween.get(filter.uniforms).set({_progress: start}).to({_progress: end}, duration * 1000, easeType).call(()=>{
-                resolve();
+                egret.Tween.get(filter.uniforms).set({_progress: start}).to({_progress: end}, duration * 1000, easeType).call(()=>{
+                    resolve();
+                });
             });
-        });
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Graphics/Transitions/WindTransition.ts b/source/src/Graphics/Transitions/WindTransition.ts
index 3bf540f4..4fe72e54 100644
--- a/source/src/Graphics/Transitions/WindTransition.ts
+++ b/source/src/Graphics/Transitions/WindTransition.ts
@@ -1,65 +1,67 @@
-class WindTransition extends SceneTransition {
-    private _mask: egret.Shape;
-    private _windEffect: egret.CustomFilter;
+module es {
+    export class WindTransition extends SceneTransition {
+        private _mask: egret.Shape;
+        private _windEffect: egret.CustomFilter;
 
-    public duration = 1;
-    public set windSegments(value: number) {
-        this._windEffect.uniforms._windSegments = value;
+        public duration = 1;
+        public set windSegments(value: number) {
+            this._windEffect.uniforms._windSegments = value;
+        }
+        public set size(value: number) {
+            this._windEffect.uniforms._size = value;
+        }
+        public easeType = egret.Ease.quadOut;
+        constructor(sceneLoadAction: Function) {
+            super(sceneLoadAction);
+
+            let vertexSrc =  "attribute vec2 aVertexPosition;\n" +
+                "attribute vec2 aTextureCoord;\n" +
+
+                "uniform vec2 projectionVector;\n" +
+
+                "varying vec2 vTextureCoord;\n" +
+
+                "const vec2 center = vec2(-1.0, 1.0);\n" +
+
+                "void main(void) {\n" +
+                "   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n" +
+                "   vTextureCoord = aTextureCoord;\n" +
+                "}";
+            let fragmentSrc = "precision lowp float;\n" +
+                "varying vec2 vTextureCoord;\n" +
+                "uniform sampler2D uSampler;\n" +
+                "uniform float _progress;\n" +
+                "uniform float _size;\n" +
+                "uniform float _windSegments;\n" +
+
+                "void main(void) {\n" +
+                "vec2 co = floor(vec2(0.0, vTextureCoord.y * _windSegments));\n" +
+                "float x = sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453;\n" +
+                "float r = x - floor(x);\n" +
+                "float m = smoothstep(0.0, -_size, vTextureCoord.x * (1.0 - _size) + _size * r - (_progress * (1.0 + _size)));\n" +
+                "vec4 fg = texture2D(uSampler, vTextureCoord);\n" +
+                "gl_FragColor = mix(fg, vec4(0, 0, 0, 0), m);\n" +
+                "}";
+
+            this._windEffect = new egret.CustomFilter(vertexSrc, fragmentSrc, {
+                _progress: 0,
+                _size: 0.3,
+                _windSegments: 100
+            });
+
+            this._mask = new egret.Shape();
+            this._mask.graphics.beginFill(0xFFFFFF, 1);
+            this._mask.graphics.drawRect(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
+            this._mask.graphics.endFill();
+            this._mask.filters = [this._windEffect];
+            SceneManager.stage.addChild(this._mask);
+        }
+
+        public async onBeginTransition() {
+            this.loadNextScene();
+            await this.tickEffectProgressProperty(this._windEffect, this.duration, this.easeType);
+            this.transitionComplete();
+            SceneManager.stage.removeChild(this._mask);
+        }
     }
-    public set size(value: number) {
-        this._windEffect.uniforms._size = value;
-    }
-    public easeType = egret.Ease.quadOut;
-    constructor(sceneLoadAction: Function) {
-        super(sceneLoadAction);
-
-        let vertexSrc =  "attribute vec2 aVertexPosition;\n" +
-            "attribute vec2 aTextureCoord;\n" +
-
-            "uniform vec2 projectionVector;\n" +
-
-            "varying vec2 vTextureCoord;\n" +
-
-            "const vec2 center = vec2(-1.0, 1.0);\n" +
-
-            "void main(void) {\n" +
-            "   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n" +
-            "   vTextureCoord = aTextureCoord;\n" +
-            "}";
-        let fragmentSrc = "precision lowp float;\n" +
-            "varying vec2 vTextureCoord;\n" +
-            "uniform sampler2D uSampler;\n" +
-            "uniform float _progress;\n" +
-            "uniform float _size;\n" +
-            "uniform float _windSegments;\n" +
-
-            "void main(void) {\n" +
-            "vec2 co = floor(vec2(0.0, vTextureCoord.y * _windSegments));\n" +
-            "float x = sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453;\n" +
-            "float r = x - floor(x);\n" +
-            "float m = smoothstep(0.0, -_size, vTextureCoord.x * (1.0 - _size) + _size * r - (_progress * (1.0 + _size)));\n" +
-            "vec4 fg = texture2D(uSampler, vTextureCoord);\n" +
-            "gl_FragColor = mix(fg, vec4(0, 0, 0, 0), m);\n" +
-            "}";
-
-        this._windEffect = new egret.CustomFilter(vertexSrc, fragmentSrc, {
-            _progress: 0,
-            _size: 0.3,
-            _windSegments: 100
-        });
-
-        this._mask = new egret.Shape();
-        this._mask.graphics.beginFill(0xFFFFFF, 1);
-        this._mask.graphics.drawRect(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-        this._mask.graphics.endFill();
-        this._mask.filters = [this._windEffect];
-        SceneManager.stage.addChild(this._mask);
-    }
-
-    public async onBeginTransition() {
-        this.loadNextScene();
-        await this.tickEffectProgressProperty(this._windEffect, this.duration, this.easeType);
-        this.transitionComplete();
-        SceneManager.stage.removeChild(this._mask); 
-    }
-}
\ No newline at end of file
+}
diff --git a/source/src/Graphics/Viewport.ts b/source/src/Graphics/Viewport.ts
index 38ebef3f..182b4223 100644
--- a/source/src/Graphics/Viewport.ts
+++ b/source/src/Graphics/Viewport.ts
@@ -1,34 +1,36 @@
-class Viewport {
-    private _x: number;
-    private _y: number;
-    private _width: number;
-    private _height: number;
-    private _minDepth: number;
-    private _maxDepth: number;
-    
-    public get aspectRatio(){
-        if ((this._height != 0) && (this._width != 0))
-            return (this._width / this._height);
-        return 0;
-    }
+module es {
+    export class Viewport {
+        private _x: number;
+        private _y: number;
+        private _width: number;
+        private _height: number;
+        private _minDepth: number;
+        private _maxDepth: number;
 
-    public get bounds(){
-        return new Rectangle(this._x, this._y, this._width, this._height);
-    }
-    public set bounds(value: Rectangle){
-        this._x = value.x;
-        this._y = value.y;
-        this._width = value.width;
-        this._height = value.height;
-    }
+        public get aspectRatio(){
+            if ((this._height != 0) && (this._width != 0))
+                return (this._width / this._height);
+            return 0;
+        }
+
+        public get bounds(){
+            return new Rectangle(this._x, this._y, this._width, this._height);
+        }
+        public set bounds(value: Rectangle){
+            this._x = value.x;
+            this._y = value.y;
+            this._width = value.width;
+            this._height = value.height;
+        }
+
+        constructor(x: number, y: number, width: number, height: number){
+            this._x = x;
+            this._y = y;
+            this._width = width;
+            this._height = height;
+            this._minDepth = 0;
+            this._maxDepth = 1;
+        }
 
-    constructor(x: number, y: number, width: number, height: number){
-        this._x = x;
-        this._y = y;
-        this._width = width;
-        this._height = height;
-        this._minDepth = 0;
-        this._maxDepth = 1;
     }
-    
-}
\ No newline at end of file
+}
diff --git a/source/src/Math/Bezier.ts b/source/src/Math/Bezier.ts
index 53668d82..e6a4fbe1 100644
--- a/source/src/Math/Bezier.ts
+++ b/source/src/Math/Bezier.ts
@@ -1,121 +1,123 @@
-/** 贝塞尔帮助类 */
-class Bezier {
-    /**
-     * 二次贝塞尔曲线
-     * @param p0 
-     * @param p1 
-     * @param p2 
-     * @param t 
-     */
-    public static getPoint(p0: Vector2, p1: Vector2, p2: Vector2, t: number): Vector2 {
-        t = MathHelper.clamp01(t);
-        let oneMinusT = 1 - t;
-        return Vector2.add(Vector2.add(Vector2.multiply(new Vector2(oneMinusT * oneMinusT), p0),
-            Vector2.multiply(new Vector2(2 * oneMinusT * t), p1)), Vector2.multiply(new Vector2(t * t), p2));
-    }
-
-    /**
-     * 得到二次贝塞尔函数的一阶导数
-     * @param p0 
-     * @param p1 
-     * @param p2 
-     * @param t 
-     */
-    public static getFirstDerivative(p0: Vector2, p1: Vector2, p2: Vector2, t: number) {
-        return Vector2.add(Vector2.multiply(new Vector2(2 * (1 - t)), Vector2.subtract(p1, p0)),
-            Vector2.multiply(new Vector2(2 * t), Vector2.subtract(p2, p1)));
-    }
-
-    /**
-     * 得到一个三次贝塞尔函数的一阶导数
-     * @param start 
-     * @param firstControlPoint 
-     * @param secondControlPoint 
-     * @param end 
-     * @param t 
-     */
-    public static getFirstDerivativeThree(start: Vector2, firstControlPoint: Vector2, secondControlPoint: Vector2,
-        end: Vector2, t: number) {
-        t = MathHelper.clamp01(t);
-        let oneMunusT = 1 - t;
-        return Vector2.add(Vector2.add(Vector2.multiply(new Vector2(3 * oneMunusT * oneMunusT), Vector2.subtract(firstControlPoint, start)),
-            Vector2.multiply(new Vector2(6 * oneMunusT * t), Vector2.subtract(secondControlPoint, firstControlPoint))),
-            Vector2.multiply(new Vector2(3 * t * t), Vector2.subtract(end, secondControlPoint)));
-    }
-
-    /**
-     * 计算一个三次贝塞尔
-     * @param start 
-     * @param firstControlPoint 
-     * @param secondControlPoint 
-     * @param end 
-     * @param t 
-     */
-    public static getPointThree(start: Vector2, firstControlPoint: Vector2, secondControlPoint: Vector2,
-        end: Vector2, t: number) {
-        t = MathHelper.clamp01(t);
-        let oneMunusT = 1 - t;
-        return Vector2.add(Vector2.add(Vector2.add(Vector2.multiply(new Vector2(oneMunusT * oneMunusT * oneMunusT), start),
-            Vector2.multiply(new Vector2(3 * oneMunusT * oneMunusT * t), firstControlPoint)),
-            Vector2.multiply(new Vector2(3 * oneMunusT * t * t), secondControlPoint)),
-            Vector2.multiply(new Vector2(t * t * t), end));
-    }
-
-    /**
-     * 递归地细分bezier曲线，直到满足距离校正
-     * 在这种算法中，平面切片的点要比曲面切片少。返回完成后应返回到ListPool的合并列表。
-     * @param start 
-     * @param firstCtrlPoint 
-     * @param secondCtrlPoint 
-     * @param end 
-     * @param distanceTolerance 
-     */
-    public static getOptimizedDrawingPoints(start: Vector2, firstCtrlPoint: Vector2, secondCtrlPoint: Vector2,
-        end: Vector2, distanceTolerance: number = 1) {
-        let points = ListPool.obtain<Vector2>();
-        points.push(start);
-        this.recursiveGetOptimizedDrawingPoints(start, firstCtrlPoint, secondCtrlPoint, end, points, distanceTolerance);
-        points.push(end);
-
-        return points;
-    }
-
-    /**
-     * 递归地细分bezier曲线，直到满足距离校正。在这种算法中，平面切片的点要比曲面切片少。
-     * @param start 
-     * @param firstCtrlPoint 
-     * @param secondCtrlPoint 
-     * @param end 
-     * @param points 
-     * @param distanceTolerance 
-     */
-    private static recursiveGetOptimizedDrawingPoints(start: Vector2, firstCtrlPoint: Vector2, secondCtrlPoint: Vector2,
-        end: Vector2, points: Vector2[], distanceTolerance: number) {
-        // 计算线段的所有中点
-        let pt12 = Vector2.divide(Vector2.add(start, firstCtrlPoint), new Vector2(2));
-        let pt23 = Vector2.divide(Vector2.add(firstCtrlPoint, secondCtrlPoint), new Vector2(2));
-        let pt34 = Vector2.divide(Vector2.add(secondCtrlPoint, end), new Vector2(2));
-
-        // 计算新半直线的中点
-        let pt123 = Vector2.divide(Vector2.add(pt12, pt23), new Vector2(2));
-        let pt234 = Vector2.divide(Vector2.add(pt23, pt34), new Vector2(2));
-
-        // 最后再细分最后两个中点。如果我们满足我们的距离公差，这将是我们使用的最后一点。
-        let pt1234 = Vector2.divide(Vector2.add(pt123, pt234), new Vector2(2));
-
-        // 试着用一条直线来近似整个三次曲线
-        let deltaLine = Vector2.subtract(end, start);
-
-        let d2 = Math.abs(((firstCtrlPoint.x, end.x) * deltaLine.y - (firstCtrlPoint.y - end.y) * deltaLine.x));
-        let d3 = Math.abs(((secondCtrlPoint.x - end.x) * deltaLine.y - (secondCtrlPoint.y - end.y) * deltaLine.x));
-
-        if ((d2 + d3) * (d2 + d3) < distanceTolerance * (deltaLine.x * deltaLine.x + deltaLine.y * deltaLine.y)) {
-            points.push(pt1234);
-            return;
+module es {
+    /** 贝塞尔帮助类 */
+    export class Bezier {
+        /**
+         * 二次贝塞尔曲线
+         * @param p0
+         * @param p1
+         * @param p2
+         * @param t
+         */
+        public static getPoint(p0: Vector2, p1: Vector2, p2: Vector2, t: number): Vector2 {
+            t = MathHelper.clamp01(t);
+            let oneMinusT = 1 - t;
+            return Vector2.add(Vector2.add(Vector2.multiply(new Vector2(oneMinusT * oneMinusT), p0),
+                Vector2.multiply(new Vector2(2 * oneMinusT * t), p1)), Vector2.multiply(new Vector2(t * t), p2));
         }
 
-        // 继续细分
-        this.recursiveGetOptimizedDrawingPoints(start, pt12, pt123, pt1234, points, distanceTolerance);
-        this.recursiveGetOptimizedDrawingPoints(pt1234, pt234, pt34, end, points, distanceTolerance);
+        /**
+         * 得到二次贝塞尔函数的一阶导数
+         * @param p0
+         * @param p1
+         * @param p2
+         * @param t
+         */
+        public static getFirstDerivative(p0: Vector2, p1: Vector2, p2: Vector2, t: number) {
+            return Vector2.add(Vector2.multiply(new Vector2(2 * (1 - t)), Vector2.subtract(p1, p0)),
+                Vector2.multiply(new Vector2(2 * t), Vector2.subtract(p2, p1)));
+        }
+
+        /**
+         * 得到一个三次贝塞尔函数的一阶导数
+         * @param start
+         * @param firstControlPoint
+         * @param secondControlPoint
+         * @param end
+         * @param t
+         */
+        public static getFirstDerivativeThree(start: Vector2, firstControlPoint: Vector2, secondControlPoint: Vector2,
+                                              end: Vector2, t: number) {
+            t = MathHelper.clamp01(t);
+            let oneMunusT = 1 - t;
+            return Vector2.add(Vector2.add(Vector2.multiply(new Vector2(3 * oneMunusT * oneMunusT), Vector2.subtract(firstControlPoint, start)),
+                Vector2.multiply(new Vector2(6 * oneMunusT * t), Vector2.subtract(secondControlPoint, firstControlPoint))),
+                Vector2.multiply(new Vector2(3 * t * t), Vector2.subtract(end, secondControlPoint)));
+        }
+
+        /**
+         * 计算一个三次贝塞尔
+         * @param start
+         * @param firstControlPoint
+         * @param secondControlPoint
+         * @param end
+         * @param t
+         */
+        public static getPointThree(start: Vector2, firstControlPoint: Vector2, secondControlPoint: Vector2,
+                                    end: Vector2, t: number) {
+            t = MathHelper.clamp01(t);
+            let oneMunusT = 1 - t;
+            return Vector2.add(Vector2.add(Vector2.add(Vector2.multiply(new Vector2(oneMunusT * oneMunusT * oneMunusT), start),
+                Vector2.multiply(new Vector2(3 * oneMunusT * oneMunusT * t), firstControlPoint)),
+                Vector2.multiply(new Vector2(3 * oneMunusT * t * t), secondControlPoint)),
+                Vector2.multiply(new Vector2(t * t * t), end));
+        }
+
+        /**
+         * 递归地细分bezier曲线，直到满足距离校正
+         * 在这种算法中，平面切片的点要比曲面切片少。返回完成后应返回到ListPool的合并列表。
+         * @param start
+         * @param firstCtrlPoint
+         * @param secondCtrlPoint
+         * @param end
+         * @param distanceTolerance
+         */
+        public static getOptimizedDrawingPoints(start: Vector2, firstCtrlPoint: Vector2, secondCtrlPoint: Vector2,
+                                                end: Vector2, distanceTolerance: number = 1) {
+            let points = ListPool.obtain<Vector2>();
+            points.push(start);
+            this.recursiveGetOptimizedDrawingPoints(start, firstCtrlPoint, secondCtrlPoint, end, points, distanceTolerance);
+            points.push(end);
+
+            return points;
+        }
+
+        /**
+         * 递归地细分bezier曲线，直到满足距离校正。在这种算法中，平面切片的点要比曲面切片少。
+         * @param start
+         * @param firstCtrlPoint
+         * @param secondCtrlPoint
+         * @param end
+         * @param points
+         * @param distanceTolerance
+         */
+        private static recursiveGetOptimizedDrawingPoints(start: Vector2, firstCtrlPoint: Vector2, secondCtrlPoint: Vector2,
+                                                          end: Vector2, points: Vector2[], distanceTolerance: number) {
+            // 计算线段的所有中点
+            let pt12 = Vector2.divide(Vector2.add(start, firstCtrlPoint), new Vector2(2));
+            let pt23 = Vector2.divide(Vector2.add(firstCtrlPoint, secondCtrlPoint), new Vector2(2));
+            let pt34 = Vector2.divide(Vector2.add(secondCtrlPoint, end), new Vector2(2));
+
+            // 计算新半直线的中点
+            let pt123 = Vector2.divide(Vector2.add(pt12, pt23), new Vector2(2));
+            let pt234 = Vector2.divide(Vector2.add(pt23, pt34), new Vector2(2));
+
+            // 最后再细分最后两个中点。如果我们满足我们的距离公差，这将是我们使用的最后一点。
+            let pt1234 = Vector2.divide(Vector2.add(pt123, pt234), new Vector2(2));
+
+            // 试着用一条直线来近似整个三次曲线
+            let deltaLine = Vector2.subtract(end, start);
+
+            let d2 = Math.abs(((firstCtrlPoint.x, end.x) * deltaLine.y - (firstCtrlPoint.y - end.y) * deltaLine.x));
+            let d3 = Math.abs(((secondCtrlPoint.x - end.x) * deltaLine.y - (secondCtrlPoint.y - end.y) * deltaLine.x));
+
+            if ((d2 + d3) * (d2 + d3) < distanceTolerance * (deltaLine.x * deltaLine.x + deltaLine.y * deltaLine.y)) {
+                points.push(pt1234);
+                return;
+            }
+
+            // 继续细分
+            this.recursiveGetOptimizedDrawingPoints(start, pt12, pt123, pt1234, points, distanceTolerance);
+            this.recursiveGetOptimizedDrawingPoints(pt1234, pt234, pt34, end, points, distanceTolerance);
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Math/Flags.ts b/source/src/Math/Flags.ts
index ab415c81..f83ed4b5 100644
--- a/source/src/Math/Flags.ts
+++ b/source/src/Math/Flags.ts
@@ -1,62 +1,64 @@
-/**
- * 帮助处理位掩码的实用程序类
- * 除了isFlagSet之外，所有方法都期望flag参数是一个非移位的标志
- * 允许您使用普通的(0、1、2、3等)来设置/取消您的标记
- */
-class Flags {
+module es {
     /**
-     * 检查位标志是否已在数值中设置
-     * 检查期望标志是否已经移位
-     * @param self 
-     * @param flag 
+     * 帮助处理位掩码的实用程序类
+     * 除了isFlagSet之外，所有方法都期望flag参数是一个非移位的标志
+     * 允许您使用普通的(0、1、2、3等)来设置/取消您的标记
      */
-    public static isFlagSet(self: number, flag: number): boolean{
-        return (self & flag) != 0;
-    }
+    export class Flags {
+        /**
+         * 检查位标志是否已在数值中设置
+         * 检查期望标志是否已经移位
+         * @param self
+         * @param flag
+         */
+        public static isFlagSet(self: number, flag: number): boolean{
+            return (self & flag) != 0;
+        }
 
-    /**
-     * 检查位标志是否在数值中设置
-     * @param self 
-     * @param flag 
-     */
-    public static isUnshiftedFlagSet(self: number, flag: number): boolean{
-        flag = 1 << flag;
-        return (self & flag) != 0;
-    }
+        /**
+         * 检查位标志是否在数值中设置
+         * @param self
+         * @param flag
+         */
+        public static isUnshiftedFlagSet(self: number, flag: number): boolean{
+            flag = 1 << flag;
+            return (self & flag) != 0;
+        }
 
-    /**
-     *  设置数值标志位，移除所有已经设置的标志
-     * @param self 
-     * @param flag 
-     */
-    public static setFlagExclusive(self: number, flag: number){
-        return 1 << flag;
-    }
+        /**
+         *  设置数值标志位，移除所有已经设置的标志
+         * @param self
+         * @param flag
+         */
+        public static setFlagExclusive(self: number, flag: number){
+            return 1 << flag;
+        }
 
-    /**
-     * 设置标志位
-     * @param self 
-     * @param flag 
-     */
-    public static setFlag(self: number, flag: number){
-        return (self | 1 << flag);
-    }
+        /**
+         * 设置标志位
+         * @param self
+         * @param flag
+         */
+        public static setFlag(self: number, flag: number){
+            return (self | 1 << flag);
+        }
 
-    /**
-     * 取消标志位
-     * @param self 
-     * @param flag 
-     */
-    public static unsetFlag(self: number, flag: number){
-        flag = 1 << flag;
-        return (self & (~flag));
-    }
+        /**
+         * 取消标志位
+         * @param self
+         * @param flag
+         */
+        public static unsetFlag(self: number, flag: number){
+            flag = 1 << flag;
+            return (self & (~flag));
+        }
 
-    /**
-     * 反转数值集合位
-     * @param self 
-     */
-    public static invertFlags(self: number){
-        return ~self;
+        /**
+         * 反转数值集合位
+         * @param self
+         */
+        public static invertFlags(self: number){
+            return ~self;
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Math/MathHelper.ts b/source/src/Math/MathHelper.ts
index 0c37c500..24186325 100644
--- a/source/src/Math/MathHelper.ts
+++ b/source/src/Math/MathHelper.ts
@@ -1,78 +1,80 @@
-class MathHelper {
-    public static readonly Epsilon: number = 0.00001;
-    public static readonly Rad2Deg = 57.29578;
-    public static readonly Deg2Rad = 0.0174532924;
+module es {
+    export class MathHelper {
+        public static readonly Epsilon: number = 0.00001;
+        public static readonly Rad2Deg = 57.29578;
+        public static readonly Deg2Rad = 0.0174532924;
 
-    /**
-     * 将弧度转换成角度。
-     * @param radians 用弧度表示的角
-     */
-    public static toDegrees(radians: number){
-        return radians * 57.295779513082320876798154814105;
+        /**
+         * 将弧度转换成角度。
+         * @param radians 用弧度表示的角
+         */
+        public static toDegrees(radians: number){
+            return radians * 57.295779513082320876798154814105;
+        }
+
+        /**
+         * 将角度转换为弧度
+         * @param degrees
+         */
+        public static toRadians(degrees: number){
+            return degrees * 0.017453292519943295769236907684886;
+        }
+
+        /**
+         * mapps值(在leftMin - leftMax范围内)到rightMin - rightMax范围内的值
+         * @param value
+         * @param leftMin
+         * @param leftMax
+         * @param rightMin
+         * @param rightMax
+         */
+        public static map(value: number, leftMin: number, leftMax: number, rightMin: number, rightMax: number){
+            return rightMin + (value - leftMin) * (rightMax - rightMin) / (leftMax - leftMin);
+        }
+
+        public static lerp(value1: number, value2: number, amount: number){
+            return value1 + (value2 - value1) * amount;
+        }
+
+        public static clamp(value: number, min: number, max: number){
+            if (value < min)
+                return min;
+
+            if (value > max)
+                return max;
+
+            return value;
+        }
+
+        public static pointOnCirlce(circleCenter: Vector2, radius: number, angleInDegrees: number){
+            let radians = MathHelper.toRadians(angleInDegrees);
+            return new Vector2(Math.cos(radians) * radians + circleCenter.x, Math.sin(radians) * radians + circleCenter.y);
+        }
+
+        /**
+         * 如果值为偶数，返回true
+         * @param value
+         */
+        public static isEven(value: number){
+            return value % 2 == 0;
+        }
+
+        /**
+         * 数值限定在0-1之间
+         * @param value
+         */
+        public static clamp01(value: number){
+            if (value < 0)
+                return 0;
+
+            if (value > 1)
+                return 1;
+
+            return value;
+        }
+
+        public static angleBetweenVectors(from: Vector2, to: Vector2){
+            return Math.atan2(to.y - from.y, to.x - from.x);
+        }
     }
-
-    /**
-     * 将角度转换为弧度
-     * @param degrees 
-     */
-    public static toRadians(degrees: number){
-        return degrees * 0.017453292519943295769236907684886;
-    }
-
-    /**
-     * mapps值(在leftMin - leftMax范围内)到rightMin - rightMax范围内的值
-     * @param value 
-     * @param leftMin 
-     * @param leftMax 
-     * @param rightMin 
-     * @param rightMax 
-     */
-    public static map(value: number, leftMin: number, leftMax: number, rightMin: number, rightMax: number){
-        return rightMin + (value - leftMin) * (rightMax - rightMin) / (leftMax - leftMin);
-    }
-
-    public static lerp(value1: number, value2: number, amount: number){
-        return value1 + (value2 - value1) * amount;
-    }
-
-    public static clamp(value: number, min: number, max: number){
-        if (value < min)
-            return min;
-
-        if (value > max)
-            return max;
-
-        return value;
-    }
-
-    public static pointOnCirlce(circleCenter: Vector2, radius: number, angleInDegrees: number){
-        let radians = MathHelper.toRadians(angleInDegrees);
-        return new Vector2(Math.cos(radians) * radians + circleCenter.x, Math.sin(radians) * radians + circleCenter.y);
-    }
-
-    /**
-     * 如果值为偶数，返回true
-     * @param value 
-     */
-    public static isEven(value: number){
-        return value % 2 == 0;
-    }
-
-    /**
-     * 数值限定在0-1之间
-     * @param value 
-     */
-    public static clamp01(value: number){
-        if (value < 0)
-            return 0;
-
-        if (value > 1)
-            return 1;
-
-        return value;
-    }
-
-    public static angleBetweenVectors(from: Vector2, to: Vector2){
-        return Math.atan2(to.y - from.y, to.x - from.x);
-    }
-}
\ No newline at end of file
+}
diff --git a/source/src/Math/Matrix2D.ts b/source/src/Math/Matrix2D.ts
index 41794194..9b1e69e7 100644
--- a/source/src/Math/Matrix2D.ts
+++ b/source/src/Math/Matrix2D.ts
@@ -1,217 +1,219 @@
-/**
- * 表示右手3 * 3的浮点矩阵，可以存储平移、缩放和旋转信息。
- */
-class Matrix2D {
-    public m11: number = 0;
-    public m12: number = 0;
-
-    public m21: number = 0;
-    public m22: number = 0;
-
-    public m31: number = 0;
-    public m32: number = 0;
-
-    private static _identity: Matrix2D = new Matrix2D(1, 0, 0, 1, 0, 0);
-
+module es {
     /**
-     * 单位矩阵
+     * 表示右手3 * 3的浮点矩阵，可以存储平移、缩放和旋转信息。
      */
-    public static get identity(){
-        return Matrix2D._identity;
+    export class Matrix2D {
+        public m11: number = 0;
+        public m12: number = 0;
+
+        public m21: number = 0;
+        public m22: number = 0;
+
+        public m31: number = 0;
+        public m32: number = 0;
+
+        private static _identity: Matrix2D = new Matrix2D(1, 0, 0, 1, 0, 0);
+
+        /**
+         * 单位矩阵
+         */
+        public static get identity(){
+            return Matrix2D._identity;
+        }
+
+        constructor(m11?: number, m12?: number, m21?: number, m22?: number, m31?: number, m32?: number){
+            this.m11 = m11 ? m11 : 1;
+            this.m12 = m12 ? m12 : 0;
+
+            this.m21 = m21 ? m21 : 0;
+            this.m22 = m22 ? m22 : 1;
+
+            this.m31 = m31 ? m31 : 0;
+            this.m32 = m32 ? m32 : 0;
+        }
+
+        /** 存储在这个矩阵中的位置 */
+        public get translation(){
+            return new Vector2(this.m31, this.m32);
+        }
+
+        public set translation(value: Vector2){
+            this.m31 = value.x;
+            this.m32 = value.y;
+        }
+
+        /** 以弧度表示的旋转存储在这个矩阵中 */
+        public get rotation(){
+            return Math.atan2(this.m21, this.m11);
+        }
+
+        public set rotation(value: number){
+            let val1 = Math.cos(value);
+            let val2 = Math.sin(value);
+
+            this.m11 = val1;
+            this.m12 = val2;
+            this.m21 = -val2;
+            this.m22 = val1;
+        }
+
+        /**
+         * 以度为单位的旋转存储在这个矩阵中
+         */
+        public get rotationDegrees(){
+            return MathHelper.toDegrees(this.rotation);
+        }
+
+        public set rotationDegrees(value: number){
+            this.rotation = MathHelper.toRadians(value);
+        }
+
+        public get scale(){
+            return new Vector2(this.m11, this.m22);
+        }
+
+        public set scale(value: Vector2){
+            this.m11 = value.x;
+            this.m12 = value.y;
+        }
+
+        /**
+         * 创建一个新的matrix, 它包含两个矩阵的和。
+         * @param matrix1
+         * @param matrix2
+         */
+        public static add(matrix1: Matrix2D, matrix2: Matrix2D){
+            matrix1.m11 += matrix2.m11;
+            matrix1.m12 += matrix2.m12;
+
+            matrix1.m21 += matrix2.m21;
+            matrix1.m22 += matrix2.m22;
+
+            matrix1.m31 += matrix2.m31;
+            matrix1.m32 += matrix2.m32;
+
+            return matrix1;
+        }
+
+        public static divide(matrix1: Matrix2D, matrix2: Matrix2D){
+            matrix1.m11 /= matrix2.m11;
+            matrix1.m12 /= matrix2.m12;
+
+            matrix1.m21 /= matrix2.m21;
+            matrix1.m22 /= matrix2.m22;
+
+            matrix1.m31 /= matrix2.m31;
+            matrix1.m32 /= matrix2.m32;
+
+            return matrix1;
+        }
+
+        public static multiply(matrix1: Matrix2D, matrix2: Matrix2D){
+            let result = new Matrix2D();
+
+            let m11 = ( matrix1.m11 * matrix2.m11 ) + ( matrix1.m12 * matrix2.m21 );
+            let m12 = ( matrix1.m11 * matrix2.m12 ) + ( matrix1.m12 * matrix2.m22 );
+
+            let m21 = ( matrix1.m21 * matrix2.m11 ) + ( matrix1.m22 * matrix2.m21 );
+            let m22 = ( matrix1.m21 * matrix2.m12 ) + ( matrix1.m22 * matrix2.m22 );
+
+            let m31 = ( matrix1.m31 * matrix2.m11 ) + ( matrix1.m32 * matrix2.m21 ) + matrix2.m31;
+            let m32 = ( matrix1.m31 * matrix2.m12 ) + ( matrix1.m32 * matrix2.m22 ) + matrix2.m32;
+
+            result.m11 = m11;
+            result.m12 = m12;
+
+            result.m21 = m21;
+            result.m22 = m22;
+
+            result.m31 = m31;
+            result.m32 = m32;
+
+            return result;
+        }
+
+        public static multiplyTranslation(matrix: Matrix2D, x: number, y: number){
+            let trans = Matrix2D.createTranslation(x, y);
+            return Matrix2D.multiply(matrix, trans);
+        }
+
+        public determinant(){
+            return this.m11 * this.m22 - this.m12 * this.m21;
+        }
+
+        public static invert(matrix: Matrix2D, result: Matrix2D = new Matrix2D()){
+            let det = 1 / matrix.determinant();
+
+            result.m11 = matrix.m22 * det;
+            result.m12 = -matrix.m12 * det;
+
+            result.m21 = -matrix.m21 * det;
+            result.m22 = matrix.m11 * det;
+
+            result.m31 = (matrix.m32 * matrix.m21 - matrix.m31 * matrix.m22) * det;
+            result.m32 = -(matrix.m32 * matrix.m11 - matrix.m31 * matrix.m12) * det;
+
+            return result;
+        }
+
+        /**
+         * 创建一个新的tranlation
+         * @param xPosition
+         * @param yPosition
+         */
+        public static createTranslation(xPosition: number, yPosition: number){
+            let result = new Matrix2D();
+
+            result.m11 = 1;
+            result.m12 = 0;
+
+            result.m21 = 0;
+            result.m22 = 1;
+
+            result.m31 = xPosition;
+            result.m32 = yPosition;
+
+            return result;
+        }
+
+        /**
+         * 根据position 创建一个translation
+         * @param position
+         */
+        public static createTranslationVector(position: Vector2){
+            return this.createTranslation(position.x, position.y);
+        }
+
+        public static createRotation(radians: number, result?: Matrix2D){
+            result = new Matrix2D();
+
+            let val1 = Math.cos(radians);
+            let val2 = Math.sin(radians);
+
+            result.m11 = val1;
+            result.m12 = val2;
+            result.m21 = -val2;
+            result.m22 = val1;
+
+            return result;
+        }
+
+        public static createScale(xScale: number, yScale: number, result: Matrix2D = new Matrix2D()){
+            result.m11 = xScale;
+            result.m12 = 0;
+
+            result.m21 = 0;
+            result.m22 = yScale;
+
+            result.m31 = 0;
+            result.m32 = 0;
+
+            return result;
+        }
+
+        public toEgretMatrix(): egret.Matrix{
+            let matrix = new egret.Matrix(this.m11, this.m12, this.m21, this.m22, this.m31, this.m32);
+            return matrix;
+        }
     }
-
-    constructor(m11?: number, m12?: number, m21?: number, m22?: number, m31?: number, m32?: number){
-        this.m11 = m11 ? m11 : 1;
-        this.m12 = m12 ? m12 : 0;
-
-        this.m21 = m21 ? m21 : 0;
-        this.m22 = m22 ? m22 : 1;
-        
-        this.m31 = m31 ? m31 : 0;
-        this.m32 = m32 ? m32 : 0;
-    }
-
-    /** 存储在这个矩阵中的位置 */
-    public get translation(){
-        return new Vector2(this.m31, this.m32);
-    }
-
-    public set translation(value: Vector2){
-        this.m31 = value.x;
-        this.m32 = value.y;
-    }
-
-    /** 以弧度表示的旋转存储在这个矩阵中 */
-    public get rotation(){
-        return Math.atan2(this.m21, this.m11);
-    }
-
-    public set rotation(value: number){
-        let val1 = Math.cos(value);
-        let val2 = Math.sin(value);
-
-        this.m11 = val1;
-        this.m12 = val2;
-        this.m21 = -val2;
-        this.m22 = val1;
-    }
-
-    /**
-     * 以度为单位的旋转存储在这个矩阵中
-     */
-    public get rotationDegrees(){
-        return MathHelper.toDegrees(this.rotation);
-    }
-
-    public set rotationDegrees(value: number){
-        this.rotation = MathHelper.toRadians(value);
-    }
-
-    public get scale(){
-        return new Vector2(this.m11, this.m22);
-    }
-
-    public set scale(value: Vector2){
-        this.m11 = value.x;
-        this.m12 = value.y;
-    }
-
-    /**
-     * 创建一个新的matrix, 它包含两个矩阵的和。
-     * @param matrix1 
-     * @param matrix2 
-     */
-    public static add(matrix1: Matrix2D, matrix2: Matrix2D){
-        matrix1.m11 += matrix2.m11;
-        matrix1.m12 += matrix2.m12;
-
-        matrix1.m21 += matrix2.m21;
-        matrix1.m22 += matrix2.m22;
-
-        matrix1.m31 += matrix2.m31;
-        matrix1.m32 += matrix2.m32;
-
-        return matrix1;
-    }
-
-    public static divide(matrix1: Matrix2D, matrix2: Matrix2D){
-        matrix1.m11 /= matrix2.m11;
-        matrix1.m12 /= matrix2.m12;
-
-        matrix1.m21 /= matrix2.m21;
-        matrix1.m22 /= matrix2.m22;
-
-        matrix1.m31 /= matrix2.m31;
-        matrix1.m32 /= matrix2.m32;
-
-        return matrix1;
-    }
-
-    public static multiply(matrix1: Matrix2D, matrix2: Matrix2D){
-        let result = new Matrix2D();
-
-        let m11 = ( matrix1.m11 * matrix2.m11 ) + ( matrix1.m12 * matrix2.m21 );
-        let m12 = ( matrix1.m11 * matrix2.m12 ) + ( matrix1.m12 * matrix2.m22 );
-
-        let m21 = ( matrix1.m21 * matrix2.m11 ) + ( matrix1.m22 * matrix2.m21 );
-        let m22 = ( matrix1.m21 * matrix2.m12 ) + ( matrix1.m22 * matrix2.m22 );
-
-        let m31 = ( matrix1.m31 * matrix2.m11 ) + ( matrix1.m32 * matrix2.m21 ) + matrix2.m31;
-        let m32 = ( matrix1.m31 * matrix2.m12 ) + ( matrix1.m32 * matrix2.m22 ) + matrix2.m32;
-
-        result.m11 = m11;
-        result.m12 = m12;
-
-        result.m21 = m21;
-        result.m22 = m22;
-
-        result.m31 = m31;
-        result.m32 = m32;
-
-        return result;
-    }
-
-    public static multiplyTranslation(matrix: Matrix2D, x: number, y: number){
-        let trans = Matrix2D.createTranslation(x, y);
-        return Matrix2D.multiply(matrix, trans);
-    }
-
-    public determinant(){
-        return this.m11 * this.m22 - this.m12 * this.m21;
-    }
-
-    public static invert(matrix: Matrix2D, result: Matrix2D = new Matrix2D()){
-        let det = 1 / matrix.determinant();
-
-        result.m11 = matrix.m22 * det;
-        result.m12 = -matrix.m12 * det;
-
-        result.m21 = -matrix.m21 * det;
-        result.m22 = matrix.m11 * det;
-
-        result.m31 = (matrix.m32 * matrix.m21 - matrix.m31 * matrix.m22) * det;
-        result.m32 = -(matrix.m32 * matrix.m11 - matrix.m31 * matrix.m12) * det;
-
-        return result;
-    }
-
-    /**
-     * 创建一个新的tranlation
-     * @param xPosition 
-     * @param yPosition 
-     */
-    public static createTranslation(xPosition: number, yPosition: number){
-        let result = new Matrix2D();
-        
-        result.m11 = 1;
-        result.m12 = 0;
-
-        result.m21 = 0;
-        result.m22 = 1;
-
-        result.m31 = xPosition;
-        result.m32 = yPosition;
-
-        return result;
-    }
-
-    /**
-     * 根据position 创建一个translation
-     * @param position 
-     */
-    public static createTranslationVector(position: Vector2){
-        return this.createTranslation(position.x, position.y);
-    }
-
-    public static createRotation(radians: number, result?: Matrix2D){
-        result = new Matrix2D();
-
-        let val1 = Math.cos(radians);
-        let val2 = Math.sin(radians);
-
-        result.m11 = val1;
-        result.m12 = val2;
-        result.m21 = -val2;
-        result.m22 = val1;
-
-        return result;
-    }
-
-    public static createScale(xScale: number, yScale: number, result: Matrix2D = new Matrix2D()){
-        result.m11 = xScale;
-        result.m12 = 0;
-
-        result.m21 = 0;
-        result.m22 = yScale;
-
-        result.m31 = 0;
-        result.m32 = 0;
-
-        return result;
-    }
-
-    public toEgretMatrix(): egret.Matrix{
-        let matrix = new egret.Matrix(this.m11, this.m12, this.m21, this.m22, this.m31, this.m32);
-        return matrix;
-    }
-}
\ No newline at end of file
+}
diff --git a/source/src/Math/Rectangle.ts b/source/src/Math/Rectangle.ts
index 694b553a..22e368e4 100644
--- a/source/src/Math/Rectangle.ts
+++ b/source/src/Math/Rectangle.ts
@@ -1,183 +1,185 @@
-class Rectangle extends egret.Rectangle {
-    /**
-     * 获取矩形的最大点，即右下角
-     */
-    public get max() {
-        return new Vector2(this.right, this.bottom);
-    }
+module es {
+    export class Rectangle extends egret.Rectangle {
+        /**
+         * 获取矩形的最大点，即右下角
+         */
+        public get max() {
+            return new Vector2(this.right, this.bottom);
+        }
 
-    /** 中心点坐标 */
-    public get center() {
-        return new Vector2(this.x + (this.width / 2), this.y + (this.height / 2));
-    }
+        /** 中心点坐标 */
+        public get center() {
+            return new Vector2(this.x + (this.width / 2), this.y + (this.height / 2));
+        }
 
-    /** 左上角的坐标 */
-    public get location() {
-        return new Vector2(this.x, this.y);
-    }
-    /** 左上角的坐标 */
-    public set location(value: Vector2) {
-        this.x = value.x;
-        this.y = value.y;
-    }
+        /** 左上角的坐标 */
+        public get location() {
+            return new Vector2(this.x, this.y);
+        }
+        /** 左上角的坐标 */
+        public set location(value: Vector2) {
+            this.x = value.x;
+            this.y = value.y;
+        }
 
-    public get size() {
-        return new Vector2(this.width, this.height);
-    }
+        public get size() {
+            return new Vector2(this.width, this.height);
+        }
 
-    public set size(value: Vector2) {
-        this.width = value.x;
-        this.height = value.y;
-    }
+        public set size(value: Vector2) {
+            this.width = value.x;
+            this.height = value.y;
+        }
 
-    /**
-     * 是否与另一个矩形相交
-     * @param value 
-     */
-    public intersects(value: egret.Rectangle) {
-        return value.left < this.right &&
-            this.left < value.right &&
-            value.top < this.bottom &&
-            this.top < value.bottom;
-    }
+        /**
+         * 是否与另一个矩形相交
+         * @param value
+         */
+        public intersects(value: egret.Rectangle) {
+            return value.left < this.right &&
+                this.left < value.right &&
+                value.top < this.bottom &&
+                this.top < value.bottom;
+        }
 
-    /**
-     * 获取所提供的矩形是否在此矩形的边界内
-     * @param value 
-     */
-    public containsRect(value: Rectangle) {
-        return ((((this.x <= value.x) && (value.x < (this.x + this.width))) &&
-            (this.y <= value.y)) &&
-            (value.y < (this.y + this.height)));
-    }
+        /**
+         * 获取所提供的矩形是否在此矩形的边界内
+         * @param value
+         */
+        public containsRect(value: Rectangle) {
+            return ((((this.x <= value.x) && (value.x < (this.x + this.width))) &&
+                (this.y <= value.y)) &&
+                (value.y < (this.y + this.height)));
+        }
 
-    public getHalfSize() {
-        return new Vector2(this.width * 0.5, this.height * 0.5);
-    }
+        public getHalfSize() {
+            return new Vector2(this.width * 0.5, this.height * 0.5);
+        }
 
-    /**
-     * 创建一个矩形的最小/最大点(左上角，右下角的点)
-     * @param minX 
-     * @param minY 
-     * @param maxX 
-     * @param maxY 
-     */
-    public static fromMinMax(minX: number, minY: number, maxX: number, maxY: number) {
-        return new Rectangle(minX, minY, maxX - minX, maxY - minY);
-    }
+        /**
+         * 创建一个矩形的最小/最大点(左上角，右下角的点)
+         * @param minX
+         * @param minY
+         * @param maxX
+         * @param maxY
+         */
+        public static fromMinMax(minX: number, minY: number, maxX: number, maxY: number) {
+            return new Rectangle(minX, minY, maxX - minX, maxY - minY);
+        }
 
-    /**
-     * 获取矩形边界上与给定点最近的点
-     * @param point 
-     */
-    public getClosestPointOnRectangleBorderToPoint(point: Vector2): { res: Vector2, edgeNormal: Vector2 } {
-        let edgeNormal = Vector2.zero;
+        /**
+         * 获取矩形边界上与给定点最近的点
+         * @param point
+         */
+        public getClosestPointOnRectangleBorderToPoint(point: Vector2): { res: Vector2, edgeNormal: Vector2 } {
+            let edgeNormal = Vector2.zero;
 
-        // 对于每个轴，如果点在盒子外面
-        let res = new Vector2();
-        res.x = MathHelper.clamp(point.x, this.left, this.right);
-        res.y = MathHelper.clamp(point.y, this.top, this.bottom);
+            // 对于每个轴，如果点在盒子外面
+            let res = new Vector2();
+            res.x = MathHelper.clamp(point.x, this.left, this.right);
+            res.y = MathHelper.clamp(point.y, this.top, this.bottom);
 
-        // 如果点在矩形内，我们需要推res到边界，因为它将在矩形内
-        if (this.contains(res.x, res.y)) {
-            let dl = res.x - this.left;
-            let dr = this.right - res.x;
-            let dt = res.y - this.top;
-            let db = this.bottom - res.y;
+            // 如果点在矩形内，我们需要推res到边界，因为它将在矩形内
+            if (this.contains(res.x, res.y)) {
+                let dl = res.x - this.left;
+                let dr = this.right - res.x;
+                let dt = res.y - this.top;
+                let db = this.bottom - res.y;
 
-            let min = Math.min(dl, dr, dt, db);
-            if (min == dt) {
-                res.y = this.top;
-                edgeNormal.y = -1;
-            } else if (min == db) {
-                res.y = this.bottom;
-                edgeNormal.y = 1;
-            } else if (min == dl) {
-                res.x = this.left;
-                edgeNormal.x = -1;
+                let min = Math.min(dl, dr, dt, db);
+                if (min == dt) {
+                    res.y = this.top;
+                    edgeNormal.y = -1;
+                } else if (min == db) {
+                    res.y = this.bottom;
+                    edgeNormal.y = 1;
+                } else if (min == dl) {
+                    res.x = this.left;
+                    edgeNormal.x = -1;
+                } else {
+                    res.x = this.right;
+                    edgeNormal.x = 1;
+                }
             } else {
-                res.x = this.right;
-                edgeNormal.x = 1;
+                if (res.x == this.left) edgeNormal.x = -1;
+                if (res.x == this.right) edgeNormal.x = 1;
+                if (res.y == this.top) edgeNormal.y = -1;
+                if (res.y == this.bottom) edgeNormal.y = 1;
             }
-        } else {
-            if (res.x == this.left) edgeNormal.x = -1;
-            if (res.x == this.right) edgeNormal.x = 1;
-            if (res.y == this.top) edgeNormal.y = -1;
-            if (res.y == this.bottom) edgeNormal.y = 1;
+
+            return { res: res, edgeNormal: edgeNormal };
         }
 
-        return { res: res, edgeNormal: edgeNormal };
-    }
+        /**
+         *
+         */
+        public getClosestPointOnBoundsToOrigin() {
+            let max = this.max;
+            let minDist = Math.abs(this.location.x);
+            let boundsPoint = new Vector2(this.location.x, 0);
 
-    /**
-     * 
-     */
-    public getClosestPointOnBoundsToOrigin() {
-        let max = this.max;
-        let minDist = Math.abs(this.location.x);
-        let boundsPoint = new Vector2(this.location.x, 0);
+            if (Math.abs(max.x) < minDist) {
+                minDist = Math.abs(max.x);
+                boundsPoint.x = max.x;
+                boundsPoint.y = 0;
+            }
 
-        if (Math.abs(max.x) < minDist) {
-            minDist = Math.abs(max.x);
-            boundsPoint.x = max.x;
-            boundsPoint.y = 0;
+            if (Math.abs(max.y) < minDist) {
+                minDist = Math.abs(max.y);
+                boundsPoint.x = 0;
+                boundsPoint.y = max.y;
+            }
+
+            if (Math.abs(this.location.y) < minDist) {
+                minDist = Math.abs(this.location.y);
+                boundsPoint.x = 0;
+                boundsPoint.y = this.location.y;
+            }
+
+            return boundsPoint;
         }
 
-        if (Math.abs(max.y) < minDist) {
-            minDist = Math.abs(max.y);
-            boundsPoint.x = 0;
-            boundsPoint.y = max.y;
+        public calculateBounds(parentPosition: Vector2, position: Vector2, origin: Vector2, scale: Vector2, rotation: number, width: number, height: number){
+            this.x = parentPosition.x + position.x - origin.x * scale.x;
+            this.y = parentPosition.y + position.y - origin.y * scale.y;
+            this.width = width * scale.x;
+            this.height = height * scale.y;
         }
 
-        if (Math.abs(this.location.y) < minDist) {
-            minDist = Math.abs(this.location.y);
-            boundsPoint.x = 0;
-            boundsPoint.y = this.location.y;
+        /**
+         * 将egret矩形转化为Rectangle
+         * @param rect
+         */
+        public setEgretRect(rect: egret.Rectangle): Rectangle{
+            this.x = rect.x;
+            this.y = rect.y;
+            this.width = rect.width;
+            this.height = rect.height;
+            return this;
         }
 
-        return boundsPoint;
-    }
+        /**
+         * 给定多边形的点，计算边界
+         * @param points
+         */
+        public static rectEncompassingPoints(points: Vector2[]) {
+            // 我们需要求出x/y的最小值/最大值
+            let minX = Number.POSITIVE_INFINITY;
+            let minY = Number.POSITIVE_INFINITY;
+            let maxX = Number.NEGATIVE_INFINITY;
+            let maxY = Number.NEGATIVE_INFINITY;
 
-    public calculateBounds(parentPosition: Vector2, position: Vector2, origin: Vector2, scale: Vector2, rotation: number, width: number, height: number){
-        this.x = parentPosition.x + position.x - origin.x * scale.x;
-        this.y = parentPosition.y + position.y - origin.y * scale.y;
-        this.width = width * scale.x;
-        this.height = height * scale.y;
-    }
+            for (let i = 0; i < points.length; i++) {
+                let pt = points[i];
 
-    /**
-     * 将egret矩形转化为Rectangle
-     * @param rect 
-     */
-    public setEgretRect(rect: egret.Rectangle): Rectangle{
-        this.x = rect.x;
-        this.y = rect.y;
-        this.width = rect.width;
-        this.height = rect.height;
-        return this;
-    }
-   
-    /**
-     * 给定多边形的点，计算边界
-     * @param points 
-     */
-    public static rectEncompassingPoints(points: Vector2[]) {
-        // 我们需要求出x/y的最小值/最大值
-        let minX = Number.POSITIVE_INFINITY;
-        let minY = Number.POSITIVE_INFINITY;
-        let maxX = Number.NEGATIVE_INFINITY;
-        let maxY = Number.NEGATIVE_INFINITY;
+                if (pt.x < minX) minX = pt.x;
+                if (pt.x > maxX) maxX = pt.x;
 
-        for (let i = 0; i < points.length; i++) {
-            let pt = points[i];
+                if (pt.y < minY) minY = pt.y;
+                if (pt.y > maxY) maxY = pt.y;
+            }
 
-            if (pt.x < minX) minX = pt.x;
-            if (pt.x > maxX) maxX = pt.x;
-
-            if (pt.y < minY) minY = pt.y;
-            if (pt.y > maxY) maxY = pt.y;
+            return this.fromMinMax(minX, minY, maxX, maxY);
         }
-
-        return this.fromMinMax(minX, minY, maxX, maxY);
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Math/Vector2.ts b/source/src/Math/Vector2.ts
index 9529ac41..13dbe2aa 100644
--- a/source/src/Math/Vector2.ts
+++ b/source/src/Math/Vector2.ts
@@ -1,183 +1,185 @@
-/** 2d 向量 */
-class Vector2 {
-    public x: number = 0;
-    public y: number = 0;
+module es {
+    /** 2d 向量 */
+    export class Vector2 {
+        public x: number = 0;
+        public y: number = 0;
 
-    private static readonly unitYVector = new Vector2(0, 1);
-    private static readonly unitXVector = new Vector2(1, 0);
-    private static readonly unitVector2 = new Vector2(1, 1);
-    private static readonly zeroVector2 = new Vector2(0, 0);
-    public static get zero(){
-        return Vector2.zeroVector2;
+        private static readonly unitYVector = new Vector2(0, 1);
+        private static readonly unitXVector = new Vector2(1, 0);
+        private static readonly unitVector2 = new Vector2(1, 1);
+        private static readonly zeroVector2 = new Vector2(0, 0);
+        public static get zero(){
+            return Vector2.zeroVector2;
+        }
+
+        public static get one(){
+            return Vector2.unitVector2;
+        }
+
+        public static get unitX(){
+            return Vector2.unitXVector;
+        }
+
+        public static get unitY(){
+            return Vector2.unitYVector;
+        }
+
+        /**
+         * 从两个值构造一个带有X和Y的二维向量。
+         * @param x 二维空间中的x坐标
+         * @param y 二维空间的y坐标
+         */
+        constructor(x? : number, y?: number){
+            this.x = x ? x : 0;
+            this.y = y ? y : this.x;
+        }
+
+        /**
+         *
+         * @param value1
+         * @param value2
+         */
+        public static add(value1: Vector2, value2: Vector2){
+            let result: Vector2 = new Vector2(0, 0);
+            result.x = value1.x + value2.x;
+            result.y = value1.y + value2.y;
+            return result;
+        }
+
+        /**
+         *
+         * @param value1
+         * @param value2
+         */
+        public static divide(value1: Vector2, value2: Vector2){
+            let result: Vector2 = new Vector2(0, 0);
+            result.x = value1.x / value2.x;
+            result.y = value1.y / value2.y;
+            return result;
+        }
+
+        /**
+         *
+         * @param value1
+         * @param value2
+         */
+        public static multiply(value1: Vector2, value2: Vector2){
+            let result: Vector2 = new Vector2(0, 0);
+            result.x = value1.x * value2.x;
+            result.y = value1.y * value2.y;
+            return result;
+        }
+
+        /**
+         *
+         * @param value1
+         * @param value2
+         */
+        public static subtract(value1: Vector2, value2: Vector2){
+            let result: Vector2 = new Vector2(0, 0);
+            result.x = value1.x - value2.x;
+            result.y = value1.y - value2.y;
+            return result;
+        }
+
+        /** 变成一个方向相同的单位向量 */
+        public normalize(){
+            let val = 1 / Math.sqrt((this.x * this.x) + (this.y * this.y));
+            this.x *= val;
+            this.y *= val;
+        }
+
+        /** 返回它的长度 */
+        public length(){
+            return Math.sqrt((this.x * this.x) + (this.y * this.y));
+        }
+
+        /** 对x和y值四舍五入 */
+        public round(): Vector2{
+            return new Vector2(Math.round(this.x), Math.round(this.y));
+        }
+
+        /**
+         * 创建一个新的Vector2
+         * 它包含来自另一个向量的标准化值。
+         * @param value
+         */
+        public static normalize(value: Vector2){
+            let val = 1 / Math.sqrt((value.x * value.x) + (value.y * value.y));
+            value.x *= val;
+            value.y *= val;
+            return value;
+        }
+
+        /**
+         * 返回两个向量的点积
+         * @param value1
+         * @param value2
+         */
+        public static dot(value1: Vector2, value2: Vector2): number{
+            return (value1.x * value2.x) + (value1.y * value2.y);
+        }
+
+        /**
+         * 返回两个向量之间距离的平方
+         * @param value1
+         * @param value2
+         */
+        public static distanceSquared(value1: Vector2, value2: Vector2){
+            let v1 = value1.x - value2.x, v2 = value1.y - value2.y;
+            return (v1 * v1) + (v2 * v2);
+        }
+
+        /**
+         *
+         * @param value1
+         * @param min
+         * @param max
+         */
+        public static clamp(value1: Vector2, min: Vector2, max: Vector2){
+            return new Vector2(MathHelper.clamp(value1.x, min.x, max.x),
+                MathHelper.clamp(value1.y, min.y, max.y));
+        }
+
+        /**
+         * 包含指定向量的线性插值
+         * @param value1 第一个向量
+         * @param value2 第二个向量
+         * @param amount 权重值(0.0到1.0之间)
+         */
+        public static lerp(value1: Vector2, value2: Vector2, amount: number){
+            return new Vector2(MathHelper.lerp(value1.x, value2.x, amount), MathHelper.lerp(value1.y, value2.y, amount));
+        }
+
+        /**
+         *
+         * @param position
+         * @param matrix
+         */
+        public static transform(position: Vector2, matrix: Matrix2D){
+            return new Vector2((position.x * matrix.m11) + (position.y * matrix.m21), (position.x * matrix.m12) + (position.y * matrix.m22));
+        }
+
+        /**
+         * 返回两个向量之间的距离
+         * @param value1
+         * @param value2
+         */
+        public static distance(value1: Vector2, value2: Vector2){
+            let v1 = value1.x - value2.x, v2 = value1.y - value2.y;
+            return Math.sqrt((v1 * v1) + (v2 * v2));
+        }
+
+        /**
+         * 矢量反演的结果
+         * @param value
+         */
+        public static negate(value: Vector2){
+            let result: Vector2 = new Vector2();
+            result.x = -value.x;
+            result.y = -value.y;
+
+            return result;
+        }
     }
-
-    public static get one(){
-        return Vector2.unitVector2;
-    }
-
-    public static get unitX(){
-        return Vector2.unitXVector;
-    }
-
-    public static get unitY(){
-        return Vector2.unitYVector;
-    }
-
-    /**
-     * 从两个值构造一个带有X和Y的二维向量。
-     * @param x 二维空间中的x坐标
-     * @param y 二维空间的y坐标
-     */
-    constructor(x? : number, y?: number){
-        this.x = x ? x : 0;
-        this.y = y ? y : this.x;
-    }
-
-    /**
-     * 
-     * @param value1 
-     * @param value2 
-     */
-    public static add(value1: Vector2, value2: Vector2){
-        let result: Vector2 = new Vector2(0, 0);
-        result.x = value1.x + value2.x;
-        result.y = value1.y + value2.y;
-        return result;
-    }
-
-    /**
-     * 
-     * @param value1 
-     * @param value2 
-     */
-    public static divide(value1: Vector2, value2: Vector2){
-        let result: Vector2 = new Vector2(0, 0);
-        result.x = value1.x / value2.x;
-        result.y = value1.y / value2.y;
-        return result;
-    }
-
-    /**
-     * 
-     * @param value1 
-     * @param value2 
-     */
-    public static multiply(value1: Vector2, value2: Vector2){
-        let result: Vector2 = new Vector2(0, 0);
-        result.x = value1.x * value2.x;
-        result.y = value1.y * value2.y;
-        return result;
-    }
-
-    /**
-     * 
-     * @param value1 
-     * @param value2 
-     */
-    public static subtract(value1: Vector2, value2: Vector2){
-        let result: Vector2 = new Vector2(0, 0);
-        result.x = value1.x - value2.x;
-        result.y = value1.y - value2.y;
-        return result;
-    }
-
-    /** 变成一个方向相同的单位向量 */
-    public normalize(){
-        let val = 1 / Math.sqrt((this.x * this.x) + (this.y * this.y));
-        this.x *= val;
-        this.y *= val;
-    }
-
-    /** 返回它的长度 */
-    public length(){
-        return Math.sqrt((this.x * this.x) + (this.y * this.y));
-    }
-
-    /** 对x和y值四舍五入 */
-    public round(): Vector2{
-        return new Vector2(Math.round(this.x), Math.round(this.y));
-    }
-
-    /**
-     * 创建一个新的Vector2
-     * 它包含来自另一个向量的标准化值。
-     * @param value 
-     */
-    public static normalize(value: Vector2){
-        let val = 1 / Math.sqrt((value.x * value.x) + (value.y * value.y));
-        value.x *= val;
-        value.y *= val;
-        return value;
-    }
-
-    /**
-     * 返回两个向量的点积
-     * @param value1 
-     * @param value2 
-     */
-    public static dot(value1: Vector2, value2: Vector2): number{
-        return (value1.x * value2.x) + (value1.y * value2.y);
-    }
-
-    /**
-     * 返回两个向量之间距离的平方
-     * @param value1 
-     * @param value2 
-     */
-    public static distanceSquared(value1: Vector2, value2: Vector2){
-        let v1 = value1.x - value2.x, v2 = value1.y - value2.y;
-        return (v1 * v1) + (v2 * v2);
-    }
-
-    /**
-     * 
-     * @param value1 
-     * @param min 
-     * @param max 
-     */
-    public static clamp(value1: Vector2, min: Vector2, max: Vector2){
-        return new Vector2(MathHelper.clamp(value1.x, min.x, max.x),
-            MathHelper.clamp(value1.y, min.y, max.y));
-    }
-
-    /**
-     * 包含指定向量的线性插值
-     * @param value1 第一个向量
-     * @param value2 第二个向量
-     * @param amount 权重值(0.0到1.0之间)
-     */
-    public static lerp(value1: Vector2, value2: Vector2, amount: number){
-        return new Vector2(MathHelper.lerp(value1.x, value2.x, amount), MathHelper.lerp(value1.y, value2.y, amount));
-    }
-
-    /**
-     * 
-     * @param position 
-     * @param matrix 
-     */
-    public static transform(position: Vector2, matrix: Matrix2D){
-        return new Vector2((position.x * matrix.m11) + (position.y * matrix.m21), (position.x * matrix.m12) + (position.y * matrix.m22));
-    }
-
-    /**
-     * 返回两个向量之间的距离
-     * @param value1 
-     * @param value2 
-     */
-    public static distance(value1: Vector2, value2: Vector2){
-        let v1 = value1.x - value2.x, v2 = value1.y - value2.y;
-        return Math.sqrt((v1 * v1) + (v2 * v2));
-    }
-
-    /**
-     * 矢量反演的结果
-     * @param value 
-     */
-    public static negate(value: Vector2){
-        let result: Vector2 = new Vector2();
-        result.x = -value.x;
-        result.y = -value.y;
-
-        return result;
-    }
-}
\ No newline at end of file
+}
diff --git a/source/src/Math/Vector3.ts b/source/src/Math/Vector3.ts
index 7ef18989..72f627c7 100644
--- a/source/src/Math/Vector3.ts
+++ b/source/src/Math/Vector3.ts
@@ -1,11 +1,13 @@
-class Vector3 {
-    public x: number;
-    public y: number;
-    public z: number;
+module es {
+    export class Vector3 {
+        public x: number;
+        public y: number;
+        public z: number;
 
-    constructor(x: number, y: number, z: number){
-        this.x = x;
-        this.y = y;
-        this.z = z;
+        constructor(x: number, y: number, z: number){
+            this.x = x;
+            this.y = y;
+            this.z = z;
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Physics/ColliderTriggerHelper.ts b/source/src/Physics/ColliderTriggerHelper.ts
index 303c678d..c4a5de78 100644
--- a/source/src/Physics/ColliderTriggerHelper.ts
+++ b/source/src/Physics/ColliderTriggerHelper.ts
@@ -1,101 +1,105 @@
-/** 移动器使用的帮助器类，用于管理触发器碰撞器交互并调用itriggerlistener。 */
-class ColliderTriggerHelper {
-    private _entity: Entity;
-    /** 存储当前帧中发生的所有活动交集对 */
-    private _activeTriggerIntersections: Pair<Collider>[] = [];
-    /** 存储前一帧的交叉对，以便我们可以在移动该帧后检测出口 */
-    private _previousTriggerIntersections: Pair<Collider>[] = [];
-    private _tempTriggerList: ITriggerListener[] = [];
-    
-    constructor(entity: Entity) {
-        this._entity = entity;
-    }
-
+module es {
     /**
-     * 实体被移动后，应该调用更新。它会处理碰撞器重叠的任何itriggerlistener。
+     * 移动器使用的帮助器类，用于管理触发器碰撞器交互并调用itriggerlistener
      */
-    public update() {
-        let colliders = this._entity.getComponents(Collider);
-        for (let i = 0; i < colliders.length; i++) {
-            let collider = colliders[i];
+    export class ColliderTriggerHelper {
+        private _entity: Entity;
+        /** 存储当前帧中发生的所有活动交集对 */
+        private _activeTriggerIntersections: Pair<Collider>[] = [];
+        /** 存储前一帧的交叉对，以便我们可以在移动该帧后检测出口 */
+        private _previousTriggerIntersections: Pair<Collider>[] = [];
+        private _tempTriggerList: ITriggerListener[] = [];
 
-            let boxcastResult = Physics.boxcastBroadphase(collider.bounds, collider.collidesWithLayers);
-            collider.bounds = boxcastResult.rect;
-            let neighbors = boxcastResult.colliders;
-            for (let j = 0; j < neighbors.length; j++) {
-                let neighbor = neighbors[j];
-                if (!collider.isTrigger && !neighbor.isTrigger)
-                    continue;
+        constructor(entity: Entity) {
+            this._entity = entity;
+        }
 
-                if (collider.overlaps(neighbor)) {
-                    let pair = new Pair<Collider>(collider, neighbor);
-                    let shouldReportTriggerEvent = this._activeTriggerIntersections.findIndex(value => {
-                        return value.first == pair.first && value.second == pair.second;
-                    }) == -1 && this._previousTriggerIntersections.findIndex(value => {
-                        return value.first == pair.first && value.second == pair.second;
-                    }) == -1;
+        /**
+         * 实体被移动后，应该调用更新。它会处理碰撞器重叠的任何itriggerlistener。
+         */
+        public update() {
+            let colliders = this._entity.getComponents(Collider);
+            for (let i = 0; i < colliders.length; i++) {
+                let collider = colliders[i];
 
-                    if (shouldReportTriggerEvent)
-                        this.notifyTriggerListeners(pair, true);
+                let boxcastResult = Physics.boxcastBroadphase(collider.bounds, collider.collidesWithLayers);
+                collider.bounds = boxcastResult.rect;
+                let neighbors = boxcastResult.colliders;
+                for (let j = 0; j < neighbors.length; j++) {
+                    let neighbor = neighbors[j];
+                    if (!collider.isTrigger && !neighbor.isTrigger)
+                        continue;
 
-                    if (!this._activeTriggerIntersections.contains(pair))
-                        this._activeTriggerIntersections.push(pair);
+                    if (collider.overlaps(neighbor)) {
+                        let pair = new Pair<Collider>(collider, neighbor);
+                        let shouldReportTriggerEvent = this._activeTriggerIntersections.findIndex(value => {
+                            return value.first == pair.first && value.second == pair.second;
+                        }) == -1 && this._previousTriggerIntersections.findIndex(value => {
+                            return value.first == pair.first && value.second == pair.second;
+                        }) == -1;
+
+                        if (shouldReportTriggerEvent)
+                            this.notifyTriggerListeners(pair, true);
+
+                        if (!this._activeTriggerIntersections.contains(pair))
+                            this._activeTriggerIntersections.push(pair);
+                    }
                 }
             }
+
+            ListPool.free(colliders);
+
+            this.checkForExitedColliders();
         }
 
-        ListPool.free(colliders);
+        private checkForExitedColliders(){
+            for (let i = 0; i < this._activeTriggerIntersections.length; i ++){
+                let index = this._previousTriggerIntersections.findIndex(value => {
+                    if (value.first == this._activeTriggerIntersections[i].first && value.second == this._activeTriggerIntersections[i].second)
+                        return true;
 
-        this.checkForExitedColliders();
-    }
-
-    private checkForExitedColliders(){
-        for (let i = 0; i < this._activeTriggerIntersections.length; i ++){
-            let index = this._previousTriggerIntersections.findIndex(value => {
-                if (value.first == this._activeTriggerIntersections[i].first && value.second == this._activeTriggerIntersections[i].second)
-                    return true;
-
-                return false;
-            });
-            if (index != -1)
-                this._previousTriggerIntersections.removeAt(index);
-        }
-
-        for (let i = 0; i < this._previousTriggerIntersections.length; i ++){
-            this.notifyTriggerListeners(this._previousTriggerIntersections[i], false)
-        }
-        this._previousTriggerIntersections.length = 0;
-        for (let i = 0; i < this._activeTriggerIntersections.length; i ++){
-            if (!this._previousTriggerIntersections.contains(this._activeTriggerIntersections[i])){
-                this._previousTriggerIntersections.push(this._activeTriggerIntersections[i]);
-            }
-        }
-        this._activeTriggerIntersections.length = 0;
-    }
-
-    private notifyTriggerListeners(collisionPair: Pair<Collider>, isEntering: boolean) {
-        collisionPair.first.entity.getComponents("ITriggerListener", this._tempTriggerList);
-        for (let i = 0; i < this._tempTriggerList.length; i ++){
-            if (isEntering){
-                this._tempTriggerList[i].onTriggerEnter(collisionPair.second, collisionPair.first);
-            } else {
-                this._tempTriggerList[i].onTriggerExit(collisionPair.second, collisionPair.first);
+                    return false;
+                });
+                if (index != -1)
+                    this._previousTriggerIntersections.removeAt(index);
             }
 
-            this._tempTriggerList.length = 0;
+            for (let i = 0; i < this._previousTriggerIntersections.length; i ++){
+                this.notifyTriggerListeners(this._previousTriggerIntersections[i], false)
+            }
+            this._previousTriggerIntersections.length = 0;
+            for (let i = 0; i < this._activeTriggerIntersections.length; i ++){
+                if (!this._previousTriggerIntersections.contains(this._activeTriggerIntersections[i])){
+                    this._previousTriggerIntersections.push(this._activeTriggerIntersections[i]);
+                }
+            }
+            this._activeTriggerIntersections.length = 0;
+        }
 
-            if (collisionPair.second.entity){
-                collisionPair.second.entity.getComponents("ITriggerListener", this._tempTriggerList);
-                for (let i = 0; i < this._tempTriggerList.length; i ++){
-                    if (isEntering){
-                        this._tempTriggerList[i].onTriggerEnter(collisionPair.first, collisionPair.second);
-                    } else {
-                        this._tempTriggerList[i].onTriggerExit(collisionPair.first, collisionPair.second);
-                    }
+        private notifyTriggerListeners(collisionPair: Pair<Collider>, isEntering: boolean) {
+            collisionPair.first.entity.getComponents("ITriggerListener", this._tempTriggerList);
+            for (let i = 0; i < this._tempTriggerList.length; i ++){
+                if (isEntering){
+                    this._tempTriggerList[i].onTriggerEnter(collisionPair.second, collisionPair.first);
+                } else {
+                    this._tempTriggerList[i].onTriggerExit(collisionPair.second, collisionPair.first);
                 }
 
                 this._tempTriggerList.length = 0;
+
+                if (collisionPair.second.entity){
+                    collisionPair.second.entity.getComponents("ITriggerListener", this._tempTriggerList);
+                    for (let i = 0; i < this._tempTriggerList.length; i ++){
+                        if (isEntering){
+                            this._tempTriggerList[i].onTriggerEnter(collisionPair.first, collisionPair.second);
+                        } else {
+                            this._tempTriggerList[i].onTriggerExit(collisionPair.first, collisionPair.second);
+                        }
+                    }
+
+                    this._tempTriggerList.length = 0;
+                }
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Physics/Collision.ts b/source/src/Physics/Collision.ts
index eed7f5b5..06b14bf5 100644
--- a/source/src/Physics/Collision.ts
+++ b/source/src/Physics/Collision.ts
@@ -1,168 +1,170 @@
-enum PointSectors {
-    center = 0,
-    top = 1,
-    bottom = 2,
-    topLeft = 9,
-    topRight = 5,
-    left = 8,
-    right = 4,
-    bottomLeft = 10,
-    bottomRight = 6
-}
-
-class Collisions {
-    public static isLineToLine(a1: Vector2, a2: Vector2, b1: Vector2, b2: Vector2): boolean {
-        let b = Vector2.subtract(a2, a1);
-        let d = Vector2.subtract(b2, b1);
-        let bDotDPerp = b.x * d.y - b.y * d.x;
-
-        // 如果b*d = 0，表示这两条直线平行，因此有无穷个交点
-        if (bDotDPerp == 0)
-            return false;
-
-        let c = Vector2.subtract(b1, a1);
-        let t = (c.x * d.y - c.y * d.x) / bDotDPerp;
-        if (t < 0 || t > 1)
-            return false;
-
-        let u = (c.x * b.y - c.y * b.x) / bDotDPerp;
-        if (u < 0 || u > 1)
-            return false;
-
-        return true;
+module es {
+    export enum PointSectors {
+        center = 0,
+        top = 1,
+        bottom = 2,
+        topLeft = 9,
+        topRight = 5,
+        left = 8,
+        right = 4,
+        bottomLeft = 10,
+        bottomRight = 6
     }
 
-    public static lineToLineIntersection(a1: Vector2, a2: Vector2, b1: Vector2, b2: Vector2): Vector2 {
-        let intersection = new Vector2(0, 0);
+    export class Collisions {
+        public static isLineToLine(a1: Vector2, a2: Vector2, b1: Vector2, b2: Vector2): boolean {
+            let b = Vector2.subtract(a2, a1);
+            let d = Vector2.subtract(b2, b1);
+            let bDotDPerp = b.x * d.y - b.y * d.x;
 
-        let b = Vector2.subtract(a2, a1);
-        let d = Vector2.subtract(b2, b1);
-        let bDotDPerp = b.x * d.y - b.y * d.x;
+            // 如果b*d = 0，表示这两条直线平行，因此有无穷个交点
+            if (bDotDPerp == 0)
+                return false;
 
-        // 如果b*d = 0，表示这两条直线平行，因此有无穷个交点
-        if (bDotDPerp == 0)
-            return intersection;
+            let c = Vector2.subtract(b1, a1);
+            let t = (c.x * d.y - c.y * d.x) / bDotDPerp;
+            if (t < 0 || t > 1)
+                return false;
 
-        let c = Vector2.subtract(b1, a1);
-        let t = (c.x * d.y - c.y * d.x) / bDotDPerp;
-        if (t < 0 || t > 1)
-            return intersection;
+            let u = (c.x * b.y - c.y * b.x) / bDotDPerp;
+            if (u < 0 || u > 1)
+                return false;
 
-        let u = (c.x * b.y - c.y * b.x) / bDotDPerp;
-        if (u < 0 || u > 1)
-            return intersection;
-
-        intersection = Vector2.add(a1, new Vector2(t * b.x, t * b.y));
-
-        return intersection;
-    }
-
-    public static closestPointOnLine(lineA: Vector2, lineB: Vector2, closestTo: Vector2) {
-        let v = Vector2.subtract(lineB, lineA);
-        let w = Vector2.subtract(closestTo, lineA);
-        let t = Vector2.dot(w, v) / Vector2.dot(v, v);
-        t = MathHelper.clamp(t, 0, 1);
-
-        return Vector2.add(lineA, new Vector2(v.x * t, v.y * t));
-    }
-
-    public static isCircleToCircle(circleCenter1: Vector2, circleRadius1: number, circleCenter2: Vector2, circleRadius2: number): boolean {
-        return Vector2.distanceSquared(circleCenter1, circleCenter2) < (circleRadius1 + circleRadius2) * (circleRadius1 + circleRadius2);
-    }
-
-    public static isCircleToLine(circleCenter: Vector2, radius: number, lineFrom: Vector2, lineTo: Vector2): boolean {
-        return Vector2.distanceSquared(circleCenter, this.closestPointOnLine(lineFrom, lineTo, circleCenter)) < radius * radius;
-    }
-
-    public static isCircleToPoint(circleCenter: Vector2, radius: number, point: Vector2): boolean {
-        return Vector2.distanceSquared(circleCenter, point) < radius * radius;
-    }
-
-    public static isRectToCircle(rect: egret.Rectangle, cPosition: Vector2, cRadius: number): boolean {
-        let ew = rect.width * 0.5;
-        let eh = rect.height * 0.5;
-        let vx = Math.max(0, Math.max(cPosition.x - rect.x) - ew);
-        let vy = Math.max(0, Math.max(cPosition.y - rect.y) - eh);
-
-        return vx * vx + vy * vy < cRadius * cRadius;
-    }
-
-    public static isRectToLine(rect: Rectangle, lineFrom: Vector2, lineTo: Vector2){
-        let fromSector = this.getSector(rect.x, rect.y, rect.width, rect.height, lineFrom);
-        let toSector = this.getSector(rect.x, rect.y, rect.width, rect.height, lineTo);
-
-        if (fromSector == PointSectors.center || toSector == PointSectors.center){
             return true;
-        } else if((fromSector & toSector) != 0){
-            return false;
-        } else{
-            let both = fromSector | toSector;
-            // 线对边进行检查
-            let edgeFrom: Vector2;
-            let edgeTo: Vector2;
-
-            if ((both & PointSectors.top) != 0){
-                edgeFrom = new Vector2(rect.x, rect.y);
-                edgeTo = new Vector2(rect.x + rect.width, rect.y);
-                if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
-                    return true;
-            }
-
-            if ((both & PointSectors.bottom) != 0){
-                edgeFrom = new Vector2(rect.x, rect.y + rect.height);
-                edgeTo = new Vector2(rect.x + rect.width, rect.y + rect.height);
-                if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
-                    return true;
-            }
-
-            if ((both & PointSectors.left) != 0){
-                edgeFrom = new Vector2(rect.x, rect.y);
-                edgeTo = new Vector2(rect.x, rect.y + rect.height);
-                if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
-                    return true;
-            }
-
-            if ((both & PointSectors.right) != 0){
-                edgeFrom = new Vector2(rect.x + rect.width, rect.y);
-                edgeTo = new Vector2(rect.x + rect.width, rect.y + rect.height);
-                if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
-                    return true;
-            }
         }
 
-        return false;
+        public static lineToLineIntersection(a1: Vector2, a2: Vector2, b1: Vector2, b2: Vector2): Vector2 {
+            let intersection = new Vector2(0, 0);
+
+            let b = Vector2.subtract(a2, a1);
+            let d = Vector2.subtract(b2, b1);
+            let bDotDPerp = b.x * d.y - b.y * d.x;
+
+            // 如果b*d = 0，表示这两条直线平行，因此有无穷个交点
+            if (bDotDPerp == 0)
+                return intersection;
+
+            let c = Vector2.subtract(b1, a1);
+            let t = (c.x * d.y - c.y * d.x) / bDotDPerp;
+            if (t < 0 || t > 1)
+                return intersection;
+
+            let u = (c.x * b.y - c.y * b.x) / bDotDPerp;
+            if (u < 0 || u > 1)
+                return intersection;
+
+            intersection = Vector2.add(a1, new Vector2(t * b.x, t * b.y));
+
+            return intersection;
+        }
+
+        public static closestPointOnLine(lineA: Vector2, lineB: Vector2, closestTo: Vector2) {
+            let v = Vector2.subtract(lineB, lineA);
+            let w = Vector2.subtract(closestTo, lineA);
+            let t = Vector2.dot(w, v) / Vector2.dot(v, v);
+            t = MathHelper.clamp(t, 0, 1);
+
+            return Vector2.add(lineA, new Vector2(v.x * t, v.y * t));
+        }
+
+        public static isCircleToCircle(circleCenter1: Vector2, circleRadius1: number, circleCenter2: Vector2, circleRadius2: number): boolean {
+            return Vector2.distanceSquared(circleCenter1, circleCenter2) < (circleRadius1 + circleRadius2) * (circleRadius1 + circleRadius2);
+        }
+
+        public static isCircleToLine(circleCenter: Vector2, radius: number, lineFrom: Vector2, lineTo: Vector2): boolean {
+            return Vector2.distanceSquared(circleCenter, this.closestPointOnLine(lineFrom, lineTo, circleCenter)) < radius * radius;
+        }
+
+        public static isCircleToPoint(circleCenter: Vector2, radius: number, point: Vector2): boolean {
+            return Vector2.distanceSquared(circleCenter, point) < radius * radius;
+        }
+
+        public static isRectToCircle(rect: egret.Rectangle, cPosition: Vector2, cRadius: number): boolean {
+            let ew = rect.width * 0.5;
+            let eh = rect.height * 0.5;
+            let vx = Math.max(0, Math.max(cPosition.x - rect.x) - ew);
+            let vy = Math.max(0, Math.max(cPosition.y - rect.y) - eh);
+
+            return vx * vx + vy * vy < cRadius * cRadius;
+        }
+
+        public static isRectToLine(rect: Rectangle, lineFrom: Vector2, lineTo: Vector2){
+            let fromSector = this.getSector(rect.x, rect.y, rect.width, rect.height, lineFrom);
+            let toSector = this.getSector(rect.x, rect.y, rect.width, rect.height, lineTo);
+
+            if (fromSector == PointSectors.center || toSector == PointSectors.center){
+                return true;
+            } else if((fromSector & toSector) != 0){
+                return false;
+            } else{
+                let both = fromSector | toSector;
+                // 线对边进行检查
+                let edgeFrom: Vector2;
+                let edgeTo: Vector2;
+
+                if ((both & PointSectors.top) != 0){
+                    edgeFrom = new Vector2(rect.x, rect.y);
+                    edgeTo = new Vector2(rect.x + rect.width, rect.y);
+                    if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
+                        return true;
+                }
+
+                if ((both & PointSectors.bottom) != 0){
+                    edgeFrom = new Vector2(rect.x, rect.y + rect.height);
+                    edgeTo = new Vector2(rect.x + rect.width, rect.y + rect.height);
+                    if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
+                        return true;
+                }
+
+                if ((both & PointSectors.left) != 0){
+                    edgeFrom = new Vector2(rect.x, rect.y);
+                    edgeTo = new Vector2(rect.x, rect.y + rect.height);
+                    if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
+                        return true;
+                }
+
+                if ((both & PointSectors.right) != 0){
+                    edgeFrom = new Vector2(rect.x + rect.width, rect.y);
+                    edgeTo = new Vector2(rect.x + rect.width, rect.y + rect.height);
+                    if (this.isLineToLine(edgeFrom, edgeTo, lineFrom, lineTo))
+                        return true;
+                }
+            }
+
+            return false;
+        }
+
+        public static isRectToPoint(rX: number, rY: number, rW: number, rH: number, point: Vector2) {
+            return point.x >= rX && point.y >= rY && point.x < rX + rW && point.y < rY + rH;
+        }
+
+        /**
+         * 位标志和帮助使用Cohen–Sutherland算法
+         *
+         * 位标志:
+         * 1001 1000 1010
+         * 0001 0000 0010
+         * 0101 0100 0110
+         * @param rX
+         * @param rY
+         * @param rW
+         * @param rH
+         * @param point
+         */
+        public static getSector(rX: number, rY: number, rW: number, rH: number, point: Vector2): PointSectors {
+            let sector = PointSectors.center;
+
+            if (point.x < rX)
+                sector |= PointSectors.left;
+            else if (point.x >= rX + rW)
+                sector |= PointSectors.right;
+
+            if (point.y < rY)
+                sector |= PointSectors.top;
+            else if (point.y >= rY + rH)
+                sector |= PointSectors.bottom;
+
+            return sector;
+        }
     }
-
-    public static isRectToPoint(rX: number, rY: number, rW: number, rH: number, point: Vector2) {
-        return point.x >= rX && point.y >= rY && point.x < rX + rW && point.y < rY + rH;
-    }
-
-    /**
-     * 位标志和帮助使用Cohen–Sutherland算法
-     * 
-     * 位标志:
-     * 1001 1000 1010
-     * 0001 0000 0010
-     * 0101 0100 0110
-     * @param rX 
-     * @param rY 
-     * @param rW 
-     * @param rH 
-     * @param point 
-     */
-    public static getSector(rX: number, rY: number, rW: number, rH: number, point: Vector2): PointSectors {
-        let sector = PointSectors.center;
-
-        if (point.x < rX)
-            sector |= PointSectors.left;
-        else if (point.x >= rX + rW)
-            sector |= PointSectors.right;
-
-        if (point.y < rY)
-            sector |= PointSectors.top;
-        else if (point.y >= rY + rH)
-            sector |= PointSectors.bottom;
-
-        return sector;
-    }
-}
\ No newline at end of file
+}
diff --git a/source/src/Physics/Physics.ts b/source/src/Physics/Physics.ts
index 08757b42..57be0921 100644
--- a/source/src/Physics/Physics.ts
+++ b/source/src/Physics/Physics.ts
@@ -1,64 +1,66 @@
-class Physics {
-    private static _spatialHash: SpatialHash;
-    /** 调用reset并创建一个新的SpatialHash时使用的单元格大小 */
-    public static spatialHashCellSize = 100;
-    /** 接受layerMask的所有方法的默认值 */
-    public static readonly allLayers: number = -1;
+module es {
+    export class Physics {
+        private static _spatialHash: SpatialHash;
+        /** 调用reset并创建一个新的SpatialHash时使用的单元格大小 */
+        public static spatialHashCellSize = 100;
+        /** 接受layerMask的所有方法的默认值 */
+        public static readonly allLayers: number = -1;
 
-    public static reset(){
-        this._spatialHash = new SpatialHash(this.spatialHashCellSize);
-    }
+        public static reset(){
+            this._spatialHash = new SpatialHash(this.spatialHashCellSize);
+        }
 
-    /**
-     * 从SpatialHash中移除所有碰撞器
-     */
-    public static clear(){
-        this._spatialHash.clear();
-    }
+        /**
+         * 从SpatialHash中移除所有碰撞器
+         */
+        public static clear(){
+            this._spatialHash.clear();
+        }
 
-    public static overlapCircleAll(center: Vector2, randius: number, results: any[], layerMask = -1){
-        return this._spatialHash.overlapCircle(center, randius, results, layerMask);
-    }
+        public static overlapCircleAll(center: Vector2, randius: number, results: any[], layerMask = -1){
+            return this._spatialHash.overlapCircle(center, randius, results, layerMask);
+        }
 
-    public static boxcastBroadphase(rect: Rectangle, layerMask: number = this.allLayers){
-        let boxcastResult = this._spatialHash.aabbBroadphase(rect, null, layerMask);
-        return {colliders: boxcastResult.tempHashSet, rect: boxcastResult.bounds};
-    }
+        public static boxcastBroadphase(rect: Rectangle, layerMask: number = this.allLayers){
+            let boxcastResult = this._spatialHash.aabbBroadphase(rect, null, layerMask);
+            return {colliders: boxcastResult.tempHashSet, rect: boxcastResult.bounds};
+        }
 
-    public static boxcastBroadphaseExcludingSelf(collider: Collider, rect: Rectangle, layerMask = this.allLayers){
-        return this._spatialHash.aabbBroadphase(rect, collider, layerMask);
-    }
+        public static boxcastBroadphaseExcludingSelf(collider: Collider, rect: Rectangle, layerMask = this.allLayers){
+            return this._spatialHash.aabbBroadphase(rect, collider, layerMask);
+        }
 
-    /**
-     * 将对撞机添加到物理系统中
-     * @param collider 
-     */
-    public static addCollider(collider: Collider){
-        Physics._spatialHash.register(collider);
-    }
+        /**
+         * 将对撞机添加到物理系统中
+         * @param collider
+         */
+        public static addCollider(collider: Collider){
+            Physics._spatialHash.register(collider);
+        }
 
-    /**
-     * 从物理系统中移除对撞机
-     * @param collider 
-     */
-    public static removeCollider(collider: Collider){
-        Physics._spatialHash.remove(collider);
-    }
+        /**
+         * 从物理系统中移除对撞机
+         * @param collider
+         */
+        public static removeCollider(collider: Collider){
+            Physics._spatialHash.remove(collider);
+        }
 
-    /**
-     * 更新物理系统中对撞机的位置。这实际上只是移除然后重新添加带有新边界的碰撞器
-     * @param collider 
-     */
-    public static updateCollider(collider: Collider){
-        this._spatialHash.remove(collider);
-        this._spatialHash.register(collider);
-    }
+        /**
+         * 更新物理系统中对撞机的位置。这实际上只是移除然后重新添加带有新边界的碰撞器
+         * @param collider
+         */
+        public static updateCollider(collider: Collider){
+            this._spatialHash.remove(collider);
+            this._spatialHash.register(collider);
+        }
 
-    /**
-     * debug绘制空间散列的内容
-     * @param secondsToDisplay 
-     */
-    public static debugDraw(secondsToDisplay){
-        this._spatialHash.debugDraw(secondsToDisplay, 2);
+        /**
+         * debug绘制空间散列的内容
+         * @param secondsToDisplay
+         */
+        public static debugDraw(secondsToDisplay){
+            this._spatialHash.debugDraw(secondsToDisplay, 2);
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Physics/Shapes/CollisionResult.ts b/source/src/Physics/Shapes/CollisionResult.ts
index 3593068c..50a78dcc 100644
--- a/source/src/Physics/Shapes/CollisionResult.ts
+++ b/source/src/Physics/Shapes/CollisionResult.ts
@@ -1,11 +1,13 @@
-class CollisionResult {
-    public collider: Collider;
-    public minimumTranslationVector: Vector2 = Vector2.zero;
-    public normal: Vector2 = Vector2.zero;
-    public point: Vector2 = Vector2.zero;
+module es {
+    export class CollisionResult {
+        public collider: Collider;
+        public minimumTranslationVector: Vector2 = Vector2.zero;
+        public normal: Vector2 = Vector2.zero;
+        public point: Vector2 = Vector2.zero;
 
-    public invertResult(){
-        this.minimumTranslationVector = Vector2.negate(this.minimumTranslationVector);
-        this.normal = Vector2.negate(this.normal);
+        public invertResult(){
+            this.minimumTranslationVector = Vector2.negate(this.minimumTranslationVector);
+            this.normal = Vector2.negate(this.normal);
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Physics/Shapes/ShapeCollisions/ShapeCollisions.ts b/source/src/Physics/Shapes/ShapeCollisions/ShapeCollisions.ts
index 4f55d338..fd6e5659 100644
--- a/source/src/Physics/Shapes/ShapeCollisions/ShapeCollisions.ts
+++ b/source/src/Physics/Shapes/ShapeCollisions/ShapeCollisions.ts
@@ -1,302 +1,304 @@
-class ShapeCollisions {
-    /**
-     * 检查两个多边形之间的碰撞
-     * @param first 
-     * @param second 
-     */
-    public static polygonToPolygon(first: Polygon, second: Polygon) {
-        let result = new CollisionResult();
-        let isIntersecting = true;
+module es {
+    export class ShapeCollisions {
+        /**
+         * 检查两个多边形之间的碰撞
+         * @param first
+         * @param second
+         */
+        public static polygonToPolygon(first: Polygon, second: Polygon) {
+            let result = new CollisionResult();
+            let isIntersecting = true;
 
-        let firstEdges = first.edgeNormals;
-        let secondEdges = second.edgeNormals;
-        let minIntervalDistance = Number.POSITIVE_INFINITY;
-        let translationAxis = new Vector2();
-        let polygonOffset = Vector2.subtract(first.position, second.position);
-        let axis: Vector2;
+            let firstEdges = first.edgeNormals;
+            let secondEdges = second.edgeNormals;
+            let minIntervalDistance = Number.POSITIVE_INFINITY;
+            let translationAxis = new Vector2();
+            let polygonOffset = Vector2.subtract(first.position, second.position);
+            let axis: Vector2;
 
-        // 循环穿过两个多边形的所有边
-        for (let edgeIndex = 0; edgeIndex < firstEdges.length + secondEdges.length; edgeIndex++) {
-            // 1. 找出当前多边形是否相交
-            // 多边形的归一化轴垂直于缓存给我们的当前边
-            if (edgeIndex < firstEdges.length) {
-                axis = firstEdges[edgeIndex];
-            } else {
-                axis = secondEdges[edgeIndex - firstEdges.length];
+            // 循环穿过两个多边形的所有边
+            for (let edgeIndex = 0; edgeIndex < firstEdges.length + secondEdges.length; edgeIndex++) {
+                // 1. 找出当前多边形是否相交
+                // 多边形的归一化轴垂直于缓存给我们的当前边
+                if (edgeIndex < firstEdges.length) {
+                    axis = firstEdges[edgeIndex];
+                } else {
+                    axis = secondEdges[edgeIndex - firstEdges.length];
+                }
+
+                // 求多边形在当前轴上的投影
+                let minA = 0;
+                let minB = 0;
+                let maxA = 0;
+                let maxB = 0;
+                let intervalDist = 0;
+                let ta = this.getInterval(axis, first, minA, maxA);
+                minA = ta.min;
+                minB = ta.max;
+                let tb = this.getInterval(axis, second, minB, maxB);
+                minB = tb.min;
+                maxB = tb.max;
+
+                // 将区间设为第二个多边形的空间。由轴上投影的位置差偏移。
+                let relativeIntervalOffset = Vector2.dot(polygonOffset, axis);
+                minA += relativeIntervalOffset;
+                maxA += relativeIntervalOffset;
+
+                // 检查多边形投影是否正在相交
+                intervalDist = this.intervalDistance(minA, maxA, minB, maxB);
+                if (intervalDist > 0)
+                    isIntersecting = false;
+
+                // 对于多对多数据类型转换，添加一个Vector2?参数称为deltaMovement。为了提高速度，我们这里不使用它
+                // TODO: 现在找出多边形是否会相交。只要检查速度就行了
+
+                // 如果多边形不相交，也不会相交，退出循环
+                if (!isIntersecting)
+                    return null;
+
+                // 检查当前间隔距离是否为最小值。如果是，则存储间隔距离和当前距离。这将用于计算最小平移向量
+                intervalDist = Math.abs(intervalDist);
+                if (intervalDist < minIntervalDistance) {
+                    minIntervalDistance = intervalDist;
+                    translationAxis = axis;
+
+                    if (Vector2.dot(translationAxis, polygonOffset) < 0)
+                        translationAxis = new Vector2(-translationAxis);
+                }
             }
 
-            // 求多边形在当前轴上的投影
-            let minA = 0;
-            let minB = 0;
-            let maxA = 0;
-            let maxB = 0;
-            let intervalDist = 0;
-            let ta = this.getInterval(axis, first, minA, maxA);
-            minA = ta.min;
-            minB = ta.max;
-            let tb = this.getInterval(axis, second, minB, maxB);
-            minB = tb.min;
-            maxB = tb.max;
-
-            // 将区间设为第二个多边形的空间。由轴上投影的位置差偏移。
-            let relativeIntervalOffset = Vector2.dot(polygonOffset, axis);
-            minA += relativeIntervalOffset;
-            maxA += relativeIntervalOffset;
-
-            // 检查多边形投影是否正在相交
-            intervalDist = this.intervalDistance(minA, maxA, minB, maxB);
-            if (intervalDist > 0)
-                isIntersecting = false;
-
-            // 对于多对多数据类型转换，添加一个Vector2?参数称为deltaMovement。为了提高速度，我们这里不使用它
-            // TODO: 现在找出多边形是否会相交。只要检查速度就行了
-
-            // 如果多边形不相交，也不会相交，退出循环
-            if (!isIntersecting)
-                return null;
-
-            // 检查当前间隔距离是否为最小值。如果是，则存储间隔距离和当前距离。这将用于计算最小平移向量
-            intervalDist = Math.abs(intervalDist);
-            if (intervalDist < minIntervalDistance) {
-                minIntervalDistance = intervalDist;
-                translationAxis = axis;
-
-                if (Vector2.dot(translationAxis, polygonOffset) < 0)
-                    translationAxis = new Vector2(-translationAxis);
-            }
-        }
-
-        // 利用最小平移向量对多边形进行推入。
-        result.normal = translationAxis;
-        result.minimumTranslationVector = Vector2.multiply(new Vector2(-translationAxis.x, -translationAxis.y), new Vector2(minIntervalDistance));
-
-        return result;
-    }
-
-    /**
-     * 计算[minA, maxA]和[minB, maxB]之间的距离。如果间隔重叠，距离是负的
-     * @param minA 
-     * @param maxA 
-     * @param minB 
-     * @param maxB 
-     */
-    public static intervalDistance(minA: number, maxA: number, minB: number, maxB) {
-        if (minA < minB)
-            return minB - maxA;
-
-        return minA - minB;
-    }
-
-    /**
-     * 计算一个多边形在一个轴上的投影，并返回一个[min，max]区间
-     * @param axis 
-     * @param polygon 
-     * @param min 
-     * @param max 
-     */
-    public static getInterval(axis: Vector2, polygon: Polygon, min: number, max: number) {
-        let dot = Vector2.dot(polygon.points[0], axis);
-        min = max = dot;
-
-        for (let i = 1; i < polygon.points.length; i++) {
-            dot = Vector2.dot(polygon.points[i], axis);
-            if (dot < min) {
-                min = dot;
-            } else if (dot > max) {
-                max = dot;
-            }
-        }
-
-        return { min: min, max: max };
-    }
-
-    /**
-     * 
-     * @param circle 
-     * @param polygon 
-     */
-    public static circleToPolygon(circle: Circle, polygon: Polygon) {
-        let result = new CollisionResult();
-
-        let poly2Circle = Vector2.subtract(circle.position, polygon.position);
-
-        let gpp = Polygon.getClosestPointOnPolygonToPoint(polygon.points, poly2Circle);
-        let closestPoint: Vector2 = gpp.closestPoint;
-        let distanceSquared: number = gpp.distanceSquared;
-        result.normal = gpp.edgeNormal;
-
-        let circleCenterInsidePoly = polygon.containsPoint(circle.position);
-        if (distanceSquared > circle.radius * circle.radius && !circleCenterInsidePoly)
-            return null;
-
-        let mtv: Vector2;
-        if (circleCenterInsidePoly) {
-            mtv = Vector2.multiply(result.normal, new Vector2(Math.sqrt(distanceSquared) - circle.radius));
-        } else {
-            if (distanceSquared == 0) {
-                mtv = Vector2.multiply(result.normal, new Vector2(circle.radius));
-            } else {
-                let distance = Math.sqrt(distanceSquared);
-                mtv = Vector2.multiply(new Vector2(-Vector2.subtract(poly2Circle, closestPoint)), new Vector2((circle.radius - distanceSquared) / distance));
-            }
-        }
-
-        result.minimumTranslationVector = mtv;
-        result.point = Vector2.add(closestPoint, polygon.position);
-
-        return result;
-    }
-
-    /**
-     * 适用于圆心在方框内以及只与方框外圆心重叠的圆。
-     * @param circle 
-     * @param box 
-     */
-    public static circleToBox(circle: Circle, box: Box): CollisionResult {
-        let result = new CollisionResult();
-        let closestPointOnBounds = box.bounds.getClosestPointOnRectangleBorderToPoint(circle.position).res;
-
-        if (box.containsPoint(circle.position)) {
-            result.point = closestPointOnBounds;
-
-            let safePlace = Vector2.add(closestPointOnBounds, Vector2.subtract(result.normal, new Vector2(circle.radius)));
-            result.minimumTranslationVector = Vector2.subtract(circle.position, safePlace);
+            // 利用最小平移向量对多边形进行推入。
+            result.normal = translationAxis;
+            result.minimumTranslationVector = Vector2.multiply(new Vector2(-translationAxis.x, -translationAxis.y), new Vector2(minIntervalDistance));
 
             return result;
         }
 
-        let sqrDistance = Vector2.distanceSquared(closestPointOnBounds, circle.position);
-        if (sqrDistance == 0) {
-            result.minimumTranslationVector = Vector2.multiply(result.normal, new Vector2(circle.radius));
-        } else if (sqrDistance <= circle.radius * circle.radius) {
-            result.normal = Vector2.subtract(circle.position, closestPointOnBounds);
-            let depth = result.normal.length() - circle.radius;
-            result.normal = Vector2Ext.normalize(result.normal);
-            result.minimumTranslationVector = Vector2.multiply(new Vector2(depth), result.normal);
+        /**
+         * 计算[minA, maxA]和[minB, maxB]之间的距离。如果间隔重叠，距离是负的
+         * @param minA
+         * @param maxA
+         * @param minB
+         * @param maxB
+         */
+        public static intervalDistance(minA: number, maxA: number, minB: number, maxB) {
+            if (minA < minB)
+                return minB - maxA;
 
-            return result;
+            return minA - minB;
         }
 
-        return null;
-    }
+        /**
+         * 计算一个多边形在一个轴上的投影，并返回一个[min，max]区间
+         * @param axis
+         * @param polygon
+         * @param min
+         * @param max
+         */
+        public static getInterval(axis: Vector2, polygon: Polygon, min: number, max: number) {
+            let dot = Vector2.dot(polygon.points[0], axis);
+            min = max = dot;
 
-    /**
-     * 
-     * @param point 
-     * @param circle 
-     */
-    public static pointToCircle(point: Vector2, circle: Circle) {
-        let result = new CollisionResult();
+            for (let i = 1; i < polygon.points.length; i++) {
+                dot = Vector2.dot(polygon.points[i], axis);
+                if (dot < min) {
+                    min = dot;
+                } else if (dot > max) {
+                    max = dot;
+                }
+            }
 
-        let distanceSquared = Vector2.distanceSquared(point, circle.position);
-        let sumOfRadii = 1 + circle.radius;
-        let collided = distanceSquared < sumOfRadii * sumOfRadii;
-        if (collided) {
-            result.normal = Vector2.normalize(Vector2.subtract(point, circle.position));
-            let depth = sumOfRadii - Math.sqrt(distanceSquared);
-            result.minimumTranslationVector = Vector2.multiply(new Vector2(-depth, -depth), result.normal);
-            result.point = Vector2.add(circle.position, Vector2.multiply(result.normal, new Vector2(circle.radius, circle.radius)));
-
-            return result;
+            return { min: min, max: max };
         }
 
-        return null;
-    }
+        /**
+         *
+         * @param circle
+         * @param polygon
+         */
+        public static circleToPolygon(circle: Circle, polygon: Polygon) {
+            let result = new CollisionResult();
 
-    /**
-     * 
-     * @param lineA 
-     * @param lineB 
-     * @param closestTo 
-     */
-    public static closestPointOnLine(lineA: Vector2, lineB: Vector2, closestTo: Vector2) {
-        let v = Vector2.subtract(lineB, lineA);
-        let w = Vector2.subtract(closestTo, lineA);
-        let t = Vector2.dot(w, v) / Vector2.dot(v, v);
-        t = MathHelper.clamp(t, 0, 1);
+            let poly2Circle = Vector2.subtract(circle.position, polygon.position);
 
-        return Vector2.add(lineA, Vector2.multiply(v, new Vector2(t, t)));
-    }
-
-    /**
-     * 
-     * @param point 
-     * @param poly 
-     */
-    public static pointToPoly(point: Vector2, poly: Polygon) {
-        let result = new CollisionResult();
-
-        if (poly.containsPoint(point)) {
-            let distanceSquared: number;
-            let gpp = Polygon.getClosestPointOnPolygonToPoint(poly.points, Vector2.subtract(point, poly.position));
-            let closestPoint = gpp.closestPoint;
-            distanceSquared = gpp.distanceSquared;
+            let gpp = Polygon.getClosestPointOnPolygonToPoint(polygon.points, poly2Circle);
+            let closestPoint: Vector2 = gpp.closestPoint;
+            let distanceSquared: number = gpp.distanceSquared;
             result.normal = gpp.edgeNormal;
 
-            result.minimumTranslationVector = Vector2.multiply(result.normal, new Vector2(Math.sqrt(distanceSquared), Math.sqrt(distanceSquared)));
-            result.point = Vector2.add(closestPoint, poly.position);
-
-            return result;
-        }
-
-        return null;
-    }
-
-    /**
-     * 
-     * @param first 
-     * @param second 
-     */
-    public static circleToCircle(first: Circle, second: Circle){
-        let result = new CollisionResult();
-
-        let distanceSquared = Vector2.distanceSquared(first.position, second.position);
-        let sumOfRadii = first.radius + second.radius;
-        let collided = distanceSquared < sumOfRadii * sumOfRadii;
-        if (collided){
-            result.normal = Vector2.normalize(Vector2.subtract(first.position, second.position));
-            let depth = sumOfRadii - Math.sqrt(distanceSquared);
-            result.minimumTranslationVector = Vector2.multiply(new Vector2(-depth), result.normal);
-            result.point = Vector2.add(second.position, Vector2.multiply(result.normal, new Vector2(second.radius)));
-
-            return result;
-        }
-
-        return null;
-    }
-
-    /**
-     * 
-     * @param first 
-     * @param second 
-     */
-    public static boxToBox(first: Box, second: Box){
-        let result = new CollisionResult();
-
-        let minkowskiDiff = this.minkowskiDifference(first, second);
-        if (minkowskiDiff.contains(0, 0)){
-            // 计算MTV。如果它是零，我们就可以称它为非碰撞
-            result.minimumTranslationVector = minkowskiDiff.getClosestPointOnBoundsToOrigin();
-
-            if (result.minimumTranslationVector.x == 0 && result.minimumTranslationVector.y == 0)
+            let circleCenterInsidePoly = polygon.containsPoint(circle.position);
+            if (distanceSquared > circle.radius * circle.radius && !circleCenterInsidePoly)
                 return null;
-            
-            result.normal = new Vector2(-result.minimumTranslationVector.x, -result.minimumTranslationVector.y);
-            result.normal.normalize();
+
+            let mtv: Vector2;
+            if (circleCenterInsidePoly) {
+                mtv = Vector2.multiply(result.normal, new Vector2(Math.sqrt(distanceSquared) - circle.radius));
+            } else {
+                if (distanceSquared == 0) {
+                    mtv = Vector2.multiply(result.normal, new Vector2(circle.radius));
+                } else {
+                    let distance = Math.sqrt(distanceSquared);
+                    mtv = Vector2.multiply(new Vector2(-Vector2.subtract(poly2Circle, closestPoint)), new Vector2((circle.radius - distanceSquared) / distance));
+                }
+            }
+
+            result.minimumTranslationVector = mtv;
+            result.point = Vector2.add(closestPoint, polygon.position);
 
             return result;
         }
 
-        return null;
-    }
+        /**
+         * 适用于圆心在方框内以及只与方框外圆心重叠的圆。
+         * @param circle
+         * @param box
+         */
+        public static circleToBox(circle: Circle, box: Box): CollisionResult {
+            let result = new CollisionResult();
+            let closestPointOnBounds = box.bounds.getClosestPointOnRectangleBorderToPoint(circle.position).res;
 
-    private static minkowskiDifference(first: Box, second: Box){
-        // 我们需要第一个框的左上角
-        // 碰撞器只会修改运动的位置所以我们需要用位置来计算出运动是什么。
-        let positionOffset = Vector2.subtract(first.position, Vector2.add(first.bounds.location, Vector2.divide(first.bounds.size, new Vector2(2))));
-        let topLeft = Vector2.subtract(Vector2.add(first.bounds.location, positionOffset), second.bounds.max);
-        let fullSize = Vector2.add(first.bounds.size, second.bounds.size);
+            if (box.containsPoint(circle.position)) {
+                result.point = closestPointOnBounds;
 
-        return new Rectangle(topLeft.x, topLeft.y, fullSize.x, fullSize.y)
+                let safePlace = Vector2.add(closestPointOnBounds, Vector2.subtract(result.normal, new Vector2(circle.radius)));
+                result.minimumTranslationVector = Vector2.subtract(circle.position, safePlace);
+
+                return result;
+            }
+
+            let sqrDistance = Vector2.distanceSquared(closestPointOnBounds, circle.position);
+            if (sqrDistance == 0) {
+                result.minimumTranslationVector = Vector2.multiply(result.normal, new Vector2(circle.radius));
+            } else if (sqrDistance <= circle.radius * circle.radius) {
+                result.normal = Vector2.subtract(circle.position, closestPointOnBounds);
+                let depth = result.normal.length() - circle.radius;
+                result.normal = Vector2Ext.normalize(result.normal);
+                result.minimumTranslationVector = Vector2.multiply(new Vector2(depth), result.normal);
+
+                return result;
+            }
+
+            return null;
+        }
+
+        /**
+         *
+         * @param point
+         * @param circle
+         */
+        public static pointToCircle(point: Vector2, circle: Circle) {
+            let result = new CollisionResult();
+
+            let distanceSquared = Vector2.distanceSquared(point, circle.position);
+            let sumOfRadii = 1 + circle.radius;
+            let collided = distanceSquared < sumOfRadii * sumOfRadii;
+            if (collided) {
+                result.normal = Vector2.normalize(Vector2.subtract(point, circle.position));
+                let depth = sumOfRadii - Math.sqrt(distanceSquared);
+                result.minimumTranslationVector = Vector2.multiply(new Vector2(-depth, -depth), result.normal);
+                result.point = Vector2.add(circle.position, Vector2.multiply(result.normal, new Vector2(circle.radius, circle.radius)));
+
+                return result;
+            }
+
+            return null;
+        }
+
+        /**
+         *
+         * @param lineA
+         * @param lineB
+         * @param closestTo
+         */
+        public static closestPointOnLine(lineA: Vector2, lineB: Vector2, closestTo: Vector2) {
+            let v = Vector2.subtract(lineB, lineA);
+            let w = Vector2.subtract(closestTo, lineA);
+            let t = Vector2.dot(w, v) / Vector2.dot(v, v);
+            t = MathHelper.clamp(t, 0, 1);
+
+            return Vector2.add(lineA, Vector2.multiply(v, new Vector2(t, t)));
+        }
+
+        /**
+         *
+         * @param point
+         * @param poly
+         */
+        public static pointToPoly(point: Vector2, poly: Polygon) {
+            let result = new CollisionResult();
+
+            if (poly.containsPoint(point)) {
+                let distanceSquared: number;
+                let gpp = Polygon.getClosestPointOnPolygonToPoint(poly.points, Vector2.subtract(point, poly.position));
+                let closestPoint = gpp.closestPoint;
+                distanceSquared = gpp.distanceSquared;
+                result.normal = gpp.edgeNormal;
+
+                result.minimumTranslationVector = Vector2.multiply(result.normal, new Vector2(Math.sqrt(distanceSquared), Math.sqrt(distanceSquared)));
+                result.point = Vector2.add(closestPoint, poly.position);
+
+                return result;
+            }
+
+            return null;
+        }
+
+        /**
+         *
+         * @param first
+         * @param second
+         */
+        public static circleToCircle(first: Circle, second: Circle){
+            let result = new CollisionResult();
+
+            let distanceSquared = Vector2.distanceSquared(first.position, second.position);
+            let sumOfRadii = first.radius + second.radius;
+            let collided = distanceSquared < sumOfRadii * sumOfRadii;
+            if (collided){
+                result.normal = Vector2.normalize(Vector2.subtract(first.position, second.position));
+                let depth = sumOfRadii - Math.sqrt(distanceSquared);
+                result.minimumTranslationVector = Vector2.multiply(new Vector2(-depth), result.normal);
+                result.point = Vector2.add(second.position, Vector2.multiply(result.normal, new Vector2(second.radius)));
+
+                return result;
+            }
+
+            return null;
+        }
+
+        /**
+         *
+         * @param first
+         * @param second
+         */
+        public static boxToBox(first: Box, second: Box){
+            let result = new CollisionResult();
+
+            let minkowskiDiff = this.minkowskiDifference(first, second);
+            if (minkowskiDiff.contains(0, 0)){
+                // 计算MTV。如果它是零，我们就可以称它为非碰撞
+                result.minimumTranslationVector = minkowskiDiff.getClosestPointOnBoundsToOrigin();
+
+                if (result.minimumTranslationVector.x == 0 && result.minimumTranslationVector.y == 0)
+                    return null;
+
+                result.normal = new Vector2(-result.minimumTranslationVector.x, -result.minimumTranslationVector.y);
+                result.normal.normalize();
+
+                return result;
+            }
+
+            return null;
+        }
+
+        private static minkowskiDifference(first: Box, second: Box){
+            // 我们需要第一个框的左上角
+            // 碰撞器只会修改运动的位置所以我们需要用位置来计算出运动是什么。
+            let positionOffset = Vector2.subtract(first.position, Vector2.add(first.bounds.location, Vector2.divide(first.bounds.size, new Vector2(2))));
+            let topLeft = Vector2.subtract(Vector2.add(first.bounds.location, positionOffset), second.bounds.max);
+            let fullSize = Vector2.add(first.bounds.size, second.bounds.size);
+
+            return new Rectangle(topLeft.x, topLeft.y, fullSize.x, fullSize.y)
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Utils/Analysis/Layout.ts b/source/src/Utils/Analysis/Layout.ts
index c6181014..d11b611f 100644
--- a/source/src/Utils/Analysis/Layout.ts
+++ b/source/src/Utils/Analysis/Layout.ts
@@ -1,69 +1,71 @@
-/**
- * 支持标题安全区的布局类。
- */
-class Layout {
-    public clientArea: Rectangle;
-    public safeArea: Rectangle;
+module es {
+    /**
+     * 支持标题安全区的布局类。
+     */
+    export class Layout {
+        public clientArea: Rectangle;
+        public safeArea: Rectangle;
 
-    constructor(){
-        this.clientArea = new Rectangle(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
-        this.safeArea = this.clientArea;
+        constructor(){
+            this.clientArea = new Rectangle(0, 0, SceneManager.stage.stageWidth, SceneManager.stage.stageHeight);
+            this.safeArea = this.clientArea;
+        }
+
+        public place(size: Vector2, horizontalMargin: number, verticalMargine: number, alignment: Alignment){
+            let rc = new Rectangle(0, 0, size.x, size.y);
+            if ((alignment & Alignment.left) != 0){
+                rc.x = this.clientArea.x + (this.clientArea.width * horizontalMargin);
+            }else if((alignment & Alignment.right) != 0){
+                rc.x = this.clientArea.x + (this.clientArea.width * (1 - horizontalMargin)) - rc.width;
+            } else if((alignment & Alignment.horizontalCenter) != 0){
+                rc.x = this.clientArea.x + (this.clientArea.width - rc.width) / 2 + (horizontalMargin * this.clientArea.width);
+            }else{
+
+            }
+
+            if ((alignment & Alignment.top) != 0){
+                rc.y = this.clientArea.y + (this.clientArea.height * verticalMargine);
+            }else if((alignment & Alignment.bottom) != 0){
+                rc.y = this.clientArea.y + (this.clientArea.height * (1 - verticalMargine)) - rc.height;
+            } else if((alignment & Alignment.verticalCenter) != 0){
+                rc.y = this.clientArea.y + (this.clientArea.height - rc.height) / 2 + (verticalMargine * this.clientArea.height);
+            }else{
+
+            }
+
+            // 确保布局区域在安全区域内。
+            if (rc.left < this.safeArea.left)
+                rc.x = this.safeArea.left;
+
+            if (rc.right > this.safeArea.right)
+                rc.x = this.safeArea.right - rc.width;
+
+            if (rc.top < this.safeArea.top)
+                rc.y = this.safeArea.top;
+
+            if (rc.bottom > this.safeArea.bottom)
+                rc.y = this.safeArea.bottom - rc.height;
+
+            return rc;
+        }
     }
 
-    public place(size: Vector2, horizontalMargin: number, verticalMargine: number, alignment: Alignment){
-        let rc = new Rectangle(0, 0, size.x, size.y);
-        if ((alignment & Alignment.left) != 0){
-            rc.x = this.clientArea.x + (this.clientArea.width * horizontalMargin);
-        }else if((alignment & Alignment.right) != 0){
-            rc.x = this.clientArea.x + (this.clientArea.width * (1 - horizontalMargin)) - rc.width;
-        } else if((alignment & Alignment.horizontalCenter) != 0){
-            rc.x = this.clientArea.x + (this.clientArea.width - rc.width) / 2 + (horizontalMargin * this.clientArea.width);
-        }else{
-
-        }
-
-        if ((alignment & Alignment.top) != 0){
-            rc.y = this.clientArea.y + (this.clientArea.height * verticalMargine);
-        }else if((alignment & Alignment.bottom) != 0){
-            rc.y = this.clientArea.y + (this.clientArea.height * (1 - verticalMargine)) - rc.height;
-        } else if((alignment & Alignment.verticalCenter) != 0){
-            rc.y = this.clientArea.y + (this.clientArea.height - rc.height) / 2 + (verticalMargine * this.clientArea.height);
-        }else{
-
-        }
-
-        // 确保布局区域在安全区域内。
-        if (rc.left < this.safeArea.left)
-            rc.x = this.safeArea.left;
-
-        if (rc.right > this.safeArea.right)
-            rc.x = this.safeArea.right - rc.width;
-
-        if (rc.top < this.safeArea.top)
-            rc.y = this.safeArea.top;
-
-        if (rc.bottom > this.safeArea.bottom)
-            rc.y = this.safeArea.bottom - rc.height;
-
-        return rc;
+    export enum Alignment {
+        none = 0,
+        left = 1,
+        right = 2,
+        horizontalCenter = 4,
+        top = 8,
+        bottom = 16,
+        verticalCenter = 32,
+        topLeft = top | left,
+        topRight = top | right,
+        topCenter = top | horizontalCenter,
+        bottomLeft = bottom | left,
+        bottomRight = bottom | right,
+        bottomCenter = bottom | horizontalCenter,
+        centerLeft = verticalCenter | left,
+        centerRight = verticalCenter | right,
+        center = verticalCenter | horizontalCenter
     }
 }
-
-enum Alignment {
-    none = 0,
-    left = 1,
-    right = 2,
-    horizontalCenter = 4,
-    top = 8,
-    bottom = 16,
-    verticalCenter = 32,
-    topLeft = top | left,
-    topRight = top | right,
-    topCenter = top | horizontalCenter,
-    bottomLeft = bottom | left,
-    bottomRight = bottom | right,
-    bottomCenter = bottom | horizontalCenter,
-    centerLeft = verticalCenter | left,
-    centerRight = verticalCenter | right,
-    center = verticalCenter | horizontalCenter
-}
\ No newline at end of file
diff --git a/source/src/Utils/Analysis/TimeRuler.ts b/source/src/Utils/Analysis/TimeRuler.ts
index b4ca2e78..846043aa 100644
--- a/source/src/Utils/Analysis/TimeRuler.ts
+++ b/source/src/Utils/Analysis/TimeRuler.ts
@@ -1,349 +1,351 @@
-/**
- * 通过使用这个类，您可以直观地找到瓶颈和基本的CPU使用情况。
- */
-class TimeRuler {
-    /** 最大条数 8 */
-    public static readonly maxBars = 8;
-    /**  */
-    public static readonly maxSamples = 256;
-    /** 每条的最大嵌套调用 */
-    public static readonly maxNestCall = 32;
-    /** 条的高度(以像素为单位) */
-    public static readonly barHeight = 8;
-    /** 最大显示帧 */
-    public static readonly maxSampleFrames = 4;
-    /** 持续时间(帧数)为采取抓拍日志。 */
-    public static readonly logSnapDuration = 120;
-    public static readonly barPadding = 2;
-    public static readonly autoAdjustDelay = 30;
-    public static Instance: TimeRuler;
-    private _frameKey = 'frame';
-    private _logKey = 'log';
-
-    /** 每帧的日志 */
-    private _logs: FrameLog[];
-    /** 当前显示帧计数 */
-    private sampleFrames: number;
-    /** 获取/设置目标样本帧。 */
-    public targetSampleFrames: number;
-    /** 获取/设置计时器标尺宽度。 */
-    public width: number;
-    public enabled: true;
-    /** TimerRuler画的位置。 */
-    private _position: Vector2;
-    /** 上一帧日志 */
-    private _prevLog: FrameLog;
-    /** 当前帧日志 */
-    private _curLog: FrameLog;
-    /** 当前帧数量 */
-    private frameCount: number;
-    /**  */
-    private markers: MarkerInfo[] = [];
-    /** 秒表用来测量时间。 */
-    private stopwacth: stopwatch.Stopwatch = new stopwatch.Stopwatch();
-    /** 从标记名映射到标记id的字典。 */
-    private _markerNameToIdMap: Map<string, number> = new Map<string, number>();
+module es {
     /**
-     * 你想在游戏开始时调用StartFrame更新方法。
-     * 当游戏在固定时间步进模式下运行缓慢时，更新会多次调用。
-     * 在这种情况下，我们应该忽略StartFrame调用。
-     * 为此，我们只需一直跟踪StartFrame调用的次数，直到Draw被调用。
+     * 通过使用这个类，您可以直观地找到瓶颈和基本的CPU使用情况。
      */
-    private _updateCount: number;
-    /**  */
-    public showLog = false;
-    private _frameAdjust: number;
+    export class TimeRuler {
+        /** 最大条数 8 */
+        public static readonly maxBars = 8;
+        /**  */
+        public static readonly maxSamples = 256;
+        /** 每条的最大嵌套调用 */
+        public static readonly maxNestCall = 32;
+        /** 条的高度(以像素为单位) */
+        public static readonly barHeight = 8;
+        /** 最大显示帧 */
+        public static readonly maxSampleFrames = 4;
+        /** 持续时间(帧数)为采取抓拍日志。 */
+        public static readonly logSnapDuration = 120;
+        public static readonly barPadding = 2;
+        public static readonly autoAdjustDelay = 30;
+        public static Instance: TimeRuler;
+        private _frameKey = 'frame';
+        private _logKey = 'log';
 
-    constructor() {
-        TimeRuler.Instance = this;
-        this._logs = new Array<FrameLog>(2);
-        for (let i = 0; i < this._logs.length; ++i)
-            this._logs[i] = new FrameLog();
+        /** 每帧的日志 */
+        private _logs: FrameLog[];
+        /** 当前显示帧计数 */
+        private sampleFrames: number;
+        /** 获取/设置目标样本帧。 */
+        public targetSampleFrames: number;
+        /** 获取/设置计时器标尺宽度。 */
+        public width: number;
+        public enabled: true;
+        /** TimerRuler画的位置。 */
+        private _position: Vector2;
+        /** 上一帧日志 */
+        private _prevLog: FrameLog;
+        /** 当前帧日志 */
+        private _curLog: FrameLog;
+        /** 当前帧数量 */
+        private frameCount: number;
+        /**  */
+        private markers: MarkerInfo[] = [];
+        /** 秒表用来测量时间。 */
+        private stopwacth: stopwatch.Stopwatch = new stopwatch.Stopwatch();
+        /** 从标记名映射到标记id的字典。 */
+        private _markerNameToIdMap: Map<string, number> = new Map<string, number>();
+        /**
+         * 你想在游戏开始时调用StartFrame更新方法。
+         * 当游戏在固定时间步进模式下运行缓慢时，更新会多次调用。
+         * 在这种情况下，我们应该忽略StartFrame调用。
+         * 为此，我们只需一直跟踪StartFrame调用的次数，直到Draw被调用。
+         */
+        private _updateCount: number;
+        /**  */
+        public showLog = false;
+        private _frameAdjust: number;
 
-        this.sampleFrames = this.targetSampleFrames = 1;
-        this.width = SceneManager.stage.stageWidth * 0.8;
-        this.onGraphicsDeviceReset();
-    }
+        constructor() {
+            TimeRuler.Instance = this;
+            this._logs = new Array<FrameLog>(2);
+            for (let i = 0; i < this._logs.length; ++i)
+                this._logs[i] = new FrameLog();
 
-    private onGraphicsDeviceReset() {
-        let layout = new Layout();
-        this._position = layout.place(new Vector2(this.width, TimeRuler.barHeight), 0, 0.01, Alignment.bottomCenter).location;
-    }
+            this.sampleFrames = this.targetSampleFrames = 1;
+            this.width = SceneManager.stage.stageWidth * 0.8;
+            this.onGraphicsDeviceReset();
+        }
 
-    /**
-     * 
-     */
-    public startFrame() {
-        // 当这个方法被多次调用时，我们跳过重置帧。
-        let lock = new LockUtils(this._frameKey);
-        lock.lock().then(() => {
-            this._updateCount = parseInt(egret.localStorage.getItem(this._frameKey), 10);
-            if (isNaN(this._updateCount))
-                this._updateCount = 0;
-            let count = this._updateCount;
-            count += 1;
-            egret.localStorage.setItem(this._frameKey, count.toString());
-            if (this.enabled && (1 < count && count < TimeRuler.maxSampleFrames))
-                return;
+        private onGraphicsDeviceReset() {
+            let layout = new Layout();
+            this._position = layout.place(new Vector2(this.width, TimeRuler.barHeight), 0, 0.01, Alignment.bottomCenter).location;
+        }
 
-            // 更新当前帧日志。
-            this._prevLog = this._logs[this.frameCount++ & 0x1];
-            this._curLog = this._logs[this.frameCount & 0x1];
+        /**
+         *
+         */
+        public startFrame() {
+            // 当这个方法被多次调用时，我们跳过重置帧。
+            let lock = new LockUtils(this._frameKey);
+            lock.lock().then(() => {
+                this._updateCount = parseInt(egret.localStorage.getItem(this._frameKey), 10);
+                if (isNaN(this._updateCount))
+                    this._updateCount = 0;
+                let count = this._updateCount;
+                count += 1;
+                egret.localStorage.setItem(this._frameKey, count.toString());
+                if (this.enabled && (1 < count && count < TimeRuler.maxSampleFrames))
+                    return;
 
-            let endFrameTime = this.stopwacth.getTime();
-            // 更新标记并创建日志。
-            for (let barIndex = 0; barIndex < this._prevLog.bars.length; ++barIndex) {
-                let prevBar = this._prevLog.bars[barIndex];
-                let nextBar = this._curLog.bars[barIndex];
+                // 更新当前帧日志。
+                this._prevLog = this._logs[this.frameCount++ & 0x1];
+                this._curLog = this._logs[this.frameCount & 0x1];
 
-                // 重新打开在前一帧中没有调用结束标记的标记。
-                for (let nest = 0; nest < prevBar.nestCount; ++nest) {
-                    let markerIdx = prevBar.markerNests[nest];
-                    prevBar.markers[markerIdx].endTime = endFrameTime;
-                    nextBar.markerNests[nest] = nest;
-                    nextBar.markers[nest].markerId = prevBar.markers[markerIdx].markerId;
-                    nextBar.markers[nest].beginTime = 0;
-                    nextBar.markers[nest].endTime = -1;
-                    nextBar.markers[nest].color = prevBar.markers[markerIdx].color;
-                }
+                let endFrameTime = this.stopwacth.getTime();
+                // 更新标记并创建日志。
+                for (let barIndex = 0; barIndex < this._prevLog.bars.length; ++barIndex) {
+                    let prevBar = this._prevLog.bars[barIndex];
+                    let nextBar = this._curLog.bars[barIndex];
 
-                // 更新日志标记
-                for (let markerIdx = 0; markerIdx < prevBar.markCount; ++markerIdx) {
-                    let duration = prevBar.markers[markerIdx].endTime - prevBar.markers[markerIdx].beginTime;
-                    let markerId = prevBar.markers[markerIdx].markerId;
-                    let m = this.markers[markerId];
+                    // 重新打开在前一帧中没有调用结束标记的标记。
+                    for (let nest = 0; nest < prevBar.nestCount; ++nest) {
+                        let markerIdx = prevBar.markerNests[nest];
+                        prevBar.markers[markerIdx].endTime = endFrameTime;
+                        nextBar.markerNests[nest] = nest;
+                        nextBar.markers[nest].markerId = prevBar.markers[markerIdx].markerId;
+                        nextBar.markers[nest].beginTime = 0;
+                        nextBar.markers[nest].endTime = -1;
+                        nextBar.markers[nest].color = prevBar.markers[markerIdx].color;
+                    }
 
-                    m.logs[barIndex].color = prevBar.markers[markerIdx].color;
-                    if (!m.logs[barIndex].initialized) {
-                        m.logs[barIndex].min = duration;
-                        m.logs[barIndex].max = duration;
-                        m.logs[barIndex].avg = duration;
-                        m.logs[barIndex].initialized = true;
-                    } else {
-                        m.logs[barIndex].min = Math.min(m.logs[barIndex].min, duration);
-                        m.logs[barIndex].max = Math.min(m.logs[barIndex].max, duration);
-                        m.logs[barIndex].avg += duration;
-                        m.logs[barIndex].avg *= 0.5;
+                    // 更新日志标记
+                    for (let markerIdx = 0; markerIdx < prevBar.markCount; ++markerIdx) {
+                        let duration = prevBar.markers[markerIdx].endTime - prevBar.markers[markerIdx].beginTime;
+                        let markerId = prevBar.markers[markerIdx].markerId;
+                        let m = this.markers[markerId];
 
-                        if (m.logs[barIndex].samples++ >= TimeRuler.logSnapDuration) {
-                            m.logs[barIndex].snapMin = m.logs[barIndex].min;
-                            m.logs[barIndex].snapMax = m.logs[barIndex].max;
-                            m.logs[barIndex].snapAvg = m.logs[barIndex].avg;
-                            m.logs[barIndex].samples = 0;
+                        m.logs[barIndex].color = prevBar.markers[markerIdx].color;
+                        if (!m.logs[barIndex].initialized) {
+                            m.logs[barIndex].min = duration;
+                            m.logs[barIndex].max = duration;
+                            m.logs[barIndex].avg = duration;
+                            m.logs[barIndex].initialized = true;
+                        } else {
+                            m.logs[barIndex].min = Math.min(m.logs[barIndex].min, duration);
+                            m.logs[barIndex].max = Math.min(m.logs[barIndex].max, duration);
+                            m.logs[barIndex].avg += duration;
+                            m.logs[barIndex].avg *= 0.5;
+
+                            if (m.logs[barIndex].samples++ >= TimeRuler.logSnapDuration) {
+                                m.logs[barIndex].snapMin = m.logs[barIndex].min;
+                                m.logs[barIndex].snapMax = m.logs[barIndex].max;
+                                m.logs[barIndex].snapAvg = m.logs[barIndex].avg;
+                                m.logs[barIndex].samples = 0;
+                            }
                         }
                     }
+
+                    nextBar.markCount = prevBar.nestCount;
+                    nextBar.nestCount = prevBar.nestCount;
                 }
 
-                nextBar.markCount = prevBar.nestCount;
-                nextBar.nestCount = prevBar.nestCount;
-            }
-
-            this.stopwacth.reset();
-            this.stopwacth.start();
-        });
-    }
-
-    /**
-     * 开始测量时间。
-     * @param markerName 
-     * @param color 
-     */
-    public beginMark(markerName: string, color: number, barIndex: number = 0) {
-        let lock = new LockUtils(this._frameKey);
-        lock.lock().then(() => {
-            if (barIndex < 0 || barIndex >= TimeRuler.maxBars)
-                throw new Error("barIndex argument out of range");
-
-            let bar = this._curLog.bars[barIndex];
-            if (bar.markCount >= TimeRuler.maxSamples) {
-                throw new Error("exceeded sample count. either set larger number to timeruler.maxsaple or lower sample count");
-            }
-
-            if (bar.nestCount >= TimeRuler.maxNestCall) {
-                throw new Error("exceeded nest count. either set larger number to timeruler.maxnestcall or lower nest calls");
-            }
-
-            // 获取注册的标记
-            let markerId = this._markerNameToIdMap.get(markerName);
-            if (isNaN(markerId)) {
-                // 如果此标记未注册，则注册此标记。
-                markerId = this.markers.length;
-                this._markerNameToIdMap.set(markerName, markerId);
-            }
-
-            bar.markerNests[bar.nestCount++] = bar.markCount;
-            bar.markers[bar.markCount].markerId = markerId;
-            bar.markers[bar.markCount].color = color;
-            bar.markers[bar.markCount].beginTime = this.stopwacth.getTime();
-            bar.markers[bar.markCount].endTime = -1;
-        });
-    }
-
-    /**
-     * 
-     * @param markerName 
-     * @param barIndex 
-     */
-    public endMark(markerName: string, barIndex: number = 0) {
-        let lock = new LockUtils(this._frameKey);
-        lock.lock().then(() => {
-            if (barIndex < 0 || barIndex >= TimeRuler.maxBars)
-                throw new Error("barIndex argument out of range");
-
-            let bar = this._curLog.bars[barIndex];
-            if (bar.nestCount <= 0) {
-                throw new Error("call beginMark method before calling endMark method");
-            }
-
-            let markerId = this._markerNameToIdMap.get(markerName);
-            if (isNaN(markerId)) {
-                throw new Error(`Marker ${markerName} is not registered. Make sure you specifed same name as you used for beginMark method`);
-            }
-
-            let markerIdx = bar.markerNests[--bar.nestCount];
-            if (bar.markers[markerIdx].markerId != markerId) {
-                throw new Error("Incorrect call order of beginMark/endMark method. beginMark(A), beginMark(B), endMark(B), endMark(A) But you can't called it like beginMark(A), beginMark(B), endMark(A), endMark(B).");
-            }
-
-            bar.markers[markerIdx].endTime = this.stopwacth.getTime();
-        });
-    }
-
-    /**
-     * 获取给定bar索引和标记名称的平均时间。
-     * @param barIndex 
-     * @param markerName 
-     */
-    public getAverageTime(barIndex: number, markerName: string) {
-        if (barIndex < 0 || barIndex >= TimeRuler.maxBars) {
-            throw new Error("barIndex argument out of range");
-        }
-        let result = 0;
-        let markerId = this._markerNameToIdMap.get(markerName);
-        if (markerId) {
-            result = this.markers[markerId].logs[barIndex].avg;
-        }
-
-        return result;
-    }
-
-    /**
-     * 
-     */
-    public resetLog() {
-        let lock = new LockUtils(this._logKey);
-        lock.lock().then(() => {
-            let count = parseInt(egret.localStorage.getItem(this._logKey), 10);
-            count += 1;
-            egret.localStorage.setItem(this._logKey, count.toString());
-            this.markers.forEach(markerInfo => {
-                for (let i = 0; i < markerInfo.logs.length; ++i){
-                    markerInfo.logs[i].initialized = false;
-                    markerInfo.logs[i].snapMin = 0;
-                    markerInfo.logs[i].snapMax = 0;
-                    markerInfo.logs[i].snapAvg = 0;
-
-                    markerInfo.logs[i].min = 0;
-                    markerInfo.logs[i].max = 0;
-                    markerInfo.logs[i].avg = 0;
-
-                    markerInfo.logs[i].samples = 0;
-                }
+                this.stopwacth.reset();
+                this.stopwacth.start();
             });
-        });
-    }
+        }
 
-    public render(position: Vector2 = this._position, width: number = this.width){
-        egret.localStorage.setItem(this._frameKey, "0");
+        /**
+         * 开始测量时间。
+         * @param markerName
+         * @param color
+         */
+        public beginMark(markerName: string, color: number, barIndex: number = 0) {
+            let lock = new LockUtils(this._frameKey);
+            lock.lock().then(() => {
+                if (barIndex < 0 || barIndex >= TimeRuler.maxBars)
+                    throw new Error("barIndex argument out of range");
 
-        if (!this.showLog)
-            return;
+                let bar = this._curLog.bars[barIndex];
+                if (bar.markCount >= TimeRuler.maxSamples) {
+                    throw new Error("exceeded sample count. either set larger number to timeruler.maxsaple or lower sample count");
+                }
 
-        let height = 0;
-        let maxTime = 0;
-        this._prevLog.bars.forEach(bar => {
-            if (bar.markCount > 0){
-                height += TimeRuler.barHeight + TimeRuler.barPadding * 2;
-                maxTime = Math.max(maxTime, bar.markers[bar.markCount - 1].endTime);
+                if (bar.nestCount >= TimeRuler.maxNestCall) {
+                    throw new Error("exceeded nest count. either set larger number to timeruler.maxnestcall or lower nest calls");
+                }
+
+                // 获取注册的标记
+                let markerId = this._markerNameToIdMap.get(markerName);
+                if (isNaN(markerId)) {
+                    // 如果此标记未注册，则注册此标记。
+                    markerId = this.markers.length;
+                    this._markerNameToIdMap.set(markerName, markerId);
+                }
+
+                bar.markerNests[bar.nestCount++] = bar.markCount;
+                bar.markers[bar.markCount].markerId = markerId;
+                bar.markers[bar.markCount].color = color;
+                bar.markers[bar.markCount].beginTime = this.stopwacth.getTime();
+                bar.markers[bar.markCount].endTime = -1;
+            });
+        }
+
+        /**
+         *
+         * @param markerName
+         * @param barIndex
+         */
+        public endMark(markerName: string, barIndex: number = 0) {
+            let lock = new LockUtils(this._frameKey);
+            lock.lock().then(() => {
+                if (barIndex < 0 || barIndex >= TimeRuler.maxBars)
+                    throw new Error("barIndex argument out of range");
+
+                let bar = this._curLog.bars[barIndex];
+                if (bar.nestCount <= 0) {
+                    throw new Error("call beginMark method before calling endMark method");
+                }
+
+                let markerId = this._markerNameToIdMap.get(markerName);
+                if (isNaN(markerId)) {
+                    throw new Error(`Marker ${markerName} is not registered. Make sure you specifed same name as you used for beginMark method`);
+                }
+
+                let markerIdx = bar.markerNests[--bar.nestCount];
+                if (bar.markers[markerIdx].markerId != markerId) {
+                    throw new Error("Incorrect call order of beginMark/endMark method. beginMark(A), beginMark(B), endMark(B), endMark(A) But you can't called it like beginMark(A), beginMark(B), endMark(A), endMark(B).");
+                }
+
+                bar.markers[markerIdx].endTime = this.stopwacth.getTime();
+            });
+        }
+
+        /**
+         * 获取给定bar索引和标记名称的平均时间。
+         * @param barIndex
+         * @param markerName
+         */
+        public getAverageTime(barIndex: number, markerName: string) {
+            if (barIndex < 0 || barIndex >= TimeRuler.maxBars) {
+                throw new Error("barIndex argument out of range");
+            }
+            let result = 0;
+            let markerId = this._markerNameToIdMap.get(markerName);
+            if (markerId) {
+                result = this.markers[markerId].logs[barIndex].avg;
             }
-        })
 
-        const frameSpan = 1 / 60 * 1000;
-        let sampleSpan = this.sampleFrames * frameSpan;
-
-        if (maxTime > sampleSpan){
-            this._frameAdjust = Math.max(0, this._frameAdjust) + 1;
-        }else{
-            this._frameAdjust = Math.min(0, this._frameAdjust) - 1;
+            return result;
         }
 
-        if (Math.max(this._frameAdjust) > TimeRuler.autoAdjustDelay){
-            this.sampleFrames = Math.min(TimeRuler.maxSampleFrames, this.sampleFrames);
-            this.sampleFrames = Math.max(this.targetSampleFrames, (maxTime / frameSpan) + 1);
+        /**
+         *
+         */
+        public resetLog() {
+            let lock = new LockUtils(this._logKey);
+            lock.lock().then(() => {
+                let count = parseInt(egret.localStorage.getItem(this._logKey), 10);
+                count += 1;
+                egret.localStorage.setItem(this._logKey, count.toString());
+                this.markers.forEach(markerInfo => {
+                    for (let i = 0; i < markerInfo.logs.length; ++i){
+                        markerInfo.logs[i].initialized = false;
+                        markerInfo.logs[i].snapMin = 0;
+                        markerInfo.logs[i].snapMax = 0;
+                        markerInfo.logs[i].snapAvg = 0;
 
-            this._frameAdjust = 0;
+                        markerInfo.logs[i].min = 0;
+                        markerInfo.logs[i].max = 0;
+                        markerInfo.logs[i].avg = 0;
+
+                        markerInfo.logs[i].samples = 0;
+                    }
+                });
+            });
         }
 
-        let msToPs = width / sampleSpan;
-        let startY = position.y - (height - TimeRuler.barHeight);
-        let y = startY;
+        public render(position: Vector2 = this._position, width: number = this.width){
+            egret.localStorage.setItem(this._frameKey, "0");
 
-        // TODO: draw
+            if (!this.showLog)
+                return;
+
+            let height = 0;
+            let maxTime = 0;
+            this._prevLog.bars.forEach(bar => {
+                if (bar.markCount > 0){
+                    height += TimeRuler.barHeight + TimeRuler.barPadding * 2;
+                    maxTime = Math.max(maxTime, bar.markers[bar.markCount - 1].endTime);
+                }
+            })
+
+            const frameSpan = 1 / 60 * 1000;
+            let sampleSpan = this.sampleFrames * frameSpan;
+
+            if (maxTime > sampleSpan){
+                this._frameAdjust = Math.max(0, this._frameAdjust) + 1;
+            }else{
+                this._frameAdjust = Math.min(0, this._frameAdjust) - 1;
+            }
+
+            if (Math.max(this._frameAdjust) > TimeRuler.autoAdjustDelay){
+                this.sampleFrames = Math.min(TimeRuler.maxSampleFrames, this.sampleFrames);
+                this.sampleFrames = Math.max(this.targetSampleFrames, (maxTime / frameSpan) + 1);
+
+                this._frameAdjust = 0;
+            }
+
+            let msToPs = width / sampleSpan;
+            let startY = position.y - (height - TimeRuler.barHeight);
+            let y = startY;
+
+            // TODO: draw
+        }
+    }
+
+    /**
+     * 日志信息
+     */
+    export class FrameLog {
+        public bars: MarkerCollection[];
+
+        constructor() {
+            this.bars = new Array<MarkerCollection>(TimeRuler.maxBars);
+            this.bars.fill(new MarkerCollection(), 0, TimeRuler.maxBars);
+        }
+    }
+
+    /**
+     * 标记的集合
+     */
+    export class MarkerCollection {
+        public markers: Marker[] = new Array<Marker>(TimeRuler.maxSamples);
+        public markCount: number = 0;
+        public markerNests: number[] = new Array<number>(TimeRuler.maxNestCall);
+        public nestCount: number = 0;
+
+        constructor(){
+            this.markers.fill(new Marker(), 0, TimeRuler.maxSamples);
+            this.markerNests.fill(0, 0, TimeRuler.maxNestCall);
+        }
+    }
+
+    export class Marker {
+        public markerId: number = 0;
+        public beginTime: number = 0;
+        public endTime: number = 0;
+        public color: number = 0x000000;
+    }
+
+    export class MarkerInfo {
+        public name: string;
+        public logs: MarkerLog[] = new Array<MarkerLog>(TimeRuler.maxBars);
+
+        constructor(name) {
+            this.name = name;
+            this.logs.fill(new MarkerLog(), 0, TimeRuler.maxBars);
+        }
+    }
+
+    export class MarkerLog {
+        public snapMin: number = 0;
+        public snapMax: number = 0;
+        public snapAvg: number = 0;
+        public min: number = 0;
+        public max: number = 0;
+        public avg: number = 0;
+        public samples: number = 0;
+        public color: number = 0x000000;
+        public initialized: boolean = false;
     }
 }
-
-/** 
- * 日志信息
- */
-class FrameLog {
-    public bars: MarkerCollection[];
-
-    constructor() {
-        this.bars = new Array<MarkerCollection>(TimeRuler.maxBars);
-        this.bars.fill(new MarkerCollection(), 0, TimeRuler.maxBars);
-    }
-}
-
-/**
- * 标记的集合
- */
-class MarkerCollection {
-    public markers: Marker[] = new Array<Marker>(TimeRuler.maxSamples);
-    public markCount: number = 0;
-    public markerNests: number[] = new Array<number>(TimeRuler.maxNestCall);
-    public nestCount: number = 0;
-
-    constructor(){
-        this.markers.fill(new Marker(), 0, TimeRuler.maxSamples);
-        this.markerNests.fill(0, 0, TimeRuler.maxNestCall);
-    }
-}
-
-class Marker {
-    public markerId: number = 0;
-    public beginTime: number = 0;
-    public endTime: number = 0;
-    public color: number = 0x000000;
-}
-
-class MarkerInfo {
-    public name: string;
-    public logs: MarkerLog[] = new Array<MarkerLog>(TimeRuler.maxBars);
-
-    constructor(name) {
-        this.name = name;
-        this.logs.fill(new MarkerLog(), 0, TimeRuler.maxBars);
-    }
-}
-
-class MarkerLog {
-    public snapMin: number = 0;
-    public snapMax: number = 0;
-    public snapAvg: number = 0;
-    public min: number = 0;
-    public max: number = 0;
-    public avg: number = 0;
-    public samples: number = 0;
-    public color: number = 0x000000;
-    public initialized: boolean = false;
-}
\ No newline at end of file
diff --git a/source/src/Utils/ContentManager.ts b/source/src/Utils/ContentManager.ts
index 9d651295..4d80348e 100644
--- a/source/src/Utils/ContentManager.ts
+++ b/source/src/Utils/ContentManager.ts
@@ -1,41 +1,43 @@
-class ContentManager {
-    protected loadedAssets: Map<string, any> = new Map<string, any>();
+module es {
+    export class ContentManager {
+        protected loadedAssets: Map<string, any> = new Map<string, any>();
 
-    /** 异步加载资源 */
-    public loadRes(name: string, local: boolean = true): Promise<any> {
-        return new Promise((resolve, reject) => {
-            let res = this.loadedAssets.get(name);
-            if (res) {
-                resolve(res);
-                return;
-            }
+        /** 异步加载资源 */
+        public loadRes(name: string, local: boolean = true): Promise<any> {
+            return new Promise((resolve, reject) => {
+                let res = this.loadedAssets.get(name);
+                if (res) {
+                    resolve(res);
+                    return;
+                }
 
-            if (local) {
-                RES.getResAsync(name).then((data) => {
-                    this.loadedAssets.set(name, data);
-                    resolve(data);
-                }).catch((err) => {
-                    console.error("资源加载错误:", name, err);
-                    reject(err);
-                });
-            } else {
-                RES.getResByUrl(name).then((data) => {
-                    this.loadedAssets.set(name, data);
-                    resolve(data);
-                }).catch((err) => {
-                    console.error("资源加载错误:", name, err);
-                    reject(err);
-                });
-            }
-        });
+                if (local) {
+                    RES.getResAsync(name).then((data) => {
+                        this.loadedAssets.set(name, data);
+                        resolve(data);
+                    }).catch((err) => {
+                        console.error("资源加载错误:", name, err);
+                        reject(err);
+                    });
+                } else {
+                    RES.getResByUrl(name).then((data) => {
+                        this.loadedAssets.set(name, data);
+                        resolve(data);
+                    }).catch((err) => {
+                        console.error("资源加载错误:", name, err);
+                        reject(err);
+                    });
+                }
+            });
+        }
+
+        public dispose() {
+            this.loadedAssets.forEach(value => {
+                let assetsToRemove = value;
+                assetsToRemove.dispose();
+            });
+
+            this.loadedAssets.clear();
+        }
     }
-
-    public dispose() {
-        this.loadedAssets.forEach(value => {
-            let assetsToRemove = value;
-            assetsToRemove.dispose();
-        });
-
-        this.loadedAssets.clear();
-    }
-}
\ No newline at end of file
+}
diff --git a/source/src/Utils/DrawUtils.ts b/source/src/Utils/DrawUtils.ts
index 54be26fd..2ae27506 100644
--- a/source/src/Utils/DrawUtils.ts
+++ b/source/src/Utils/DrawUtils.ts
@@ -1,59 +1,61 @@
-/** 各种辅助方法来辅助绘图 */
-class DrawUtils {
-    public static drawLine(shape: egret.Shape, start: Vector2, end: Vector2, color: number, thickness: number = 1){
-        this.drawLineAngle(shape, start, MathHelper.angleBetweenVectors(start, end), Vector2.distance(start, end), color, thickness);
-    }
-
-    public static drawLineAngle(shape: egret.Shape, start: Vector2, radians: number, length: number, color: number, thickness = 1){
-        shape.graphics.beginFill(color);
-        shape.graphics.drawRect(start.x, start.y, 1, 1);
-        shape.graphics.endFill();
-
-        shape.scaleX = length;
-        shape.scaleY = thickness;
-        shape.$anchorOffsetX = 0;
-        shape.$anchorOffsetY = 0;
-        shape.rotation = radians;
-    }
-
-    public static drawHollowRect(shape: egret.Shape, rect: Rectangle, color: number, thickness = 1){
-        this.drawHollowRectR(shape, rect.x, rect.y, rect.width, rect.height, color, thickness);
-    }
-
-    public static drawHollowRectR(shape: egret.Shape, x: number, y: number, width: number, height: number, color: number, thickness = 1){
-        let tl = new Vector2(x, y).round();
-        let tr = new Vector2(x + width, y).round();
-        let br = new Vector2(x + width, y + height).round();
-        let bl = new Vector2(x, y + height).round();
-
-        this.drawLine(shape, tl, tr, color, thickness);
-        this.drawLine(shape, tr, br, color, thickness);
-        this.drawLine(shape, br, bl, color, thickness);
-        this.drawLine(shape, bl, tl, color, thickness);
-    }
-
-    public static drawPixel(shape: egret.Shape, position: Vector2, color: number, size: number = 1){
-        let destRect = new Rectangle(position.x, position.y, size, size);
-        if (size != 1){
-            destRect.x -= size * 0.5;
-            destRect.y -= size * 0.5;
+module es {
+    /** 各种辅助方法来辅助绘图 */
+    export class DrawUtils {
+        public static drawLine(shape: egret.Shape, start: Vector2, end: Vector2, color: number, thickness: number = 1){
+            this.drawLineAngle(shape, start, MathHelper.angleBetweenVectors(start, end), Vector2.distance(start, end), color, thickness);
         }
 
-        shape.graphics.beginFill(color);
-        shape.graphics.drawRect(destRect.x, destRect.y, destRect.width, destRect.height);
-        shape.graphics.endFill();
-    }
+        public static drawLineAngle(shape: egret.Shape, start: Vector2, radians: number, length: number, color: number, thickness = 1){
+            shape.graphics.beginFill(color);
+            shape.graphics.drawRect(start.x, start.y, 1, 1);
+            shape.graphics.endFill();
 
-    public static getColorMatrix(color: number): egret.ColorMatrixFilter{
-        let colorMatrix = [
-            1, 0, 0, 0, 0,
-            0, 1, 0, 0, 0,
-            0, 0, 1, 0, 0,
-            0, 0, 0, 1, 0
-        ];
-        colorMatrix[0] = Math.floor(color / 256 / 256) / 255;
-        colorMatrix[6] = Math.floor(color / 256 % 256) / 255;
-        colorMatrix[12] = color % 256 / 255;
-        return new egret.ColorMatrixFilter(colorMatrix);
+            shape.scaleX = length;
+            shape.scaleY = thickness;
+            shape.$anchorOffsetX = 0;
+            shape.$anchorOffsetY = 0;
+            shape.rotation = radians;
+        }
+
+        public static drawHollowRect(shape: egret.Shape, rect: Rectangle, color: number, thickness = 1){
+            this.drawHollowRectR(shape, rect.x, rect.y, rect.width, rect.height, color, thickness);
+        }
+
+        public static drawHollowRectR(shape: egret.Shape, x: number, y: number, width: number, height: number, color: number, thickness = 1){
+            let tl = new Vector2(x, y).round();
+            let tr = new Vector2(x + width, y).round();
+            let br = new Vector2(x + width, y + height).round();
+            let bl = new Vector2(x, y + height).round();
+
+            this.drawLine(shape, tl, tr, color, thickness);
+            this.drawLine(shape, tr, br, color, thickness);
+            this.drawLine(shape, br, bl, color, thickness);
+            this.drawLine(shape, bl, tl, color, thickness);
+        }
+
+        public static drawPixel(shape: egret.Shape, position: Vector2, color: number, size: number = 1){
+            let destRect = new Rectangle(position.x, position.y, size, size);
+            if (size != 1){
+                destRect.x -= size * 0.5;
+                destRect.y -= size * 0.5;
+            }
+
+            shape.graphics.beginFill(color);
+            shape.graphics.drawRect(destRect.x, destRect.y, destRect.width, destRect.height);
+            shape.graphics.endFill();
+        }
+
+        public static getColorMatrix(color: number): egret.ColorMatrixFilter{
+            let colorMatrix = [
+                1, 0, 0, 0, 0,
+                0, 1, 0, 0, 0,
+                0, 0, 1, 0, 0,
+                0, 0, 0, 1, 0
+            ];
+            colorMatrix[0] = Math.floor(color / 256 / 256) / 255;
+            colorMatrix[6] = Math.floor(color / 256 % 256) / 255;
+            colorMatrix[12] = color % 256 / 255;
+            return new egret.ColorMatrixFilter(colorMatrix);
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Utils/Emitter.ts b/source/src/Utils/Emitter.ts
index a9c91edf..521aa9b8 100644
--- a/source/src/Utils/Emitter.ts
+++ b/source/src/Utils/Emitter.ts
@@ -1,68 +1,69 @@
-/**
- * 用于事件管理
- */
-class Emitter<T> {
-    private _messageTable: Map<T, FuncPack[]>;
-
-    constructor(){
-        this._messageTable = new Map<T, FuncPack[]>();
-    }
-
+module es {
     /**
-     * 开始监听项
-     * @param eventType 监听类型
-     * @param handler 监听函数
-     * @param context 监听上下文
+     * 用于包装事件的一个小类
      */
-    public addObserver(eventType: T, handler: Function, context: any){
-        let list: FuncPack[] = this._messageTable.get(eventType);
-        if (!list){
-            list = [];
-            this._messageTable.set(eventType, list);
+    export class FuncPack {
+        /** 函数 */
+        public func: Function;
+        /** 上下文 */
+        public context: any;
+
+        constructor(func: Function, context: any){
+            this.func = func;
+            this.context = context;
+        }
+    }
+    /**
+     * 用于事件管理
+     */
+    export class Emitter<T> {
+        private _messageTable: Map<T, FuncPack[]>;
+
+        constructor(){
+            this._messageTable = new Map<T, FuncPack[]>();
         }
 
-        if (list.contains(handler))
-            console.warn("您试图添加相同的观察者两次");
-        list.push(new FuncPack(handler, context));
-    }
+        /**
+         * 开始监听项
+         * @param eventType 监听类型
+         * @param handler 监听函数
+         * @param context 监听上下文
+         */
+        public addObserver(eventType: T, handler: Function, context: any){
+            let list: FuncPack[] = this._messageTable.get(eventType);
+            if (!list){
+                list = [];
+                this._messageTable.set(eventType, list);
+            }
 
-    /**
-     * 移除监听项
-     * @param eventType 事件类型
-     * @param handler 事件函数
-     */
-    public removeObserver(eventType: T, handler: Function){
-        let messageData = this._messageTable.get(eventType);
-        let index = messageData.findIndex(data => data.func == handler);
-        if (index != -1)
-            messageData.removeAt(index);
-    }
+            if (list.contains(handler))
+                console.warn("您试图添加相同的观察者两次");
+            list.push(new FuncPack(handler, context));
+        }
 
-    /**
-     * 触发该事件
-     * @param eventType 事件类型
-     * @param data 事件数据
-     */
-    public emit(eventType: T, data?: any){
-        let list: FuncPack[] = this._messageTable.get(eventType);
-        if (list){
-            for (let i = list.length - 1; i >= 0; i --)
-                list[i].func.call(list[i].context, data);
+        /**
+         * 移除监听项
+         * @param eventType 事件类型
+         * @param handler 事件函数
+         */
+        public removeObserver(eventType: T, handler: Function){
+            let messageData = this._messageTable.get(eventType);
+            let index = messageData.findIndex(data => data.func == handler);
+            if (index != -1)
+                messageData.removeAt(index);
+        }
+
+        /**
+         * 触发该事件
+         * @param eventType 事件类型
+         * @param data 事件数据
+         */
+        public emit(eventType: T, data?: any){
+            let list: FuncPack[] = this._messageTable.get(eventType);
+            if (list){
+                for (let i = list.length - 1; i >= 0; i --)
+                    list[i].func.call(list[i].context, data);
+            }
         }
     }
 }
-
-/**
- * 用于包装事件的一个小类
- */
-class FuncPack {
-    /** 函数 */
-    public func: Function;
-    /** 上下文 */
-    public context: any;
-
-    constructor(func: Function, context: any){
-        this.func = func;
-        this.context = context;
-    }
-}
\ No newline at end of file
diff --git a/source/src/Utils/GlobalManager.ts b/source/src/Utils/GlobalManager.ts
index 1e48ee99..e962b6c3 100644
--- a/source/src/Utils/GlobalManager.ts
+++ b/source/src/Utils/GlobalManager.ts
@@ -1,46 +1,48 @@
-class GlobalManager {
-    public static globalManagers: GlobalManager[] = [];
-    private _enabled: boolean;
+module es {
+    export class GlobalManager {
+        public static globalManagers: GlobalManager[] = [];
+        private _enabled: boolean;
 
-    public get enabled(){
-        return this._enabled;
-    }
-    public set enabled(value: boolean){
-        this.setEnabled(value);
-    }
-    public setEnabled(isEnabled: boolean){
-        if (this._enabled != isEnabled){
-            this._enabled = isEnabled;
-            if (this._enabled){
-                this.onEnabled();
-            } else {
-                this.onDisabled();
+        public get enabled(){
+            return this._enabled;
+        }
+        public set enabled(value: boolean){
+            this.setEnabled(value);
+        }
+        public setEnabled(isEnabled: boolean){
+            if (this._enabled != isEnabled){
+                this._enabled = isEnabled;
+                if (this._enabled){
+                    this.onEnabled();
+                } else {
+                    this.onDisabled();
+                }
             }
         }
-    }
 
-    public onEnabled(){}
+        public onEnabled(){}
 
-    public onDisabled(){}
+        public onDisabled(){}
 
-    public update(){}
+        public update(){}
 
-    public static registerGlobalManager(manager: GlobalManager){
-        this.globalManagers.push(manager);
-        manager.enabled = true;
-    }
-
-    public static unregisterGlobalManager(manager: GlobalManager){
-        this.globalManagers.remove(manager);
-        manager.enabled = false;
-    }
-
-    public static getGlobalManager<T extends GlobalManager>(type){
-        for (let i = 0; i < this.globalManagers.length; i ++){
-            if (this.globalManagers[i] instanceof type)
-                return this.globalManagers[i] as T;
+        public static registerGlobalManager(manager: GlobalManager){
+            this.globalManagers.push(manager);
+            manager.enabled = true;
         }
 
-        return null;
+        public static unregisterGlobalManager(manager: GlobalManager){
+            this.globalManagers.remove(manager);
+            manager.enabled = false;
+        }
+
+        public static getGlobalManager<T extends GlobalManager>(type){
+            for (let i = 0; i < this.globalManagers.length; i ++){
+                if (this.globalManagers[i] instanceof type)
+                    return this.globalManagers[i] as T;
+            }
+
+            return null;
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Utils/Input.ts b/source/src/Utils/Input.ts
index 09d961f9..a66e9493 100644
--- a/source/src/Utils/Input.ts
+++ b/source/src/Utils/Input.ts
@@ -1,147 +1,149 @@
-class TouchState {
-    public x = 0;
-    public y = 0;
-    public touchPoint: number = -1;
-    public touchDown: boolean = false;
-    public get position(){
-        return new Vector2(this.x, this.y);
-    }
-
-    public reset(){
-        this.x = 0;
-        this.y = 0;
-        this.touchDown = false;
-        this.touchPoint = -1;
-    }
-}
-
-class Input {
-    private static _init: boolean = false;
-    private static _stage: egret.Stage;
-    private static _previousTouchState: TouchState = new TouchState();
-    private static _gameTouchs: TouchState[] = [];
-    private static _resolutionOffset: Vector2 = new Vector2();
-    private static _resolutionScale: Vector2 = Vector2.one;
-    private static _touchIndex: number = 0;
-    private static _totalTouchCount: number = 0;
-    /** 返回第一个触摸点的坐标 */
-    public static get touchPosition(){
-        if (!this._gameTouchs[0])
-            return Vector2.zero;
-        return this._gameTouchs[0].position;
-    }
-    /** 获取最大触摸数 */
-    public static get maxSupportedTouch(){
-        return this._stage.maxTouches;
-    }
-    /**
-     * 设置最大触摸数
-     */
-    public static set maxSupportedTouch(value: number){
-        this._stage.maxTouches = value;
-        this.initTouchCache();
-    }
-    /** 获取缩放值 默认为1 */
-    public static get resolutionScale(){
-        return this._resolutionScale;
-    }
-    /** 当前触摸点数量 */
-    public static get totalTouchCount(){
-        return this._totalTouchCount;
-    }
-    /** 
-     * 触摸列表 存放最大个数量触摸点信息 
-     * 可通过判断touchPoint是否为-1 来确定是否为有触摸
-     * 通过判断touchDown 判断触摸点是否有按下
-     */
-    public static get gameTouchs(){
-        return this._gameTouchs;
-    }
-
-    /** 获取第一个触摸点距离上次距离的增量 */
-    public static get touchPositionDelta(){
-        let delta = Vector2.subtract(this.touchPosition, this._previousTouchState.position);
-        if (delta.length() > 0){
-            this.setpreviousTouchState(this._gameTouchs[0]);
+module es {
+    export class TouchState {
+        public x = 0;
+        public y = 0;
+        public touchPoint: number = -1;
+        public touchDown: boolean = false;
+        public get position(){
+            return new Vector2(this.x, this.y);
         }
-        return delta;
-    }
 
-    public static initialize(stage: egret.Stage){
-        if (this._init)
-            return;
-
-        this._init = true;
-        this._stage = stage;
-        this._stage.addEventListener(egret.TouchEvent.TOUCH_BEGIN, this.touchBegin, this);
-        this._stage.addEventListener(egret.TouchEvent.TOUCH_MOVE, this.touchMove, this);
-        this._stage.addEventListener(egret.TouchEvent.TOUCH_END, this.touchEnd, this);
-        this._stage.addEventListener(egret.TouchEvent.TOUCH_CANCEL, this.touchEnd, this);
-        this._stage.addEventListener(egret.TouchEvent.TOUCH_RELEASE_OUTSIDE, this.touchEnd, this);
-
-        this.initTouchCache();
-    }
-
-    private static initTouchCache(){
-        this._totalTouchCount = 0;
-        this._touchIndex = 0;
-        this._gameTouchs.length = 0;
-        for (let i = 0; i < this.maxSupportedTouch; i ++){
-            this._gameTouchs.push(new TouchState());
+        public reset(){
+            this.x = 0;
+            this.y = 0;
+            this.touchDown = false;
+            this.touchPoint = -1;
         }
     }
 
-    private static touchBegin(evt: egret.TouchEvent){
-        if (this._touchIndex < this.maxSupportedTouch){
-            this._gameTouchs[this._touchIndex].touchPoint = evt.touchPointID;
-            this._gameTouchs[this._touchIndex].touchDown = evt.touchDown;
-            this._gameTouchs[this._touchIndex].x = evt.stageX;
-            this._gameTouchs[this._touchIndex].y = evt.stageY;
-            if (this._touchIndex == 0){
+    export class Input {
+        private static _init: boolean = false;
+        private static _stage: egret.Stage;
+        private static _previousTouchState: TouchState = new TouchState();
+        private static _gameTouchs: TouchState[] = [];
+        private static _resolutionOffset: Vector2 = new Vector2();
+        private static _resolutionScale: Vector2 = Vector2.one;
+        private static _touchIndex: number = 0;
+        private static _totalTouchCount: number = 0;
+        /** 返回第一个触摸点的坐标 */
+        public static get touchPosition(){
+            if (!this._gameTouchs[0])
+                return Vector2.zero;
+            return this._gameTouchs[0].position;
+        }
+        /** 获取最大触摸数 */
+        public static get maxSupportedTouch(){
+            return this._stage.maxTouches;
+        }
+        /**
+         * 设置最大触摸数
+         */
+        public static set maxSupportedTouch(value: number){
+            this._stage.maxTouches = value;
+            this.initTouchCache();
+        }
+        /** 获取缩放值 默认为1 */
+        public static get resolutionScale(){
+            return this._resolutionScale;
+        }
+        /** 当前触摸点数量 */
+        public static get totalTouchCount(){
+            return this._totalTouchCount;
+        }
+        /**
+         * 触摸列表 存放最大个数量触摸点信息
+         * 可通过判断touchPoint是否为-1 来确定是否为有触摸
+         * 通过判断touchDown 判断触摸点是否有按下
+         */
+        public static get gameTouchs(){
+            return this._gameTouchs;
+        }
+
+        /** 获取第一个触摸点距离上次距离的增量 */
+        public static get touchPositionDelta(){
+            let delta = Vector2.subtract(this.touchPosition, this._previousTouchState.position);
+            if (delta.length() > 0){
                 this.setpreviousTouchState(this._gameTouchs[0]);
             }
-            this._touchIndex ++;
-            this._totalTouchCount ++;
-        }
-    }
-
-    private static touchMove(evt: egret.TouchEvent){
-        if (evt.touchPointID == this._gameTouchs[0].touchPoint){
-            this.setpreviousTouchState(this._gameTouchs[0]);
+            return delta;
         }
 
-        let touchIndex = this._gameTouchs.findIndex(touch => touch.touchPoint == evt.touchPointID);
-        if (touchIndex != -1){
-            let touchData = this._gameTouchs[touchIndex];
-            touchData.x = evt.stageX;
-            touchData.y = evt.stageY;
-        }
-    }
+        public static initialize(stage: egret.Stage){
+            if (this._init)
+                return;
 
-    private static touchEnd(evt: egret.TouchEvent){
-        let touchIndex = this._gameTouchs.findIndex(touch => touch.touchPoint == evt.touchPointID);
-        if (touchIndex != -1){
-            let touchData = this._gameTouchs[touchIndex];
-            touchData.reset();
-            if (touchIndex == 0)
-                this._previousTouchState.reset();
-            this._totalTouchCount --;
-            if (this.totalTouchCount == 0){
-                this._touchIndex = 0;
+            this._init = true;
+            this._stage = stage;
+            this._stage.addEventListener(egret.TouchEvent.TOUCH_BEGIN, this.touchBegin, this);
+            this._stage.addEventListener(egret.TouchEvent.TOUCH_MOVE, this.touchMove, this);
+            this._stage.addEventListener(egret.TouchEvent.TOUCH_END, this.touchEnd, this);
+            this._stage.addEventListener(egret.TouchEvent.TOUCH_CANCEL, this.touchEnd, this);
+            this._stage.addEventListener(egret.TouchEvent.TOUCH_RELEASE_OUTSIDE, this.touchEnd, this);
+
+            this.initTouchCache();
+        }
+
+        private static initTouchCache(){
+            this._totalTouchCount = 0;
+            this._touchIndex = 0;
+            this._gameTouchs.length = 0;
+            for (let i = 0; i < this.maxSupportedTouch; i ++){
+                this._gameTouchs.push(new TouchState());
             }
         }
-    }
 
-    private static setpreviousTouchState(touchState: TouchState){
-        this._previousTouchState = new TouchState();
-        this._previousTouchState.x = touchState.position.x;
-        this._previousTouchState.y = touchState.position.y;
-        this._previousTouchState.touchPoint = touchState.touchPoint;
-        this._previousTouchState.touchDown = touchState.touchDown;
-    }
+        private static touchBegin(evt: egret.TouchEvent){
+            if (this._touchIndex < this.maxSupportedTouch){
+                this._gameTouchs[this._touchIndex].touchPoint = evt.touchPointID;
+                this._gameTouchs[this._touchIndex].touchDown = evt.touchDown;
+                this._gameTouchs[this._touchIndex].x = evt.stageX;
+                this._gameTouchs[this._touchIndex].y = evt.stageY;
+                if (this._touchIndex == 0){
+                    this.setpreviousTouchState(this._gameTouchs[0]);
+                }
+                this._touchIndex ++;
+                this._totalTouchCount ++;
+            }
+        }
 
-    public static scaledPosition(position: Vector2){
-        let scaledPos = new Vector2(position.x - this._resolutionOffset.x, position.y - this._resolutionOffset.y);
-        return Vector2.multiply(scaledPos, this.resolutionScale);
+        private static touchMove(evt: egret.TouchEvent){
+            if (evt.touchPointID == this._gameTouchs[0].touchPoint){
+                this.setpreviousTouchState(this._gameTouchs[0]);
+            }
+
+            let touchIndex = this._gameTouchs.findIndex(touch => touch.touchPoint == evt.touchPointID);
+            if (touchIndex != -1){
+                let touchData = this._gameTouchs[touchIndex];
+                touchData.x = evt.stageX;
+                touchData.y = evt.stageY;
+            }
+        }
+
+        private static touchEnd(evt: egret.TouchEvent){
+            let touchIndex = this._gameTouchs.findIndex(touch => touch.touchPoint == evt.touchPointID);
+            if (touchIndex != -1){
+                let touchData = this._gameTouchs[touchIndex];
+                touchData.reset();
+                if (touchIndex == 0)
+                    this._previousTouchState.reset();
+                this._totalTouchCount --;
+                if (this.totalTouchCount == 0){
+                    this._touchIndex = 0;
+                }
+            }
+        }
+
+        private static setpreviousTouchState(touchState: TouchState){
+            this._previousTouchState = new TouchState();
+            this._previousTouchState.x = touchState.position.x;
+            this._previousTouchState.y = touchState.position.y;
+            this._previousTouchState.touchPoint = touchState.touchPoint;
+            this._previousTouchState.touchDown = touchState.touchDown;
+        }
+
+        public static scaledPosition(position: Vector2){
+            let scaledPos = new Vector2(position.x - this._resolutionOffset.x, position.y - this._resolutionOffset.y);
+            return Vector2.multiply(scaledPos, this.resolutionScale);
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Utils/ListPool.ts b/source/src/Utils/ListPool.ts
index a208a76f..f40a6dc2 100644
--- a/source/src/Utils/ListPool.ts
+++ b/source/src/Utils/ListPool.ts
@@ -1,54 +1,56 @@
-/**
- * 可以用于列表池的简单类
- */
-class ListPool {
-    private static readonly _objectQueue = [];
-
+module es {
     /**
-     * 预热缓存，使用最大的cacheCount对象填充缓存
-     * @param cacheCount 
+     * 可以用于列表池的简单类
      */
-    public static warmCache(cacheCount: number){
-        cacheCount -= this._objectQueue.length;
-        if (cacheCount > 0){
-            for (let i = 0; i < cacheCount; i ++){
-                this._objectQueue.unshift([]);
+    export class ListPool {
+        private static readonly _objectQueue = [];
+
+        /**
+         * 预热缓存，使用最大的cacheCount对象填充缓存
+         * @param cacheCount
+         */
+        public static warmCache(cacheCount: number){
+            cacheCount -= this._objectQueue.length;
+            if (cacheCount > 0){
+                for (let i = 0; i < cacheCount; i ++){
+                    this._objectQueue.unshift([]);
+                }
             }
         }
-    }
 
-    /**
-     * 将缓存修剪为cacheCount项目
-     * @param cacheCount 
-     */
-    public static trimCache(cacheCount){
-        while (cacheCount > this._objectQueue.length)
-            this._objectQueue.shift();
-    }
+        /**
+         * 将缓存修剪为cacheCount项目
+         * @param cacheCount
+         */
+        public static trimCache(cacheCount){
+            while (cacheCount > this._objectQueue.length)
+                this._objectQueue.shift();
+        }
 
-    /**
-     * 清除缓存
-     */
-    public static clearCache(){
-        this._objectQueue.length = 0;
-    }
+        /**
+         * 清除缓存
+         */
+        public static clearCache(){
+            this._objectQueue.length = 0;
+        }
 
-    /**
-     * 如果可以的话，从堆栈中弹出一个项
-     */
-    public static obtain<T>(): T[] {
-        if (this._objectQueue.length > 0)
-            return this._objectQueue.shift();
+        /**
+         * 如果可以的话，从堆栈中弹出一个项
+         */
+        public static obtain<T>(): T[] {
+            if (this._objectQueue.length > 0)
+                return this._objectQueue.shift();
 
-        return [];
-    }
+            return [];
+        }
 
-    /**
-     * 将项推回堆栈
-     * @param obj 
-     */
-    public static free<T>(obj: Array<T>){
-        this._objectQueue.unshift(obj);
-        obj.length = 0;
+        /**
+         * 将项推回堆栈
+         * @param obj
+         */
+        public static free<T>(obj: Array<T>){
+            this._objectQueue.unshift(obj);
+            obj.length = 0;
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Utils/Pair.ts b/source/src/Utils/Pair.ts
index cc3cf6f2..f11e98bf 100644
--- a/source/src/Utils/Pair.ts
+++ b/source/src/Utils/Pair.ts
@@ -1,20 +1,22 @@
-/**
- * 用于管理一对对象的简单DTO
- */
-class Pair<T> {
-    public first: T;
-    public second: T;
+module es {
+    /**
+     * 用于管理一对对象的简单DTO
+     */
+    export class Pair<T> {
+        public first: T;
+        public second: T;
 
-    constructor(first: T, second: T){
-        this.first = first;
-        this.second = second;
-    }
+        constructor(first: T, second: T){
+            this.first = first;
+            this.second = second;
+        }
 
-    public clear(){
-        this.first = this.second = null;
-    }
+        public clear(){
+            this.first = this.second = null;
+        }
 
-    public equals(other: Pair<T>){
-        return this.first == other.first && this.second == other.second;
+        public equals(other: Pair<T>){
+            return this.first == other.first && this.second == other.second;
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Utils/RectangleExt.ts b/source/src/Utils/RectangleExt.ts
index 4b83e05f..03eb3124 100644
--- a/source/src/Utils/RectangleExt.ts
+++ b/source/src/Utils/RectangleExt.ts
@@ -1,17 +1,19 @@
-class RectangleExt {
-    /**
-     * 计算两个矩形的并集。结果将是一个包含其他两个的矩形。
-     * @param first 
-     * @param point 
-     */
-    public static union(first: Rectangle, point: Vector2){
-        let rect = new Rectangle(point.x, point.y, 0, 0);
-        // let rectResult = first.union(rect);
-        let result = new Rectangle();
-        result.x = Math.min(first.x, rect.x);
-        result.y = Math.min(first.y, rect.y);
-        result.width = Math.max(first.right, rect.right) - result.x;
-        result.height = Math.max(first.bottom, result.bottom) - result.y;
-        return result;
+module es {
+    export class RectangleExt {
+        /**
+         * 计算两个矩形的并集。结果将是一个包含其他两个的矩形。
+         * @param first
+         * @param point
+         */
+        public static union(first: Rectangle, point: Vector2){
+            let rect = new Rectangle(point.x, point.y, 0, 0);
+            // let rectResult = first.union(rect);
+            let result = new Rectangle();
+            result.x = Math.min(first.x, rect.x);
+            result.y = Math.min(first.y, rect.y);
+            result.width = Math.max(first.right, rect.right) - result.x;
+            result.height = Math.max(first.bottom, result.bottom) - result.y;
+            return result;
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/source/src/Utils/Triangulator.ts b/source/src/Utils/Triangulator.ts
index e283e4ce..2ec650c4 100644
--- a/source/src/Utils/Triangulator.ts
+++ b/source/src/Utils/Triangulator.ts
@@ -1,111 +1,113 @@
-/**
- * 三角剖分
- */
-class Triangulator {
-    /** 
-     * 最后一次三角调用中使用的点列表的三角形列表项的索引
-     */
-    public triangleIndices: number[] = [];
-
-    private _triPrev: number[] = new Array<number>(12);
-    private _triNext: number[] = new Array<number>(12);
-
+module es {
     /**
-     * 计算一个三角形列表，该列表完全覆盖给定点集所包含的区域。如果点不是CCW，则将arePointsCCW参数传递为false
-     * @param points 定义封闭路径的点列表
-     * @param arePointsCCW 
+     * 三角剖分
      */
-    public triangulate(points: Vector2[], arePointsCCW: boolean = true){
-        let count = points.length;
+    export class Triangulator {
+        /**
+         * 最后一次三角调用中使用的点列表的三角形列表项的索引
+         */
+        public triangleIndices: number[] = [];
 
-        // 设置前一个链接和下一个链接
-        this.initialize(count);
+        private _triPrev: number[] = new Array<number>(12);
+        private _triNext: number[] = new Array<number>(12);
 
-        // 非三角的多边形断路器
-        let iterations = 0;
+        /**
+         * 计算一个三角形列表，该列表完全覆盖给定点集所包含的区域。如果点不是CCW，则将arePointsCCW参数传递为false
+         * @param points 定义封闭路径的点列表
+         * @param arePointsCCW
+         */
+        public triangulate(points: Vector2[], arePointsCCW: boolean = true){
+            let count = points.length;
 
-        // 从0开始
-        let index = 0;
+            // 设置前一个链接和下一个链接
+            this.initialize(count);
 
-        // 继续移除所有的三角形，直到只剩下一个三角形
-        while (count > 3 && iterations < 500){
-            iterations ++;
+            // 非三角的多边形断路器
+            let iterations = 0;
 
-            let isEar = true;
-            let a = points[this._triPrev[index]];
-            let b = points[index];
-            let c = points[this._triNext[index]];
+            // 从0开始
+            let index = 0;
 
-            if (Vector2Ext.isTriangleCCW(a, b, c)){
-                let k = this._triNext[this._triNext[index]];
-                do {
-                    if (Triangulator.testPointTriangle(points[k], a, b, c)){
-                        isEar = false;
-                        break;
-                    }
+            // 继续移除所有的三角形，直到只剩下一个三角形
+            while (count > 3 && iterations < 500){
+                iterations ++;
 
-                    k = this._triNext[k];
-                } while (k != this._triPrev[index]);
-            }else{
-                isEar = false;
+                let isEar = true;
+                let a = points[this._triPrev[index]];
+                let b = points[index];
+                let c = points[this._triNext[index]];
+
+                if (Vector2Ext.isTriangleCCW(a, b, c)){
+                    let k = this._triNext[this._triNext[index]];
+                    do {
+                        if (Triangulator.testPointTriangle(points[k], a, b, c)){
+                            isEar = false;
+                            break;
+                        }
+
+                        k = this._triNext[k];
+                    } while (k != this._triPrev[index]);
+                }else{
+                    isEar = false;
+                }
+
+                if (isEar){
+                    this.triangleIndices.push(this._triPrev[index]);
+                    this.triangleIndices.push(index);
+                    this.triangleIndices.push(this._triNext[index]);
+
+                    // 删除vert通过重定向相邻vert的上一个和下一个链接，从而减少vertext计数
+                    this._triNext[this._triPrev[index]] = this._triNext[index];
+                    this._triPrev[this._triNext[index]] = this._triPrev[index];
+                    count --;
+
+                    // 接下来访问前一个vert
+                    index = this._triPrev[index];
+                }else{
+                    index = this._triNext[index];
+                }
             }
 
-            if (isEar){
-                this.triangleIndices.push(this._triPrev[index]);
-                this.triangleIndices.push(index);
-                this.triangleIndices.push(this._triNext[index]);
+            this.triangleIndices.push(this._triPrev[index]);
+            this.triangleIndices.push(index);
+            this.triangleIndices.push(this._triNext[index]);
 
-                // 删除vert通过重定向相邻vert的上一个和下一个链接，从而减少vertext计数
-                this._triNext[this._triPrev[index]] = this._triNext[index];
-                this._triPrev[this._triNext[index]] = this._triPrev[index];
-                count --;
+            if (!arePointsCCW)
+                this.triangleIndices.reverse();
+        }
 
-                // 接下来访问前一个vert
-                index = this._triPrev[index];
-            }else{
-                index = this._triNext[index];
+        private initialize(count: number){
+            this.triangleIndices.length = 0;
+
+            if (this._triNext.length < count){
+                this._triNext.reverse();
+                this._triNext = new Array<number>(Math.max(this._triNext.length * 2, count));
             }
+            if (this._triPrev.length < count){
+                this._triPrev.reverse();
+                this._triPrev = new Array<number>(Math.max(this._triPrev.length * 2, count));
+            }
+
+            for (let i = 0; i < count;i ++){
+                this._triPrev[i] = i - 1;
+                this._triNext[i] = i + 1;
+            }
+
+            this._triPrev[0] = count - 1;
+            this._triNext[count - 1] = 0;
         }
 
-        this.triangleIndices.push(this._triPrev[index]);
-        this.triangleIndices.push(index);
-        this.triangleIndices.push(this._triNext[index]);
+        public static testPointTriangle(point: Vector2, a: Vector2, b: Vector2, c: Vector2): boolean{
+            if (Vector2Ext.cross(Vector2.subtract(point, a), Vector2.subtract(b, a)) < 0)
+                return false;
 
-        if (!arePointsCCW)
-            this.triangleIndices.reverse();
-    }
+            if (Vector2Ext.cross(Vector2.subtract(point, b), Vector2.subtract(c, b)) < 0)
+                return false;
 
-    private initialize(count: number){
-        this.triangleIndices.length = 0;
+            if (Vector2Ext.cross(Vector2.subtract(point, c), Vector2.subtract(a, c)) < 0)
+                return false;
 
-        if (this._triNext.length < count){
-            this._triNext.reverse();
-            this._triNext = new Array<number>(Math.max(this._triNext.length * 2, count));
-        } 
-        if (this._triPrev.length < count){
-            this._triPrev.reverse();
-            this._triPrev = new Array<number>(Math.max(this._triPrev.length * 2, count));
+            return true;
         }
-
-        for (let i = 0; i < count;i ++){
-            this._triPrev[i] = i - 1;
-            this._triNext[i] = i + 1;
-        }
-
-        this._triPrev[0] = count - 1;
-        this._triNext[count - 1] = 0;
     }
-
-    public static testPointTriangle(point: Vector2, a: Vector2, b: Vector2, c: Vector2): boolean{
-        if (Vector2Ext.cross(Vector2.subtract(point, a), Vector2.subtract(b, a)) < 0)
-            return false;
-
-        if (Vector2Ext.cross(Vector2.subtract(point, b), Vector2.subtract(c, b)) < 0)
-            return false;
-
-        if (Vector2Ext.cross(Vector2.subtract(point, c), Vector2.subtract(a, c)) < 0)
-            return false;
-
-        return true;
-    }
-}
\ No newline at end of file
+}
diff --git a/source/src/Utils/Vector2Ext.ts b/source/src/Utils/Vector2Ext.ts
index 17789716..60ee6a4d 100644
--- a/source/src/Utils/Vector2Ext.ts
+++ b/source/src/Utils/Vector2Ext.ts
@@ -1,59 +1,60 @@
-class Vector2Ext {
-    /**
-     * 检查三角形是CCW还是CW
-     * @param a 
-     * @param center 
-     * @param c 
-     */
-    public static isTriangleCCW(a: Vector2, center: Vector2, c: Vector2) {
-        return this.cross(Vector2.subtract(center, a), Vector2.subtract(c, center)) < 0;
-    }
-
-    /**
-     * 计算二维伪叉乘点(Perp(u)， v)
-     * @param u 
-     * @param v 
-     */
-    public static cross(u: Vector2, v: Vector2) {
-        return u.y * v.x - u.x * v.y;
-    }
-
-    /**
-     * 返回与传入向量垂直的向量
-     * @param first 
-     * @param second 
-     */
-    public static perpendicular(first: Vector2, second: Vector2) {
-        return new Vector2(-1 * (second.y - first.y), second.x - first.x);
-    }
-
-    /**
-     * Vector2的临时解决方案
-     * 标准化把向量弄乱了
-     * @param vec 
-     */
-    public static normalize(vec: Vector2) {
-        let magnitude = Math.sqrt((vec.x * vec.x) + (vec.y * vec.y));
-        if (magnitude > MathHelper.Epsilon) {
-            vec = Vector2.divide(vec, new Vector2(magnitude));
-        } else {
-            vec.x = vec.y = 0;
+module es {
+    export class Vector2Ext {
+        /**
+         * 检查三角形是CCW还是CW
+         * @param a
+         * @param center
+         * @param c
+         */
+        public static isTriangleCCW(a: Vector2, center: Vector2, c: Vector2) {
+            return this.cross(Vector2.subtract(center, a), Vector2.subtract(c, center)) < 0;
         }
 
-        return vec;
-    }
+        /**
+         * 计算二维伪叉乘点(Perp(u)， v)
+         * @param u
+         * @param v
+         */
+        public static cross(u: Vector2, v: Vector2) {
+            return u.y * v.x - u.x * v.y;
+        }
 
-    /**
-     * 通过指定的矩阵对Vector2的数组中的向量应用变换，并将结果放置在另一个数组中。
-     * @param sourceArray 
-     * @param sourceIndex 
-     * @param matrix 
-     * @param destinationArray 
-     * @param destinationIndex 
-     * @param length 
-     */
-    public static transformA(sourceArray: Vector2[], sourceIndex: number, matrix: Matrix2D,
-        destinationArray: Vector2[], destinationIndex: number, length: number) {
+        /**
+         * 返回与传入向量垂直的向量
+         * @param first
+         * @param second
+         */
+        public static perpendicular(first: Vector2, second: Vector2) {
+            return new Vector2(-1 * (second.y - first.y), second.x - first.x);
+        }
+
+        /**
+         * Vector2的临时解决方案
+         * 标准化把向量弄乱了
+         * @param vec
+         */
+        public static normalize(vec: Vector2) {
+            let magnitude = Math.sqrt((vec.x * vec.x) + (vec.y * vec.y));
+            if (magnitude > MathHelper.Epsilon) {
+                vec = Vector2.divide(vec, new Vector2(magnitude));
+            } else {
+                vec.x = vec.y = 0;
+            }
+
+            return vec;
+        }
+
+        /**
+         * 通过指定的矩阵对Vector2的数组中的向量应用变换，并将结果放置在另一个数组中。
+         * @param sourceArray
+         * @param sourceIndex
+         * @param matrix
+         * @param destinationArray
+         * @param destinationIndex
+         * @param length
+         */
+        public static transformA(sourceArray: Vector2[], sourceIndex: number, matrix: Matrix2D,
+                                 destinationArray: Vector2[], destinationIndex: number, length: number) {
             for (let i = 0; i < length; i ++){
                 let position = sourceArray[sourceIndex + i];
                 let destination = destinationArray[destinationIndex + i];
@@ -61,25 +62,26 @@ class Vector2Ext {
                 destination.y = (position.x * matrix.m12) + (position.y * matrix.m22) + matrix.m32;
                 destinationArray[destinationIndex + i] = destination;
             }
-    }
+        }
 
-    public static transformR(position: Vector2, matrix: Matrix2D){
-        let x = (position.x * matrix.m11) + (position.y * matrix.m21) + matrix.m31;
-        let y = (position.x * matrix.m12) + (position.y * matrix.m22) + matrix.m32;
-        return new Vector2(x, y);
-    }
+        public static transformR(position: Vector2, matrix: Matrix2D){
+            let x = (position.x * matrix.m11) + (position.y * matrix.m21) + matrix.m31;
+            let y = (position.x * matrix.m12) + (position.y * matrix.m22) + matrix.m32;
+            return new Vector2(x, y);
+        }
 
-    /**
-     * 通过指定的矩阵对Vector2的数组中的所有向量应用变换，并将结果放到另一个数组中。
-     * @param sourceArray 
-     * @param matrix 
-     * @param destinationArray 
-     */
-    public static transform(sourceArray: Vector2[], matrix: Matrix2D, destinationArray: Vector2[]) {
-        this.transformA(sourceArray, 0, matrix, destinationArray, 0, sourceArray.length);
-    }
+        /**
+         * 通过指定的矩阵对Vector2的数组中的所有向量应用变换，并将结果放到另一个数组中。
+         * @param sourceArray
+         * @param matrix
+         * @param destinationArray
+         */
+        public static transform(sourceArray: Vector2[], matrix: Matrix2D, destinationArray: Vector2[]) {
+            this.transformA(sourceArray, 0, matrix, destinationArray, 0, sourceArray.length);
+        }
 
-    public static round(vec: Vector2){
-        return new Vector2(Math.round(vec.x), Math.round(vec.y));
+        public static round(vec: Vector2){
+            return new Vector2(Math.round(vec.x), Math.round(vec.y));
+        }
     }
-}
\ No newline at end of file
+}