[from now] 2013/03/13 09:08:14

diff --git a/MyOMake/TypeScript.om b/MyOMake/TypeScript.om
index 23c32c8..627f028 100644
--- a/MyOMake/TypeScript.om
+++ b/MyOMake/TypeScript.om
@@ -42,16 +42,7 @@ public.Tsc() =
 # Dependecies on TypeScript are automatic calculating by TypeScript compiler, so
 # this file does not include scanner for .ts files.
 %.js : %.ts
-	match $<
-	case $"\(.*\)\.d\.ts"
-		eprintln(declaration file can not compile to .js)
-	case $"\(.*\)\.ts"
-		$(Tsc) $<
-	default
-    	eprintln(not target file)
-
-%.d.js : %.d.ts
-	eprintln(do not compile)
+	$(Tsc) $<

 # build rules
 # ======================================================================
diff --git a/src/animation.ts b/src/animation.ts
index c4bb1e6..48abb19 100644
--- a/src/animation.ts
+++ b/src/animation.ts
@@ -145,7 +145,7 @@ export class Symbol implements Symbolize {
 }

 // レンダリングターゲットに対して、各種のアニメーションを管理するための
-// singletonなクラス
+// singletonなクラス。
 // アニメーションを実行したいオブジェクトは、Animaから生成されるアニメーションオブジェクト
 // を取得し、各フレームごとにAnimaの更新処理を行うことで、全体のアニメーションを、時間ベースで
 // 一極管理することができる。
@@ -153,12 +153,16 @@ export class Anima {

     static private _instance: Anima = null;

-    private static getInstance(): Anima {
+    private constructor() {}
+
+    public static getInstance(): Anima {
         if (this._instance == null) {
             this._instance = new Anima();
         }
         return this._instance;
     }
+
+
 }

 // 描画オブジェクトの描画先となるコンテキストクラス
diff --git a/src/firework.js b/src/firework.js
index 9d02d96..4cf6e67 100644
--- a/src/firework.js
+++ b/src/firework.js
@@ -3,8 +3,7 @@ var __extends = this.__extends || function (d, b) {
     __.prototype = b.prototype;
     d.prototype = new __();
 };
-define(["require", "exports", "util", "animation", "gameLib"], function(require, exports, __util__, __animation__, __gl__) {
-    /// <reference path='star.d.ts' />
+define(["require", "exports", "util", "animation", "gameLib", "star"], function(require, exports, __util__, __animation__, __gl__, __star__) {
     var util = __util__;

     var animation = __animation__;
@@ -12,6 +11,8 @@ define(["require", "exports", "util", "animation", "gameLib"], function(require,
     var gl = __gl__;

     var I = util.Illiegals;
+    var star = __star__;
+
     // �I�u�W�F�N�g�̎��ʂ��\��
     (function (ObjectType) {
         ObjectType._map = [];
@@ -46,6 +47,7 @@ define(["require", "exports", "util", "animation", "gameLib"], function(require,
     })();
     exports.ObjectInfo = ObjectInfo;
     (function (GameObj) {
+        GameObj.Star = star.Star;
         var StarCaseOption = (function () {
             function StarCaseOption() {
                 // ���E���ǂ̕�
diff --git a/src/firework.ts b/src/firework.ts
index 7aa352f..add36b6 100644
--- a/src/firework.ts
+++ b/src/firework.ts
@@ -1,9 +1,8 @@
-/// <reference path='star.d.ts' />
-
 import util = module("util");
 import animation = module("animation");
 import gl = module("gameLib");
 import I = util.Illiegals
+import star = module("star");

 export interface ObjectBase {
     // IuWFNgªLøł 邩ðԂ·B
@@ -35,6 +34,8 @@ export class ObjectInfo {

 export module GameObj {

+    export var Star = star.Star;
+
     export interface IStar extends gl.Entity, gl.Physics.BodyBindable, ObjectBase {}
     export interface IStarCase extends gl.Entity, gl.Physics.BodyBindable {}

diff --git a/src/gameLib.ts b/src/gameLib.ts
index 38e3c87..79bad71 100644
--- a/src/gameLib.ts
+++ b/src/gameLib.ts
@@ -47,6 +47,12 @@ export interface Group extends EventTarget {

     // 指定されたcontextに対してレンダリングを行う
     render(context: animation.Context): void;
+
+    // 管理対象のentityに対して、Timelineが登録されている場合には、
+    // Entityに対してTimelineを進める。
+    // 自分自身のonenterframeイベントが登録されている場合は、他のtimeline
+    // が発行される前に、自分自身のonenterframeが実行される。
+    doFrame() : void;
 }

 // ゲーム内における各シーンのインターフェース。
@@ -120,6 +126,14 @@ export class SceneImpl extends EventTargetImpl implements Scene {
         this._correctedEntities.forEach(elem => elem.render(context));
         this._nonCorrectedEntities.forEach(elem => elem.render(context));
     }
+
+    // 指定されたcontextに対してレンダリングを行う
+    render(context: animation.Context): void {
+        this.fire(EventConstants.ENTER_FRAME, null);
+
+        // TODO タイムラインは、animation.Animaクラスが全て担当するため、
+        // そっちも実装する。
+    }
 }

 // Gameで格納されるオブジェクトのベース
@@ -341,7 +355,7 @@ export class Game {
         }

         this._intervalHandle = window.setInterval(() => {
-            this.currentScene.fire(EventConstants.ENTER_FRAME, null);
+            this.currentScene.doFrame();

             this.render();

diff --git a/src/star.js b/src/star.js
index d27a309..edd7597 100644
--- a/src/star.js
+++ b/src/star.js
@@ -55,265 +55,262 @@ define(["require", "exports", "util", "animation", "gameLib", "firework"], funct
         }
         StarUtil.getSomeSize = getSomeSize;
     })(StarUtil || (StarUtil = {}));
-    (function (GameObj) {
-        // Starに係るロジック周辺の処理を担当する。
-        // StarLogic自体はStarにコンポジションされているが、
-        // StarLogicにもStarが渡されている。
-        var StarLogic = (function () {
-            function StarLogic(starShape, data) {
-                this.starShape = starShape;
-                this.data = data;
-                // 各starで共通するFixtureDefinition
-                this._fixDef = (function () {
-                    var fix = new Box2D.Dynamics.b2FixtureDef();
-                    fix.density = 1.0// 密度
-                    ;
-                    fix.friction = 1.5// 摩擦係数
-                    ;
-                    fix.restitution = 0.2// 反発係数
-                    ;
-                    return fix;
-                })();
-                this.state = new fw.ObjectInfo(fw.ObjectType.Star);
-                this.scale = 1;
-            }
-            StarLogic.prototype.onreflect = function () {
-                var body = this.starShape.body;
-                var count = 0;
-                var contacts = [];
-                for(var n = body.GetContactList(); n != null; n = n.next) {
-                    if(n.contact.IsTouching()) {
-                        contacts.push(n.other);
-                    }
-                }
-                // 星同士が4つ以上隣接したら、staticに変更する。
-                if(contacts.length >= 4 && this.isConnectable()) {
-                    contacts.filter(function (e) {
-                        var info_e = e.GetUserData();
-                        return info_e.objectState == fw.ObjectState.Free;
-                    }).forEach(function (e) {
-                        var info_e = e.GetUserData();
-                        info_e.objectState = fw.ObjectState.Connected;
-                        if(body != e && info_e.type == fw.ObjectType.Star) {
-                            e.SetType(Box2D.Dynamics.b2Body.b2_staticBody);
-                        }
-                    });
-                    body.SetType(Box2D.Dynamics.b2Body.b2_staticBody);
-                    var info = body.GetUserData();
-                    info.objectState = fw.ObjectState.Connected;
-                    return false;
-                }
-                return true;
-            };
-            StarLogic.prototype.isConnectable = function () {
-                return this.state.objectState === fw.ObjectState.Free;
-            };
-            StarLogic.prototype.ontouchstart = // タッチを開始した際の処理。
-            function (scene, e) {
-                var s = this.starShape;
-                if(this.state.objectState === fw.ObjectState.Connected) {
-                    s.x -= s.width;
-                    s.y -= s.height;
-                    this.data.radius *= 2;
-                    s.width *= 2;
-                    s.height *= 2;
-                    this.data.color.a = 0.3;
-                    this.state.objectState = fw.ObjectState.Touched;
-                }
-                return true;
-            };
-            StarLogic.prototype.ontouchend = // タッチして離されたとき、その時点での領域にかかっている星を
-            // 消して、自身を拡大する。
-            // ただし、領域内に、すでにLaunch状態になっているものがある場合は
-            // 元に戻る。
-            function (scene, e) {
-                var _this = this;
-                if(this.state.objectState !== fw.ObjectState.Touched) {
-                    return false;
+    // Starに係るロジック周辺の処理を担当する。
+    // StarLogic自体はStarにコンポジションされているが、
+    // StarLogicにもStarが渡されている。
+    var StarLogic = (function () {
+        function StarLogic(starShape, data) {
+            this.starShape = starShape;
+            this.data = data;
+            // 各starで共通するFixtureDefinition
+            this._fixDef = (function () {
+                var fix = new Box2D.Dynamics.b2FixtureDef();
+                fix.density = 1.0// 密度
+                ;
+                fix.friction = 1.5// 摩擦係数
+                ;
+                fix.restitution = 0.2// 反発係数
+                ;
+                return fix;
+            })();
+            this.state = new fw.ObjectInfo(fw.ObjectType.Star);
+            this.scale = 1;
+        }
+        StarLogic.prototype.onreflect = function () {
+            var body = this.starShape.body;
+            var count = 0;
+            var contacts = [];
+            for(var n = body.GetContactList(); n != null; n = n.next) {
+                if(n.contact.IsTouching()) {
+                    contacts.push(n.other);
                 }
-                var s = this.starShape;
-                var contain = scene.entities.filter(function (elem) {
-                    if(elem === s) {
-                        return false;
+            }
+            // 星同士が4つ以上隣接したら、staticに変更する。
+            if(contacts.length >= 4 && this.isConnectable()) {
+                contacts.filter(function (e) {
+                    var info_e = e.GetUserData();
+                    return info_e.objectState == fw.ObjectState.Free;
+                }).forEach(function (e) {
+                    var info_e = e.GetUserData();
+                    info_e.objectState = fw.ObjectState.Connected;
+                    if(body != e && info_e.type == fw.ObjectType.Star) {
+                        e.SetType(Box2D.Dynamics.b2Body.b2_staticBody);
                     }
-                    return _this.starShape.within(elem, _this.data.radius);
                 });
-                // 広がった中に存在しなければ、大きさを元に戻す。
-                if(contain.length === 0) {
-                    this.data.radius /= 2;
-                    s.width /= 2;
-                    s.height /= 2;
-                    this.state.objectState = fw.ObjectState.Connected;
+                body.SetType(Box2D.Dynamics.b2Body.b2_staticBody);
+                var info = body.GetUserData();
+                info.objectState = fw.ObjectState.Connected;
+                return false;
+            }
+            return true;
+        };
+        StarLogic.prototype.isConnectable = function () {
+            return this.state.objectState === fw.ObjectState.Free;
+        };
+        StarLogic.prototype.ontouchstart = // タッチを開始した際の処理。
+        function (scene, e) {
+            var s = this.starShape;
+            if(this.state.objectState === fw.ObjectState.Connected) {
+                s.x -= s.width;
+                s.y -= s.height;
+                this.data.radius *= 2;
+                s.width *= 2;
+                s.height *= 2;
+                this.data.color.a = 0.3;
+                this.state.objectState = fw.ObjectState.Touched;
+            }
+            return true;
+        };
+        StarLogic.prototype.ontouchend = // タッチして離されたとき、その時点での領域にかかっている星を
+        // 消して、自身を拡大する。
+        // ただし、領域内に、すでにLaunch状態になっているものがある場合は
+        // 元に戻る。
+        function (scene, e) {
+            var _this = this;
+            if(this.state.objectState !== fw.ObjectState.Touched) {
+                return false;
+            }
+            var s = this.starShape;
+            var contain = scene.entities.filter(function (elem) {
+                if(elem === s) {
                     return false;
                 }
-                contain.forEach(function (elem) {
-                    scene.removeEntity(elem);
-                });
-                // 剛体の情報を更新する。
-                s.body.SetType(Box2D.Dynamics.b2Body.b2_dynamicBody);
-                s.body.DestroyFixture(s.body.GetFixtureList());
-                var fixDef = this._fixDef;
-                fixDef.shape = new Box2D.Collision.Shapes.b2CircleShape(this.data.radius / this.scale);
-                s.body.CreateFixture(fixDef);
-                // 準備段階は終了とする
-                this.state.objectState = fw.ObjectState.PrepareLaunch;
-                return true;
+                return _this.starShape.within(elem, _this.data.radius);
+            });
+            // 広がった中に存在しなければ、大きさを元に戻す。
+            if(contain.length === 0) {
+                this.data.radius /= 2;
+                s.width /= 2;
+                s.height /= 2;
+                this.state.objectState = fw.ObjectState.Connected;
+                return false;
+            }
+            contain.forEach(function (elem) {
+                scene.removeEntity(elem);
+            });
+            // 剛体の情報を更新する。
+            s.body.SetType(Box2D.Dynamics.b2Body.b2_dynamicBody);
+            s.body.DestroyFixture(s.body.GetFixtureList());
+            var fixDef = this._fixDef;
+            fixDef.shape = new Box2D.Collision.Shapes.b2CircleShape(this.data.radius / this.scale);
+            s.body.CreateFixture(fixDef);
+            // 準備段階は終了とする
+            this.state.objectState = fw.ObjectState.PrepareLaunch;
+            return true;
+        };
+        StarLogic.prototype.createFixture = // 渡されたstarに適合するbodyの設定を作成する。
+        function (scale) {
+            var fixDef = this._fixDef;
+            var bodyDef = new Box2D.Dynamics.b2BodyDef();
+            bodyDef.type = Box2D.Dynamics.b2Body.b2_dynamicBody;
+            bodyDef.userData = this.state;
+            bodyDef.position.Set((this.data.x + this.data.width / 2) / scale, (this.data.y + this.data.height / 2) / scale);
+            bodyDef.angularVelocity = (Math.random() * 2 % 2 ? -1 : 1) * 10;
+            fixDef.shape = new Box2D.Collision.Shapes.b2CircleShape(this.data.width / 2 / scale);
+            this.scale = scale;
+            return {
+                bodyDef: bodyDef,
+                fixtureDef: fixDef
             };
-            StarLogic.prototype.createFixture = // 渡されたstarに適合するbodyの設定を作成する。
-            function (scale) {
-                var fixDef = this._fixDef;
-                var bodyDef = new Box2D.Dynamics.b2BodyDef();
-                bodyDef.type = Box2D.Dynamics.b2Body.b2_dynamicBody;
-                bodyDef.userData = this.state;
-                bodyDef.position.Set((this.data.x + this.data.width / 2) / scale, (this.data.y + this.data.height / 2) / scale);
-                bodyDef.angularVelocity = (Math.random() * 2 % 2 ? -1 : 1) * 10;
-                fixDef.shape = new Box2D.Collision.Shapes.b2CircleShape(this.data.width / 2 / scale);
-                this.scale = scale;
-                return {
-                    bodyDef: bodyDef,
-                    fixtureDef: fixDef
-                };
+        };
+        return StarLogic;
+    })();
+    var Renderer;
+    (function (Renderer) {
+        // 通常状態のStarをレンダリングする。
+        var NormalStarRenderer = (function () {
+            function NormalStarRenderer(data) {
+                this.data = data;
+                this._renderer = new animation.Renderer.Circle.CircleRenderer(this.data);
+            }
+            NormalStarRenderer.prototype.render = function (context) {
+                var r = this.data.radius;
+                var d = this.data;
+                var grad = new animation.Gradation.Radial(context);
+                grad.from(d.x + r * 0.7, d.y + r * 0.5, 1).to(d.x + r, d.y + r, r);
+                grad.colorStop(0.0, "#fff").colorStop(0.5, d.color.toFillStyle()).colorStop(1.0, "#000");
+                d.gradient = grad;
+                this._renderer.render(context);
             };
-            return StarLogic;
+            return NormalStarRenderer;
         })();
-        var Renderer;
-        (function (Renderer) {
-            // 通常状態のStarをレンダリングする。
-            var NormalStarRenderer = (function () {
-                function NormalStarRenderer(data) {
-                    this.data = data;
-                    this._renderer = new animation.Renderer.Circle.CircleRenderer(this.data);
-                }
-                NormalStarRenderer.prototype.render = function (context) {
-                    var r = this.data.radius;
-                    var d = this.data;
-                    var grad = new animation.Gradation.Radial(context);
-                    grad.from(d.x + r * 0.7, d.y + r * 0.5, 1).to(d.x + r, d.y + r, r);
-                    grad.colorStop(0.0, "#fff").colorStop(0.5, d.color.toFillStyle()).colorStop(1.0, "#000");
-                    d.gradient = grad;
-                    this._renderer.render(context);
-                };
-                return NormalStarRenderer;
-            })();
-            // 連結状態のStarをレンダリングする。
-            var ConnectedStarRenderer = (function () {
-                function ConnectedStarRenderer(data) {
-                    this.data = data;
-                    this._renderer = new animation.Renderer.Circle.CircleRenderer(this.data);
-                }
-                ConnectedStarRenderer.prototype.render = function (context) {
-                    var r = this.data.radius;
-                    var d = this.data;
-                    var grad = new animation.Gradation.Radial(context);
-                    grad.from(d.x + r * 0.7, d.y + r * 0.5, 1).to(d.x + r, d.y + r, r);
-                    grad.colorStop(0.0, "#fff").colorStop(0.8, "#888").colorStop(1.0, "#000");
-                    d.gradient = grad;
-                    this._renderer.render(context);
-                };
-                return ConnectedStarRenderer;
-            })();
-            // PrepareLaunch状態のレンダリングを行う。
-            var PrepareLaunchRenderer = (function () {
-                function PrepareLaunchRenderer(data) {
-                    this.data = data;
-                    this._renderer = new animation.Renderer.Circle.CircleRenderer(this.data);
-                }
-                PrepareLaunchRenderer.prototype.render = function (context) {
-                    var r = this.data.radius;
-                    var d = this.data;
-                    var grad = new animation.Gradation.Radial(context);
-                    grad.from(d.x + r * 0.7, d.y + r * 0.5, 1).to(d.x + r, d.y + r, r);
-                    grad.colorStop(0.0, d.color.toFillStyle()).colorStop(1.0, d.color.toFillStyle());
-                    this.data.gradient = grad;
-                    this._renderer.render(context);
-                };
-                return PrepareLaunchRenderer;
-            })();
-            // Starで利用するrenderの切り替えをコントロールするためのクラス
-            var StarRenderController = (function () {
-                function StarRenderController(data) {
-                    this.data = data;
-                    this._renderStock = [];
-                    this._renderStock.push({
-                        state: fw.ObjectState.Free,
-                        render: new NormalStarRenderer(data)
-                    });
-                    this._renderStock.push({
-                        state: fw.ObjectState.Touched,
-                        render: new NormalStarRenderer(data)
-                    });
-                    this._renderStock.push({
-                        state: fw.ObjectState.Connected,
-                        render: new ConnectedStarRenderer(data)
-                    });
-                    this._renderStock.push({
-                        state: fw.ObjectState.PrepareLaunch,
-                        render: new PrepareLaunchRenderer(data)
-                    });
-                }
-                StarRenderController.prototype.getRenderer = function (state) {
-                    var render = this._renderStock.filter(function (elem) {
-                        return elem.state === state;
-                    });
-                    return render.length === 0 ? new animation.NullRenderable() : render[0].render;
-                };
-                return StarRenderController;
-            })();
-            Renderer.StarRenderController = StarRenderController;
-        })(Renderer || (Renderer = {}));
-        // メインのオブジェクトとなるStar
-        var Star = (function (_super) {
-            __extends(Star, _super);
-            function Star() {
-                        _super.call(this);
-                this.data = new animation.Renderer.Circle.Data(0, 0, StarUtil.getSomeSize());
-                this._controller = new Renderer.StarRenderController(this.data);
-                this._logic = new StarLogic(this, this.data);
-                // バインドしておく
-                I.propBind([
-                    I.binder("x"),
-                    I.binder("y"),
-                    I.binder("zIndex"),
-                    I.binder("width"),
-                    I.binder("height"),
-                    I.binder("visible"),
-                    I.binder("color")
-                ], this, this.data);
+        // 連結状態のStarをレンダリングする。
+        var ConnectedStarRenderer = (function () {
+            function ConnectedStarRenderer(data) {
+                this.data = data;
+                this._renderer = new animation.Renderer.Circle.CircleRenderer(this.data);
             }
-            Star.prototype.isValid = function () {
-                return true;
-            };
-            Star.prototype.isConnectable = function () {
-                return this._logic.isConnectable();
-            };
-            Star.prototype.onreflect = // bodyからデータを反映させる際に呼び出されるコールバック
-            function () {
-                return this._logic.onreflect();
+            ConnectedStarRenderer.prototype.render = function (context) {
+                var r = this.data.radius;
+                var d = this.data;
+                var grad = new animation.Gradation.Radial(context);
+                grad.from(d.x + r * 0.7, d.y + r * 0.5, 1).to(d.x + r, d.y + r, r);
+                grad.colorStop(0.0, "#fff").colorStop(0.8, "#888").colorStop(1.0, "#000");
+                d.gradient = grad;
+                this._renderer.render(context);
             };
-            Star.prototype.render = // starをレンダリングする。レンダリング処理自体は、circleのrenderに任せる。
-            function (context) {
-                this._controller.getRenderer(this._logic.state.objectState).render(context);
+            return ConnectedStarRenderer;
+        })();
+        // PrepareLaunch状態のレンダリングを行う。
+        var PrepareLaunchRenderer = (function () {
+            function PrepareLaunchRenderer(data) {
+                this.data = data;
+                this._renderer = new animation.Renderer.Circle.CircleRenderer(this.data);
+            }
+            PrepareLaunchRenderer.prototype.render = function (context) {
+                var r = this.data.radius;
+                var d = this.data;
+                var grad = new animation.Gradation.Radial(context);
+                grad.from(d.x + r * 0.7, d.y + r * 0.5, 1).to(d.x + r, d.y + r, r);
+                grad.colorStop(0.0, d.color.toFillStyle()).colorStop(1.0, d.color.toFillStyle());
+                this.data.gradient = grad;
+                this._renderer.render(context);
             };
-            Star.prototype.createFixture = function (scale) {
-                return this._logic.createFixture(scale);
+            return PrepareLaunchRenderer;
+        })();
+        // Starで利用するrenderの切り替えをコントロールするためのクラス
+        var StarRenderController = (function () {
+            function StarRenderController(data) {
+                this.data = data;
+                this._renderStock = [];
+                this._renderStock.push({
+                    state: fw.ObjectState.Free,
+                    render: new NormalStarRenderer(data)
+                });
+                this._renderStock.push({
+                    state: fw.ObjectState.Touched,
+                    render: new NormalStarRenderer(data)
+                });
+                this._renderStock.push({
+                    state: fw.ObjectState.Connected,
+                    render: new ConnectedStarRenderer(data)
+                });
+                this._renderStock.push({
+                    state: fw.ObjectState.PrepareLaunch,
+                    render: new PrepareLaunchRenderer(data)
+                });
+            }
+            StarRenderController.prototype.getRenderer = function (state) {
+                var render = this._renderStock.filter(function (elem) {
+                    return elem.state === state;
+                });
+                return render.length === 0 ? new animation.NullRenderable() : render[0].render;
             };
-            Star.prototype.makeTouchStartHandler = // ontouchstartのハンドラを作成して返す。
-            function (scene) {
-                var _this = this;
-                return function (e) {
-                    return _this._logic.ontouchstart(scene, e);
-                };
+            return StarRenderController;
+        })();
+        Renderer.StarRenderController = StarRenderController;
+    })(Renderer || (Renderer = {}));
+    // メインのオブジェクトとなるStar
+    var Star = (function (_super) {
+        __extends(Star, _super);
+        function Star() {
+                _super.call(this);
+            this.data = new animation.Renderer.Circle.Data(0, 0, StarUtil.getSomeSize());
+            this._controller = new Renderer.StarRenderController(this.data);
+            this._logic = new StarLogic(this, this.data);
+            // バインドしておく
+            I.propBind([
+                I.binder("x"),
+                I.binder("y"),
+                I.binder("zIndex"),
+                I.binder("width"),
+                I.binder("height"),
+                I.binder("visible"),
+                I.binder("color")
+            ], this, this.data);
+        }
+        Star.prototype.isValid = function () {
+            return true;
+        };
+        Star.prototype.isConnectable = function () {
+            return this._logic.isConnectable();
+        };
+        Star.prototype.onreflect = // bodyからデータを反映させる際に呼び出されるコールバック
+        function () {
+            return this._logic.onreflect();
+        };
+        Star.prototype.render = // starをレンダリングする。レンダリング処理自体は、circleのrenderに任せる。
+        function (context) {
+            this._controller.getRenderer(this._logic.state.objectState).render(context);
+        };
+        Star.prototype.createFixture = function (scale) {
+            return this._logic.createFixture(scale);
+        };
+        Star.prototype.makeTouchStartHandler = // ontouchstartのハンドラを作成して返す。
+        function (scene) {
+            var _this = this;
+            return function (e) {
+                return _this._logic.ontouchstart(scene, e);
             };
-            Star.prototype.makeTouchEndHandler = // ontouchendのハンドラを作成して返す
-            function (scene) {
-                var _this = this;
-                return function (e) {
-                    return _this._logic.ontouchend(scene, e);
-                };
+        };
+        Star.prototype.makeTouchEndHandler = // ontouchendのハンドラを作成して返す
+        function (scene) {
+            var _this = this;
+            return function (e) {
+                return _this._logic.ontouchend(scene, e);
             };
-            return Star;
-        })(gl.BaseClasses.EntityImpl);
-        GameObj.Star = Star;
-    })(exports.GameObj || (exports.GameObj = {}));
-    var GameObj = exports.GameObj;
+        };
+        return Star;
+    })(gl.BaseClasses.EntityImpl);
+    exports.Star = Star;
 })
diff --git a/src/star.ts b/src/star.ts
index 17c8a52..c80f6a8 100644
--- a/src/star.ts
+++ b/src/star.ts
@@ -35,290 +35,286 @@ module StarUtil {
     }
 }

-export module GameObj {
-
-    // Starに係るロジック周辺の処理を担当する。
-    // StarLogic自体はStarにコンポジションされているが、
-    // StarLogicにもStarが渡されている。
-    class StarLogic {
-
-
-        // 各starで共通するFixtureDefinition
-        private _fixDef = (): B2FixtureDef => {
-            var fix = new Box2D.Dynamics.b2FixtureDef();
-            fix.density = 1.0;       // 密度
-            fix.friction = 1.5;      // 摩擦係数
-            fix.restitution = 0.2;   // 反発係数
-            return fix;
-        } ();
-
-        state: fw.ObjectInfo = new fw.ObjectInfo(fw.ObjectType.Star);
-        scale: number = 1;
-
-        constructor(public starShape: Star, public data: animation.Renderer.Circle.Data) { }
-
-        onreflect(): bool {
-            var body = this.starShape.body;
-            var count = 0;
-            var contacts = [];
-            for (var n = body.GetContactList(); n != null;
-                 n = n.next) {
-                if (n.contact.IsTouching()) {
-                    contacts.push(n.other);
-                }
-            }
-            // 星同士が4つ以上隣接したら、staticに変更する。
-            if (contacts.length >= 4 && this.isConnectable()) {
-                contacts.filter((e) => {
-                    var info_e: fw.ObjectInfo = e.GetUserData();
-                    return info_e.objectState == fw.ObjectState.Free;
-                }).forEach((e) => {
-                    var info_e: fw.ObjectInfo = e.GetUserData();
-                    info_e.objectState = fw.ObjectState.Connected;
-                    if (body != e && info_e.type == fw.ObjectType.Star) {
-                        e.SetType(Box2D.Dynamics.b2Body.b2_staticBody);
-                    }
-                });
-                body.SetType(Box2D.Dynamics.b2Body.b2_staticBody);
-                var info: fw.ObjectInfo = body.GetUserData();
-                info.objectState = fw.ObjectState.Connected;
-                return false;
+// Starに係るロジック周辺の処理を担当する。
+// StarLogic自体はStarにコンポジションされているが、
+// StarLogicにもStarが渡されている。
+class StarLogic {
+
+    // 各starで共通するFixtureDefinition
+    private _fixDef = (): B2FixtureDef => {
+        var fix = new Box2D.Dynamics.b2FixtureDef();
+        fix.density = 1.0;       // 密度
+        fix.friction = 1.5;      // 摩擦係数
+        fix.restitution = 0.2;   // 反発係数
+        return fix;
+    } ();
+
+    state: fw.ObjectInfo = new fw.ObjectInfo(fw.ObjectType.Star);
+    scale: number = 1;
+
+    constructor(public starShape: Star, public data: animation.Renderer.Circle.Data) { }
+
+    onreflect(): bool {
+        var body = this.starShape.body;
+        var count = 0;
+        var contacts = [];
+        for (var n = body.GetContactList(); n != null;
+             n = n.next) {
+            if (n.contact.IsTouching()) {
+                contacts.push(n.other);
             }
+        }
+        // 星同士が4つ以上隣接したら、staticに変更する。
+        if (contacts.length >= 4 && this.isConnectable()) {
+            contacts.filter((e) => {
+                var info_e: fw.ObjectInfo = e.GetUserData();
+                return info_e.objectState == fw.ObjectState.Free;
+            }).forEach((e) => {
+                var info_e: fw.ObjectInfo = e.GetUserData();
+                info_e.objectState = fw.ObjectState.Connected;
+                if (body != e && info_e.type == fw.ObjectType.Star) {
+                    e.SetType(Box2D.Dynamics.b2Body.b2_staticBody);
+                }
+            });
+            body.SetType(Box2D.Dynamics.b2Body.b2_staticBody);
+            var info: fw.ObjectInfo = body.GetUserData();
+            info.objectState = fw.ObjectState.Connected;
+            return false;
+        }
+
+        return true;
+    }
+
+    isConnectable(): bool {
+        return this.state.objectState === fw.ObjectState.Free;
+    }

-            return true;
+    // タッチを開始した際の処理。
+    ontouchstart(scene: gl.Scene, e: Event): bool {
+        var s = this.starShape;
+        if (this.state.objectState === fw.ObjectState.Connected) {
+            s.x -= s.width;
+            s.y -= s.height;
+            this.data.radius *= 2;
+            s.width *= 2;
+            s.height *= 2;
+            this.data.color.a = 0.3;
+            this.state.objectState = fw.ObjectState.Touched;
         }
+        return true;
+    }

-        isConnectable(): bool {
-            return this.state.objectState === fw.ObjectState.Free;
+    // タッチして離されたとき、その時点での領域にかかっている星を
+    // 消して、自身を拡大する。
+    // ただし、領域内に、すでにLaunch状態になっているものがある場合は
+    // 元に戻る。
+    ontouchend(scene: gl.Scene, e: Event): bool {
+
+        if (this.state.objectState !== fw.ObjectState.Touched) {
+            return false;
         }

-        // タッチを開始した際の処理。
-        ontouchstart(scene: gl.Scene, e: Event): bool {
-            var s = this.starShape;
-            if (this.state.objectState === fw.ObjectState.Connected) {
-                s.x -= s.width;
-                s.y -= s.height;
-                this.data.radius *= 2;
-                s.width *= 2;
-                s.height *= 2;
-                this.data.color.a = 0.3;
-                this.state.objectState = fw.ObjectState.Touched;
-            }
-            return true;
+        var s = this.starShape;
+        var contain = scene.entities.filter((elem) => {
+            if (elem === s) return false;
+            return this.starShape.within(elem, this.data.radius);
+        });
+
+        // 広がった中に存在しなければ、大きさを元に戻す。
+        if (contain.length === 0) {
+            this.data.radius /= 2;
+            s.width /= 2;
+            s.height /= 2;
+            this.state.objectState = fw.ObjectState.Connected;
+            return false;
         }

-        // タッチして離されたとき、その時点での領域にかかっている星を
-        // 消して、自身を拡大する。
-        // ただし、領域内に、すでにLaunch状態になっているものがある場合は
-        // 元に戻る。
-        ontouchend(scene: gl.Scene, e: Event): bool {
+        contain.forEach((elem) => {scene.removeEntity(elem);});

-            if (this.state.objectState !== fw.ObjectState.Touched) {
-                return false;
-            }
+        // 剛体の情報を更新する。
+        s.body.SetType(Box2D.Dynamics.b2Body.b2_dynamicBody);
+        s.body.DestroyFixture(s.body.GetFixtureList());
+        var fixDef = this._fixDef;
+        fixDef.shape = new Box2D.Collision.Shapes.b2CircleShape(this.data.radius / this.scale);
+        s.body.CreateFixture(fixDef);

-            var s = this.starShape;
-            var contain = scene.entities.filter((elem) => {
-                if (elem === s) return false;
-                return this.starShape.within(elem, this.data.radius);
-            });
+        // 準備段階は終了とする
+        this.state.objectState = fw.ObjectState.PrepareLaunch;
+        return true;
+    }

-            // 広がった中に存在しなければ、大きさを元に戻す。
-            if (contain.length === 0) {
-                this.data.radius /= 2;
-                s.width /= 2;
-                s.height /= 2;
-                this.state.objectState = fw.ObjectState.Connected;
-                return false;
-            }

-            contain.forEach((elem) => {scene.removeEntity(elem);});
+    // 渡されたstarに適合するbodyの設定を作成する。
+    createFixture(scale: number): gl.Physics.BodyDefinition {
+        var fixDef = this._fixDef;
+        var bodyDef = new Box2D.Dynamics.b2BodyDef();
+        bodyDef.type = Box2D.Dynamics.b2Body.b2_dynamicBody;
+        bodyDef.userData = this.state;
+        bodyDef.position.Set((this.data.x + this.data.width / 2) / scale,
+                             (this.data.y + this.data.height / 2) / scale);
+        bodyDef.angularVelocity = (Math.random() * 2 % 2 ? -1 : 1) * 10;
+        fixDef.shape = new Box2D.Collision.Shapes.b2CircleShape(this.data.width / 2 / scale);

-            // 剛体の情報を更新する。
-            s.body.SetType(Box2D.Dynamics.b2Body.b2_dynamicBody);
-            s.body.DestroyFixture(s.body.GetFixtureList());
-            var fixDef = this._fixDef;
-            fixDef.shape = new Box2D.Collision.Shapes.b2CircleShape(this.data.radius / this.scale);
-            s.body.CreateFixture(fixDef);
+        this.scale = scale;
+        return { bodyDef: bodyDef, fixtureDef: fixDef };
+    }

-            // 準備段階は終了とする
-            this.state.objectState = fw.ObjectState.PrepareLaunch;
-            return true;
-        }
+}
+
+module Renderer {

+    // 通常状態のStarをレンダリングする。
+    class NormalStarRenderer implements animation.Renderable {

-        // 渡されたstarに適合するbodyの設定を作成する。
-        createFixture(scale: number): gl.Physics.BodyDefinition {
-            var fixDef = this._fixDef;
-            var bodyDef = new Box2D.Dynamics.b2BodyDef();
-            bodyDef.type = Box2D.Dynamics.b2Body.b2_dynamicBody;
-            bodyDef.userData = this.state;
-            bodyDef.position.Set((this.data.x + this.data.width / 2) / scale,
-                                 (this.data.y + this.data.height / 2) / scale);
-            bodyDef.angularVelocity = (Math.random() * 2 % 2 ? -1 : 1) * 10;
-            fixDef.shape = new Box2D.Collision.Shapes.b2CircleShape(this.data.width / 2 / scale);
+        private _renderer : animation.Renderer.Circle.CircleRenderer;

-            this.scale = scale;
-            return { bodyDef: bodyDef, fixtureDef: fixDef };
+        constructor(public data: animation.Renderer.Circle.Data) {
+            this._renderer = new animation.Renderer.Circle.CircleRenderer(this.data);
         }

-    }
+        render(context:animation.Context) : void {
+            var r = this.data.radius;
+            var d = this.data;
+            var grad = new animation.Gradation.Radial(context);
+            grad.from(d.x + r * 0.7, d.y + r * 0.5, 1).to(d.x + r, d.y + r, r);

-    module Renderer {
+            grad.colorStop(0.0, "#fff").colorStop(0.5, d.color.toFillStyle()).
+                colorStop(1.0, "#000");

-        // 通常状態のStarをレンダリングする。
-        class NormalStarRenderer implements animation.Renderable {
+            d.gradient = grad;
+            this._renderer.render(context);
+        }
+    }

-            private _renderer : animation.Renderer.Circle.CircleRenderer;
+    // 連結状態のStarをレンダリングする。
+    class ConnectedStarRenderer implements animation.Renderable {

-            constructor(public data: animation.Renderer.Circle.Data) {
-                this._renderer = new animation.Renderer.Circle.CircleRenderer(this.data);
-            }
+        private _renderer : animation.Renderer.Circle.CircleRenderer;

-            render(context:animation.Context) : void {
-                var r = this.data.radius;
-                var d = this.data;
-                var grad = new animation.Gradation.Radial(context);
-                grad.from(d.x + r * 0.7, d.y + r * 0.5, 1).to(d.x + r, d.y + r, r);
+        constructor(public data: animation.Renderer.Circle.Data) {
+            this._renderer = new animation.Renderer.Circle.CircleRenderer(this.data);
+        }

-                grad.colorStop(0.0, "#fff").colorStop(0.5, d.color.toFillStyle()).
-                    colorStop(1.0, "#000");
+        render(context:animation.Context) : void {
+            var r = this.data.radius;
+            var d = this.data;
+            var grad = new animation.Gradation.Radial(context);
+            grad.from(d.x + r * 0.7, d.y + r * 0.5, 1).to(d.x + r, d.y + r, r);

-                d.gradient = grad;
-                this._renderer.render(context);
-            }
+            grad.colorStop(0.0, "#fff").colorStop(0.8, "#888").colorStop(1.0, "#000");
+            d.gradient = grad;
+            this._renderer.render(context);
         }
+    }

-        // 連結状態のStarをレンダリングする。
-        class ConnectedStarRenderer implements animation.Renderable {
+    // PrepareLaunch状態のレンダリングを行う。
+    class PrepareLaunchRenderer implements animation.Renderable {

-            private _renderer : animation.Renderer.Circle.CircleRenderer;
+        private _renderer : animation.Renderer.Circle.CircleRenderer;

-            constructor(public data: animation.Renderer.Circle.Data) {
-                this._renderer = new animation.Renderer.Circle.CircleRenderer(this.data);
-            }
+        constructor(public data: animation.Renderer.Circle.Data) {
+            this._renderer = new animation.Renderer.Circle.CircleRenderer(this.data);
+        }

-            render(context:animation.Context) : void {
-                var r = this.data.radius;
-                var d = this.data;
-                var grad = new animation.Gradation.Radial(context);
-                grad.from(d.x + r * 0.7, d.y + r * 0.5, 1).to(d.x + r, d.y + r, r);
+        render(context:animation.Context) : void {
+            var r = this.data.radius;
+            var d = this.data;
+            var grad = new animation.Gradation.Radial(context);
+            grad.from(d.x + r * 0.7, d.y + r * 0.5, 1).to(d.x + r, d.y + r, r);

-                grad.colorStop(0.0, "#fff").colorStop(0.8, "#888").colorStop(1.0, "#000");
-                d.gradient = grad;
-                this._renderer.render(context);
-            }
+            grad.colorStop(0.0, d.color.toFillStyle()).
+                colorStop(1.0, d.color.toFillStyle());
+            this.data.gradient = grad;
+            this._renderer.render(context);
         }
+    }

-        // PrepareLaunch状態のレンダリングを行う。
-        class PrepareLaunchRenderer implements animation.Renderable {
-
-            private _renderer : animation.Renderer.Circle.CircleRenderer;
+    // Starで利用するrenderの切り替えをコントロールするためのクラス
+    export class StarRenderController {

-            constructor(public data: animation.Renderer.Circle.Data) {
-                this._renderer = new animation.Renderer.Circle.CircleRenderer(this.data);
-            }
+        private _renderStock: {state: fw.ObjectState; render: animation.Renderable;}[];

-            render(context:animation.Context) : void {
-                var r = this.data.radius;
-                var d = this.data;
-                var grad = new animation.Gradation.Radial(context);
-                grad.from(d.x + r * 0.7, d.y + r * 0.5, 1).to(d.x + r, d.y + r, r);
+        constructor(public data : animation.Renderer.Circle.Data) {
+            this._renderStock = []

-                grad.colorStop(0.0, d.color.toFillStyle()).
-                    colorStop(1.0, d.color.toFillStyle());
-                this.data.gradient = grad;
-                this._renderer.render(context);
-            }
+            this._renderStock.push({
+                state : fw.ObjectState.Free, render : new NormalStarRenderer(data)
+            });
+            this._renderStock.push({
+                state : fw.ObjectState.Touched, render : new NormalStarRenderer(data)
+            });
+            this._renderStock.push({
+                state : fw.ObjectState.Connected, render : new ConnectedStarRenderer(data)
+            });
+            this._renderStock.push({
+                state : fw.ObjectState.PrepareLaunch, render : new PrepareLaunchRenderer(Data)
+            });
         }

-        // Starで利用するrenderの切り替えをコントロールするためのクラス
-        export class StarRenderController {
-
-            private _renderStock: {state: fw.ObjectState; render: animation.Renderable;}[];
-
-            constructor(public data : animation.Renderer.Circle.Data) {
-                this._renderStock = []
-
-                this._renderStock.push({
-                    state : fw.ObjectState.Free, render : new NormalStarRenderer(data)
-                });
-                this._renderStock.push({
-                    state : fw.ObjectState.Touched, render : new NormalStarRenderer(data)
-                });
-                this._renderStock.push({
-                    state : fw.ObjectState.Connected, render : new ConnectedStarRenderer(data)
-                });
-                this._renderStock.push({
-                    state : fw.ObjectState.PrepareLaunch, render : new PrepareLaunchRenderer(data)
-                });
-            }
-
-            getRenderer(state:fw.ObjectState) : animation.Renderable {
-                var render = this._renderStock.filter((elem) => {
-                    return elem.state === state
-                });
+        getRenderer(state:fw.ObjectState) : animation.Renderable {
+            var render = this._renderStock.filter((elem) => {
+                return elem.state === state
+            });

-                return render.length === 0 ? new animation.NullRenderable : render[0].render;
-            }
+            return render.length === 0 ? new animation.NullRenderable : render[0].render;
         }
     }
+}

-    // メインのオブジェクトとなるStar
-    export class Star extends gl.BaseClasses.EntityImpl implements fw.GameObj.IStar {
+// メインのオブジェクトとなるStar
+export class Star extends gl.BaseClasses.EntityImpl implements fw.GameObj.IStar {

-        private _logic: StarLogic;
-        private _controller: Renderer.StarRenderController;
+    private _logic: StarLogic;
+    private _controller: Renderer.StarRenderController;

-        body: B2Body;
-        private data: animation.Renderer.Circle.Data;
+    body: B2Body;
+    private data: animation.Renderer.Circle.Data;

-        color:animation.Common.Color;
+    color:animation.Common.Color;

-        constructor() {
-            super();
-            this.data = new animation.Renderer.Circle.Data(0, 0, StarUtil.getSomeSize());
-            this._controller = new Renderer.StarRenderController(this.data);
+    constructor() {
+        super();
+        this.data = new animation.Renderer.Circle.Data(0, 0, StarUtil.getSomeSize());
+        this._controller = new Renderer.StarRenderController(this.data);

-            this._logic = new StarLogic(this, this.data);
+        this._logic = new StarLogic(this, this.data);

-            // バインドしておく
-            I.propBind([I.binder("x"), I.binder("y"), I.binder("zIndex"),
-                        I.binder("width"), I.binder("height"),
-                        I.binder("visible"), I.binder("color")], this, this.data);
-        }
+        // バインドしておく
+        I.propBind([I.binder("x"), I.binder("y"), I.binder("zIndex"),
+                    I.binder("width"), I.binder("height"),
+                    I.binder("visible"), I.binder("color")], this, this.data);
+    }

-        isValid(): bool {
-            return true;
-        }
+    isValid(): bool {
+        return true;
+    }

-        isConnectable(): bool { return this._logic.isConnectable(); }
+    isConnectable(): bool { return this._logic.isConnectable(); }

-        // bodyからデータを反映させる際に呼び出されるコールバック
-        onreflect(): bool { return this._logic.onreflect(); }
+    // bodyからデータを反映させる際に呼び出されるコールバック
+    onreflect(): bool { return this._logic.onreflect(); }

-        // starをレンダリングする。レンダリング処理自体は、circleのrenderに任せる。
-        render(context: animation.Context): void {
+    // starをレンダリングする。レンダリング処理自体は、circleのrenderに任せる。
+    render(context: animation.Context): void {

-            this._controller.getRenderer(this._logic.state.objectState).render(context);
-        }
+        this._controller.getRenderer(this._logic.state.objectState).render(context);
+    }

-        createFixture(scale: number): gl.Physics.BodyDefinition {
-            return this._logic.createFixture(scale);
-        }
+    createFixture(scale: number): gl.Physics.BodyDefinition {
+        return this._logic.createFixture(scale);
+    }

-        // ontouchstartのハンドラを作成して返す。
-        makeTouchStartHandler(scene: gl.Scene): (e: Event) => bool {
-            return (e: Event) => {
-                return this._logic.ontouchstart(scene, e);
-            }
+    // ontouchstartのハンドラを作成して返す。
+    makeTouchStartHandler(scene: gl.Scene): (e: Event) => bool {
+        return (e: Event) => {
+            return this._logic.ontouchstart(scene, e);
         }
+    }

-        // ontouchendのハンドラを作成して返す
-        makeTouchEndHandler(scene: gl.Scene): (e: Event) => bool {
-            return (e: Event) => {
-                return this._logic.ontouchend(scene, e);
-            }
+    // ontouchendのハンドラを作成して返す
+    makeTouchEndHandler(scene: gl.Scene): (e: Event) => bool {
+        return (e: Event) => {
+            return this._logic.ontouchend(scene, e);
         }
     }
 }
diff --git a/src/timeline.ts b/src/timeline.ts
index e27f71c..aa8ffe4 100644
--- a/src/timeline.ts
+++ b/src/timeline.ts
@@ -1,8 +1,10 @@

-/**
+import act = module("action");
+
+/*
  * 時間ベースでのアニメーションを行うオブジェクトのインターフェース。
  * 基本的にはメソッドチェインで行われるようにする。
- * 基本的な処理については、TimelineImplで実装されている
+ * それぞれのメソッドは、最終的にActionを生成する。
  */
 export interface Timeline {

@@ -11,11 +13,24 @@ export interface Timeline {
     // 指定したフレームかけて、x/yに移動する
     moveTo(x: number, y: number, frame: number): Timeline;

-    // 指定したフレームかけて、sにスケールする
+    // 指定したフレームかけて、s倍にスケールする
     scale(s: number, frame: number): Timeline;

-    // 指定した位置を中心として、指定したフレームかけて、sにスケールする
-    scaleWithCenter(s: number, x: number, y: number, frame: number): Timeline;
+    // 指定した内容のactionをtimelineに追加する。
+    add(frame:number, onactionstart:() => void, onactiontick: () => void,
+        onactionend:() => void) : Timeline;
+}
+
+export class TimelineImpl implements Timeline {
+
+    // タイムライン上にのせるアクションを定義する。
+    private _actionQueue : act.Action[] = [];
+
+    moveBy(x: number, y:number, frame:number) : Timeline {
+        return this;
+    }
+
 }

-class Timeline {}
\ No newline at end of file
+module Actions {
+}
\ No newline at end of file