trunk/lib/jgame.d.ts

declare module jg {
    /**
     * 座標を示すインターフェース
     */
    interface CommonOffset {
        /** 横座標 */
        x: number;
        /** 縦座標 */
        y: number;
    }
    /**
     * 大きさを示すインターフェース
     */
    interface CommonSize {
        /** 横幅 */
        width: number;
        /** 縦幅 */
        height: number;
    }
    /**
     * 領域を示すインターフェース
     */
    interface CommonArea extends CommonOffset, CommonSize {
    }
    /**
     * 四角形を現すインターフェース
     */
    interface IRectangle {
        /** 左位置 */
        left: number;
        /** 上位置 */
        top: number;
        /** 右位置 */
        right: number;
        /** 下位置 */
        bottom: number;
    }
}
declare module jg {
    /**
     * 方向
     */
    enum Angle {
        Unknown = 0,
        Left = 1,
        Right = 2,
        Up = 3,
        Down = 4,
    }
    /**
     * 描画モード。Transfer = デフォルト、Flip = フリップ、Direct = 直接。
     * jgame.jsでは動作に支障が無いことが確認出来る環境では、Directを使うことを推奨している。
     */
    enum RenderTransferMode {
        Unknown = 0,
        Transfer = 1,
        Flip = 2,
        Direct = 3,
    }
    /**
     * 入力イベント種別
     */
    enum InputEventType {
        Unknown = 0,
        Keyboard = 1,
        Point = 2,
    }
    /**
     * 入力イベントの挙動
     */
    enum InputEventAction {
        Unknown = 0,
        Down = 1,
        Move = 2,
        Up = 3,
    }
    /**
     * キーの種別
     */
    enum Keytype {
        Unknown = 0,
        Left = 1,
        Right = 2,
        Up = 3,
        Down = 4,
        Enter = 5,
        Esc = 6,
    }
    /**
     * Shapeの描画スタイル。塗りつぶす(Fill)か線(Stroke)かを指定。
     */
    enum ShapeStyle {
        /** 未定義 */
        Unknown = 0,
        /**
         * 線を描画
         */
        Stroke = 1,
        /**
         *
         塗りつぶして描画
         */
        Fill = 2,
    }
    /**
     * Shapeの形状。
     * Rectで四角、Arcで丸
     */
    enum ShapeType {
        Unknown = 0,
        Rect = 1,
        Arc = 2,
    }
    /**
     * エフェクトの種類
     */
    enum EffectType {
        None = 0,
        Fade = 1,
        Mosaic = 2,
        Blur = 3,
        SlideUp = 4,
        SlideDown = 5,
        SlideLeft = 6,
        SlideRight = 7,
        WipeUp = 8,
        WipeDown = 9,
        WipeLeft = 10,
        WipeRight = 11,
        WipeFadeUp = 12,
        WipeFadeDown = 13,
        WipeFadeLeft = 14,
        WipeFadeRight = 15,
        BoxOut = 16,
        BoxOut45 = 17,
        BoxIn = 18,
        BoxIn45 = 19,
        ArcOut = 20,
        ArcIn = 21,
    }
}
/**
 * windowインターフェースの拡張
 */
interface Window {
    createCanvas(width: number, height: number): HTMLCanvasElement;
}
declare module jg {
    /**
     * 四角形クラス
     */
    class Rectangle implements IRectangle {
        /** 左座標 */
        left: number;
        /** 上座標 */
        top: number;
        /** 右座標 */
        right: number;
        /** 下座標 */
        bottom: number;
        /**
         * コンストラクタ
         * @param left 左座標
         * @param top 上座標
         * @param right 右座標
         * @param bottom 下座標
         */
        constructor(left?: number, top?: number, right?: number, bottom?: number);
        /**
         * 多少の座標がこの四角形に当たっているかを判定する
         * @param point 判定対象の座標
         */
        hitTest(point: CommonOffset): boolean;
        /**
         * 対象の座標をこの四角形に吸着させる
         * @param point 対象の座標
         */
        fit(point: CommonOffset): void;
        /**
         * この四角形の横幅を得る
         */
        width(): number;
        /**
         * この四角形の縦幅を得る
         */
        height(): number;
    }
}
declare module jg {
    /**
     * ============================================================================================
     * Easing Equations v2.0
     * September 1, 2003
     * (c) 2003 Robert Penner, all rights reserved.
     * This work is subject to the terms in http://www.robertpenner.com/easing_terms_of_use.html.
     * ============================================================================================
     */
    /**
     * イージング関数ライブラリ
     * enchant.jsプロジェクトで
     * 「ActionScript で広く使われている Robert Penner による Easing Equations を JavaScript に移植した」
     * ライブラリを、さらにType script用に移植したもの。
     *
     * @see http://www.robertpenner.com/easing/
     * @see http://www.robertpenner.com/easing/penner_chapter7_tweening.pdf
     *
     * Easing function library, from "Easing Equations" by Robert Penner.
     */
    class Easing {
        static LINEAR(t: number, b: number, c: number, d: number): number;
        static SWING(t: number, b: number, c: number, d: number): number;
        static QUAD_EASEIN(t: number, b: number, c: number, d: number): number;
        static QUAD_EASEOUT(t: number, b: number, c: number, d: number): number;
        static QUAD_EASEINOUT(t: number, b: number, c: number, d: number): number;
        static CUBIC_EASEIN(t: number, b: number, c: number, d: number): number;
        static CUBIC_EASEOUT(t: number, b: number, c: number, d: number): number;
        static CUBIC_EASEINOUT(t: number, b: number, c: number, d: number): number;
        static QUART_EASEIN(t: number, b: number, c: number, d: number): number;
        static QUART_EASEOUT(t: number, b: number, c: number, d: number): number;
        static QUART_EASEINOUT(t: number, b: number, c: number, d: number): number;
        static QUINT_EASEIN(t: number, b: number, c: number, d: number): number;
        static QUINT_EASEOUT(t: number, b: number, c: number, d: number): number;
        static QUINT_EASEINOUT(t: number, b: number, c: number, d: number): number;
        static SIN_EASEIN(t: number, b: number, c: number, d: number): number;
        static SIN_EASEOUT(t: number, b: number, c: number, d: number): number;
        static SIN_EASEINOUT(t: number, b: number, c: number, d: number): number;
        static CIRC_EASEIN(t: number, b: number, c: number, d: number): number;
        static CIRC_EASEOUT(t: number, b: number, c: number, d: number): number;
        static CIRC_EASEINOUT(t: number, b: number, c: number, d: number): number;
        static ELASTIC_EASEIN(t: number, b: number, c: number, d: number, a?: number, p?: number): number;
        static ELASTIC_EASEOUT(t: number, b: number, c: number, d: number, a?: number, p?: number): number;
        static ELASTIC_EASEINOUT(t: number, b: number, c: number, d: number, a?: number, p?: number): number;
        static BOUNCE_EASEOUT(t: number, b: number, c: number, d: number): number;
        static BOUNCE_EASEIN(t: number, b: number, c: number, d: number): number;
        static BOUNCE_EASEINOUT(t: number, b: number, c: number, d: number): number;
        static BACK_EASEIN(t: number, b: number, c: number, d: number, s?: number): number;
        static BACK_EASEOUT(t: number, b: number, c: number, d: number, s?: number): number;
        static BACK_EASEINOUT(t: number, b: number, c: number, d: number, s?: number): number;
        static EXPO_EASEIN(t: number, b: number, c: number, d: number): number;
        static EXPO_EASEOUT(t: number, b: number, c: number, d: number): number;
        static EXPO_EASEINOUT(t: number, b: number, c: number, d: number): number;
    }
}
declare module jg {
    /**
     * 描画オプションをあらわすインターフェース
     */
    interface IEntityOptions {
        /** 回転確度 */
        rotate: number;
        /** 位置 */
        translate: CommonOffset;
        /** 変形 */
        transform: {
            m11: number;
            m12: number;
            m21: number;
            m22: number;
            dx: number;
            dy: number;
        };
        /** 拡縮 */
        scale: CommonOffset;
        /** 左上を基準とした拡縮 */
        purescale: CommonOffset;
        /** 透明度 */
        globalAlpha?: number;
        /** フォント */
        font?: string;
        /** 塗りつぶしスタイル */
        fillStyle?: string;
        /** 線スタイル */
        strokeStyle?: string;
        /**
         * 線の末端形状。
         * butt, round, squareのいずれかを指定。デフォルトはbutt
         */
        lineCap?: string;
        /**
         * 線の結合形状。
         * bevel, round, miterのいずれかを指定。デフォルトはmiter
         */
        lineJoin?: string;
        /** 線の太さ */
        lineWidth?: number;
        /** マイター限界比率 */
        miterLimit?: string;
        /** 影の量 */
        shadowBlur?: number;
        /** 影の色 */
        shadowColor?: string;
        /** 影のオフセットX座標 */
        shadowOffsetX?: number;
        /** 影のオフセットY座標 */
        shadowOffsetY?: number;
        /**
         * 文字の方向。
         * start, end, left, right, centerのいずれかを指定。デフォルトはstart
         */
        textAlign?: string;
        /**
         * 文字基準線。
         *  top, hanging, middle, alphabetic, ideographic, bottomのいずれかを指定。デフォルトはalphabetic
         */
        textBaseline?: string;
        /**
         * 結合方式。以下いずれか、または各種ベンダー拡張方式を指定。
         * source-atop
         * source-in
         * source-out
         * source-over (default)
         * destination-atop
         * destination-in
         * destination-out
         * destination-over
         * lighter
         * copy
         * xor
         */
        globalCompositeOperation?: string;
    }
    /**
     * デフォルトの描画オプション
     */
    var ENTITY_OPTIONS_DEFAULT_VALUES: IEntityOptions;
    /**
     * jgame.jsにおいて、最も基本的な描画単位です。より正確な名称はエンティティ（Entity）です。
     * Sprite、Shape、Label、Tile、さらにはLayerもこのクラスを継承して作られています。jgame.jsで描画される全てのオブジェクトはEntityであり、Entityでないもの（Sceneなど）は描画されません。
     * 動作速度が重用視されるjgame.jsにおいて、Gameクラス、Rendererクラスと並ぶ最も重要なクラスですが、通常のユーザがこのクラスを利用することはありません。
     * このクラスを利用するのは、このクラスを継承して新しい描画オブジェクトを作るなど、一歩進んだ使い方をする時でしょう。
     */
    class E {
        /** X座標 */
        x: number;
        /** Y座標 */
        y: number;
        /** 横幅 */
        width: number;
        /** 縦幅 */
        height: number;
        /** Timelineのインスタンス。通常このフィールドを直接参照せず、tl()メソッドを通して参照する */
        _tl: Timeline;
        /** 現在のシーン */
        scene: Scene;
        /** 親Entity */
        parent: E;
        /** 初期化が可能な状態になった場合に実行する処理群 */
        active_queue: Function[];
        /** startメソッドを実行済みかどうかのフラグ */
        started: boolean;
        /** 前回の描画から更新されているかを表すフラグ */
        isUpdated: boolean;
        /** 変形などを無効化するかのフラグ。これがセットされているものは、座標計算を含めて自前で描画処理を実装する必要があるが、その分高速 */
        disableTransform: boolean;
        /** 子Entity */
        entities: E[];
        /** ポイントイベントを受信するかどうか */
        pointCapture: boolean;
        /** ポインティングデバイスで押下処理が発生したことを示すイベント。InputPointEventをパラメータとして受け取る */
        pointDown: Trigger;
        /** ポインティングデバイスで押下処理が終了したことを示すイベント。InputPointEventをパラメータとして受け取る */
        pointUp: Trigger;
        /** ポインティングデバイスで押下処理中に移動が発生したことを示す。InputPointEventをパラメータとして受け取る */
        pointMove: Trigger;
        /** 描画オプション。詳細はIEntityOptionsなどを参照 */
        options: Object;
        /** このEntityの子Entityを描画する際に利用する描画順制御関数 */
        orderDraw: (target: E) => void;
        /** フィルタ */
        filter: ImageFilter.FilterChain;
        /** スクロール座標 */
        scroll: CommonOffset;
        /** 透明度 */
        opacity: number;
        /**
         * コンストラクタ
         */
        constructor();
        /**
         * ポインティングイベントを有効化する
         */
        enablePointingEvent(): void;
        /**
         * ポインティングイベントを無効化する。
         * pointDown, pointMove, pointUpに設定したハンドラの解放処理は別途行う必要がある
         */
        disablePointingEvent(): void;
        /**
         * 描画オプションを一つ削除する。詳細はIEntityOptionsなどを参照
         *  一つも描画オプションを指定していない状態が最速であるため、利用が終わったオプションは迅速な削除が推奨される。
         * @param name 削除するオプション
         */
        removeDrawOption(name: string): void;
        /**
         * 描画オプションを指定する。詳細はIEntityOptionsなどを参照
         * @param name 指定するオプション名
         * @param value オプションに指定する値
         */
        setDrawOption(name: string, value: any): void;
        /**
         * 描画オプションの現在値を取得する。
         * なお、指定されていない場合はデフォルト値を返すため、指定されているかどうかの判定でこのメソッドを利用してはならない。
         * 指定されているかどうかの判定は、optionsフィールドを直接見る必要がある。
         * @param name 取得する描画オプション名
         */
        getDrawOption(name: string): any;
        /**
         * 指定座標に移動し、更新フラグを立てる。x, yフィールドを直接操作すると、更新フラグを立てずに移動させることも可能。
         * @param x 移動先x座標
         * @param y 移動先y座標
         */
        moveTo(x: number, y: number): void;
        /**
         * 現在位置から相対的に移動させ、更新フラグを立てる。x, yフィールドを直接操作すると、更新フラグを立てずに移動させることも可能。
         * @param x x座標の移動量
         * @param y y座標の移動量
         */
        moveBy(x: number, y: number): void;
        /**
         * 指定座標にスクロールさせる
         * @param x スクロール先x座標
         * @param y スクロール先y座標
         */
        scrollTo(x: number, y: number): void;
        /**
         * 相対的にスクロールさせる
         * @param x x座標のスクロール量
         * @param y y座標のスクロール量
         */
        scrollBy(x: number, y: number): void;
        /**
         * このEntityの初期化処理を行う
         */
        activate(): void;
        /**
         * 初期化処理を追加する
         */
        addActiveQueue(f: Function): void;
        /**
         * このEntityをシーンに追加する
         * @param scene 追加対象scene
         * @param layerName 追加対象レイヤー名。省略時はrootになる
         */
        appendTo(scene: Scene, layerName?: string): void;
        /**
         * このEntityを削除する。
         * Layerはこのメソッドでは削除出来ないため、Scene.deleteLayerメソッドを利用する必要がある
         */
        remove(): void;
        /**
         * このEntityの指定位置に子供を挿入する。
         * @param entity 挿入対象の子Entity
         * @param index 挿入位置
         */
        insert(entity: E, index: any): void;
        /**
         * このEntityに子供を追加する
         * @param entity 追加対象の子Entity
         */
        append(entity: E): void;
        /**
         * このEntityから子供を削除する
         * @param entity 削除対象の子Entity
         */
        removeChild(entity: E): boolean;
        /**
         * このEntityを活性化させる。このメソッドを呼び出した後は、game.updateイベントのハンドラとしてE.updateメソッドが呼び出されるようになる
         */
        start(): void;
        /**
         * このEntityを非活性化させる。
         */
        stop(): void;
        /**
         * 指定のタイマーを稼動させる。
         * @param wait タイマー起動間隔をミリ秒で指定
         * @param method タイマーのコールバック。省略時はintervalメソッドが指定される
         */
        startTimer(wait: number, method?: Function): void;
        /**
         * 指定のタイマーを停止させる
         * @param wait 停止対象タイマーの起動間隔
         * @param method 停止対象タイマーのコールバック。省略時はintervalメソッド
         */
        stopTimer(wait: number, method?: Function): void;
        /**
         * 更新フラグを立てる。これが立っていないと再描画されない。
         * 高速描画を目指すjgame.jsで一番多いトラブルが更新フラグ立て忘れなので、怪しい場合は呼び出してみるといいかもしれない。
         * なお、親要素がある場合は親要素の更新フラグ更新を優先させるため、本メソッドを呼び出した後に必ずthis.isUpdate()の戻り値がtrueになるわけではない
         */
        updated(): void;
        /**
         * このEntityのTimelineを取得する
         */
        tl(): Timeline;
        /**
         * このEntityを破棄する
         */
        destroy(): void;
        /**
         * このEntityのゲームから見たオフセット位置を取得する。
         * x, y単体とは異なり、親要素の座標も考慮に入れた座標を返す。
         */
        offset(): CommonOffset;
        /**
         * この要素のゲーム中での領域を取得する。
         * offsetと同じく、親要素の座標も考慮に入れた領域を返す。
         */
        rect(): Rectangle;
        /**
         * 指定の座標がこの要素と接触しているかを判定する。
         * @param point 判定する座標。
         */
        hitTest(point: CommonOffset): boolean;
        /**
         * 指定の座標との距離を取得する。中心点からの距離である点に注意
         * @param point 距離を取得する座標。CommonAreaの場合領域の中心からの距離を取得する
         */
        getDistance(point: CommonOffset): CommonOffset;
        /**
         * 指定座標に合致する要素を返す。子要素や自分自身も含めて判定する
         * @param point 判定する座標
         * @param force trueの場合、各EntityのenablePointingEvent設定値を無視
         */
        getEntityByPoint(point: CommonOffset, force?: boolean): E;
        /**
         * このEntityをSpriteに変換する
         */
        createSprite(): Sprite;
        /** startによる活性化で呼び出されるGame.updateイベントのイベントハンドラ */
        update(t: number): void;
        /** startTimerによって呼び出されるタイマーのコールバック */
        interval(): void;
        /**
         * 描画
         * @param context 描画対象context
         */
        draw(context: CanvasRenderingContext2D): void;
        /**
         * このEntityを表示し、更新フラグを立てる
         */
        show(): void;
        /**
         * このEntityを非表示にし、更新フラグを立てる
         */
        hide(): void;
    }
}
declare module jg {
    /**
     * 図形を現すクラス。クリッピング領域の指定にも使える
     */
    class Shape extends E {
        /** Shapeの描画スタイル。塗りつぶすか外周かを指定。変更する際はsetStyleを利用 */
        style: ShapeStyle;
        /** Shapeの形状。円か四角 */
        type: ShapeType;
        /** 同期対象オブジェクト */
        syncObj: any;
        /** 同期処理を行う関数 */
        syncFunc: (shape: Shape) => void;
        /** Math.PI * 2 */
        static PI_200_PER: number;
        /** クリッピング領域にするかどうかを指定。変更する場合はこのプロパティを直接操作せず、setClipメソッドを利用する */
        clip: boolean;
        /**
         * 新しいShapeクラスを生成する
         * @param width 横幅。
         * @param height 縦幅。ShapeTypeがArcの場合無視される
         * @param style Shapeの描画スタイル。デフォルトはShapeStyle.Stroke（線）
         * @param color Shapeの色。デフォルトは黒
         * @param type Shapeの形状。デフォルトはShapeType.Rect（四角）
         */
        constructor(width: number, height: number, style?: ShapeStyle, color?: any, type?: ShapeType);
        /**
         * このオブジェクトをクリップモードにする。またはクリップモードを解除する。
         * クリップモードとなったShapeは描画されず、以降に描画されるオブジェクトの描画領域を制限する。
         */
        setClip(value: boolean): void;
        /**
         * Shapeの描画スタイルを変更する
         */
        setStyle(style: ShapeStyle): void;
        /**
         * Shapeの線の太さを変更する
         */
        setLineWidth(width: number): void;
        /**
         * Shapeの線の太さを取得する
         */
        getLineWidth(): any;
        /**
         * Shapeの色を指定する
         * @param color 指定する色。CSS Color形式やグラデーションなどで指定
         */
        setColor(color: any): void;
        /**
         * Shapeの色を取得する
         */
        getColor(): any;
        /**
         * このShapeを特定のオブジェクトに同期させる
         * @param syncObj 同期するオブジェクト。
         * @param syncFunc 同期に利用する関数。例えばこの関数内でshape.x = this.xなどとやれば、ShapeのX座標は常に同期する
         */
        synchronize(syncObj: any, syncFunc: (shape: Shape) => void): void;
        draw(context: CanvasRenderingContext2D): void;
    }
}
declare module jg {
    /**
     * ハンドラ用インターフェース
     */
    interface TriggerHandler {
        /** ハンドラ所有者 */
        owner: any;
        /** コールバック */
        handler: Function;
    }
    /**
     * jgame.jsのイベント機構を管理するクラス。
     * TypeScriptに合ったイベント機構として、thisを指定可能なイベントハンドラを用いるために考案された。
     * 1イベントに付き1つのTriggerを作る事を想定しているため、例えばDOMであるkeyDown、keyUpのイベントを作るなら、このようにする。
     * this.keyDown = new jg.Trigger();
     * this.keyUp = new jg.Trigger();
     *
     * イベントハンドラの指定はhandleで行い、イベントの発火はfireで行う。
     * イベントハンドラの削除はremove, removeAll, removeAllByHandler, destroyの4種が用意されており、匿名メソッドにおけるハンドラ削除をやりやすくしている。
     *
     * Genericsにするとよりタイプセーフになるが、jgame.js開発開始時点ではGenericsが存在しなかったため導入されていない。将来のGenericsは検討中。
     */
    class Trigger {
        /** このTriggerに登録された全ハンドラ */
        handlers: TriggerHandler[];
        /**
         * コンストラクタ
         */
        constructor();
        /**
         * 所定の位置にハンドラを挿入する。ハンドラ順序が処理に影響する場合に指定する
         * @param index 挿入位置。添え字は0から
         * @param owner ハンドラ所有者。イベント発火時には、この値がthisとなる
         * @param handler ハンドラのコールバック関数
         */
        handleInsert(index: number, owner: any, handler?: Function): void;
        /**
         * ハンドラを追加する
         * @param owner ハンドラ所有者。イベント発火時には、この値がthisとなる
         * @param handler ハンドラのコールバック関数
         */
        handle(owner: any, handler?: Function): void;
        /**
         * すべてのハンドラを削除する
         */
        destroy(): void;
        /**
         * 指定された所有者のハンドラをすべて削除する
         * @param owner 削除対象のハンドラ所有者
         */
        removeAll(owner: any): void;
        /**
         * 指定されたコールバック関数のハンドラをすべて削除する
         * @param handler 削除対象のコールバック関数
         */
        removeAllByHandler(handler: Function): void;
        /**
         * ハンドラを削除する
         * @param owner 削除対象のハンドラ所有者
         * @param handler 削除対象のコールバック関数
         */
        remove(owner: any, handler?: Function): void;
        /**
         * イベントを発火する
         * @param param イベントパラメータ
         */
        fire(param?: any): void;
        /**
         * 非セーフティな形でイベントを発火する。
         * このメソッドの利用は極力控えるべき。ハンドラ内でイベントハンドラの追加や削除が行われると、すべてのハンドラに処理が伝達されないため。
         * ハンドラ内で削除されないことが保障されている場合や、複数処理されてもかまわないような場合にのみ利用する。
         * @param param イベントパラメータ
         */
        fastFire(param?: any): void;
    }
}
declare module jg {
    /**
     * 最低限のサウンドサポートを提供するクラス。
     * jgame.js的には、別のライブラリでサウンド実装することを推奨している。
     */
    class SimpleSound {
        /** BGMに利用するAudio。一つのみ指定可 */
        static bgm: HTMLAudioElement;
        /**
         * サウンドを再生する
         * @param sound 再生するサウンド
         * @param loop trueでloop再生する
         */
        static play(sound: HTMLAudioElement, loop?: boolean): HTMLAudioElement;
        /**
         * BGMが存在するかどうかを返す
         */
        static hasBgm(): boolean;
        /**
         * BGMを再生する
         * @param sound 再生するBGM
         * @param loop trueの場合loop再生する
         */
        static playBgm(sound: HTMLAudioElement, loop?: boolean): HTMLAudioElement;
        /**
         * サウンドの再生を停止する
         * @param source 再生を停止する対象のサウンド
         */
        static stop(source: HTMLAudioElement): void;
        /**
         * BGMの再生を停止する
         */
        static stopBgm(): void;
    }
}
declare module jg {
    /**
     * リソース構造クラス
     */
    class ResourceStructure {
        /** 画像のパス */
        img: string;
        /** サウンドのパス */
        sound: string;
        /** デフォルトのリソース構造 */
        static Default: ResourceStructure;
        /** よく使われることを想定しているプレーンな構造 */
        static Plain: ResourceStructure;
        /**
         * コンストラクタ
         * @param img 画像のパス
         * @param sound サウンドのパス
         */
        constructor(img: string, sound: string);
        /**
         * 絶対パスかどうかを判定
         * @param url 判定するURL
         */
        isAbsolute(url: string): string;
        /**
         * 構造に則った画像のURLを返す
         * @param url 画像のパス
         */
        imageUrl(url: string): string;
        /**
         * 構造に則ったサウンドのURLを返す
         * @param url サウンドのパス
         */
        soundUrl(url: string): string;
    }
}
declare module jg {
    /**
     * リソースを読み込むくラス
     */
    class ResourceLoader {
        /** 読み込み対象のリソース */
        resource: Resource;
        /**
         * コンストラクタ
         * @param resource 読み込み対象のリソース
         */
        constructor(resource: Resource);
        /**
         * リソースを読み込む。サブクラスでオーバーライドする想定であり、このメソッドは何もしない
         * @param url リソースのURL
         * @param identifier リソースの識別子
         */
        load(url: string, identifier: string): void;
    }
    /**
     * 画像リソースを読み込む
     */
    class ImageResourceLoader extends ResourceLoader {
        /**
         * 画像リソースを読み込む
         * @param url 画像リソースのURL
         * @param identifier リソースの識別子
         */
        load(url: string, identifier: string): void;
        /**
         * 完了時のコールバック。リソースクラスに画像を登録し、読み込み完了を通知する
         * @param name 画像の識別子
         * @param image 読み込んだ画像
         * @param is_success trueで成功、falseでエラー
         */
        completed(name: string, image: HTMLImageElement, is_success: boolean): void;
    }
    /**
     * 外部JavaScriptを読み込むクラス。
     * このクラスではjavascriptの依存関係を解決するため、先に読み込んだリソースの読み込みが完了するまで、次のリソースを読み込むことはない
     */
    class ScriptResourceLoader extends ResourceLoader {
        /** ロード中かをあらわすフラグ */
        static loading: boolean;
        /**
         * javascriptリソースを読み込む
         * @param url javascriptリソースのURL
         * @param identifier リソースの識別子
         */
        load(url: string, identifier: string): void;
        /**
         * 完了時のコールバック。リソースクラスにスクリプトを登録し、読み込み完了を通知する
         * @param name スクリプトの識別子
         * @param image 読み込んだスクリプト
         * @param is_success trueで成功、falseでエラー
         */
        completed(name: string, script: HTMLScriptElement, is_success: boolean): void;
    }
    /**
     * サウンドを読み込む
     */
    class SoundResourceLoader extends ResourceLoader {
        /**
         * サウンドリソースを読み込む
         * @param url サウンドリソースのURL
         * @param identifier リソースの識別子
         */
        load(url: string, identifier: string): void;
        /**
         * 完了時のコールバック。リソースクラスにサウンドを登録し、読み込み完了を通知する
         * @param name サウンドの識別子
         * @param image 読み込んだサウンド
         * @param is_success trueで成功、falseでエラー
         */
        completed(name: string, audio: HTMLAudioElement, is_success: boolean): void;
    }
}
declare module jg {
    /**
     * 画像やサウンドなどのリソースを管理するクラス。
     * このクラスはjgame.jsでは例外的な単一インスタンスのクラスであるため、複数ゲームを1ページに読み込む場合は注意が必要
     */
    class Resource {
        /** 読み込み済みの画像 */
        images: {
            [key: string]: HTMLImageElement;
        };
        /** 読み込み済みのスクリプト */
        scripts: {
            [key: string]: HTMLScriptElement;
        };
        /** 読み込み済みのサウンド */
        sounds: {
            [key: string]: any;
        };
        /** 読み込み予定の識別子リスト */
        requests: string[];
        /**
         * 読み込みが完了するたびに発火されるイベント。
         * パラメータで残りリクエスト数を受け取るため、全読み込み完了はloaded.handle((e) => {if (e == 0) console.log("completed");});などで判定可能 */
        loaded: Trigger;
        /**
         * リソースの読み込みリクエストが追加される度に発火されるイベント。
         * パラメータとして、{name: リソース識別子, url: リソースのURL, loader: ResourceLoaderクラス}を持つ
         */
        added: Trigger;
        /**
         * このクラスが管理しているResourceLoader。拡張子ごとのResourceLoaderのマップになっている。
         * デフォルトでは以下の通り。"default"は登録されていないすべての拡張子が該当する。
         * "js": ScriptResourceLoader
         * "default": ImageResourceLoader
         * "mp3": SoundResourceLoader
         * "ogg": SoundResourceLoader
         * "wav": SoundResourceLoader
         * "mid": SoundResourceLoader
         */
        loaders: {
            [key: string]: ResourceLoader;
        };
        /** このリソースの現在の構造 */
        structure: ResourceStructure;
        /** 単一のインスタンス */
        static instance: Resource;
        /**
         * 唯一のインスタンスを取得する。
         */
        static getInstance(): Resource;
        /**
         * 新しいResourceクラスを生成するが、この方法でResourceクラスを生成するべきではなく、jgame.jsではgetInstanceによる単一インスタンスでの利用を推奨している
         */
        constructor();
        /**
         * すべてのリソースを解放する
         */
        clear(): void;
        /**
         * 画像リソースを取得する
         */
        get(name: string): HTMLImageElement;
        /**
         * サウンドリソースを取得する
         */
        sound(name: string): any;
        /**
         * リクエストの完了を通知する
         * @param name リクエストが完了したリソースの識別子
         */
        requestCompleted(name: string): void;
        /**
         * リソースを読み込む
         * @param name リソースの識別子。url省略時は、urlと同じ値になる
         * @param url リソースのURL
         */
        load(name: string, url?: string): void;
        /**
         * 手動で読み込むを行う。
         * このメソッド内でResourceクラスは何も処理をせず、ただリクエストを登録する。
         * ロードが完了したリソースは、別途completeManualを通じてResourceクラスに読み込み完了を手動通知する必要がある。
         * 主に、外部ライブラリでの読み込み処理での利用を想定している。
         * @param name リソース識別子
         */
        loadManual(name: string): void;
        /**
         * 手動で読み込み完了を行う。通常はloadManualとセットで利用する
         * @param name リソース識別子
         */
        completeManual(name: string): void;
    }
}
declare module jg {
    /**
     * シーンを表すクラス
     */
    class Scene {
        /** 管理している全レイヤー */
        layers: {
            [key: string]: Layer;
        };
        /** レイヤー数 */
        layerCount: number;
        /** このシーンを管理しているゲーム */
        game: Game;
        /** スタックされたモード */
        mode: string[];
        /** 表示された時に発生するイベントハンドラ。startedとは異なり、endSceneで自身が再表示された時に発生する */
        showed: Trigger;
        /** 隠された時に発生するイベントハンドラ。changeSceneで自分が隠された時に発生する */
        hid: Trigger;
        /** このシーンが終了した時に発生するイベントハンドラ */
        ended: Trigger;
        /** このシーンが開始された時に発生するイベントハンドラ */
        started: Trigger;
        /** ルートレイヤー */
        root: Layer;
        /** キーが押された場合のイベントハンドラ。通常はundefinedであるため、利用する場合は自前でscene.keyDown = new jg.Trigger()を行う必要がある */
        keyDown: Trigger;
        /** キーが離された場合のイベントハンドラ。通常はundefinedであるため、利用する場合は自前でscene.keyDown = new jg.Trigger()を行う必要がある */
        keyUp: Trigger;
        /** ポイントが押された場合のイベントハンドラ。enablePointingEventを呼び出すまではundefined */
        pointDown: Trigger;
        /** ポイントが離された場合のイベントハンドラ。enablePointingEventを呼び出すまではundefined */
        pointUp: Trigger;
        /** ポイントが移動した場合のイベントハンドラ。enablePointingEventを呼び出すまではundefined */
        pointMove: Trigger;
        /**
         * コンストラクタ
         * @param game 関連するgame
         */
        constructor(game: Game);
        /**
         * 現在のモードを返す
         */
        currentMode(): string;
        /**
         * 管理しているレイヤーを配列にして返す
         */
        getLayerArray(): Layer[];
        /**
         * ポインティングイベントを有効にする。
         * この処理はrootレイヤーのポインティングイベントも有効にする点に注意
         */
        enablePointingEvent(): void;
        /**
         * ポインティングイベントを無効にする。実際はrootレイヤーのポインティングイベントを無効にしている。
         * sceneクラスのpointDown, pointUp, pointMoveのイベントハンドラは解放されないため、解放処理は別途行う必要がある点に注意
         */
        disablePointingEvent(): void;
        /**
         * モードを変更する。
         * この処理を行った際、引数modeがgameであり、現在のmodeがtitleである場合、以下のメソッドが本クラスのインスタンスに存在する場合には呼び出される。
         * titleHide
         * gameStart
         * gameShow
         * @param mode 新しいモード
         */
        changeMode(mode: string): void;
        /**
         * 現在のモードを終了する。すべてのモードが終了した場合、シーン自体も終了させる。
         * この処理を行った際、現在のmodeがgameであり、次のモードがtitleである場合、以下のメソッドが本クラスのインスタンスに存在する場合には呼び出される。
         * gameEnd
         * titleShow
         * ただし、newMode引数を指定した場合titleShowは発生しない。
         * @param newMode 次のモードを指定する。省略時は変更しない
         */
        endCurrentMode(newMode?: string): void;
        /**
         * 指定したレイヤーを作成する
         * @param name 作成するレイヤー名
         * @param size レイヤーの大きさ。またはLayerクラスのインスタンス
         */
        createLayer(name: string, size?: CommonSize): Layer;
        /**
         * 指定した名前のレイヤーを削除する。rootレイヤーは削除できない
         * @param name 削除するレイヤー名
         */
        deleteLayer(name: string): void;
        /**
         * このシーンとシーンに関連するリソースをすべて削除する
         */
        destroy(): void;
        /**
         * このシーンを終了する
         */
        end(): void;
        /**
         * このシーンとそれに関連するリソースをすべて再構築する
         */
        refresh(): void;
        /**
         * シーンをスクロールする
         * @param x スクロール先X座標
         * @param y スクロール先Y座標
         * @param layerName レイヤー名を指定する。省略した場合rootレイヤーが対象になる
         */
        scrollTo(x: number, y: number, layerName?: string): void;
        /**
         * シーンを相対的にスクロールする
         * @param x X座標の変化値
         * @param y Y座標の変化値
         * @param layerName レイヤー名を指定する。省略した場合rootレイヤーが対象になる
         */
        scrollBy(x: number, y: number, layerName?: string): void;
        /**
         * このシーンにentityを追加する
         * @param entity 追加するentity
         * @param layerName 追加するレイヤー名。省略時はrootレイヤー
         */
        append(entity: E, layerName?: string): void;
        /**
         * このシーンからentityを削除する。
         * どのレイヤーにあっても必ず削除されるが、entity.remove()の利用を推奨。
         * @param entity 削除するentity
         */
        removeEntity(entity: E): void;
    }
}
declare module jg {
    /**
     * 画像をあらわす最も基本的な描画オブジェクト
     */
    class Sprite extends E {
        /** 描画対象の画像。HTMLImageElement, HTMLVideoElement, HTMLCanvasElementのいずれかが指定可能 */
        image: any;
        /** 転送元横幅。通常は画像と同サイズ */
        srcWidth: number;
        /** 転送元縦幅。通常は画尾と同サイズ */
        srcHeight: number;
        /** 転送元横座標。通常は0 */
        srcX: number;
        /** 転送元縦座標。通常は0 */
        srcY: number;
        /**
         * Spriteクラスのインスタンスを生成する。
         * @param image このSpriteをあらわす画像
         * @param srcWidth 転送元横幅を指定。省略時は画像の横幅と同一になる
         * @param srcHeight 転送元縦幅を指定。省略時は画像の縦幅と同一になる
         */
        constructor(image: any, srcWidth?: number, srcHeight?: number);
        /**
         * 描画する
         * @paramn context 描画対象context
         */
        draw(context: CanvasRenderingContext2D): void;
    }
}
declare module jg {
    /**
     * 複数のフレームによってアニメーションを行うSprite。
     * なおこのクラスでは1枚の画像を複数のフレームに区切って扱う形のみサポートしているため、複数の画像で一つのアニメーションを後世することは出来ない。
     */
    class FrameSprite extends Sprite {
        /** 画像一列で何枚の画像が入っているか */
        sep: number;
        /** フレーム */
        frame: number[];
        /** 現在のフレーム番号 */
        fno: number;
        /** アニメーション中かどうか */
        animation: boolean;
        /** アニメーション時間 */
        wait: number;
        /** 繰り返しアニメーションを行うかどうか */
        loop: boolean;
        /** アニメーション完了時に発生するイベント。ループ中は発生しない */
        frameEnded: Trigger;
        /**
         * コンストラクタ
         * @param image 画像。1枚の画像にアニメーションパターンがすべて格納されている必要がある
         * @param srcWidth フレームの横幅
         * @param srcHeight フレームの縦幅
         * @param wait アニメーション時間をミリ秒で指定。省略時は200ミリ秒
         */
        constructor(image: any, srcWidth: number, srcHeight: number, wait?: number);
        /**
         * フレームを変更し、変更フラグを立てる
         */
        changeFrame(): void;
        /**
         * アニメーションを開始する。すでにアニメーション中である場合、noClearの設定含めて無視される
         * @param noClear 指定した場合、fnoを0にリセットする
         */
        animate(noClear?: boolean): boolean;
        /**
         * アニメーションを停止する
         */
        inanimate(): void;
        /**
         * アニメーション処理を行うコールバック
         */
        interval(): void;
    }
}
declare module jg {
    /**
     * キャラクタの移動情報
     */
    interface CharacterMoveInfo {
        /** 移動元X座標 */
        x: number;
        /** 移動元Y座標 */
        y: number;
        /** 移動先X座標 */
        dx: number;
        /** 移動先Y座標 */
        dy: number;
        /** 移動に要する時間。歴史的な理由でフレーム数を意味するfという名前になっている */
        f: number;
        /** これまでかかった時間 */
        t: number;
    }
    /**
     * 移動完了イベントパラメータ
     */
    interface CharacterMovedEventArgs {
        /** 次の移動先 */
        nextMove?: string;
    }
    /**
     * キャラクタをあらわすクラス。
     * 足踏み、方向、移動といった基本的な概念を持っている。
     */
    class Character extends FrameSprite {
        /** 移動中かどうか */
        moving: boolean;
        /** 現在の移動情報 */
        moveInfo: CharacterMoveInfo;
        /** 次の移動先を表す文字列 */
        nextMove: string;
        /** 移動開始イベント。CharacterMoveInfoをパラメータとして持つ */
        beginMove: Trigger;
        /** 移動完了イベント。CharacterMovedEventArgsをパラメータとして持つ */
        moved: Trigger;
        /** キャラクター番号 */
        charaSeq: number;
        /** 画像のキャラクタ列数 */
        charaCol: number;
        /** 足踏みのアニメーションフレーム数 */
        animeCnt: number;
        /** 一度の移動で移動するピクセル数 */
        movePixel: number;
        /** 移動に要する時間 */
        moveTime: number;
        /** キャラクタの方向とキャラチップの番号の相対表。{[key:Angle]: number; }形式で指定 */
        angleSeq: any;
        /** 現在の方向 */
        currentAngle: Angle;
        /**
         * コンストラクタ
         * @param image キャラクタの画像。複数のキャラクタが一つになった画像を指定することも可能
         * @param width キャラクターの横幅
         * @param height キャラクターの縦幅
         * @param wait 足踏みに要する時間をミリ秒単位で指定。省略時は200ミリ秒
         */
        constructor(image: any, width: number, height: number, wait?: number);
        /**
         * キャラクターが移動していない場合、左に移動させる
         * @param stackNext 移動が出来ず、前の移動からある程度時間が経っていたら、次の移動先にこの方向をセットする
         */
        moveLeft(stackNext?: boolean): boolean;
        /**
         * キャラクターが移動していない場合、右に移動させる
         * @param stackNext 移動が出来ず、前の移動からある程度時間が経っていたら、次の移動先にこの方向をセットする
         */
        moveRight(stackNext?: boolean): boolean;
        /**
         * キャラクターが移動していない場合、上に移動させる
         * @param stackNext 移動が出来ず、前の移動からある程度時間が経っていたら、次の移動先にこの方向をセットする
         */
        moveUp(stackNext?: boolean): boolean;
        /**
         * キャラクターが移動していない場合、下に移動させる
         * @param stackNext 移動が出来ず、前の移動からある程度時間が経っていたら、次の移動先にこの方向をセットする
         */
        moveDown(stackNext?: boolean): boolean;
        /**
         * キャラクターを移動させる
         * @param x 移動先X座標
         * @param y 移動先Y座標
         * @param f 移動に要する時間
         */
        move(x: number, y: number, f: number): boolean;
        /**
         * 毎フレーム更新処理のイベントハンドラ
         * @param t  経過時間
         */
        update(t: number): void;
        /**
         * 移動完了処理を行う
         */
        endMove(): void;
        /**
         * 方向を変更する
         * @param angle 変更後の方向
         */
        angle(angle: Angle): void;
    }
}
declare module jg {
    /**
     * Characterクラスを量産するためのファクトリ
     */
    class CharacterFactory {
        /** 画像のキャラクタ列数 */
        charaCol: number;
        /** 足踏みのアニメーションフレーム数 */
        animeCnt: number;
        /** 一度の移動で移動するピクセル数 */
        movePixel: number;
        /** 移動に要する時間 */
        moveTime: number;
        /** キャラクタに指定する画像 */
        image: HTMLImageElement;
        /** キャラクタの横幅 */
        width: number;
        /** キャラクタの縦幅 */
        height: number;
        /** 足踏みに要する時間 */
        wait: number;
        /** 最初に向いている方向 */
        angle: Angle;
        /**
         * 利用するコンストラクタ。通常はjg.Characterだが、継承したクラスなどを使いたい場合それを指定する
         */
        createClass: any;
        /** キャラクタの方向とキャラチップの番号の相対表。{[key:Angle]: number; }形式で指定 */
        angleSeq: any;
        /**
         * コンストラクタ
         * @param image キャラクタに指定する画像
         * @param width キャラクタの横幅
         * @param height キャラクタの縦幅
         */
        constructor(image: HTMLImageElement, width: number, height: number);
        /**
         * キャラクタを生成する
         * @param charaSeq 利用する画像のキャラ番号
         * @param offset 初期x, y座標。省略時はx:0, y:0に配置される
         * @param angle 初期方向。省略時はthis.angle
         */
        create(charaSeq: number, offset?: CommonOffset, angle?: Angle): Character;
    }
}
declare module jg {
    /**
     * 文字を表示するクラス
     */
    class Label extends E {
        /** 表示する文字列。変更する場合はこのフィールドを直接編集するのではなく、setTextを呼ぶべき */
        text: string;
        /** 最大幅。変更する場合はこのフィールドを直接編集するのではなく、setMaxWidthを呼ぶべき */
        maxWidth: number;
        /** 同期するオブジェクト */
        syncObj: any;
        /** 同期するプロパティ */
        syncProp: string;
        /** 同期時にMath.roundをかけるかどうか */
        syncRound: boolean;
        /**
         * コンストラクタ
         * @param text 表示文字列
         * @param fontSize 文字の大きさ
         * @param fontColor 文字色
         * @param baseLine ベースライン
         */
        constructor(text?: string, fontSize?: number, fontColor?: string, baseline?: string);
        /**
         * 最大幅を変更する。描画される文字列がこの幅を上回る場合、自動的に縮小される
         * @param maxWidth 最大幅
         */
        setMaxWidth(maxWidth: number): void;
        /**
         * 内部サイズを更新する
         */
        updateSize(): void;
        /**
         * 文字に影をつける
         * @param color カラーの色。省略時は黒
         */
        addShadow(color?: string): void;
        /**
         * 文字の影を削除する
         */
        removeShadow(): void;
        /**
         * 表示する文字列を変更する
         * @param text 変更後の文字列
         */
        setText(text: string): void;
        /**
         * 文字描画に利用するフォントを変更する。
         * 指定できる値はCSS Font形式で、かつline-height指定を除いた値。line-heightについては常にnormalに固定される。
         * @param fontString フォントを現す文字列
         */
        setFont(fontString: string): void;
        /**
         * 現在の文字描画に利用するフォントを取得する
         */
        getFont(): string;
        /**
         * フォントサイズを指定する。
         * @param size 設定するフォントサイズ。単位は常にピクセル
         */
        setFontSize(size: number): void;
        /**
         * フォントサイズを取得する。単位は常にピクセル
         */
        getFontSize(): number;
        /**
         * フォントファミリを取得する
         */
        getFontFamily(): string;
        /**
         * フォントファミリを設定する
         * @param family 設定するフォントファミリ
         */
        setFontFamily(family: string): void;
        /**
         * 文字列の寄せ方を、start, end, left, right, centerいずれかの文字列で指定する
         * @param align 文字列の寄せ方
         */
        setTextAlign(align: string): void;
        /**
         * 現在の文字列の寄せ方を取得する
         */
        getTextAlign(): string;
        /**
         * 文字列の基準線をtop, hanging, middle, alphabetic, ideographic, bottomのいずれかの文字列で指定する
         * @param baseline 文字列の基準線
         */
        setTextBaseline(baseline: string): void;
        /**
         * 現在の文字列の基準線を取得する
         */
        getTextBaseline(): string;
        /**
         * 文字色を設定する
         * @param color 設定する文字色。CSSカラーで指定
         */
        setColor(color: string): void;
        /**
         * 現在の文字色を取得する
         */
        getColor(): string;
        /**
         * 表示文字列を特定オブジェクトの状態に同期させる。
         * sprite.xに同期させる場合は次のようにする。
         * label.synchronize(sprite, "x", true);
         * @param obj 同期させるオブジェクト
         * @param prop 同期させるオブジェクトのプロパティ
         * @param round 同期時にMath.roundをかけるかどうか。省略時はかけない
         */
        synchronize(obj: any, prop: string, round?: boolean): void;
        /**
         * 描画
         * @param context 対象の描画コンテキスト
         */
        draw(context: CanvasRenderingContext2D): void;
    }
}
declare module jg {
    /**
     * 一行の情報
     */
    class TextLineInfo {
        /** 行の幅 */
        width: number;
        /** 行の高さ */
        height: number;
        /** 縦座標のオフセット値 */
        offsetY: number;
        /**
         * コンストラクタ
         * @param offsetY 縦座標のオフセット値
         */
        constructor(offsetY: number);
    }
    /**
     * スクリプトを解析するクラス。
     * このクラスはサンプルであり、#pageコマンドによる改ページのみしかサポートしていない。
     */
    class MultilineScriptAnalyzer {
        /** 現在のモード */
        mode: number;
        /** 対象のMultilineTextクラス */
        owner: MultilineText;
        /** 対象の描画コンテキスト */
        context: CanvasRenderingContext2D;
        /** ポジション */
        pos: CommonOffset;
        /** バッファ */
        buf: string;
        /**
         * 初期化
         * @param owner 対象のMultilineTextクラス
         * @param context 描画コンテキスト
         * @param pos ポジション
         */
        init(owner: MultilineText, context: CanvasRenderingContext2D, pos: CommonOffset): void;
        /**
         * 次の文字を判定する
         */
        next(c: string): number;
    }
    /**
     * 複数行のテキストを扱うクラス
     */
    class MultilineText extends E {
        /** 元スクリプト */
        script: string;
        /** 裏画面バッファ */
        buffer: HTMLCanvasElement;
        /** クリッピング用Line */
        clip: Line;
        /** テキスト転送用Sprite */
        sprite: Sprite;
        /** デフォルトのスタイル */
        defaultStyle: any;
        /** デフォルトのフォント */
        defaultFont: any;
        /** デフォルトの影 */
        defaultBlur: number;
        /** デフォルトの影色 */
        defaultShadowColor: any;
        /** デフォルトの影オフセットX */
        defaultShadowOffsetX: number;
        /** デフォルトの影オフセットY */
        defaultShadowOffsetY: number;
        /** テキストの影を無効にするかどうか */
        disableShadow: boolean;
        /** 全行情報 */
        lines: TextLineInfo[];
        /** 現在アニメーション中のポジション */
        animePos: CommonOffset;
        /** 現在アニメーション中の行 */
        animeLine: number;
        /** テキストのアニメーションスピード。デフォルトは400 */
        animeSpeed: number;
        /** アニメーション完了時に発火されるイベント */
        animated: Trigger;
        /** スクリプト解析クラス */
        scriptAnalyzer: MultilineScriptAnalyzer;
        /** バッファの背景 */
        bufferBg: ImageData;
        /** 通常の行の高さ */
        static LINE_HEIGHT_NORMAL: number;
        /** 特殊なブラウザにおける余白 */
        static BROWSER_BASELINE_MARGIN: number;
        /**
         * コンストラクタ
         * @param size 表示サイズ
         * @param offset 場所
         */
        constructor(size: CommonSize, offset?: CommonOffset);
        /**
         * テキストをセットする
         * @param text 設定する文字列
         * @param offset 読み込み開始位置。省略時は最初から
         */
        setText(text: string, offset?: number): number;
        /**
         * スクリプトをセットする
         * @param script 設定するスクリプト
         * @param offset 読み込み開始位置。省略時は最初から
         */
        setScript(script: string, offset?: number): number;
        /**
         * 行の高さを取得する
         * @param c 対象の描画コンテキスト
         */
        getLineHeight(c: CanvasRenderingContext2D): number;
        /**
         * バッファを生成する
         * @param offset 読み込み開始位置。省略時は最初から
         */
        createBuffer(offset?: number): number;
        /**
         * バッファの再構築を行う
         */
        refresh(): void;
        /**
         * テキストのアニメーション表示を開始する
         * @param animeSpeed アニメーションのスピード。省略時は前回の設定から変更しない
         */
        startAnimation(animeSpeed?: number): void;
        /**
         * Game.updateイベントに対するコールバック
         * @param t 経過時間
         */
        update(t: number): void;
        /**
         * テキストをすべて非表示にする
         */
        hideAll(): void;
        /**
         * テキストをすべて表示する
         */
        showAll(): void;
    }
}
declare module jg {
    /**
     * Tileでの描画に利用するチップセットをあらわすクラス。
     * 通常、ユーザがこのクラスを直接利用することは無い。
     */
    class ChipSet {
        /** 本クラスが管理する画像 */
        image: any;
        /** チップのオフセット番号。Tileクラス側が利用する */
        chipOffset: number;
        /**
         * コンストラクタ
         * @param image 対象の画像
         */
        constructor(image: any);
        /**
         * このChipSetで管理しているチップ数を取得する
         */
        count(tile: Tile): number;
        /**
         * 描画する
         * @param tile 対象のTile
         * @param c 描画対象コンテキスト
         * @param x 描画X座標
         * @param y 描画Y座標
         * @param chip 描画するチップ番号
         */
        draw(tile: Tile, c: CanvasRenderingContext2D, x: number, y: number, chip: number): void;
        /**
         * このChipSetのマップチップを個別に、Spriteの配列として取得する
         * @param tile 対象のTile
         */
        getChips(tile: Tile): Sprite[];
    }
    /**
     * オートタイル用ChipSet。現在は一つの画像で一つのオートタイルのみサポート
     */
    class AutoTileChipSet extends ChipSet {
        /**
         * 座標位置のチップを取得する便利メソッド。Tile管理外座標である場合-1を返す
         * @param tile 対象のTile
         * @param x 取得対象x座標
         * @param y 取得対象y座標
         * @param out_value Tile管轄外の場合の値。省略時は-1
         */
        map(tile: Tile, x: number, y: number, out_value?: number): number;
        /**
         * このChipSetで管理しているチップ数を取得する。
         * AutoTileChipSetクラスの場合は1固定となる。
         */
        count(tile: Tile): number;
        /**
         * 描画する
         * @param tile 対象のTile
         * @param c 描画対象context
         * @param x 描画X座標
         * @param y 描画Y座標
         * @param chip 描画するチップ番号
         */
        draw(tile: Tile, c: CanvasRenderingContext2D, x: number, y: number, chip: number): void;
        /**
         * このChipSetのマップチップを個別に、Spriteの配列として取得する
         * @param tile 対象のTile
         */
        getChips(tile: Tile): Sprite[];
    }
    /**
     * マップを描画するクラス。
     * 本クラスは高速描画のためdrawOptionを無効化しており、回転などを行いたい場合は一度Sprite化してから行う必要がある点に注意
     */
    class Tile extends E {
        /** 一つ一つのチップの横幅 */
        tileWidth: number;
        /** 一つ一つのチップの縦幅 */
        tileHeight: number;
        /** 全チップセットを表す配列。これを直接操作しないように。 */
        chips: ChipSet[];
        /** チップ番号とChipSetを相対させるための便利Map。直接操作しないように。 */
        chipMap: ChipSet[];
        /** 合計のチップ数。直接操作しないように。 */
        chipCount: number;
        /** 描画済みマップを保持しておくためのバッファ用canvas */
        canvas: HTMLCanvasElement;
        /** マップデータ。[x][y]形式で格納 */
        data: number[][];
        /**
         * このクラスが管理するマップのサイズ。
         * 常にtile.data.length == tile.size.width、tile.data[0].length == tile.size.heightであるべき値。
         * ビルドをES5にする際はプロパティにして自動更新する形にした方がいいかも
         */
        size: CommonSize;
        /**
         * コンストラクタ
         * @param image 利用するチップセット画像。nullやundefinedを指定することで省略可
         * @param tileWidth 一つ一つのチップの横幅
         * @param tileHeight 一つ一つのチップの縦幅
         */
        constructor(image: any, tileWidth: number, tileHeight: number);
        /**
         * チップセットを追加する
         * @param image 追加するチップセット画像
         * @param opt オプション。{autoTile: true}を指定すると、オートタイルのチップセットが指定可能
         */
        addChipSet(image: HTMLImageElement, opt?: any): void;
        /**
         * 指定したTileのチップセットをこのTileのチップセットと同じにする
         * @param tile 共有先のTile
         */
        copyChips(tile: Tile): void;
        /**
         * サイズなどを指定の値で初期化する汎用メソッド
         */
        _clear(width: number, height: number): void;
        /**
         * マップデータをすべて-1または指定した値で初期化する
         * @param width 横幅（チップ数）
         * @param height 縦幅（チップ数）
         * @param value 初期化する値。省略時は-1
         */
        clear(width?: number, height?: number, value?: number): void;
        /**
         * マップデータを生成する
         * @param data データの二次元配列。[x][y]型である点に注意
         * @param width マップの横幅（チップ数）。省略時はdata.lengthが利用される。なおこのパラメータにtrueを指定すると、widthとheightを省略しtranposeをtrueにしたものとして扱われる
         * @param height マップの縦幅（チップ数）。省略時はdata[0].lengthが利用される
         * @param transpose 行列を反転させるかどうか
         */
        generate(data: number[][], width?: any, height?: number, transpose?: boolean): void;
        /**
         * バッファを作り直した上で再描画を行い、更新済みフラグを立てる
         */
        refresh(): void;
        /**
         * 一マス描画する
         * @param x 描画対象X座標（チップ数）
         * @param y 描画対象Y座標（チップ数）
         * @param clear trueを指定すると描画前にクリアする。半透明チップ描画の場合は必須
         * @param context 描画対象context。省略時はthis.canvasから自動取得。複数チップを描画する場合、呼び出し元で指定してあげた方が速い
         */
        drawChip(x: number, y: number, clear?: boolean, context?: CanvasRenderingContext2D): void;
        /**
         * 描画する
         * @param context 描画対象context
         */
        draw(context: CanvasRenderingContext2D): void;
        /**
         * このクラスが管理するすべてのマップチップをSpriteの配列で取得する
         */
        getChips(): Sprite[];
    }
}
declare module jg {
    /**
     * レイヤー
     */
    class Layer extends E {
        /** レイヤーの描画結果を保持するバッファ */
        canvas: HTMLCanvasElement;
        /** レイヤーの描画コンテキスト */
        context: CanvasRenderingContext2D;
        /**
         * コンストラクタ
         * @param scene レイヤーが属するシーン
         */
        constructor(scene: Scene);
        /**
         * このレイヤーがバッファを持つ場合にはtrueを返す
         */
        hasBuffer(): boolean;
        /**
         * このレイヤーにバッファを作成する
         */
        createBuffer(): void;
        /**
         * レイヤー内のオブジェクトを更新する
         * @param must trueを指定すると必ずバッファを生成する
         */
        refresh(must?: boolean): void;
        /**
         * バッファを削除する
         */
        deleteBuffer(): void;
        /**
         * バッファなどを削除する
         */
        destroy(): void;
    }
}
declare module jg {
    /**
     * 読み込み中状態を管理するシーン
     */
    class LoadingScene extends Scene {
        /** 対象のリソース */
        resource: Resource;
        /** 読み込み完了を表すパーセンテージの外枠線 */
        shape: Shape;
        /** 読み込み完了を表すパーセンテージの内側の塗りつぶし */
        shapeP: Shape;
        /** リソース全体の読み込み予定数 */
        requestCount: number;
        /** ローディングシーンの表示が必要な状態が終わったときに発火されるイベント。このイベントが発生した際、既にLoadingSceneクラスは破棄されている。 */
        finished: Trigger;
        /**
         * コンストラクタ
         * @param game 対象のゲーム
         * @param resource 対象のリソース
         */
        constructor(game: Game, resource: Resource);
        /**
         * 初期化
         */
        init(): void;
        /**
         * 読み込み完了を表すパーセンテージ表記を進める
         */
        animate(per: number): void;
        /**
         * リソースクラスが読み込みを完了した際のイベントハンドラ
         */
        complete(cnt: number): void;
        /**
         * リソースクラスにリクエストが追加された場合のイベントハンドラ
         */
        added(e: any): void;
    }
}
declare module jg {
    /**
     * 入力イベントの基本クラス
     */
    class InputEvent {
        /** 入力イベント種別 */
        type: InputEventType;
        /** 入力イベントの動作タイプ */
        action: InputEventAction;
        /** 元イベントデータ */
        param: any;
        /**
         * コンストラクタ
         * @param type 入力イベント種別を指定。現状はPointかKeyboardのみ
         * @param action 入力イベントの動作タイプ。現状はDown, Up, Moveのみ
         * @param param 元イベントデータ
         */
        constructor(type: InputEventType, action: InputEventAction, param?: any);
    }
    /**
     * キーボードの入力イベントクラス
     */
    class InputKeyboardEvent extends InputEvent {
        /** 押されたキー。Keytypeで管理されている値のみ設定可能 */
        key: Keytype;
        /**
         * コンストラクタ
         * @param action 入力タイプ
         * @param key キー
         * @param e 元イベントデータ
         */
        constructor(action: InputEventAction, key: Keytype, e: any);
    }
    /**
     * ポインティングデバイスの入力イベント
     */
    class InputPointEvent extends InputEvent {
        /** ポインティングされた対象から見てのx座標 */
        x: number;
        /** ポインティングされた対象から見ての y座標 */
        y: number;
        /** Gameから見てのx, y座標 */
        point: CommonOffset;
        /** ポインティングされた対象 */
        entity: E;
        /**
         * コンストラクタ
         * @param action 動作タイプ
         * @param e 元イベントパラメター
         * @param point ゲームから見ての座標
         */
        constructor(action: InputEventAction, e: any, point: CommonOffset);
        /**
         * ポインティングされたEntityをセットする
         * @param entity ポインティングされたEntity
         */
        set(entity: E): void;
    }
}
declare module jg {
    /**
     * 描画クラス
     */
    class Renderer {
        /** Math.PI/180 */
        radian: number;
        /** 描画オプションを設定するための関数群 */
        drawOptionFunctions: Object;
        /** 描画後に適用するフィルタ */
        filter: ImageFilter.IFilter;
        /**
         * コンストラクタ
         */
        constructor();
        /**
         * マトリックス値を取得する
         * @param width 横幅
         * @param height 縦幅
         * @param scaleX 横方向の倍率
         * @param scaleY 縦方向の倍率
         * @param angle 角度
         */
        getMatrix(width: number, height: number, scaleX: number, scaleY: number, angle: number): number[];
        /**
         * 親オブジェクトから描画する
         * @param parent 対象の親オブジェクト
         * @param c 対象の描画コンテキスト
         */
        renderParent(parent: E, c: CanvasRenderingContext2D): void;
        /**
         * Entityを描画する
         * @param entity 描画対象のEntity
         * @param c 対象の描画コンテキスト
         */
        renderEntity(entity: E, c: CanvasRenderingContext2D): void;
        /**
         * フィルタや描画オプションをかけない描画を行う
         * @param entity 対象のEntity
         * @param c 対象の描画コンテキスト
         */
        renderPure(entity: E, c: CanvasRenderingContext2D): void;
        /**
         * フィルタをかける。
         * この処理は非常に遅いが、canvas apiはdrawImageにフィルタをかける方法を現状サポートしていないため現状はやむをえない実装。
         * @param entity 対象のEntity
         * @param c 対象の描画コンテキスト
         */
        filterDraw(entity: E, c: CanvasRenderingContext2D): void;
        /**
         * 描画オプションを利用する
         * @param entity 対象のEntity
         * @param c 対象の描画コンテキスト
         */
        useDrawOption(entity: E, c: CanvasRenderingContext2D): any;
    }
}
declare module jg {
    /**
     * ゲーム用描画クラス
     */
    class GameRenderer extends Renderer {
        /** 描画用バッファ。描画方式によっては裏画面用と表画面用の2画面 */
        buffer: HTMLCanvasElement[];
        /** 表画面用描画コンテキスト */
        fc: CanvasRenderingContext2D;
        /** 裏画面用描画コンテキスト */
        bc: CanvasRenderingContext2D;
        /** 現在のシーン。game.sceneと常に等価 */
        scene: Scene;
        /** 描画対象のゲーム */
        game: Game;
        /** 背景。廃止する可能性がある */
        bg: ImageData;
        /** DOMコンテナ */
        container: HTMLElement;
        /** 入力イベント処理用内部DOMコンテナ */
        handler: HTMLDivElement;
        /** フリップ番号。描画モードがFlipの時以外は不要 */
        flipNo: number;
        /** 描画モード。デフォルトはRenderTransferMode.Transfer */
        transferMode: RenderTransferMode;
        /** クリアを無効にする */
        disableClear: boolean;
        /** 表画面のキャンバスのサイズ。Gameのサイズと異なる場合、拡大縮小されていることになる */
        frontCanvasSize: CommonSize;
        /** 表画面のキャンバスの位置。中央寄せなどをする場合に必要な値 */
        frontCanvasOffset: CommonOffset;
        /** ハンドラのページ上の横位置 */
        _pageX: number;
        /** ハンドラのページ上の縦位置 */
        _pageY: number;
        /**
         * コンストラクタ
         * @param game 描画対象のゲーム
         * @param container 親元のDOMコンテナ。指定しない場合、jgameというIDの要素を検索し、それも見つからない場合はjgameというIDのおDIV要素を作りdocument.bodyに追加する
         * @param transferMode 描画転送モード
         * @param disableBg trueを指定すると、毎回背景色でクリアする処理を行わない
         */
        constructor(game: Game, container?: HTMLElement, transferMode?: RenderTransferMode, disableBg?: boolean);
        /**
         * 表用キャンバスのサイズを変更する
         * @param size 新しいキャンバスのサイズ
         * @param offset 省略可。新しいキャンバスのオフセット位置
         */
        changeFrontCanvasSize(size: CommonSize, offset?: CommonOffset): void;
        /**
         * 描画転送モードを変更する
         * @param mode 変更後の描画転送モード
         */
        changeTransferMode(mode: RenderTransferMode): void;
        /**
         * シーンを変更する。通常、Gameクラス内からのみ呼び出されるべきメソッド。
         * @param scene 変更後のシーン
         */
        changeScene(scene: Scene): void;
        /**
         * 表画面と裏画面を入れ替える。描画転送モードがRenderTransferMode.Flipの場合にのみ利用
         */
        flip(): void;
        /**
         * 描画する
         */
        render(): void;
        /**
         * バッファの作り直しなど、現在の設定値に基づいた再構成処理を行う
         */
        refresh(): void;
    }
}
declare module jg {
    /**
     * バッファ上に書き込む特殊なRenderer
     */
    class BufferedRenderer extends Renderer {
        /** バッファ */
        buffer: HTMLCanvasElement;
        /** 描画用context */
        c: CanvasRenderingContext2D;
        /** このバッファのサイズ */
        size: CommonSize;
        /**
         * コンストラクタ
         * @param size バッファサイズ
         */
        constructor(size: CommonSize);
        /**
         * バッファを透明でクリアする
         */
        clear(): void;
        /**
         * バッファの描画内容を基に画像を生成する
         * @param area コピー元バッファ領域。省略時は全画面
         * @param distArea コピー先バッファ領域。省略時はx:0, y:0, width:area.width, height:area.height
         * @param canavsSize 出力イメージサイズ。省略時はx: 0, y:0, width: area.width, height: area.height
         */
        createImage(area?: CommonArea, distArea?: CommonArea, canvasSize?: CommonSize): HTMLCanvasElement;
        /**
         * バッファの内容を基にSpriteを生成する
         * @param area コピー元バッファ領域。省略時は全画面
         * @param distArea コピー先バッファ領域。省略時はx:0, y:0, width:area.width, height:area.height
         * @param canavsSize Spriteが保持する画像のサイズ。省略時はx: 0, y:0, width: area.width, height: area.height
         */
        createSprite(area?: CommonArea, distArea?: CommonArea, canvasSize?: CommonSize): Sprite;
        /**
         * フィルタを適用する
         * @param c フィルタ適用対象context
         * @param size フィルタを適用するサイズ
         */
        applyFilter(c: CanvasRenderingContext2D, size: CommonSize): void;
        /**
         * オブジェクトをこのバッファに描画する
         * @param entity 描画対象オブジェクト
         */
        renderUnit(entity: E): void;
        /**
         * レイヤーをこのバッファに描画する
         * @param layer 描画対象レイヤー
         */
        renderLayer(layer: Layer): void;
        /**
         * シーンをこのバッファに描画する
         * @param scene 描画対象シーン
         */
        renderScene(scene: Scene): void;
        /**
         * バッファの内容を再生成する。この際、描画済み情報は失われる。
         * この処理はPCがスリープ状態から復帰した時などに呼び出される可能性があるため、BufferedRendererに描画済みの情報を長期間参照し続けることは推奨されない。。
         */
        refresh(): void;
        /**
         * このバッファを別の対象に描画する
         * @param context 描画対象context
         */
        draw(context: CanvasRenderingContext2D): void;
    }
}
declare module jg {
    /**
     * 曖昧に発火されるタイマー
     */
    class GameTimer {
        /** 前回発火時間 */
        tick: number;
        /** このタイマーの発火間隔 */
        wait: number;
        /** イベントハンドラ */
        trigger: Trigger;
        /**
         * タイマーを生成する
         * @param wait 発火間隔をミリ秒で指定
         */
        constructor(wait: number);
        /**
         * 発火を試みる
         * @param t 経過時間
         */
        tryFire(t: number): void;
        /**
         * 発火する
         */
        fire(): void;
    }
}
declare module jg {
    /**
     * メインループなどを管理するゲームエンジン。本クラスを基点にjgame.jsのゲームは実行される。
     * オーバーライドすることも想定しており、https://github.com/tsugehara/jgengine にいくつかサンプルがある。
     */
    class Game {
        /** 終了フラグ。_がついているが直接操作してもいい */
        _exit: boolean;
        /** 前回の実行時間 */
        tick: number;
        /** 前回の描画時間 */
        renderTick: number;
        /** KeytypeとkeyCodeの関連付けを行うマップ。JGUtilへの移行を検討中 */
        keymap: any;
        /** ドラッグ中情報。マルチタッチサポート後にインターフェース変更の可能性がある */
        dragParam: InputPointEvent;
        /** 描画オブジェクト */
        renderer: GameRenderer;
        /** 管理しているシーン */
        scenes: Scene[];
        /** 現在のシーン */
        scene: Scene;
        /** 管理しているリソース。リソースは単一インスタンスであるため、Resource.getInstanceと等価であることが保証されている */
        resource: Resource;
        /** ゲームの横幅 */
        width: number;
        /** ゲームの縦幅 */
        height: number;
        /** 表示上の拡大比率 */
        scale: number;
        /** 読み込み中シーンのコンストラクタ */
        loadingSceneClass: any;
        /** 読み込み中シーン。読み込み中の場合のみ値が設定される */
        loadingScene: LoadingScene;
        /** このゲームの内部ID。単一ページに複数のゲームを表示するような場合以外、特に利用する機会は無い */
        id: number;
        /** 画面描画間隔。指定するとこのFPS以下に画面描画が抑制される */
        targetFps: number;
        /** FPS表示用のDOM要素。将来的に変更される可能性がある */
        fps: HTMLElement;
        /** preload処理の完了時に呼び出されるイベント */
        loaded: Trigger;
        /**
         * ゲーム内時間の更新時に呼び出されるイベント。
         * 基本的なゲーム内更新処理はすべてこのイベントのハンドラで実行するが、精度が不要でかつ定期的に実行するアニメーションのような処理は、addTimerメソッドでの実行でもよい。
         * 引数として経過時間がミリ秒で渡されるため、その経過時間に則った処理を行う必要がある。
         * また、解放漏れに注意。
         */
        update: Trigger;
        /**
         * ゲーム内タイマー
         */
        timers: GameTimer[];
        /**
         * 描画時に呼び出されるイベント。利用は想定されていないので、通常時はundefined。利用する際は自前でnewする必要がある。
         * updateとは異なり、経過時間は取得出来ない。
         */
        render: Trigger;
        /**
         * キーが押された時に呼び出されるイベント。InputKeyboardEventをパラメータとして持つ。
         * 将来的にインターフェース変更の可能性あり。
         */
        keyDown: Trigger;
        /**
         * キーが離された時に呼び出されるイベント。InputKeyboardEventをパラメータとして持つ。
         * 将来的にインターフェース変更の可能性あり。
         */
        keyUp: Trigger;
        /**
         * ポインティングデバイスが押された時に呼び出されるイベント。InputPointEventをパラメータとして持つ。
         * 将来的にインターフェース変更の可能性あり。
         */
        pointDown: Trigger;
        /**
         * ポインティングデバイスが離された時に呼び出されるイベント。InputPointEventをパラメータとして持つ。
         * 将来的にインターフェース変更の可能性あり。
         */
        pointUp: Trigger;
        /**
         * ポインティングデバイスが移動された時に呼び出されるイベント。ただし移動だけでは発生せず、必ずpointDownが事前に発生している必要がある。InputPointEventをパラメータとして持つ。
         * 将来的にインターフェース変更の可能性あり。
         */
        pointMove: Trigger;
        /**
         * 現在ゲームがフォーカスを持っているかどうか
         */
        focus: boolean;
        /**
         * 発生済みのユーザ入力イベント群。
         * jgame.jsではメインループ内で入力処理を発火させるため、keydownなどのDOMイベントでいったんここにプールしてから、メインループでイベント発火という手順を踏む。
         */
        eventQueue: InputEvent[];
        /** Enumと各種イベント名のマップ */
        inputEventMap: any;
        /** pointDown発生済みかどうかのフラグ */
        isPointDown: boolean;
        /** このゲームの乱数シード */
        seed: number;
        /** このゲームの乱数エンジン */
        mt: MT;
        /** 独自イベント */
        userEvent: jg.Trigger;
        /**
         * 新しいゲームを生成する。
         * 現在引数をwidth, heightを廃止しargsのみにする変更が検討されている。
         * @param width ゲームの横幅
         * @param height ゲームの縦幅
         * @param args RenderTransferModeを指定すると、このゲームのRenderTransferModeの変更が可能。HTMLElementを指定すると、DOMコンテナを指定可能。文字列を指定すると、window[文字列]のコンストラクタをRendererに指定する
         */
        constructor(width: number, height: number, ...args: any[]);
        /**
         * 乱数シードを指定する。
         * 再現性のあるゲーム以外で明示的に呼び出す必要はなく、通常は初期化時に自動的に設定される。
         * @param seed 乱数シード。省略時は自動設定
         */
        setSeed(seed?: number): void;
        /**
         * 乱数を取得する。再現性のあるゲームを作る場合、Math.randomではなくこちらのrandomを利用する必要がある
         * @param min 最小値
         * @param max 最大値
         */
        random(min: number, max: number): number;
        /**
         * windowのサイズを取得する
         */
        getWindowSize(): {
            width: number;
            height: number;
        };
        /**
         * 現在の画面の大きさに合わせて拡大する。
         * @param no_center trueに設定すると中央寄せにしない
         */
        fitToWindow(no_center?: boolean): void;
        /**
         * 背景色を設定する。
         * このメソッドは廃止が検討されている。
         * @param r 0～255の範囲で赤色値を指定
         * @param g 0～255の範囲で緑色値を指定
         * @param b 0～255の範囲で青色値を指定
         * @param a 0～255の範囲で透明度を指定
         */
        setBgColor(r: number, g: number, b: number, a: number): void;
        /**
         * ゲーム内のすべてのオブジェクトをリフレッシュする。
         * スタンバイからの復帰時などでcanvasが壊れていても本メソッドでの復旧が可能だが、BufferedRendererなど、破壊されるオブジェクトもある点に注意。
         */
        refresh(): void;
        /**
         * 現在実行されている環境でタッチイベントが有効化を判定する。
         * copied by enchant.js (enchant.ENV.TOUCH_ENABLED)
         */
        isTouchEnable(): boolean;
        /**
         * マウスなどのDOMイベントからjgame.jsが利用可能なoffset値を取得する
         */
        getOffsetByEvent(e: any): CommonOffset;
        /**
         * DOMのmousedownに対するイベントハンドラ
         * @param e DOMのMouseEvent
         */
        onmousedown(e: MouseEvent): void;
        /**
         * DOMのtouchstartに対するイベントハンドラ。
         * 現状lib.d.tsに型情報が定義されていないようなので、anyになっている。
         * @param e DOMのTouchEvent
         */
        ontouchstart(e: any): void;
        /**
         * DOMのmousemoveに対するイベントハンドラ
         * @param e DOMのMouseEvent
         */
        onmousemove(e: MouseEvent): void;
        /**
         * DOMのtouchmoveに対するイベントハンドラ。
         * 現状lib.d.tsに型情報が定義されていないようなので、anyになっている。
         * @param e DOMのTouchEvent
         */
        ontouchmove(e: any): void;
        /**
         * DOMのmouseupに対するイベントハンドラ
         * @param e DOMのMouseEvent
         */
        onmouseup(e: MouseEvent): void;
        /**
         * DOMのtouchendに対するイベントハンドラ。
         * 現状lib.d.tsに型情報が定義されていないようなので、anyになっている。
         * @param e DOMのTouchEvent
         */
        ontouchend(e: any): void;
        /**
         * ポインティングイベントを有効にする。
         * 無効化処理も実行するため、何度も切り替えるアプリケーションの場合pointDown, pointMove, pointUpのイベントハンドラを独自に復旧する必要がある点に注意。
         */
        enablePointHandler(): void;
        /**
         * ポインティングイベントを無効化する。
         */
        disablePointHandler(): void;
        /**
         * DOMのkeydownイベントに対するイベントハンドラ。
         * lib.d.tsにおいて型情報が不明なためanyになっている。KeyboardEventExtensionsでいいのだろうか。
         * @param e DOMのキーボードイベントパラメータ。内部的にはkeyCodeしか利用していない
         */
        onkeydown(e: any): void;
        /**
         * DOMのkeyupイベントに対するイベントハンドラ。
         * lib.d.tsにおいて型情報が不明なためanyになっている。KeyboardEventExtensionsでいいのだろうか。
         * @param e DOMのキーボードイベントパラメータ。内部的にはkeyCodeしか利用していない
         */
        onkeyup(e: any): void;
        /**
         * キーボードイベントを有効化する。
         * このイベントを有効にしてしまうと、keymapに登録されているキーコードにpreventDefaultが動くため、textareaなどが存在するページで実行する場合は注意が必要。
         * また無効化処理も実行するため、何度も切り替えるアプリケーションの場合keyDown, keyUpのイベントハンドラを独自に復旧する必要がある点に注意。
         */
        enableKeyboardHandler(): void;
        /**
         * キーボードイベントを無効化する。
         */
        disableKeyboardHandler(): void;
        /**
         * 指定した時間間隔で実行するタイマーを追加する。
         * このタイマーは大体のタイマーであるため、アニメーションなど正確性の不要な作業のみの利用に限定するべきである。
         * @param wait 実行時間間隔をミリ秒で指定する
         * @param owner タイマーのコールバックに対するthis
         * @param handler コールバック
         */
        addTimer(wait: number, owner: any, handler: Function): void;
        /**
         * 指定した時間間隔で実行するタイマーのコールバックを削除する。
         * 一つもコールバックが存在しないタイマー自体の削除処理も行っている。
         * @param wait 実行時間間隔をミリ秒で指定する
         * @param owner タイマーのコールバックに対するthis
         * @param handler コールバック
         */
        removeTimer(wait: number, owner: any, handler: Function): void;
        /**
         * 指定したオーナーのタイマーに対するコールバックをすべて削除する
         * @param owner タイマーのコールバックに対するthis
         */
        removeTimerAll(owner: any): void;
        /**
         * シーンを変更する
         * @param scene 変更後のシーン
         * @param effect 変更時にかけるエフェクト。省略時はエフェクト無しになる。通常、EffectTypeの値を指定する
         * @param endOldScene trueを指定すると、切り替え前に前のシーンを削除する。
         */
        changeScene(scene: Scene, effect?: any, endOldScene?: boolean): void;
        /**
         * シーンを終了する
         * @param effect 変更時にかけるエフェクト。省略時はエフェクト無しになる。通常、EffectTypeの値を指定する
         */
        endScene(effect?: any): void;
        /**
         * 指定した名前のリソースを取得する。サウンドはsメソッドでの取得である点に注意
         * @param name リソース名
         */
        r(name: string): HTMLImageElement;
        /**
         * 指定した名前のサウンドリソースを取得する。画像などはrメソッドの取得である点に注意
         * @param name サウンドリソース名
         */
        s(name: string): any;
        /**
         * 事前の読み込み処理を行う。
         * 配列、オブジェクト、文字列のいずれかが指定可能で、複数回の呼び出しも可能。
         * 配列の場合、リソース名はURLと同じ扱いになる。
         * game.preload(["a.png", "b.png", "c.png"])
         * オブジェクトの場合、リソース名はキーで値がURLとなる。
         * game.preload({a: "a.png", b: "b.png", c: "c.png"})
         * 文字列の場合、第二、第三引数などを配列と同じように処理する。
         * game.preload("a.png", "b.png", "c.png")
         * @param ary 配列、オブジェクト、文字列のいずれかが指定可能。
         */
        preload(ary: any): void;
        /**
         * 他のライブラリで読み込み中のリソースをjgame.jsに登録する。
         * @param identity リソースの識別名
         */
        preloadOther(identity: string): void;
        /**
         * 他のライブラリで読み込み中のリソースが読み込み完了となった事をjgame.jsに通知する
         * @param identity リソースの識別名
         */
        preloadCompleteOther(identity: string): void;
        /**
         * 読み込み中シーンを設定し、現在のシーンを切り替える。
         * 現在既に読み込み中である場合、本メソッドは処理を行わない。
         */
        setLoadingScene(scene: any): void;
        /**
         * preloadの完了処理として、loadingSceneフィールドの削除、loadedイベントの発火を行う
         */
        preloadComplete(): void;
        /**
         * ゲームを終了する。
         * 実態はメインループの終了のみであり、本処理実行後でも_exitフラグの削除とmainメソッドの再実行によりゲームは再開可能
         */
        end(): boolean;
        /**
         * ゲームを再開する。
         * endによって行われたメインループの再起動。
         */
        resume(): boolean;
        /**
         * ポインティングされたEntityを設定する
         * @param param 対象のポインティングイベント
         */
        setPointingEntity(param: InputPointEvent): void;
        /**
         * 入力イベントを実行する
         */
        raiseInputEvent(): void;
        /**
         * メインループ
         */
        main(): void;
        /**
         * フルスクリーン化を行う
         */
        fullscreen(): boolean;
        /**
         * フルスクリーンを終了する
         */
        exitFullscreen(): boolean;
    }
}
declare module jg {
    /**
     * 画像フィルタ機能を提供するモジュール
     */
    module ImageFilter {
        /**
         * フィルタ用インターフェース
         */
        interface IFilter {
            /**
             * フィルタを実行する
             * @param pixels フィルタ対象のピクセルデータ
             */
            filter(pixels: ImageData): any;
        }
        /**
         * 複数フィルタを重ねがけするためのクラス
         */
        class FilterChain implements IFilter {
            /** 管理中フィルタ */
            filters: Filter[];
            /**
             * コンストラクタ
             */
            constructor();
            /**
             * 対象indexのフィルタを取得
             * @param index 取得対象index
             */
            get(index: number): Filter;
            /**
             * フィルタを追加
             * @param filter 追加するフィルタ
             */
            add(filter: Filter): FilterChain;
            /**
             * 単体のフィルタを設定する。これまでset, addしたフィルタはすべて破棄される
             * @param filter 設定するフィルタ
             */
            set(filter: Filter): FilterChain;
            /**
             * フィルタを所定の位置に挿入する
             * @param index 挿入する場所のindex
             * @param filter 挿入するフィルタ
             */
            insert(index: number, filter: Filter): FilterChain;
            /**
             * フィルタを削除する
             * @param filter 削除するフィルタ
             */
            remove(filter: Filter): void;
            /**
             * 全フィルタをクリアする
             */
            clear(): FilterChain;
            /**
             * フィルタ数を返す
             */
            count(): number;
            /**
             * このフィルタチェインに一つでもフィルタが存在するかを返す
             */
            has(): boolean;
            /**
             * このFilterChainによるフィルタを適用したSpriteを返す
             * @param entity SpriteにするEntity
             */
            createSprite(entity: E): Sprite;
            /**
             * このFilterChainによるフィルタを適用したImageを返す
             * @param entity SpriteにするEntity
             */
            createImage(entity: Sprite): HTMLCanvasElement;
            /**
             * フィルタを適用する
             * @param pixels 適用対象のピクセルデータ
             */
            filter(pixels: ImageData): void;
        }
        /**
         * 一般的な機能を持つフィルタ
         */
        class Filter implements IFilter {
            /** オプション */
            opt: any;
            /** 横幅 */
            width: number;
            /** 縦幅 */
            height: number;
            /** 対象のゲーム */
            game: Game;
            /**
             * 対象のゲームを指定してFilterクラスのインスタンスを生成する
             * @param game 対象のゲーム
             */
            constructor(game: Game);
            /**
             * フィルタを適用する
             * @param pixels 適用対象のピクセルデータ
             */
            filter(pixels: ImageData): void;
            /**
             * オプションを取得する
             * @param name オプション名
             * @param defaultValue オプションが無い場合に返す値を指定する。省略可
             */
            getOption(name: string, defaultValue?: any): any;
            /**
             * 色の相違を取得
             * @param dif
             * @param dest
             * @param src
             */
            findColorDifference(dif: number, dest: number, src: number): number;
            /**
             * 色を作成する
             * @param src
             */
            createColor(src: string): string;
            /**
             * マトリックスに基づいたフィルタを適用する
             * @param pixels 適用対象のピクセルデータ
             * @param matrix
             * @param amount
             */
            applyMatrix(pixels: ImageData, matrix: number[], amount: number): ImageData;
            /**
             * RGBの境界値をチェックする
             * @param val チェックする値
             */
            checkRGBBoundary(val: number): number;
        }
        /**
         * ユニバーサルトランジションを実現するフィルタ
         */
        class UniversalTransitionFilter extends Filter {
            /** ルール画像 */
            ruleImage: ImageData;
            /** マスク */
            mask: any;
            /**
             * コンストラクタ
             * @param game 対象のゲーム
             * @param image ルール画像
             * @param amount フィルタの影響度。省略時は255
             * @param repeat サイズが合わない場合繰り返すかどうか。省略時はfalse
             */
            constructor(game: Game, image?: any, amount?: number, repeat?: boolean);
            /**
             * ImageData取得
             * @param image 取得対象の画像
             * @param canvas 取得対象のcanvas。省略時は内部的に生成し、drawImageでimageを描画する
             */
            getImageData(image: any, canvas?: HTMLCanvasElement): ImageData;
            /**
             * ルール画像を作成する
             */
            createRuleImage(): void;
            /**
             * マスクを作成する
             */
            createMask(): any;
            /**
             * フィルタを適用する
             * @param pixels 適用対象のピクセルデータ
             */
            filter(pixels: ImageData): void;
        }
        /**
         * 逆方向からのユニバーサルトランジション
         */
        class ReverseUniversalTransitionFilter extends UniversalTransitionFilter {
            /**
             * 画像を作成する
             * @param width 横幅
             * @param height 縦幅
             */
            createImageData(width: number, height: number): ImageData;
            /**
             * ルール画像を作成する
             */
            createRuleImage(): void;
        }
        /**
         * グレースケールにするフィルタ
         */
        class GreyscaleFilter extends Filter {
            /**
             * コンストラクタ
             * @param game 対象のゲーム
             * @param opacity 透明度。省略時は1
             */
            constructor(game: Game, opacity?: number);
            /**
             * フィルタを適用する
             * @param pixels 対象のピクセルデータ
             */
            filter(pixels: ImageData): void;
        }
        /**
         * セピア色にするフィルタ
         */
        class SepiaFilter extends Filter {
            /**
             * コンストラクタ
             * @param game 対象のゲーム
             * @param opacity 透明度。省略時は1
             */
            constructor(game: Game, opacity?: number);
            /**
             * フィルタを適用する
             * @param pixels 対象のピクセルデータ
             */
            filter(pixels: ImageData): void;
        }
        /**
         * 色味をつけるフィルタ
         */
        class TintFilter extends Filter {
            /**
             * コンストラクタ
             * @param game 対象のゲーム
             * @param color 色。省略時は1
             */
            constructor(game: Game, color?: string, opacity?: number);
            /**
             * フィルタを適用する
             * @param pixels 対象のピクセルデータ
             */
            filter(pixels: ImageData): void;
        }
        /**
         * エッジを際立たせるフィルタ
         */
        class EdgesFilter extends Filter {
            /**
             * コンストラクタ
             * @param game 対象のゲーム
             * @param amount 威力。省略時は1
             */
            constructor(game: Game, amount?: number);
            /**
             * フィルタを適用する
             * @param pixels ピクセルデータ
             */
            filter(pixels: ImageData): void;
        }
        /**
         * エンボスフィルタ
         */
        class EmbossFilter extends Filter {
            /**
             * コンストラクタ
             * @param game 対象のゲーム
             * @param amount 威力。省略時は0.5
             */
            constructor(game: Game, amount?: number);
            /**
             * フィルタを適用する
             * @param pixels 対象のピクセルデータ
             */
            filter(pixels: ImageData): void;
        }
        /**
         * シャープにするフィルタ
         */
        class SharpenFilter extends Filter {
            /**
             * コンストラクタ
             * @param game 対象のゲーム
             * @param amount 威力
             */
            constructor(game: Game, amount?: number);
            /**
             * フィルタを適用する
             * @param pixels 対象のピクセルデータ
             */
            filter(pixels: ImageData): void;
        }
        /**
         * マトリックスに基づいた操作を行う汎用フィルタ
         */
        class MatrixFilter extends Filter {
            /**
             * コンストラクタ
             * @param game 対象のゲーム
             * @param amount 威力。省略時は0.5
             * @param matrix 適用するマトリックス。省略時はすべて0.111
             */
            constructor(game: Game, amount?: number, matrix?: number[]);
            /**
             * フィルタを適用する
             * @param pixels 対象のピクセルデータ
             */
            filter(pixels: ImageData): void;
        }
        /**
         * にじませるフィルタ。
         * アルゴリズムはガウシアンフィルタに順ずる。少し重い
         */
        class BlurFilter extends Filter {
            /**
             * コンストラクタ
             * @param game 対象のゲーム
             * @param amount 威力。省略時は2
             */
            constructor(game: Game, amount?: number);
            /**
             * フィルタを適用する
             * @param pixels 対象のピクセルデータ
             */
            filter(pixels: ImageData): void;
        }
        /**
         * モザイクをかけるフィルタ
         */
        class MosaicFilter extends Filter {
            /**
             * コンストラクタ
             * @param game 対象のゲーム
             * @param size モザイクサイズ。省略時は5
             * @param opacity 透明度。省略時は1
             */
            constructor(game: Game, size?: number, opacity?: number);
            /**
             * フィルタを適用する
             * @param pixels 対象のピクセルデータ
             */
            filter(pixels: ImageData): void;
        }
        /**
         * ノイズの種類。Monoでモノクロノイズ、Colorでカラーノイズ
         */
        enum NoiseType {
            Mono = 0,
            Color = 1,
        }
        /**
         * ノイズをつけるフィルタ
         */
        class NoiseFilter extends Filter {
            /**
             * コンストラクタ
             * @param game 対象のゲーム
             * @param amount 威力。省略時は30
             * @param type モノクロノイズかカラーノイズか。省略時はモノクロ
             */
            constructor(game: Game, amount?: number, type?: NoiseType);
            /**
             * フィルタを適用する
             * @param pixels 対象のピクセルデータ
             */
            filter(pixels: ImageData): void;
        }
        /**
         * ポスタライズフィルタ
         */
        class PosterizeFilter extends Filter {
            /**
             * コンストラクタ
             * @param game 対象のゲーム
             * @param amount 威力。省略時は2
             * @param opacity 透明度。省略時は1
             */
            constructor(game: Game, amount?: number, opacity?: number);
            /**
             * フィルタを適用する
             * @param pixels 対象のピクセルデータ
             */
            filter(pixels: ImageData): void;
        }
    }
}
declare module jg {
    /**
     * あらゆるAction関連イベントパラメータに格納されているパラメータ
     */
    interface ActionEventArgs {
        /** そのアクションが所属するTimelineクラス */
        timeline: Timeline;
    }
    /**
     * 時間経過時のイベントパラメータ
     */
    interface ActionTickEventArgs extends ActionEventArgs {
        /** 経過時間 */
        elapsed: number;
    }
    /**
     * 基本のアクション。Timelineクラスで利用される
     */
    class Action {
        /** このアクション完了までに要する時間 */
        time: number;
        /** 現在の経過時間 */
        frame: number;
        /** アクションごとに呼ばれるイベント。ActionEventArgsをパラメータとして持つ */
        added_to_timeline: Trigger;
        /** アクションごとに呼ばれるイベント。ActionEventArgsをパラメータとして持つ */
        removed_from_timeline: Trigger;
        /** アクションごとに呼ばれるイベント。ActionTickEventArgsをパラメータとして持つ */
        action_tick: Trigger;
        /** アクションごとに呼ばれるイベント。ActionEventArgsをパラメータとして持つ */
        action_start: Trigger;
        /** アクションごとに呼ばれるイベント。ActionEventArgsをパラメータとして持つ */
        action_end: Trigger;
        /** 所属するTimeline */
        timeline: Timeline;
        /** 操作対象のEntity  */
        entity: E;
        /**
         * コンストラクタ
         * @param param パラメータ一式
         */
        constructor(param?: any);
        /**
         * removed_from_timelineイベントのイベントハンドラ
         */
        removedFromTimeline(): void;
        /**
         * added_to_timelineイベントのイベントハンドラ
         */
        addedToTimeline(p: ActionEventArgs): void;
        /**
         * action_tickイベントのイベントハンドラ
         */
        actionTick(p: ActionTickEventArgs): void;
    }
}
declare module jg {
    class ParallelAction extends Action {
        actions: Action[];
        endedActions: Action[];
        constructor(param?: any);
        addedToTimeline(p: ActionEventArgs): void;
        removedFromTimeline(): void;
        actionTick(evt: ActionTickEventArgs): void;
        parallelActionStart(e: any): void;
    }
}
declare module jg {
    /** 描画オプションを変更するための関数群 */
    var TWEEN_DRAW_OPTION_SETTERS: {};
    /**
     * Actionを継承した、オブジェクトの特定のプロパティを、なめらかに変更したい時に用いるためのアクションクラス.
     * アクションを扱いやすく拡張したクラス.
     *
     * コンストラクタに渡す設定オブジェクトに、プロパティの目標値を指定すると、
     * アクションが実行された時に、目標値までなめらかに値を変更するようなアクションを生成する。
     *
     * トゥイーンのイージングも、easing プロパティで指定できる。
     * デフォルトでは jg.Easing.LINEAR が指定されている。
     */
    class Tween extends Action {
        /** 元値 */
        origin: any;
        /** 目標値 */
        target: any;
        /** 一つ前の値 */
        old: any;
        /** Easign関数 */
        easing: (t: number, b: number, c: number, d: number) => number;
        /** 変更する値 */
        props: Object;
        /** 特殊な操作用 */
        otherTarget: any;
        /**
         * コンストラクタ
         * @param 設定したいプロパティ値一式が入ったオブジェクト
         */
        constructor(params: any);
        /**
         * アクション開始時のコールバック
         * @param e 該当のアクションを表すイベント
         */
        actionStart(e: ActionEventArgs): void;
        /**
         * 時間経過で呼ばれるコールバック
         */
        tweenActionTick(e: ActionTickEventArgs): void;
    }
}
declare module jg {
    /**
     * アニメーションを管理するためのクラス.
     *
     * 操作するエンティティひとつに対して、必ずひとつのタイムラインが対応する。
     * Timelineクラス を読み込むと、Entity クラスを継承したすべてのクラスの
     * tl プロパティに、タイムラインクラスのインスタンスが生成される。
     *
     * タイムラインクラスは、自身に様々なアクションを追加するメソッドを持っており、
     * これらを使うことで簡潔にアニメーションや様々な操作をすることができる。
     * タイムラインクラスはフレームとタイムのアニメーションができる。
     *
     * 元ソースはenchant.jsに提供されていたtl.enchant.jsです。
     * http://enchantjs.com/ja/
     *
     * @param entity 操作の対象となるEntity
    *
     */
    class Timeline {
        /** 操作対象のEntity */
        entity: E;
        /** 対象の全アクション */
        queue: Action[];
        /** 停止中かどうか */
        paused: boolean;
        /** ループするかどうか */
        looped: boolean;
        /** */
        _activated: boolean;
        /** */
        _parallel: ParallelAction;
        /** フレームベースかどうか。jgame.jsではデフォルトfalseで、変更は推奨されない */
        isFrameBased: boolean;
        /**
         *
         * @param entity
         */
        constructor(entity: E);
        /**
         *
         * @param force
         */
        _deactivateTimeline(force?: boolean): void;
        /**
         *
         * @param force
         */
        _activateTimeline(force?: boolean): void;
        /**
         * フレームベースのアニメーションにする
         */
        setFrameBased(): void;
        /**
         * 時間ベースのアニメーションにする
         */
        setTimeBased(): void;
        /**
         * キューの先頭にあるアクションを終了し、次のアクションへ移行する。
         * @param remainingTime
         */
        next(remainingTime?: number): void;
        /**
         * 時間経過処理
         * @param t 経過時間
         */
        tick(t: number): void;
        /**
         * 新しいアクションを追加する
         * @param action 追加するアクション
         */
        add(action: Action): Timeline;
        /**
         * アクションを簡単に追加するためのメソッド。実体は add メソッドのラッパ。
         * @param params アクションの設定オブジェクト
         */
        action(params: any): Timeline;
        /**
         * トゥイーンを簡単に追加するためのメソッド。実体は add メソッドのラッパ。
         * @param  params トゥイーンの設定オブジェクト。
         */
        tween(params: any): Timeline;
        /**
         * タイムラインのキューをすべて破棄する。終了イベントは発行されない。
         */
        clear(): Timeline;
        /**
         * タイムラインを早送りする。巻き戻しは出来ない
         * @param frames 早送りするフレーム数（jgame.jsの場合は時間）
         */
        skip(frames: number): Timeline;
        /**
         * タイムラインの実行を一時停止する
         */
        pause(): Timeline;
        /**
         * タイムラインの実行を再開する
         */
        resume(): Timeline;
        /**
         * タイムラインをループさせる。
         */
        loop(): Timeline;
        /**
         * タイムラインのループを解除する。
         */
        unloop(): Timeline;
        /**
         * 指定した時間を待ち、何もしないアクションを追加する。
         * @param time 待ち時間
         */
        delay(time: number): Timeline;
        /**
         * 関数を実行し、即時に次のアクションに移るアクションを追加する。
         * @param func 実行する関数
         */
        then(func: Function): Timeline;
        /**
         * フレームを変更する。このメソッドを実行する場合、EntityがFrameSpriteである必要がある
         * @param wait この時間待ってから操作を実行
         * @param frame 切り替え後のフレーム。詳細はFrameSprite.frameを参照。省略すると待ち時間無しで第一引数に指定したフレームに変更する
         */
        frame(wait: any, frame?: number[]): Timeline;
        /**
         * フレーム番号を変更する
         * @param wait この時間待ってから操作を実行
         * @param fno 切り替え後のフレーム番号。詳細はFrameSprite.fnoを参照。省略すると待ち時間無しで第一引数に指定したフレーム番号に変更する
         */
        fno(wait: number, fno?: number): Timeline;
        /**
         * 実行したい関数を、経過時間をキーとした連想配列(オブジェクト)で複数指定し追加する。
         * sprite.tl().cue({
         *    10: function(){ 10msec後に実行される関数 },
         *    20: function(){ 20msec後に実行される関数 },
         *    30: function(){ 30msec後に実行される関数 }
         * });
         * @param cue 経過時間をキーとした連想配列
         */
        cue(cue: any): void;
        /**
         * 指定した関数を指定した時間繰り返し実行するアクションを追加する。
         * @param func 実行する関数
         * @param time 時間
         */
        repeat(func: Function, time: number): Timeline;
        /**
         * 複数のアクションを並列で実行したいときに指定する。
         * and で結ばれたすべてのアクションが終了するまで次のアクションには移行しない
         * 300msecでフェードインしながら360度回転する例
         * sprite.tl().fadeIn(300).and.rotateBy(360, 300);
         */
        and(): Timeline;
        /**
         * true値 が返るまで、関数を毎フレーム実行するアクションを追加する。
         * @param func 実行する関数
         */
        waitUntil(func: Function): Timeline;
        /**
         * 指定座標に移動する
         * @param x X座標
         * @param y Y座標
         * @param time 必要時間
         * @param easing Easing関数。省略した場合はLINEAR
         */
        moveTo(x: number, y: number, time: number, easing?: Function): Timeline;
        /**
         * 指定したX座標に移動する
         * @param x X座標
         * @param time 必要時間
         * @param easing Easing関数。省略した場合はLINEAR
         */
        moveX(x: number, time: number, easing?: Function): Timeline;
        /**
         * 指定したY座標に移動する
         * @param y Y座標
         * @param time 必要時間
         * @param easing Easing関数。省略した場合はLINEAR
         */
        moveY(y: number, time: number, easing?: Function): Timeline;
        /**
         * 現在位置から指定した座標分移動する
         * @param x X座標の変化量
         * @param y Y座標の変化量
         * @param time 必要時間
         * @param easing Easing関数。省略した場合はLINEAR
         */
        moveBy(x: number, y: number, time: number, easing?: Function): Timeline;
        /**
         * 指定座標にスクロールする
         * @param x X座標
         * @param y Y座標
         * @param time 必要時間
         * @param easing Easing関数。省略した場合はLINEAR
         */
        scrollTo(x: number, y: number, time: number, easing?: Function): Timeline;
        /**
         * 指定したX座標にスクロールする
         * @param x X座標
         * @param time 必要時間
         * @param easing Easing関数。省略した場合はLINEAR
         */
        scrollX(x: number, time: number, easing?: Function): Timeline;
        /**
         * 指定したY座標にスクロールする
         * @param y Y座標
         * @param time 必要時間
         * @param easing Easing関数。省略した場合はLINEAR
         */
        scrollY(y: number, time: number, easing?: Function): Timeline;
        /**
         * 現在位置から指定した座標分スクロールする
         * @param x X座標の変化量
         * @param y Y座標の変化量
         * @param time 必要時間
         * @param easing Easing関数。省略した場合はLINEAR
         */
        scrollBy(x: number, y: number, time: number, easing?: Function): Timeline;
        /**
         * Entityの不透明度をなめらかに変えるアクションを追加する。
         * @param opacity 目標の不透明度
         * @param time 必要時間
         * @param easing Easing関数。省略した場合はLINEAR
         */
        fadeTo(opacity: number, time: number, easing?: Function): Timeline;
        /**
         * Entityをなめらかに表示するアクションを追加する。
         * @param time 必要時間
         * @param easing Easing関数。省略した場合はLINEAR
         */
        fadeIn(time: number, easing?: Function): Timeline;
        /**
         * Entityをなめらかに非表示にするアクションを追加する。
         * @param time 必要時間
         * @param easing Easing関数。省略した場合はLINEAR
         */
        fadeOut(time: number, easing?: Function): Timeline;
        /**
         * Entityを即座に非表示にする
         */
        hide(): Timeline;
        /**
         * Entityを即座に表示する
         */
        show(): Timeline;
        /**
         * 指定した大きさにサイズを変更する。scaleToが中心から拡大されるのに対し、resizeToは右方向へ拡大される
         * @param size widthまたはwidthとheight。widthのみを指定する場合、第二引数にheightを指定する
         * @param time 必要時間
         * @param easing Easing関数。省略した場合はLINEAR
         * @param easing2 heightを指定した場合ここがeasing関数になる
         */
        resizeTo(size: number, time: number, easing?: any, easing2?: any): Timeline;
        /**
         * 現在の大きさから指定した量サイズを変化させる。scaleByが中心から拡大されるのに対し、resizeByは右方向へ拡大される
         * @param size widthまたはwidthとheightの変化量。widthのみを指定する場合、第二引数にheightを指定する
         * @param time 必要時間
         * @param easing Easing関数。省略した場合はLINEAR
         * @param easing2 heightを指定した場合ここがeasing関数になる
         */
        resizeBy(size: number, time: number, easing?: any, easing2?: any): Timeline;
        /**
         * Entity をなめらかに拡大・縮小するアクションを追加する。
         * @param scale
         * @param time
         * @param easing Easing関数。省略した場合はLINEAR
         * @param easing2
         */
        scaleTo(scale: number, time: number, easing?: any, easing2?: any): Timeline;
        /**
         * Entity をなめらかに拡大・縮小するアクションを追加する。
         * @param scale
         * @param time
         * @param easing Easing関数。省略した場合はLINEAR
         * @param easing2
         */
        scaleBy(scale: number, time: number, easing?: any, easing2?: any): Timeline;
        /**
         * Entity をなめらかに回転させるアクションを追加する。
         * @param deg 目標の回転角度 (弧度法: 1回転を 360 とする)
         * @param time フレーム数
         * @param easing Easing関数。省略した場合はLINEAR
        */
        rotateTo(deg: number, time: number, easing?: Function): Timeline;
        /**
         * Entity をなめらかに回転させるアクションを追加する。
         * @param deg 目標の回転角度 (弧度法: 1回転を 360 とする)
         * @param time フレーム数
         * @param easing Easing関数。省略した場合はLINEAR
         */
        rotateBy(deg: number, time: number, easing?: Function): Timeline;
        /**
         * フィルタをかける
         * @param targetClass ImageFilter.TintFilterなど、対象のフィルタクラスを指定する
         * @param props フィルタクラスに指定するプロパティ値。{propName: {start: val, end: val}}の形式で指定
         * @param time 必要時間
         * @param easing Easing関数。省略した場合はLINEAR
         */
        filter(targetClass: Function, props: any, time: number, easing?: Function): Timeline;
        /**
         * Entity をシーンから削除する。
         */
        removeFromScene(): Timeline;
    }
}
declare module jg {
    /**
     * ブラウザ情報
     */
    interface BrowserInfo {
        /** Chromeであればtrue */
        chrome?: boolean;
        /** Webkit系であればtrue */
        webkit?: boolean;
        /** Safariであればtrue */
        safari?: boolean;
        /** Operaであればtrue */
        opera?: boolean;
        /** Internet Explorerであればtrue */
        msie?: boolean;
        /** FireFoxであればtrue */
        mozilla?: boolean;
        /** ブラウザのバージョン */
        version?: string;
    }
    /**
     * jgame.jsのユーティリティ関数群。
     * Note: このクラスに似たようなコードが多いのは関数コールのオーバーヘッドを避けるためで、意図的に最適化をしていない結果
     */
    class JGUtil {
        /** ブラウザ情報 */
        static browser: BrowserInfo;
        /**
         * focus獲得と同時に動作し、focusが離れたら動作しないゲームにする。
         * このメソッドは一つのGameインスタンスに対して一度しか呼び出してはならない。
         */
        static autoStop(...games: Game[]): void;
        /**
         * 座標の中心地を返す。
         * 引数がCommonAreaである場合、サイズも計算して返し、CommonOffsetである場合は何も計算せずに返す
         * @param p 判定する座標または領域
         */
        static getCenterPoint(p: CommonOffset): CommonOffset;
        /**
         * 座標の中止点から見ての余白を返す。
         * 引数がCommonAreaである場合、サイズを計算して返し、CommonOffsetである場合はx:0, y:0を返す
         * @param p 判定する座標または領域
         */
        static getMargin(p: CommonOffset): CommonOffset;
        /**
         * 二つの座標または領域が衝突しているかを判定する
         * @param p1 判定する座標または領域
         * @param p2 判定する座標または領域
         */
        static intersect(p1: CommonOffset, p2: CommonOffset): boolean;
        /**
         * 二つの座標または領域の距離を返す。
         * 領域である場合、中心点からの距離となる点に注意
         * @param p1 判定する座標または領域
         * @param p2 判定する座標または領域
         */
        static getDistance(p1: CommonOffset, p2: CommonOffset): CommonOffset;
        /**
         * 二つのオブジェクトが追尾しあう場合の速度に応じた移動量を返す
         * @param p1 追尾する座標または領域
         * @param p2 追尾する座標または領域
         * @param power 移動力。省略時は1（瞬時に移動を完了するだけの量）
         * @param maxMove 移動最大値。省略時は判定しない
         */
        static getMovePoint(p1: CommonOffset, p2: CommonOffset, power?: number, maxMove?: number): CommonOffset;
        /**
         * 二つの座標または領域を比較し、p1から見てp2がどの方角にあるかをAngle型で返す
         * @param p1 判定する座標または領域
         * @param p2 判定する座標または領域
         * @param minDistance 最小距離。指定するとこの距離以上に距離がある場合、nullを返す
         */
        static getDirectionAngle(p1: CommonOffset, p2: CommonOffset, minDistance?: number): Angle;
        /**
         * 二つの座標または領域を比較し、p1から見てp2がどの方角にあるかをKeytype型で返す
         * @param p1 判定する座標または領域
         * @param p2 判定する座標または領域
         * @param minDistance 最小距離。指定するとこの距離以上に距離がある場合、nullを返す
         */
        static getDirectionKeytype(p1: CommonOffset, p2: CommonOffset, minDistance?: number): Keytype;
        /**
         * p1にp2を横方向で追尾させる
         * @param p1 追尾する座標または領域
         * @param p2 追尾される座標または領域
         * @param speed 移動速度
         * @param t 経過時間
         */
        static homingX(p1: CommonOffset, p2: CommonOffset, speed: number, t: number): boolean;
        /**
         * p1にp2を縦方向で追尾させる
         * @param p1 追尾する座標または領域
         * @param p2 追尾される座標または領域
         * @param speed 移動速度
         * @param t 経過時間
         */
        static homingY(p1: CommonOffset, p2: CommonOffset, speed: number, t: number): boolean;
        /**
         * p1にp2を横方向で追尾させる
         * @param p1 追尾する座標または領域
         * @param p2 追尾される座標または領域
         * @param speed 移動速度
         * @param t 経過時間
         */
        static homing(p1: CommonOffset, p2: CommonOffset, speed: number, t: number): boolean;
        /**
         * 表示順序をY座標順にするためのメソッドサンプル      。
         * 下記のようにLayerなどに指定すると、描画順を変更できる。
         * game.scene.root.orderDraw = JGUtil.orderDrawY;
         */
        static orderDrawY(target: E): void;
        /**
         * 線形グラデーションを作成する。ここで作成したグラデーションは、Shapeの色などに用いることが出来る。
         * @param rect グラデーションの範囲を指定。Rectangleクラス、またはjsの場合は4つの引数に分けてもよい。引数を4つにけると、colorsが第五引数、offsetsが第六引数となる
         * @param colors グラデーション色。CSSカラーで指定する
         * @param offsets グラデーションのオフセット値を0～1の範囲で指定。colorsと同じ個数指定する。省略した場合、等分に割られた値が自動的に割り当てられる
         */
        static createLinearGradient(rect: any, colors: string[], offsets?: number[]): CanvasGradient;
        /**
         * 円形グラデーションを作成する。ここで作成したグラデーションは、Shapeの色などに用いることが出来る。
         * @param rect グラデーションの範囲を指定。Rectangleクラス、またはjsの場合は4つの引数に分けてもよい。
         * @param radius1 開始円の半径
         * @param radius2 終了円の半径
         * @param colors グラデーション色。CSSカラーで指定する
         * @param offsets グラデーションのオフセット値を0～1の範囲で指定。colorsと同じ個数指定する。省略した場合、等分に割られた値が自動的に割り当てられる
         */
        static createRadialGradient(rect: any, radius1: number, radius2: number, colors: string[], offsets?: number[]): CanvasGradient;
        /**
         * パターン画像を作成する。ここで作成したパターン画像は、Shapeの色などに用いることが出来る
         * @param image パターン画像のソースイメージ
         * @param repeat 繰り返し方法を、repeat, repeat-x, repeat-y, no-repeatいずれかの文字列で指定。省略時はrepeatになる
         */
        static createPattern(image: any, repeat?: string): CanvasPattern;
        /**
         * style属性を使って拡縮しているかどうか
         */
        static isStyleScale: boolean;
        /**
         * 変形方法を返し、JGUtil.isStyleScaleに値が無い場合は値をセットする
         */
        static isTransformMode(): boolean;
        /**
         * キャンバスを引き伸ばす。通常、ゲームのサイズ変更で利用される
         * @param canvas 対象のキャンバス
         * @param size 引き伸ばした後のサイズ
         */
        static scaleCanvas(canvas: HTMLCanvasElement, size: CommonSize): void;
        /**
         * ブラウザ情報を取得する。
         * このメソッドは一度取得した後はJGUtil.browserに情報を格納し、以後はJGUtil.browserを返す。
         */
        static getBrowser(): BrowserInfo;
        /**
         * 画像描画時のアンチエイリアス効果を変更する。
         * 通常ドット絵を拡大するとアンチエイリアスによって滲むが、滲ませずにドットを強調して拡大する場合などに利用する。
         * 変更後、ゲームはrefreshによって再構築される。
         * このメソッドはページに存在するすべてのゲームに影響を及ぼす。将来的には指定されたゲームのみに影響が及ぶよう改修予定
         * @param game 対象のゲーム
         * @param crispEdges trueにすると転送時にアンチエイリアスをオフにする
         */
        static setCrispEdges(game: Game, crispEdges: boolean): void;
        /**
         * 必ず引数selfをthisとして受け取るコールバック関数を生成する。
         * このメソッドで生成したコールバックでDOMのaddEventListenerを実行すると、removeEventListenerがしにくくなる点に注意。
         * removeEventListenerをする可能性がある場合、createIdProxyの利用を検討した方がよい。
         * @param func コールバック関数
         * @param self thisとなるオブジェクト
         */
        static proxy(func: Function, self: any): () => void;
        /**
         * createIdProxyで生成されたID付きproxyデータ
         */
        private static idData;
        /**
         * ID付きのプロキシデータを生成する。
         * @param id 一意のID。通常、game.idを指定する
         * @param func コールバック関数
         * @param self thisとなるオブジェクト
         */
        static createIdProxy(id: number, func: Function, self: any): () => void;
        /**
         * 指定のID付きプロキシデータを取得する
         * @param id 一意のID。通常、game.idを指定する
         * @param func コールバック関数
         * @param self thisとなるオブジェクト
         */
        static getIdProxy(id: number, func: Function, self: any): () => void;
        /**
         * ID付きプロキシデータを削除する
         * @param id 一意のID。通常、game.idを指定する
         * @param func コールバック関数
         * @param self thisとなるオブジェクト
         */
        static deleteIdProxy(id: number, func: Function, self: any): void;
        /**
         * 一意のIDを生成する
         */
        static generateId(): number;
        /**
         * 二次元配列のX軸とY軸を入れ替えた結果を返す。
         * マトリックスのみのサポートであり、src[0].lengthとsrc[1].lengthが異なる配列はサポートされない。
         * src[x][y] == ret[y][x]
         * @param src 入力元配列
         */
        static transpose(src: any[][]): any[][];
    }
}
declare module jg {
    /**
     * 二次ベジェ曲線の座標
     */
    interface QuadraticPoint extends CommonOffset {
        /** 制御点のX座標 */
        cp1x: number;
        /** 制御点のY座標 */
        cp1y: number;
    }
    /**
     * 三次ベジェ曲線の座標
     */
    interface BezierPoint extends QuadraticPoint {
        /** 二つ目の制御点のX座標 */
        cp2x: number;
        /** 二つ目の制御点のY座標 */
        cp2y: number;
    }
    /**
     * 円弧の座標
     */
    interface ArcPoint extends CommonOffset {
        /** 終点X座標 */
        x2: number;
        /** 終点Y座標 */
        y2: number;
        /** 半径 */
        radius: number;
    }
    /**
     * 線を描画するクラス。
     * 一般的な直線から、複雑な図形描画も出来る。
     */
    class Line extends E {
        /** 各種線 */
        p: CommonOffset[];
        /** 塗りつぶすかどうか */
        fill: boolean;
        /** 直線を描くかどうか */
        stroke: boolean;
        /** パスを閉じるかどうか */
        closePath: boolean;
        /** 描画をせず、クリッピングとして使うかどうか */
        clip: boolean;
        /**
         * コンストラクタ
         * @param pos 基準点
         * @param line 直線を引く場合、最初の直線座標を入れるこ
         * @param color 線の色
         * @param width 線の幅
         */
        constructor(pos: CommonOffset, line?: CommonOffset, color?: string, width?: number);
        /**
         * クリッピングモードにする、または解除する
         * クリッピングモードにした場合、このクラスは直接描画されず、このクラスの後に描画される結果に対してクリッピング処理を行う。
         * @param value trueでクリッピングモード、falseで通常
         */
        setClip(value: boolean): void;
        /**
         * このオブジェクトのサイズを再計算する。
         * 現状あまりうまく動いていない模様。
         */
        updateSize(): void;
        /**
         * 線の色を指定する
         * @param color 線の色。CSSカラー形式の文字列や、グラデーションやパターンなど
         */
        setColor(color: any): Line;
        /**
         * 線の色を取得する
         */
        getColor(): any;
        /**
         * 塗りつぶし色を指定する
         */
        setFillColor(color: any): Line;
        /**
         * 塗りつぶし色を取得する
         * @param color 線の色。CSSカラー形式の文字列や、グラデーションやパターンなど
         */
        getFillColor(): any;
        /**
         * 線の幅を指定する
         * @param width 線の幅
         */
        setLineWidth(width: number): Line;
        /**
         * 線の幅を取得する
         */
        getLineWidth(): any;
        /**
         * 線の末端のスタイルをbutt, round, squareいずれかの文字列で指定する
         * @param lineCap 線の末端のスタイル
         */
        setLineCap(lineCap: string): Line;
        /**
         * 線の末端のスタイルを取得する
         */
        getLineCap(): any;
        /**
         * 線の結合方式をbevel, round, miterいずれかの文字列で指定する
         * @param lineJoin 線の結合形式
         */
        setLineJoin(lineJoin: string): Line;
        /**
         * 線の結合形式を取得する
         */
        getLineJoin(): any;
        /**
         * マイター限界比率を指定する
         * @param miterLimit マイター限界比率
         */
        setMiterLimit(miterLimit: number): Line;
        /**
         * マイター限界比率を取得する
         */
        getMiterLimit(): any;
        /**
         * 塗りつぶしに関して必要なパラメータを一括で指定する
         * @param fill 塗りつぶしを行うかどうか
         * @param color 塗りつぶし色
         * @param closePath パスを閉じるかどうか。省略した場合変更しない
         * @param stroke 線を描画するかどうか。fillとstrokeがいずれもtrueである場合、線描画と塗りつぶしの両方が行われる。省略した場合変更しない
         */
        setFill(fill: boolean, color: any, closePath?: boolean, stroke?: boolean): Line;
        /**
         * 線を追加する
         * @param line 数値またはCommonOffsetで指定。数値の場合はX座標
         * @param y 数値でY座標を指定。省略する場合、lineはCommonOffsetである必要がある
         */
        addLine(line: any, y?: number): Line;
        /**
         * 二次ベジェ曲線を追加
         * @param cp CommonOffsetで制御点を指定
         * @param p CommonOffsetで終点を指定
         */
        addQuadraticLine(cp: any, p?: any): Line;
        /**
         * 三次ベジェ曲線を追加
         * @param cp1 CommonOffsetで制御点1を指定
         * @param cp2 CommonOffsetで制御点2を指定
         * @param p CommonOffsetで終点を指定
         */
        addBezierLine(cp1: any, cp2?: any, p?: any): Line;
        /**
         * 曲線を追加
         * @param p CommonOffsetで地点1の座標を指定
         * @param p2 CommonOffsetで地点2の座標を指定
         * @param radius 半径
         */
        addArc(p: any, p2: any, radius: any): void;
        /**
         * 線を追加する。
         * 見直し予定。
         */
        add(): any;
        /**
         * 描画
         * @param context 対象の描画コンテキスト
         */
        draw(context: CanvasRenderingContext2D): void;
    }
}
declare module jg {
    /**
     * エフェクトを生成するクラス
     */
    class Effect {
        /** エフェクト時間 */
        static time: number;
        /** エフェクトの色 */
        static color: string;
        /**
         * シーンに対するエフェクトを生成し、実行する
         * @param game 対象のゲーム
         * @param scene1 遷移元シーン
         * @param scene2 遷移先シーン
         * @param type シーン種別。EffectTypeの数値か、EffectSceneを継承したクラスのインスタンスを指定する
         * @param collback
         * @param endOldScene trueを指定すると最初に遷移元シーンを終了させる
         */
        static sceneEffect(game: Game, scene1: Scene, scene2: Scene, type: any, callback: Function, endOldScene?: boolean): void;
        /** エフェクトを行うメソッド名 */
        method: string;
        /** エフェクトメソッドに渡す引数 */
        arguments: any[];
        /**
         * コンストラクタ
         * @param method エフェクトメソッド名
         * @param args エフェクトメソッドに引き渡す引数
         */
        constructor(method: string, ...args: any[]);
        /**
         * エフェクトを実行する
         * @param scene エフェクトを実行するためのEffectScene
         */
        callEffect(scene: EffectScene): void;
    }
    /**
     * シーンに対するEffectを実行するクラス
     */
    class EffectScene extends Scene {
        /** 遷移元シーンのキャプチャ */
        sp1: Sprite;
        /** 遷移先シーンのキャプチャ */
        sp2: Sprite;
        /** エフェクト完了後に呼び出されるイベント */
        effected: Trigger;
        /**
         * コンストラクタ
         * @param game エフェクト対象ゲーム
         * @param scene1 遷移元シーン
         * @param scene2 遷移先シーン
         */
        constructor(game: Game, scene1: Scene, scene2: Scene);
        /**
         * 現在のシーンの状態をキャプチャする
         * @param scene キャプチャ対象シーン
         */
        captureScene(scene: Scene): Sprite;
        /**
         * フェードエフェクトをかける
         * @param color フェード時の色。指定すると色へフェードアウト->色からフェードインの2段階フェードエフェクトになり、省略するとフェードアウトとフェードインが同時に行われる1段階フェードエフェクトとなる
         */
        fade(color?: any): void;
        /**
         * 色付きフェードエフェクトをかける
         * @param color フェード色
         */
        _fadeColor(color: any): void;
        /**
         * モザイクエフェクトを行う
         */
        mosaic(): void;
        /**
         * Blur（滲ませる）エフェクトを行う。非常に重いので注意
         */
        blur(): void;
        /**
         * 指定方向にスライドするエフェクトを行う
         * @param angle スライド方向
         */
        slide(angle: Angle): void;
        /**
         * 指定方向にワイプするエフェクトを行う
         * @param angle ワイプする方向
         */
        wipe(angle: Angle): void;
        /**
         * 指定方向へのワイプとフェードを組み合わせたエフェクトを行う
         * @param angle ワイプする方向
         */
        wipeFade(angle: Angle): void;
        /**
         * boxOut
         * @param rotate 四角の回転
         * @param color
         */
        boxOut(rotate?: number, color?: any): void;
        /**
         * boxIn
         * @param rotate 四角の回転
         * @param color
         */
        boxIn(rotate?: number, color?: any): void;
        /**
         * arcOut
         * @param color
         */
        arcOut(color?: any): void;
        /**
         * arcIn
         * @param color
         */
        arcIn(color?: any): void;
        /**
         * ユニバーサルエフェクトを行う
         * @param image エフェクトのための画像
         * @param repeat サイズが合わない場合、trueを指定すると繰り返し、falseを指定すると拡大する
         */
        universal(image: any, repeat?: boolean): void;
        /**
         * 遷移元シーンを画像通りのユニバーサルエフェクト、遷移先シーンを画像を反転させたユニバーサルエフェクトとして同時に実行する
         * @param image エフェクトのための画像
         * @param repeat サイズが合わない場合、trueを指定すると繰り返し、falseを指定すると拡大する
         */
        universalTwin(image: any, repeat?: boolean): void;
        /**
         * 遷移元シーンをユニバーサルエフェクトでフェードアウトさせ、その後遷移先シーンをユニバーサルエフェクトでフェードインさせる
         * @param image エフェクトのための画像
         * @param repeat サイズが合わない場合、trueを指定すると繰り返し、falseを指定すると拡大する
         * @param color フェードアウト時の色
         */
        universalDelay(image: any, repeat?: boolean, color?: any): void;
        /**
         * 対象からフィルタを取得する。対象がフィルタを持たない場合、空のImageFilter.FilterChainを返す
         * @param target フィルタ指定元オブジェクト
         */
        getFilter(target: any): any;
        /**
         * シーンのスワップショットの位置を入れ替える
         */
        swapScene(): void;
    }
}
declare module jg {
    /**
     * 継承前提で作られている基本のウィンドウクラス。
     * jgame.jsはUIライブラリではなくシンプルにエンジンのみの提供を目指しているため、本クラスを継承したUIクラスはMessageeWindowクラス以外用意されていないｋ。
     */
    class UIWindow extends E {
        /** 余白のサイズ */
        padding: IRectangle;
        /** 背景。変更する場合はsetBgを利用するべき */
        bg: E;
        /**
         * コンストラクタ
         * @param width 横幅
         * @param height 縦幅
         * @param bgImage 背景画像。省略時はdefaultSkinメソッドによるUIWindowが生成される
         * @param padding 余白
         */
        constructor(width: number, height: number, bgImage?: any, padding?: IRectangle);
        /**
         * 背景要素を返す。
         * って実態はthis.entities[0]を返しているけどいいのかこれ？
         */
        getBg(): E;
        /**
         * 背景要素を指定する。背景は常に最背面に配置される点に注意。
         * @param bg 指定する背景。通常、createBgImageで生成した画像を指定する
         */
        setBg(bg: E): void;
        /**
         * 描画要素を基に背景画像を生成する
         * @param e 背景の基となる描画要素。余白に合わせた引き伸ばし処理が行われる
         * @param srcPadding 余白。省略時はthis.paddingが用いられる
         * @param buf 生成に利用するバッファ。省略時は自動生成。フクスウUIを生成する場合には、指定すると若干高速になる
         */
        createBgImage(e: E, srcPadding?: IRectangle, buf?: BufferedRenderer): Sprite;
        /**
         * 簡素な見た目のデフォルトのスキンを生成する。
         */
        defaultSkin(): void;
    }
}
declare module jg {
    /**
     * メッセージウィンドウを表示するクラス。
     * UIWindowクラスの継承サンプル、並びにMultilineTextクラスの使用サンプルを兼ねている。
     */
    class MessageWindow extends UIWindow {
        /** 次カーソルの表示実態。本フィールドを直接編集しても次カーソルは変わらないため、次カーソルの表示を変更する場合setNextCursorメソッドを利用する */
        _nextCursor: Sprite;
        /** 次カーソルの元画像。これに対してcreateSpriteをしてから次カーソルを描画する。変更する場合setNextCursorメソッドを利用するのを推奨 */
        nextCursor: E;
        /** 現在までのテキスト表示位置 */
        scriptOffset: number;
        /** 表示するテキスト */
        script: string;
        /** テキスト表示速度（通常） */
        normalSpeed: number;
        /** テキスト表示速度（高速） */
        fastSpeed: number;
        /** 表示が完了した場合に発火されるイベント。パラメータがtrueであればまだ未読のスクリプトが次ページ以降に残っている事を示している */
        readed: Trigger;
        /** ページ表示が完了したことを示すフラグ */
        isReaded: boolean;
        /** ページ送りで利用されるクリッピング領域 */
        textClip: Shape;
        /** 次ページがあることを示すカーソルが出ているかどうか */
        hasNextCursor: boolean;
        /** テキスト表示用MultilineText */
        textArea: MultilineText;
        /**
         * コンストラクタ
         * @param width 横幅
         * @param height 縦幅
         * @param bgImage 背景画像
         * @param padding 上下左右の余白幅
         */
        constructor(width: number, height: number, bgImage?: any, padding?: IRectangle);
        /**
         * MultilineTextを設定する。
         * 通常、内部的に自動設定されるため、本メソッドを外部から呼び出す必要性は無い
         */
        setTextArea(textArea: MultilineText): void;
        /**
         * 次カーソルを取得
         */
        getNextCursor(): E;
        /**
         * 次カーソルを設定する
         * @param cursor 設定する次カーソル
         */
        setNextCursor(cursor: E): void;
        /**
         * テキストを設定する
         * @param text テキスト
         * @param offset テキストの処理開始オフセット位置
         */
        setText(text: string, offset?: number): number;
        /**
         * スクリプトを設定する
         * @param script スクリプト
         * @param offset スクリプトの処理開始オフセット位置
         */
        setScript(script: string, offset?: number): number;
        /**
         * 次カーソルを表示する。既に表示されている場合処理を行わない
         */
        showNextCursor(): void;
        /**
         * 次カーソルを削除する。表示されていない場合処理を行わない
         */
        deleteNextCursor(): void;
        /**
         * 非表示にする
         * @param fade trueにするとフェードアウトアニメーション後非表示にする
         */
        hide(fade?: boolean): void;
        /**
         * 表示する
         * @param fade trueにするとファー度インアニメーション後表示する
         */
        show(fade?: boolean): void;
        /**
         * テキストの表示を開始する
         */
        showText(): void;
        /**
         * テキストの表示速度を高速にする
         */
        fastMode(): void;
        /**
         * テキストの表示速度を通常速にする
         */
        normalMode(): void;
        /**
         * テキストをすべて表示する
         */
        showAll(): void;
        /**
         * 次のテキストを表示する
         */
        next(): boolean;
        /**
         * 古いテキストをワイプアニメーションで除外する
         */
        oldWipeOut(time?: number): void;
        /**
         * 古いテキストをフェードアウトアニメーションで除外する
         */
        oldFadeOut(time?: number): void;
        /**
         * テキスト表示完了時のイベントハンドラ
         */
        onAnimated(): void;
    }
}
declare module jg {
    /**
     * ピクセルデータを直接編集するクラス。
     * 現行バージョンでは少し扱いに癖がある
     */
    class Pixel extends E {
        /** 生ピクセルデータ */
        imageData: ImageData;
        /**
         * コンストラクタ
         * @param width 横幅
         * @param height 縦幅
         * @param srcImage 元画像
         * @param scale srcImageをwidth, heightの指定に基づいて拡大縮小した上でピクセルデータを生成するかどうか
         */
        constructor(width: number, height: number, srcImage?: any, scale?: boolean);
        /**
         * 指定した色で全ピクセルをクリアする
         * @param r 赤。省略時は0
         * @param g 緑。省略時は0
         * @param b 青。省略時は0
         * @param a 透明度。省略時は0
         */
        clear(r?: number, g?: number, b?: number, a?: number): void;
        /**
         * ピクセルデータをコンテキストに転送する
         * @param context 対象の描画コンテキスト
         */
        draw(context: CanvasRenderingContext2D): void;
    }
}
declare module jg {
    /**
     * window名前空間にjg名前空間の要素を展開する。
     * 一般的なjavascriptであれば、本関数実行後、jg.GameはGameとしてアクセスできるようになる。
     */
    function globalize(): void;
}
declare module jg {
    /**
     * Mersenne Twisterアルゴリズムによる乱数生成器。
     * このクラスがjgame.jsに組み込まれているのは、マルチプラットフォームでの乱数共有化が目的としてあり、本ソース自体もクロスプラットフォーム用Mersenne Twisterを移植したもの。
     * 移植元プロジェクト: https://github.com/tsugehara/mt-cross
     * 少数の精度の違いがありえるため、nextIntによる整数乱数を主に使うことが推奨されている。
     */
    class MT {
        /** 乱数シード群 */
        _mt: number[];
        /** シードに対するインデックス */
        _index: number;
        /**
         * コンストラクタ
         * @param seed 指定するとシードを指定して乱数生成器を生成する。省略時は自動的に設定される
         */
        constructor(seed?: number);
        /**
         * 何やってるのかよく知らない
         */
        static _mulUint32(a: number, b: number): number;
        /**
         * シード生成
         */
        setSeed(seed: any): void;
        /**
         * 次の乱数値を整数値で受け取る
         */
        _nextInt(): number;
        /**
         * 次の乱数値を小数値として受け取る。利用は推奨されない
         */
        next(): number;
        /**
         * 次の乱数値を整数値として受け取る
         */
        nextInt(min: number, sup: number): number;
    }
}