猫跳窗户 学习

using UnityEngine;
using System.Collections;

/// <summary>
/// 镜头控制
/// </summary>
public class CameraControl : MonoBehaviour {
    
    /// <summary>
    /// 玩家
    /// </summary>
    private GameObject player = null;
    /// <summary>
    /// 玩家到相机的偏移
    /// </summary>
    public Vector3 offset;
    /// <summary>
    /// 玩家到相机的y轴偏移
    /// </summary>
    public Vector3    interest;
    /// <summary>
    /// 玩家的前一个位置
    /// </summary>
    public Vector3    player_position_prev;

    void Start () {
         
        //获取玩家
        this.player = GameObject.FindGameObjectWithTag("NekoPlayer");
        //计算玩家到相机的偏移
        this.offset = this.transform.position - this.player.transform.position;
        //计算玩家到相机的y轴偏移
        this.interest = new Vector3(0.0f, this.transform.position.y - this.player.transform.position.y, 0.0f);
        //玩家的前一个位置未玩家的初始位置
        this.player_position_prev = this.player.transform.position;
    }
    
    void    Update () {
        //让相机跟随玩家
        this.transform.position = new Vector3(player.transform.position.x + this.offset.x, player.transform.position.y + this.offset.y, player.transform.position.z + this.offset.z);
    }
}

using UnityEngine;
using System.Collections;

/// <summary>
/// 特效
/// </summary>
public class Effect:MonoBehaviour {

    void Update() {
        //特效不在播放状态,删除特效物体
        if(!this.GetComponentInChildren<ParticleSystem>().isPlaying) {
            Destroy(this.gameObject);
        }
    }
}

using UnityEngine;
using System.Collections;

/// <summary>
/// 特效控制
/// </summary>
public class EffectControl:MonoBehaviour {

    /// <summary>
    /// 通过木窗特效
    /// </summary>
    public GameObject eff_break = null;
    /// <summary>
    /// Miss木窗特效
    /// </summary>
    public GameObject eff_miss = null;
    /// <summary>
    /// 摄像机
    /// </summary>
    public GameObject game_camera = null;

    void Start() {
        //获取相机引用
        this.game_camera = GameObject.FindGameObjectWithTag("MainCamera");
    }

    void Update() {

    }

    /// <summary>
    /// 创建通过木窗特效
    /// </summary>
    public void createBreakEffect(SyoujiPaperControl paper,NekoControl neko) {
        GameObject go = Instantiate(this.eff_break) as GameObject;
        go.AddComponent<Effect>();
        Vector3 position = paper.transform.position;
        position.x = neko.transform.position.x;
        position.y = neko.transform.position.y;
        position.y += 0.3f;
        go.transform.position = position;
        go.transform.parent = this.game_camera.transform;
    }

    /// <summary>
    /// 创建Miss特效
    /// </summary>
    public void createMissEffect(NekoControl neko) {
        GameObject go = Instantiate(this.eff_miss) as GameObject;
        go.AddComponent<Effect>();
        Vector3 position = neko.transform.position;
        position.y += 0.3f;
        position.z -= 0.2f;
        go.transform.position = position;
    }
}

using UnityEngine;
using System.Collections;

/// <summary>
/// 控制单间房间(窗户的关闭等)
/// </summary>
public class FloorControl:MonoBehaviour {

    /// <summary>
    /// 状态
    /// </summary>
    public enum STEP {
        /// <summary>
        /// 默认
        /// </summary>
        NONE = -1,
        /// <summary>
        /// 关闭
        /// </summary>
        CLOSE = 0,
        /// <summary>
        /// 打开
        /// </summary>
        OPEN,
        /// <summary>
        /// 打开中
        /// </summary>
        TO_OPEN,
        /// <summary>
        /// 关闭
        /// </summary>
        CLOSE_SHOJI,
        /// <summary>
        /// 关闭中
        /// </summary>
        TO_CLOSE_SHOJI,
        /// <summary>
        /// 最大值
        /// </summary>
        NUM,
    };

    /// <summary>
    /// 当前状态
    /// </summary>
    public STEP step = STEP.NONE;
    /// <summary>
    /// 下一个状态
    /// </summary>
    public STEP next_step = STEP.NONE;
    /// <summary>
    /// 状态计时
    /// </summary>
    public float step_timer = 0.0f;
    /// <summary>
    /// 上一个状态计时器
    /// </summary>
    public float step_timer_prev = 0.0f;


    /// <summary>
    /// 木窗预设
    /// </summary>
    public GameObject shojiPrefab = null;
    /// <summary>
    /// 门预设
    /// </summary>
    public GameObject fusumaPrefab = null;

    /// <summary>
    /// 门,木窗的z坐标
    /// </summary>
    public static float SHUTTER_POSITION_Z = 15.0f;
    /// <summary>
    /// 开启状态下 门,木窗的x坐标
    /// </summary> 
    public static float SHUTTER_POSITION_OPEN_X = 4.1f;
    /// <summary>
    /// 关闭状态下 门,木窗的x坐标
    /// </summary> 
    public static float SHUTTER_POSITION_CLOSE_X = 1.35f;

    /// <summary>
    /// 门数量
    /// </summary>
    public static int FUSUMA_NUM = 2;
    /// <summary>
    /// 木窗数量
    /// </summary>
    public static int SHOJI_NUM = 1;

    /// <summary>
    /// 门
    /// </summary>
    private GameObject[] fusuma_objects;
    /// <summary>
    /// 木窗
    /// </summary>
    private ShojiControl shoji_object = null;


    /// <summary>
    /// 关门模式类型
    /// </summary>
    public enum CLOSING_PATTERN_TYPE {
        /// <summary>
        /// 默认
        /// </summary>
        NONE = -1,
        /// <summary>
        /// 普通
        /// </summary>
        NORMAL = 0,         
        /// <summary>
        /// 从右边的出现，向左停了
        /// </summary>
        OVERSHOOT,          
        /// <summary>
        /// 第一次出现第二次出现
        /// </summary>
        SECONDTIME,         
        /// <summary>
        /// 从左边拉窗和麸皮同时
        /// </summary>
        ARCODION,           
        /// <summary>
        /// 从左边藏嘛，有点晚了，从右隔扇
        /// </summary>
        DELAY,             
        /// <summary>
        /// 从上面落下拉窗
        /// </summary>
        FALLDOWN,           
        /// <summary>
        /// 麸皮2张（张）后，右边来就拉着拉窗拉
        /// </summary>
        FLIP,               
        /// <summary>
        /// 慢慢地
        /// </summary>
        SLOW,              
        /// <summary>
        /// 从左边藏嘛，超市晚从右隔扇
        /// </summary>
        SUPER_DELAY,       
        /// <summary>
        /// 上限
        /// </summary>
        NUM,
    };

    /// <summary>
    /// 关门模式类型
    /// </summary>
    public CLOSING_PATTERN_TYPE closing_pattern_type = CLOSING_PATTERN_TYPE.NORMAL;
    /// <summary>
    /// 
    /// </summary>
    public bool is_flip_closing = false;                                // 登場パターンを左右反転する？.

    /// <summary>
    /// 关门模式
    /// </summary>
    public struct ClosingPattern {

        public float total_time;                    // トータルの時間.
        public int fusuma_num;                  // ふすまの数.

        // 毎フレーム更新.

        public float[] fusuma_x;                    // 各ふすまのX座標（毎フレーム更新）.
        public float shoji_x;                   // 障子のX座標（毎フレーム更新）.
        public float shoji_y;
        public float shoji_z_offset;                // 障子のZ座標のオフセット（毎フレーム更新）.

        public float[] fusuma_rot_x;                // 各ふすまのX座標（毎フレーム更新）.
        public float shoji_rot_x;               // 障子のX座標（毎フレーム更新）.

        public bool is_play_close_sound;        // 障子が閉まっているときの SE を鳴らす.
        public bool is_play_close_end_sound;    // 障子が閉まりきったときの SE を鳴らす.

        public float se_volume;
        public float se_pitch;                  // SE のピッチ.

        public float previous_distance;         // 前のフレームでの、RoomControl.getDistanceNekoToShutter()
        public float local_timer;

        public ClosingPatternParam param;           // 汎用パラメーター
    };

    /// <summary>
    /// 关门模式参数
    /// </summary>
    public struct ClosingPatternParam {

        public float as_float;
        public bool as_bool;
    }

    /// <summary>
    /// 关门模式参数
    /// </summary>
    public ClosingPattern closing_pattern;

    /// <summary>
    /// 关闭声音
    /// </summary>
    public AudioClip CLOSE_SOUND = null;
    /// <summary>
    /// 关闭结束声音
    /// </summary>
    public AudioClip CLOSE_END_SOUND = null;

    // ---------------------------------------------------------------- //

    void Start() {
        //创建门
        this.fusuma_objects = new GameObject[FUSUMA_NUM];
        for(int i = 0;i < FUSUMA_NUM;i++) {
            this.fusuma_objects[i] = Instantiate(this.fusumaPrefab) as GameObject;
            this.fusuma_objects[i].transform.parent = this.gameObject.transform;
            this.fusuma_objects[i].transform.localPosition = new Vector3(SHUTTER_POSITION_OPEN_X,0.0f,SHUTTER_POSITION_Z);
        }

        this.closing_pattern_type = CLOSING_PATTERN_TYPE.NORMAL;
    }

    void Update() {
        this.step_timer_prev = this.step_timer;
        this.step_timer += Time.deltaTime;

        //打开中状态持续时间
        const float to_open_time = 0.5f;

        if(this.next_step == STEP.NONE) {
            switch(this.step) {
            case STEP.TO_OPEN: {
                    if(this.step_timer > to_open_time) {
                        this.next_step = STEP.OPEN;
                    }
                }
                break;
            case STEP.TO_CLOSE_SHOJI: {
                    if(this.step_timer > this.closing_pattern.total_time + Time.deltaTime) {
                        this.next_step = STEP.CLOSE_SHOJI;
                    }
                }
                break;
            }
        }

        //处理下一个状态
        if(this.next_step != STEP.NONE) {

            switch(this.next_step) {

            case STEP.CLOSE: {
                    this.reset_shutters();

                    this.fusuma_objects[0].SetActive(true);
                    this.fusuma_objects[1].SetActive(true);

                    this.fusuma_objects[0].GetComponent<ShutterControl>().setX(-SHUTTER_POSITION_CLOSE_X);
                    this.fusuma_objects[1].GetComponent<ShutterControl>().setX(SHUTTER_POSITION_CLOSE_X);
                }
                break;

            case STEP.OPEN: {
                    this.reset_shutters();

                    this.fusuma_objects[0].SetActive(true);
                    this.fusuma_objects[1].SetActive(true);

                    this.fusuma_objects[0].GetComponent<ShutterControl>().setX(-SHUTTER_POSITION_OPEN_X);
                    this.fusuma_objects[1].GetComponent<ShutterControl>().setX(SHUTTER_POSITION_OPEN_X);
                }
                break;

            case STEP.TO_CLOSE_SHOJI: {
                    this.closing_pattern_init();
                }
                break;

            case STEP.CLOSE_SHOJI: {
                }
                break;
            }

            this.step = this.next_step;
            this.next_step = STEP.NONE;

            this.step_timer_prev = -Time.deltaTime;
            this.step_timer = 0.0f;
        }

        //处理当前状态
        switch(this.step) {
        //打开门
        case STEP.TO_OPEN: {
                float rate;
                float x;

                rate = Mathf.Clamp01(this.step_timer / to_open_time);
                rate = Mathf.Sin(Mathf.Lerp(0.0f,Mathf.PI / 2.0f,rate));

                x = Mathf.Lerp(SHUTTER_POSITION_CLOSE_X,SHUTTER_POSITION_OPEN_X,rate);

                this.fusuma_objects[0].GetComponent<ShutterControl>().setX(x);

                x = Mathf.Lerp(-SHUTTER_POSITION_CLOSE_X,-SHUTTER_POSITION_OPEN_X,rate);

                this.fusuma_objects[1].GetComponent<ShutterControl>().setX(x);
            }
            break;

        case STEP.TO_CLOSE_SHOJI: {
                this.closing_pattern_execute();
            }
            break;

        }

        // ---------------------------------------------------------------- //
    }

    /// <summary>
    /// 重置门
    /// </summary>
    private void reset_shutters() {
        for(int i = 0;i < this.fusuma_objects.Length;i++) {
            this.fusuma_objects[i].SetActive(false);
        }
    }

    /// <summary>
    /// 关门模式初始化
    /// </summary>
    private void closing_pattern_init() {
        switch(this.closing_pattern_type) {

        case CLOSING_PATTERN_TYPE.NORMAL: {
                this.closing_pattern.fusuma_num = 1;
                this.closing_pattern.total_time = 0.5f;
            }
            break;

        case CLOSING_PATTERN_TYPE.OVERSHOOT: {
                this.closing_pattern.fusuma_num = 2;
                this.closing_pattern.total_time = 1.0f;
            }
            break;

        case CLOSING_PATTERN_TYPE.SECONDTIME: {
                this.closing_pattern.fusuma_num = 2;
                this.closing_pattern.total_time = 1.0f;
            }
            break;

        case CLOSING_PATTERN_TYPE.ARCODION: {
                this.closing_pattern.fusuma_num = 1;
                this.closing_pattern.total_time = 0.5f;
            }
            break;

        case CLOSING_PATTERN_TYPE.DELAY: {
                this.closing_pattern.fusuma_num = 1;
                this.closing_pattern.total_time = 0.8f;
            }
            break;

        case CLOSING_PATTERN_TYPE.FALLDOWN: {
                this.closing_pattern.fusuma_num = 2;
                this.closing_pattern.total_time = 1.0f;
            }
            break;

        case CLOSING_PATTERN_TYPE.FLIP: {
                this.closing_pattern.fusuma_num = 2;
                this.closing_pattern.total_time = 1.0f;
            }
            break;

        case CLOSING_PATTERN_TYPE.SLOW: {
                this.closing_pattern.fusuma_num = 2;
                //this.closing_pattern.total_time = 2.0f;
                this.closing_pattern.total_time = this.closing_pattern.param.as_float;
            }
            break;

        case CLOSING_PATTERN_TYPE.SUPER_DELAY: {
                this.closing_pattern.fusuma_num = 1;
                this.closing_pattern.total_time = 2.5f;

            }
            break;
        }

        this.closing_pattern.fusuma_x = new float[this.closing_pattern.fusuma_num];
        this.closing_pattern.fusuma_rot_x = new float[this.closing_pattern.fusuma_num];

        //

        this.reset_shutters();

        for(int i = 0;i < this.closing_pattern.fusuma_num;i++) {

            this.fusuma_objects[i].SetActive(true);

            this.closing_pattern.fusuma_x[i] = -SHUTTER_POSITION_OPEN_X;

            this.closing_pattern.fusuma_rot_x[i] = 0.0f;
        }

        this.closing_pattern.shoji_x = SHUTTER_POSITION_OPEN_X;

        this.closing_pattern.shoji_rot_x = 0.0f;

        // 左側にあるふすまを左右反転する.
        //

        Vector3 scale = new Vector3(-1.0f,1.0f,1.0f);

        if(this.is_flip_closing) {

            scale.x *= -1.0f;
        }

        this.fusuma_objects[0].transform.localScale = scale;

        scale.x *= -1.0f;

        for(int i = 1;i < this.closing_pattern.fusuma_num;i++) {

            this.fusuma_objects[i].transform.localScale = scale;
        }

    }

    // ステップタイマーが time をまたいだ？.
    private bool is_step_timer_reach(float time) {
        bool ret = false;

        if(this.step_timer_prev < time && time <= this.step_timer) {

            ret = true;
        }

        return (ret);
    }

    // 登場パターンの実行.
    private void closing_pattern_execute() {
        float rate;

        // 「毎フレーム更新する値」を初期化しておく.

        for(int i = 0;i < this.closing_pattern.fusuma_num;i++) {

            this.closing_pattern.fusuma_x[i] = SHUTTER_POSITION_OPEN_X;
            this.closing_pattern.fusuma_rot_x[i] = 0.0f;
        }

        this.closing_pattern.shoji_x = SHUTTER_POSITION_OPEN_X;
        this.closing_pattern.shoji_y = 0.0f;
        this.closing_pattern.shoji_z_offset = 0.0f;
        this.closing_pattern.shoji_rot_x = 0.0f;

        this.closing_pattern.is_play_close_sound = false;
        this.closing_pattern.is_play_close_end_sound = false;

        this.closing_pattern.se_volume = 1.0f;
        this.closing_pattern.se_pitch = 1.0f;

        // 現在の位置、回転等を更新する.

        switch(this.closing_pattern_type) {

        case CLOSING_PATTERN_TYPE.NORMAL: {
                rate = Mathf.Clamp01(this.step_timer / this.closing_pattern.total_time);
                rate = Mathf.Sin(Mathf.Lerp(0.0f,Mathf.PI / 2.0f,rate));

                this.closing_pattern.shoji_x = Mathf.Lerp(SHUTTER_POSITION_OPEN_X,SHUTTER_POSITION_CLOSE_X,rate);

                this.closing_pattern.fusuma_x[0] = Mathf.Lerp(-SHUTTER_POSITION_OPEN_X,-SHUTTER_POSITION_CLOSE_X,rate);

                if(this.is_step_timer_reach(0.0f)) {

                    this.closing_pattern.is_play_close_sound = true;
                }
                if(this.is_step_timer_reach(this.closing_pattern.total_time)) {

                    this.closing_pattern.is_play_close_end_sound = true;
                }
            }
            break;

        case CLOSING_PATTERN_TYPE.OVERSHOOT: {
                rate = Mathf.Clamp01(this.step_timer / this.closing_pattern.total_time);
                rate = Mathf.Sin(Mathf.Lerp(0.0f,Mathf.PI / 2.0f,rate));

                this.closing_pattern.shoji_x = Mathf.Lerp(SHUTTER_POSITION_OPEN_X,-SHUTTER_POSITION_CLOSE_X,rate);

                if(rate < 0.5f) {

                    rate = Mathf.InverseLerp(0.0f,0.5f,rate);

                    this.closing_pattern.fusuma_x[0] = Mathf.Lerp(-SHUTTER_POSITION_OPEN_X,-SHUTTER_POSITION_CLOSE_X,rate);

                } else {

                    rate = Mathf.InverseLerp(0.5f,1.0f,rate);

                    this.closing_pattern.fusuma_x[0] = Mathf.Lerp(-SHUTTER_POSITION_CLOSE_X,-SHUTTER_POSITION_OPEN_X,rate);

                    this.closing_pattern.fusuma_x[1] = Mathf.Lerp(SHUTTER_POSITION_OPEN_X,SHUTTER_POSITION_CLOSE_X,rate);
                }

                if(this.is_step_timer_reach(0.0f)) {

                    this.closing_pattern.is_play_close_sound = true;
                }
                if(this.is_step_timer_reach(this.closing_pattern.total_time * Mathf.Asin(0.5f) / (Mathf.PI / 2.0f))) {

                    this.closing_pattern.is_play_close_end_sound = true;
                }
            }
            break;

        case CLOSING_PATTERN_TYPE.SECONDTIME: {
                rate = Mathf.Clamp01(this.step_timer / this.closing_pattern.total_time);
                rate = Mathf.Sin(Mathf.Lerp(0.0f,Mathf.PI / 2.0f,rate));

                this.closing_pattern.fusuma_x[1] = Mathf.Lerp(SHUTTER_POSITION_OPEN_X,-SHUTTER_POSITION_CLOSE_X,rate);

                if(rate < 0.5f) {

                    rate = Mathf.InverseLerp(0.0f,0.5f,rate);

                    this.closing_pattern.fusuma_x[0] = Mathf.Lerp(-SHUTTER_POSITION_OPEN_X,-SHUTTER_POSITION_CLOSE_X,rate);

                } else {

                    rate = Mathf.InverseLerp(0.5f,1.0f,rate);

                    this.closing_pattern.fusuma_x[0] = Mathf.Lerp(-SHUTTER_POSITION_CLOSE_X,-SHUTTER_POSITION_OPEN_X,rate);

                    this.closing_pattern.shoji_x = Mathf.Lerp(SHUTTER_POSITION_OPEN_X,SHUTTER_POSITION_CLOSE_X,rate);
                }

                if(this.is_step_timer_reach(0.0f)) {

                    this.closing_pattern.is_play_close_sound = true;
                }
                if(this.is_step_timer_reach(this.closing_pattern.total_time * Mathf.Asin(0.5f) / (Mathf.PI / 2.0f))) {

                    this.closing_pattern.is_play_close_end_sound = true;
                }
            }
            break;

        case CLOSING_PATTERN_TYPE.ARCODION: {
                rate = Mathf.Clamp01(this.step_timer / this.closing_pattern.total_time);
                rate = Mathf.Sin(Mathf.Lerp(0.0f,Mathf.PI / 2.0f,rate));

                this.closing_pattern.shoji_x = Mathf.Lerp(-SHUTTER_POSITION_OPEN_X,SHUTTER_POSITION_CLOSE_X,rate);
                this.closing_pattern.shoji_z_offset = 0.01f;

                this.closing_pattern.fusuma_x[0] = Mathf.Lerp(-SHUTTER_POSITION_OPEN_X,-SHUTTER_POSITION_CLOSE_X,rate);

                if(this.is_step_timer_reach(0.0f)) {

                    this.closing_pattern.is_play_close_sound = true;
                }
                if(this.is_step_timer_reach(this.closing_pattern.total_time)) {

                    this.closing_pattern.is_play_close_end_sound = true;
                }
            }
            break;

        case CLOSING_PATTERN_TYPE.DELAY: {
                rate = Mathf.Clamp01(this.step_timer / this.closing_pattern.total_time);

                const float time0 = 0.3f;
                const float time1 = 0.7f;

                if(rate < time0) {

                    // 右側にふすまがさっとしまる.

                    rate = Mathf.InverseLerp(0.0f,time0,rate);
                    rate = Mathf.Sin(Mathf.Lerp(0.0f,Mathf.PI / 2.0f,rate));

                    this.closing_pattern.fusuma_x[0] = Mathf.Lerp(-SHUTTER_POSITION_OPEN_X,-SHUTTER_POSITION_CLOSE_X,rate);
                    this.closing_pattern.shoji_x = SHUTTER_POSITION_OPEN_X;

                } else if(rate < time1) {

                    // しばらくためる.

                    this.closing_pattern.fusuma_x[0] = -SHUTTER_POSITION_CLOSE_X;
                    this.closing_pattern.shoji_x = SHUTTER_POSITION_OPEN_X;

                } else {

                    // 左側に障子がさっとしまる.

                    rate = Mathf.InverseLerp(time1,1.0f,rate);
                    rate = Mathf.Sin(Mathf.Lerp(0.0f,Mathf.PI / 2.0f,rate));

                    this.closing_pattern.fusuma_x[0] = -SHUTTER_POSITION_CLOSE_X;

                    if(this.closing_pattern.param.as_bool) {

                        // 障子が左から（ふすまの裏から）出てくる.

                        this.closing_pattern.shoji_x = Mathf.Lerp(-SHUTTER_POSITION_CLOSE_X,SHUTTER_POSITION_CLOSE_X,rate);

                        // ふすまのモデルからはみ出ないよう、少し後ろにずらす.
                        this.closing_pattern.shoji_z_offset = 0.01f;

                    } else {

                        this.closing_pattern.shoji_x = Mathf.Lerp(SHUTTER_POSITION_OPEN_X,SHUTTER_POSITION_CLOSE_X,rate);
                    }
                }

                if(this.is_step_timer_reach(0.0f)) {

                    this.closing_pattern.is_play_close_sound = true;
                    this.closing_pattern.se_pitch = 2.0f;
                }
                if(this.is_step_timer_reach(this.closing_pattern.total_time * time1)) {

                    this.closing_pattern.is_play_close_sound = true;
                    this.closing_pattern.se_pitch = 2.0f;
                }
                if(this.is_step_timer_reach(this.closing_pattern.total_time)) {

                    this.closing_pattern.is_play_close_end_sound = true;
                    this.closing_pattern.se_pitch = 1.5f;
                }
            }
            break;

        case CLOSING_PATTERN_TYPE.FALLDOWN: {
                const float height0 = 6.0f;
                const float height1 = height0 / 16.0f;

                rate = Mathf.Clamp01(this.step_timer / this.closing_pattern.total_time);

                if(rate < 0.1f) {

                    // 両側からふすまが閉まる（だいぶすき間をあけて）.

                    rate = Mathf.InverseLerp(0.0f,0.1f,rate);

                    this.closing_pattern.fusuma_x[0] = Mathf.Lerp(-SHUTTER_POSITION_OPEN_X,-SHUTTER_POSITION_CLOSE_X * 2.0f,rate);
                    this.closing_pattern.fusuma_x[1] = Mathf.Lerp(SHUTTER_POSITION_OPEN_X,SHUTTER_POSITION_CLOSE_X * 2.0f,rate);

                    this.closing_pattern.shoji_y = height0;

                } else {

                    // 上から障子が落ちてくる.

                    rate = Mathf.InverseLerp(0.1f,1.0f,rate);

                    this.closing_pattern.fusuma_x[0] = -SHUTTER_POSITION_CLOSE_X * 2.0f;
                    this.closing_pattern.fusuma_x[1] = SHUTTER_POSITION_CLOSE_X * 2.0f;

                    this.closing_pattern.shoji_x = 0.0f;

                    //

                    const float fall_time0 = 0.5f;
                    const float fall_time1 = 0.75f;

                    if(rate < fall_time0) {

                        rate = Mathf.InverseLerp(0.0f,fall_time0,rate);

                        rate = rate * rate;

                        this.closing_pattern.shoji_y = Mathf.Lerp(height0,0.0f,rate);

                    } else if(rate < fall_time1) {

                        // バウンドする.

                        this.closing_pattern.shoji_x = 0.0f;

                        rate = Mathf.InverseLerp(fall_time0,fall_time1,rate);

                        rate = Mathf.Lerp(-1.0f,1.0f,rate);

                        rate = 1.0f - rate * rate;

                        this.closing_pattern.shoji_y = Mathf.Lerp(0.0f,height1,rate);

                    } else {

                        Vector3 position = this.shoji_object.transform.position;

                        position.y = 0.0f;

                        this.shoji_object.transform.position = position;
                    }
                }

                if(this.is_step_timer_reach(0.0f)) {

                    this.closing_pattern.is_play_close_sound = true;
                    this.closing_pattern.se_pitch = 3.0f;
                }
                if(this.is_step_timer_reach(this.closing_pattern.total_time * 0.1f)) {

                    this.closing_pattern.is_play_close_sound = true;
                }
                if(this.is_step_timer_reach(this.closing_pattern.total_time * (0.1f + 0.9f * 0.5f))) {

                    this.closing_pattern.is_play_close_end_sound = true;
                }
                if(this.is_step_timer_reach(this.closing_pattern.total_time * (0.1f + 0.9f * 0.75f))) {

                    this.closing_pattern.is_play_close_end_sound = true;
                    this.closing_pattern.se_volume = 0.1f;
                }
            }
            break;

        case CLOSING_PATTERN_TYPE.FLIP: {
                rate = Mathf.Clamp01(this.step_timer / this.closing_pattern.total_time);
                rate = Mathf.Sin(Mathf.Lerp(0.0f,Mathf.PI / 2.0f,rate));

                const float time0 = 0.3f;
                const float time1 = 0.7f;

                if(rate < time0) {

                    // さっとしまる（両方ともふすま）.

                    rate = Mathf.InverseLerp(0.0f,time0,rate);

                    this.closing_pattern.fusuma_x[0] = Mathf.Lerp(-SHUTTER_POSITION_OPEN_X,-SHUTTER_POSITION_CLOSE_X,rate);
                    this.closing_pattern.fusuma_x[1] = Mathf.Lerp(SHUTTER_POSITION_OPEN_X,SHUTTER_POSITION_CLOSE_X,rate);
                    this.closing_pattern.shoji_x = SHUTTER_POSITION_OPEN_X;

                } else if(rate < time1) {

                    // しばらくためる.

                    this.closing_pattern.fusuma_x[0] = -SHUTTER_POSITION_CLOSE_X;
                    this.closing_pattern.fusuma_x[1] = SHUTTER_POSITION_CLOSE_X;
                    this.closing_pattern.shoji_x = SHUTTER_POSITION_OPEN_X;

                } else {

                    // 右側がくるんとまわって障子になる.

                    this.closing_pattern.fusuma_x[0] = -SHUTTER_POSITION_CLOSE_X;
                    this.closing_pattern.fusuma_x[1] = SHUTTER_POSITION_CLOSE_X;
                    this.closing_pattern.shoji_x = SHUTTER_POSITION_OPEN_X;

                    //

                    rate = Mathf.InverseLerp(time1,1.0f,rate);

                    if(rate < 0.5f) {

                        // ０～９０度　ふすまを表示.

                        rate = Mathf.InverseLerp(0.0f,0.5f,rate);

                        this.closing_pattern.fusuma_x[1] = SHUTTER_POSITION_CLOSE_X;
                        this.closing_pattern.shoji_x = SHUTTER_POSITION_OPEN_X;

                        //

                        this.closing_pattern.fusuma_rot_x[1] = Mathf.Lerp(0.0f,90.0f,rate);
                        this.closing_pattern.shoji_rot_x = 0.0f;


                    } else {

                        // ９０～１８０度　障子を表示.

                        rate = Mathf.InverseLerp(0.5f,1.0f,rate);

                        this.closing_pattern.fusuma_x[1] = SHUTTER_POSITION_OPEN_X;
                        this.closing_pattern.shoji_x = SHUTTER_POSITION_CLOSE_X;

                        //

                        this.closing_pattern.fusuma_rot_x[1] = 0.0f;
                        this.closing_pattern.shoji_rot_x = Mathf.Lerp(-90.0f,0.0f,rate);

                    }
                }

                if(this.is_step_timer_reach(0.0f)) {

                    this.closing_pattern.is_play_close_sound = true;
                    this.closing_pattern.se_pitch = 2.0f;
                }
                if(this.is_step_timer_reach(this.closing_pattern.total_time * time0)) {

                    this.closing_pattern.is_play_close_end_sound = true;
                    this.closing_pattern.se_pitch = 1.5f;
                }
                if(this.is_step_timer_reach(this.closing_pattern.total_time)) {

                    this.closing_pattern.is_play_close_end_sound = true;
                    this.closing_pattern.se_pitch = 1.5f;
                }
            }
            break;

        case CLOSING_PATTERN_TYPE.SLOW: {
                rate = Mathf.Clamp01(this.step_timer / this.closing_pattern.total_time);
                rate = Mathf.Sin(Mathf.Lerp(0.0f,Mathf.PI / 2.0f,rate));

                this.closing_pattern.shoji_x = Mathf.Lerp(SHUTTER_POSITION_OPEN_X,SHUTTER_POSITION_CLOSE_X,rate);

                this.closing_pattern.fusuma_x[0] = Mathf.Lerp(-SHUTTER_POSITION_OPEN_X,-SHUTTER_POSITION_CLOSE_X,rate);

                if(this.is_step_timer_reach(0.0f)) {

                    this.closing_pattern.is_play_close_sound = true;
                    this.closing_pattern.se_pitch = 0.5f;
                }
                if(this.is_step_timer_reach(this.closing_pattern.total_time)) {

                    this.closing_pattern.is_play_close_end_sound = true;
                    this.closing_pattern.se_pitch = 0.5f;
                    this.closing_pattern.se_volume = 0.5f;
                }
            }
            break;

        case CLOSING_PATTERN_TYPE.SUPER_DELAY: {
                rate = Mathf.Clamp01(this.step_timer / this.closing_pattern.total_time);

                const float time0 = 0.1f;
                float time1 = this.closing_pattern.param.as_float;
                float time2 = time1 + 0.1f;

                if(rate < time0) {

                    // ふすまがさっとしまる.

                    rate = Mathf.InverseLerp(0.0f,time0,rate);
                    rate = Mathf.Sin(Mathf.Lerp(0.0f,Mathf.PI / 2.0f,rate));

                    this.closing_pattern.fusuma_x[0] = Mathf.Lerp(-SHUTTER_POSITION_OPEN_X,-SHUTTER_POSITION_CLOSE_X,rate);
                    this.closing_pattern.shoji_x = SHUTTER_POSITION_OPEN_X;

                } else if(rate < time1) {

                    // しばらくためる.

                    this.closing_pattern.fusuma_x[0] = -SHUTTER_POSITION_CLOSE_X;
                    this.closing_pattern.shoji_x = SHUTTER_POSITION_OPEN_X;

                } else if(rate < time2) {

                    // 左側に障子がさっとしまる.

                    rate = Mathf.InverseLerp(time1,time2,rate);
                    rate = Mathf.Sin(Mathf.Lerp(0.0f,Mathf.PI / 2.0f,rate));

                    this.closing_pattern.fusuma_x[0] = -SHUTTER_POSITION_CLOSE_X;
                    this.closing_pattern.shoji_x = Mathf.Lerp(SHUTTER_POSITION_OPEN_X,SHUTTER_POSITION_CLOSE_X,rate);

                } else {

                    this.closing_pattern.fusuma_x[0] = -SHUTTER_POSITION_CLOSE_X;
                    this.closing_pattern.shoji_x = SHUTTER_POSITION_CLOSE_X;
                }
                //

                if(this.is_step_timer_reach(0.0f)) {

                    this.closing_pattern.is_play_close_sound = true;
                    this.closing_pattern.se_pitch = 2.0f;
                }
                if(this.is_step_timer_reach(this.closing_pattern.total_time * time1)) {

                    this.closing_pattern.is_play_close_sound = true;
                    this.closing_pattern.se_pitch = 2.0f;
                }
                if(this.is_step_timer_reach(this.closing_pattern.total_time * time2)) {

                    this.closing_pattern.is_play_close_end_sound = true;
                    this.closing_pattern.se_pitch = 1.5f;
                }
            }
            break;
        }

        // 位置、回転等を GameObject に反映させる.

        for(int i = 0;i < this.closing_pattern.fusuma_num;i++) {

            if(!this.is_flip_closing) {

                this.fusuma_objects[i].GetComponent<ShutterControl>().setX(this.closing_pattern.fusuma_x[i]);
                this.fusuma_objects[i].transform.rotation = Quaternion.AngleAxis(this.closing_pattern.fusuma_rot_x[i],Vector3.up);

            } else {

                this.fusuma_objects[i].GetComponent<ShutterControl>().setX(-this.closing_pattern.fusuma_x[i]);
                this.fusuma_objects[i].transform.rotation = Quaternion.AngleAxis(-this.closing_pattern.fusuma_rot_x[i],Vector3.up);
            }
        }

        if(this.shoji_object != null) {

            Vector3 position = this.shoji_object.transform.localPosition;

            if(!this.is_flip_closing) {

                position.x = this.closing_pattern.shoji_x;
                position.y = this.closing_pattern.shoji_y;

                this.shoji_object.transform.rotation = Quaternion.AngleAxis(this.closing_pattern.shoji_rot_x,Vector3.up);

            } else {

                position.x = -this.closing_pattern.shoji_x;
                position.y = this.closing_pattern.shoji_y;

                this.shoji_object.transform.rotation = Quaternion.AngleAxis(-this.closing_pattern.shoji_rot_x,Vector3.up);
            }

            position.z = SHUTTER_POSITION_Z + this.closing_pattern.shoji_z_offset;

            this.shoji_object.transform.localPosition = position;
        }

        // サウンド.

        if(this.closing_pattern.is_play_close_sound) {

            this.GetComponent<AudioSource>().PlayOneShot(this.CLOSE_SOUND,this.closing_pattern.se_volume);
            this.GetComponent<AudioSource>().pitch = this.closing_pattern.se_pitch;
        }
        if(this.closing_pattern.is_play_close_end_sound) {

            this.GetComponent<AudioSource>().PlayOneShot(this.CLOSE_END_SOUND,this.closing_pattern.se_volume);
            this.GetComponent<AudioSource>().pitch = this.closing_pattern.se_pitch;
        }
    }

    /// <summary>
    /// 添加窗户控制器
    /// </summary>
    public void attachShouji(ShojiControl shoji) {
        this.shoji_object = shoji;
        if(this.shoji_object != null) {
            this.shoji_object.transform.parent = this.gameObject.transform;
            this.shoji_object.transform.localPosition = new Vector3(SHUTTER_POSITION_OPEN_X,0.0f,SHUTTER_POSITION_Z);
        }
    }

    // 障子の登場パターンをセットする.
    public void setClosingPatternType(CLOSING_PATTERN_TYPE type,bool is_flip) {
        ClosingPatternParam param;

        param.as_float = 0.0f;
        param.as_bool = true;

        this.setClosingPatternType(type,is_flip,param);
    }
    // 障子の登場パターンをセットする.
    public void setClosingPatternType(CLOSING_PATTERN_TYPE type,bool is_flip,ClosingPatternParam param) {
        this.closing_pattern_type = type;

        this.is_flip_closing = is_flip;

        this.closing_pattern.param = param;
    }

    public void setClose() {
        this.next_step = STEP.CLOSE;
    }
    public void setOpen() {
        this.next_step = STEP.OPEN;
    }

    public void beginOpen() {
        this.next_step = STEP.TO_OPEN;
    }
    public void beginCloseShoji() {
        this.next_step = STEP.TO_CLOSE_SHOJI;
    }
}

using UnityEngine;
using System.Collections;

/// <summary>
/// 管理场景中使用的共通参数
/// </summary>
public class GlobalParam:MonoBehaviour {

    /// <summary>
    /// 难度
    /// </summary>
    private int m_difficultyMode = 0;

    /// <summary>
    /// 单例
    /// </summary>
    private static GlobalParam m_instance = null;

    /// <summary>
    /// 获取单例
    /// </summary>
    public static GlobalParam GetInstance() {
        if(m_instance == null) {
            GameObject g = new GameObject("GlobalParam");
            m_instance = g.AddComponent<GlobalParam>();
            DontDestroyOnLoad(g);
        }
        return m_instance;
    }

    /// <summary>
    /// 获取难度
    /// </summary>
    public int difficulty() {
        return m_difficultyMode;
    }

    /// <summary>
    /// 设置难度
    /// </summary>
    public void SetMode(int difficulty) {
        m_difficultyMode = difficulty;
    }
}

using UnityEngine;
using System.Collections;

/// <summary>
/// 根据难易程度来改变窗户的关闭方式等
/// </summary>
public class LevelControl : MonoBehaviour {

    public enum LEVEL {

        NONE = -1,

        EASY = 0,
        NORMAL = 1,
        HARD = 2,

        NUM,
    };

    public LEVEL    level = LEVEL.EASY;

    public SceneControl    scene_control = null;

    private bool    random_bool_prev;

    // ---------------------------------------------------------------- //

    // Use this for initialization
    void Start () {

        switch(GlobalParam.GetInstance().difficulty()) {

            case 0:
            {    
                this.level = LEVEL.EASY;
            }
            break;
        
            case 1:
            {    
                this.level = LEVEL.NORMAL;
            }
            break;
            
            case 2:
            {    
                this.level = LEVEL.HARD;
            }
            break;

            default:
            {    
                this.level = LEVEL.EASY;
            }
            break;
        }

        this.scene_control = GameObject.FindGameObjectWithTag("MainCamera").GetComponent<SceneControl>();

        this.random_bool_prev = Random.Range(0, 2) == 0 ? true : false;
    }
    
    // Update is called once per frame
    void Update () {
    
    }

    // 障子が閉まり始める距離.
    public float getCloseDistance()
    {
        // ちいさな値にすると障子が閉まり始めるタイミングが遅くなって、難しくなります.
        
        float    close_distance = 14.0f;
        
        int        paper_num = this.scene_control.getPaperNum();

        switch(this.level) {
        
            case LEVEL.EASY:
            {
                close_distance = 14.0f;
            }
            break;
            
            case LEVEL.NORMAL:
            {
                close_distance = 14.0f;
            }
            break;
            
            case LEVEL.HARD:
            {
                if(paper_num >= 8) {

                    close_distance = 12.0f;

                } else if(paper_num >= 5) {

                    close_distance = 12.0f;

                } else {

                    close_distance = FloorControl.SHUTTER_POSITION_Z;
                }
            }
            break;

            default:
            {
                close_distance = 14.0f;
            }
            break;
        }


        return(close_distance);
    }
    
    // 障子の閉まり方パターンを取得する.
    public void    getClosingPattern(out FloorControl.CLOSING_PATTERN_TYPE out_type, out bool out_is_flip, out FloorControl.ClosingPatternParam out_param)
    {
        int        paper_num   = this.scene_control.getPaperNum();
        bool    random_bool = Random.Range(0, 2) == 0 ? true : false;

        out_param.as_float = 0.0f;
        out_param.as_bool  = false;

        switch(this.level) {

            case LEVEL.EASY:
            {
                // easy は normal のみ.

                out_type = FloorControl.CLOSING_PATTERN_TYPE.NORMAL;

                out_is_flip = false;
            }
            break;

            case LEVEL.NORMAL:
            {
                StaticArray<FloorControl.CLOSING_PATTERN_TYPE>    out_type_cadidates = new StaticArray<FloorControl.CLOSING_PATTERN_TYPE>((int)FloorControl.CLOSING_PATTERN_TYPE.NUM);

                if(9 >= paper_num && paper_num >= 8) {

                    // １、２枚目は NORMAL.

                    out_type_cadidates.push_back(FloorControl.CLOSING_PATTERN_TYPE.NORMAL);

                    out_is_flip = false;

                } else if(paper_num == 7) {

                    // 残り７枚のときは OVERSHOOT.

                    out_type_cadidates.push_back(FloorControl.CLOSING_PATTERN_TYPE.OVERSHOOT);

                    out_is_flip = false;

                } else if(paper_num == 6) {

                    // 残り６枚のときは SECONDTIME.

                    out_type_cadidates.push_back(FloorControl.CLOSING_PATTERN_TYPE.SECONDTIME);

                    out_is_flip = false;

                } else if(paper_num == 5) {

                    // 残り５枚のときは ARCODION.

                    out_type_cadidates.push_back(FloorControl.CLOSING_PATTERN_TYPE.ARCODION);

                    out_is_flip = false;

                } else if(4 >= paper_num && paper_num >= 3) {

                    // 残り４～３枚のときは DELAY（is_flip はランダム）.

                    out_type_cadidates.push_back(FloorControl.CLOSING_PATTERN_TYPE.DELAY);

                    out_is_flip = random_bool;

                    if(paper_num == 4) {

                        // 残り４枚のときは右から.

                        out_param.as_bool = false;

                    } else {

                        // 残り３枚のときは右から（ふすまの裏から）.
                        out_param.as_bool = true;
                    }

                } else if(paper_num == 2) {

                    // 残り２枚の時は必ず FALLDOWN.

                    out_type_cadidates.push_back(FloorControl.CLOSING_PATTERN_TYPE.FALLDOWN);

                    out_is_flip = false;

                } else {

                    // 残り１枚の時は必ず FLIP（is_flip はランダム）.

                    out_type_cadidates.push_back(FloorControl.CLOSING_PATTERN_TYPE.FLIP);

                    out_is_flip = random_bool;
                }

                out_type = out_type_cadidates[Random.Range(0, out_type_cadidates.size())];
            }
            break;

            case LEVEL.HARD:
            {
                if(paper_num >= 8) {

                    // 残り９～８枚のときは NORMAL.

                    out_type = FloorControl.CLOSING_PATTERN_TYPE.NORMAL;

                    if(paper_num == 9) {

                        out_is_flip = random_bool;

                    } else {

                        out_is_flip = !this.random_bool_prev;
                    }

                } else if(paper_num >= 5) {

                    // 残り７～５枚のときは SLOW.
                    // 閉まり終わるのがだんだん遅くなる.

                    out_type = FloorControl.CLOSING_PATTERN_TYPE.SLOW;

                    if(paper_num == 7) {

                        out_is_flip        = random_bool;
                        out_param.as_float = 1.5f;

                    } else if(paper_num == 6) {

                        out_is_flip        = !this.random_bool_prev;
                        out_param.as_float = 1.7f;

                        // 次回のために上書きしておく.
                        // （7, 6, 5 で必ず交互になるように）.
                        random_bool = !this.random_bool_prev;

                    } else {

                        out_is_flip        = !this.random_bool_prev;
                        out_param.as_float = 2.0f;
                    }

                } else {

                    // 残り４～１枚のときは SUPER_DELAY.

                    out_type = FloorControl.CLOSING_PATTERN_TYPE.SUPER_DELAY;

                    out_is_flip = random_bool;

                    if(paper_num >= 4) {

                        out_param.as_float = 0.6f;

                    } else if(paper_num >= 3) {

                        out_param.as_float = 0.7f;

                    } else {

                        out_param.as_float = 0.9f;
                    }
                }
            }
            break;

            default:
            {
                out_type = FloorControl.CLOSING_PATTERN_TYPE.NORMAL;

                out_is_flip = false;
            }
            break;
        }

        this.random_bool_prev = random_bool;
    }

    // 『何回空振り（やぶった後の穴を通過）したら鉄板になるか』を取得する.
    public int    getChangeSteelCount()
    {
        // -1 のときは鉄板にならない.
        int    count = -1;

        int    paper_num = this.scene_control.getPaperNum();

        switch(this.level) {
        
            case LEVEL.EASY:
            {
                // easy は鉄板化なし.
                count = -1;
            }
            break;

            case LEVEL.NORMAL:
            {
                // hardは鉄板化なし.
                count = -1;
            }
            break;

            case LEVEL.HARD:
            {
                // （仮）です.
                // のこり枚数が少なくなるほど鉄板化しやすくなるようにしてください.

                if(paper_num >= 8) {
                
                    count = -1;
                
                } else if(paper_num >= 6) {

                    count = 5;

                } else if(paper_num >= 3) {

                    count = 2;

                } else { 

                    count = 1;
                }

            }
            break;

            default:
            {
                count = -1;
            }
            break;
        }

        return(count);
    }
}

using UnityEngine;
using System.Collections;

/// <summary>
/// 猫的碰撞结果
/// </summary>
public class NekoColiResult  {

    public NekoControl    neko = null;

    public static float    THROUGH_GAP_LIMIT = 0.4f;            //!< 格子の中心からこれ以上ずれていたら、組み木に当たる.
    public static float UNLOCK_DISTANCE = 3.0f;                //!< 誘導を解除する距離.

    // ---------------------------------------------------------------- //

    // 障子の組み木に当たったときの情報いろいろ.
    //
    public struct ShojiHitInfo {

        public bool            is_enable;

        public ShojiControl    shoji_control;

        public ShojiControl.HoleIndex    hole_index;
    };

    public ShojiHitInfo        shoji_hit_info;
    public ShojiHitInfo        shoji_hit_info_first;

    // 障子の穴に当たったときの情報いろいろ.
    //
    public struct HoleHitInfo {

        public SyoujiPaperControl    paper_control;
    };

    public StaticArray<HoleHitInfo>    hole_hit_infos;

    // ふすま、障子の組み木にあたったときの情報いろいろ.
    //
    public struct ObstacleHitInfo {

        public bool            is_enable;

        public GameObject    go;
        public bool            is_steel;
    };

    public ObstacleHitInfo    obstacle_hit_info;

    // 誘導をかける、障子の格子
    //
    public struct LockTarget {

        public bool                        enable;

        public ShojiControl.HoleIndex    hole_index;

        public Vector3                    position;
    };

    public LockTarget    lock_target;

    public bool            is_steel = false;

    // ---------------------------------------------------------------- //

    public void create()
    {
        this.hole_hit_infos = new StaticArray<HoleHitInfo>(4);

        this.shoji_hit_info.is_enable       = false;
        this.shoji_hit_info_first.is_enable = false;

        this.obstacle_hit_info.is_enable = false;

        this.lock_target.enable = false;
    }

    // 前のフレームのコリジョン結果をチェックする.

    public void    resolveCollision()
    {
        // 「格子の穴」をすり抜けて一定距離進んだら、誘導を解除する.
        if(this.lock_target.enable) {

            if(this.neko.transform.position.z > this.lock_target.position.z + UNLOCK_DISTANCE) {

                this.lock_target.enable = false;
            }
        }

        if(!this.lock_target.enable) {

            this.resolve_collision_sub();
        }
    }

    private void    resolve_collision_sub()
    {
        bool    is_collied_obstacle = false;

        this.is_steel = false;

        // ふすま/鉄板に当たったかを最初に調べる.
        //
        // ふすま/鉄板に当たった場合でも穴を通過したときは、ミスにしたくないので.

        if(this.obstacle_hit_info.is_enable) {

            is_collied_obstacle = true;

            this.is_steel = this.obstacle_hit_info.is_steel;
        }

        //

        if(this.shoji_hit_info.is_enable) {

            // 組み木と当たった？.

            ShojiControl            shoji_control = this.shoji_hit_info.shoji_control;
            ShojiControl.HoleIndex    hole_index    = this.shoji_hit_info.hole_index;

            if(shoji_control.isValidHoleIndex(hole_index)) {

                SyoujiPaperControl        paper_control = shoji_control.papers[hole_index.x, hole_index.y];

                if(paper_control.isSteel()) {

                    // 格子の穴が、鉄板だったとき.

                    is_collied_obstacle = true;

                    this.is_steel = true;

                } else  {

                    // 格子の穴が、「紙」「やぶれ紙」だったとき.

                    // 「格子の穴」にホーミングするときの、目標位置.
                    Vector3    position = NekoColiResult.get_hole_homing_position(shoji_control, hole_index);

                    //
    
                    Vector3    diff = this.neko.transform.position - position;
    
                    //Debug.Log(diff.x.ToString() + " " + diff.y);
    
                    if(Mathf.Abs(diff.x) < THROUGH_GAP_LIMIT && Mathf.Abs(diff.y) < THROUGH_GAP_LIMIT) {
    
                        // 穴の中心からある程度近い位置を通過したら、格子の穴を通りぬける.
                        // （ホーミング）.

                        is_collied_obstacle = false;

                        this.lock_target.enable     = true;
                        this.lock_target.hole_index = hole_index;
                        this.lock_target.position   = position;


                        // 「格子の穴」モデルに、プレイヤーがヒットしたことを通知する.
                        paper_control.onPlayerCollided();

                    } else {

                        // 穴の中心から大きくずれていた場合は、格子にぶつかったことにする.

                        is_collied_obstacle = true;
                    }
                }

            } else {

                // 障子の、格子の穴以外の場所にぶつかったとき.

                is_collied_obstacle = true;
            }

        } else {

            // 組み木と当たらなかったときは、二つ以上の「格子の穴」とヒットすることはないはず.
            // （二つの「格子の穴」とヒットするときは、その間の組み木にもヒットするから）
            // なので、組み木と当たらなかったときは this.hole_hit_infos[0] だけ調べれば十分.
            if(this.hole_hit_infos.size() > 0) {

                // 「格子の穴」のみにヒットした.

                HoleHitInfo            hole_hit_info = this.hole_hit_infos[0];
                SyoujiPaperControl    paper_control = hole_hit_info.paper_control;
                ShojiControl        shoji_control = paper_control.shoji_control;

                paper_control.onPlayerCollided();

                // 「格子の穴」を通りぬける.
                // （ホーミング）.

                // ロックする（誘導の目標位置にする）.

                // 「格子の穴」の中心を求める.

                ShojiControl.HoleIndex    hole_index = paper_control.hole_index;

                Vector3    position = NekoColiResult.get_hole_homing_position(shoji_control, hole_index);

                this.lock_target.enable = true;
                this.lock_target.hole_index = hole_index;
                this.lock_target.position   = position;
            }
        }


        if(is_collied_obstacle) {

            // 障害物（障子の組み木、ふすま）に当たった.

            if(this.neko.step != NekoControl.STEP.MISS) {

                this.neko.beginMissAction(this.is_steel);
            }
        }

    }


    // 「格子の穴」にホーミングするときの、目標位置.
    private static Vector3    get_hole_homing_position(ShojiControl shoji_control, ShojiControl.HoleIndex hole_index)
    {
        Vector3        position;
    
        position = shoji_control.getHoleWorldPosition(hole_index.x, hole_index.y);
    
        // コリジョンの中心からオブジェクトの原点へのオフセット.
        // コリジョンの中心が、「格子の穴」の中心を通るようにする.
        position += -NekoControl.COLLISION_OFFSET;

        return(position);
    }

}

using UnityEngine;
using System.Collections;

/// <summary>
/// 控制猫
/// </summary>
public class NekoControl : MonoBehaviour {

    private RoomControl        room_control = null;
    private SceneControl    scene_control = null;
    public EffectControl    effect_control = null;

    // ---------------------------------------------------------------- //

    public enum STEP {

        NONE = -1,

        STAND = 0,            // たち.
        RUN,                // 走り.
        JUMP,                // ジャンプ.
        MISS,                // ミス.
        GAMEOVER,            // ゲームオーバー.

        FREE_MOVE,            // 自由移動（デバッグ用）.

        NUM,
    };

    public STEP            step      = STEP.NONE;
    public STEP            next_step = STEP.NONE;
    public float        step_timer = 0.0f;
    public bool            is_grounded;                // 着地してる？.

    // ---------------------------------------------------------------- //

    // ジャンプ中のいろいろ.
    public struct ActionStand {

        public bool        is_fade_anim;                // アニメーションをフェードする？（毎フレーム true に戻る）.
    };

    // ジャンプ中のいろいろ.
    public struct ActionJump {

        public STEP        prevoius_step;                // ジャンプする前のステップ（立ちジャンプ or 走りながらジャンプ）.

        public bool        is_key_released;            // ジャンプ後、スペースキーを離した？.

        public Vector3    launch_velocity_xz;
    };

    // ミスしたときのいろいろ.
    public struct ActionMiss {

        public bool        is_steel;                    // 鉄板に当たった？.
    };

    public ActionJump    action_jump;
    public ActionMiss    action_miss;
    public ActionStand    action_stand;

    public Vector3        previous_velocity;

    private    bool        is_fallover = true;
        
    private    bool        is_auto_drive = false;        // 自動運転（クリアーした後）.

    // ---------------------------------------------------------------- //

    public static float    JUMP_HEIGHT_MAX = 5.0f;                                // ジャンプの高さ.
    public static float    JUMP_KEY_RELEASE_REDUCE = 0.5f;                        // ジャンプ中にキーを離したときの、上昇速度のスケール.

    public static float    RUN_SPEED_MAX   = 5.0f;                                // 走りのスピードの最大値.
    public static float    RUN_ACCELE      = RUN_SPEED_MAX/2.0f;                // 走りのスピードの加速.

    public static float    SLIDE_SPEED_MAX = 2.0f;                                // 左右移動のスピード.
    public static float    SLIDE_ACCEL     = SLIDE_SPEED_MAX/0.1f;                // 左右移動の加速度.

    public static float SLIDE_ACCEL_SCALE_JUMP = 0.1f;                        // 左右移動の加速度のスケール（ジャンプ中）.

    public static float    RUN_SPEED_DECELE_MISS      = RUN_SPEED_MAX/2.0f;    // ミスした時の減速度.
    public static float    RUN_SPEED_DECELE_MISS_JUMP = RUN_SPEED_MAX/5.0f;    // ミスした時の減速度（ジャンプ中）.

    public static Vector3 COLLISION_OFFSET = Vector3.up*0.2f;

    // ---------------------------------------------------------------- //

    public static float SLIDE_ROTATION_MAX = 0.2f;                            // 左右移動のローテーションスピード.
    public static float SLIDE_ROTATION_SPEED = SLIDE_ROTATION_MAX/0.1f;        // 左右移動のローテーション加速度.
    public static float SLIDE_ROTATION_COEFFICIENT = 2.0f;                    // 左右移動のローテーション加速度の係数.

    public static float JUMP_ROTATION_MAX = 0.25f;                            // 上下のローテーションスピード（ジャンプ中）.
    public static float JUMP_ROTATION_SPEED = JUMP_ROTATION_MAX/0.1f;        // 上下のローテーション加速度（ジャンプ中）.
    public static float JUMP_ROTATION_COEFFICIENT = 0.25f;                    // 上下のローテーション加速度の係数（ジャンプ中）.

    public static float SLIDE_VELOCITY = 1.0f;                                // 左右移動のローテーション速度.
    public static float JUMP_VELOCITY = 4.0f;                                // 上下のローテーション速度（ジャンプ中）.
    
    // ---------------------------------------------------------------- //

    public AudioClip START_SOUND = null;
    public AudioClip FAILED_STEEL_SOUND = null;
    public AudioClip FAILED_FUSUMA_SOUND = null;
    public AudioClip FAILED_NEKO_SOUND = null;
    public AudioClip JUMP_SOUND = null;
    public AudioClip LANDING_SOUND = null;
    public AudioClip FALL_OVER_SOUND = null;

    // ---------------------------------------------------------------- //

    NekoColiResult    coli_result;

    // ---------------------------------------------------------------- //

    public void    onRoomProceed()
    {
        this.coli_result.shoji_hit_info_first.is_enable = false;
    }

    
    void Start ()
    {
        this.room_control   = GameObject.FindGameObjectWithTag("RoomControl").GetComponent<RoomControl>();
        this.scene_control  = GameObject.FindWithTag("MainCamera").GetComponent<SceneControl>();
        this.effect_control = GameObject.FindGameObjectWithTag("EffectControl").GetComponent<EffectControl>();


        //

        this.is_grounded = false;

        GetComponent<AudioSource>().clip = START_SOUND;
        GetComponent<AudioSource>().Play();

        this.previous_velocity = Vector3.zero;

        this.next_step = STEP.STAND;

        this.coli_result = new NekoColiResult();
        this.coli_result.neko = this;
        this.coli_result.create();
    
        this.action_stand.is_fade_anim = true;    

    }

    // Update is called once per frame
    void Update ()
    {

        Animation    animation = this.GetComponentInChildren<Animation>();

        // ---------------------------------------------------------------- //

        // 着地するときに地面にめり込んでしまうので.
        // （かっこ悪いけど）.

        if(this.transform.position.y < 0.0f) {

            this.is_grounded = true;

            Vector3    pos = this.transform.position;

            pos.y = 0.0f;

            this.transform.position = pos;
        }
        
        // ---------------------------------------------------------------- //
        // ステップ内の経過時間を進める.

        this.step_timer += Time.deltaTime;

        // ---------------------------------------------------------------- //
        // 次の状態に移るかどうかを、チェックする.

        // 前のフレームのコリジョン結果を調べる.

        if(this.step != STEP.MISS) {

            this.coli_result.resolveCollision();
        }

        //

        if(this.next_step == STEP.NONE) {

            switch(this.step) {
    
                case STEP.NONE:
                {
                    this.next_step = STEP.STAND;
                }
                break;
    
                case STEP.STAND:
                {
                    // シフトキーで走り始める.
                    if(Input.GetKeyDown(KeyCode.LeftShift)) {
    
                        this.next_step = STEP.RUN;
                    }
                    // スペースキーでジャンプ.
                    if(Input.GetKeyDown(KeyCode.Space)) {
    
                        this.next_step = STEP.JUMP;
                    }
                }
                break;
    
                case STEP.RUN:
                {
                    if(!this.is_auto_drive) {

                        if(Input.GetKeyDown(KeyCode.Space)) {
        
                            this.next_step = STEP.JUMP;
                        }
                    }
                }
                break;

                case STEP.JUMP:
                {
                    // 着地したら立ち、または走りへ.
                    if(this.is_grounded) {
                    
                        GetComponent<AudioSource>().clip = LANDING_SOUND;
                        GetComponent<AudioSource>().Play();
                        this.next_step = this.action_jump.prevoius_step;
                    }
                }
                break;

                case STEP.MISS:
                {
                    if(this.step_timer > 3.0f) {
                    
                        GameObject.FindWithTag("MainCamera").transform.SendMessage("applyDamage", 1);

                        if(this.scene_control.getLifeCount() > 0) {

                            this.transform.position = this.room_control.getRestartPosition();

                            this.room_control.onRestart();

                            // アニメーションは補間しない.
                            this.action_stand.is_fade_anim = false;
                        
                            this.next_step = STEP.STAND;

                        } else {

                            this.next_step = STEP.GAMEOVER;
                        }
                    }
                }
                break;
            }
        }

        // ---------------------------------------------------------------- //
        // 状態が遷移したときの初期化.

        if(this.next_step != STEP.NONE) {

            switch(this.next_step) {
    
                case STEP.STAND:
                {
                    Vector3 v = this.GetComponent<Rigidbody>().velocity;

                    v.x = 0.0f;
                    v.z = 0.0f;

                    this.GetComponent<Rigidbody>().velocity = v;

                    // 立ちアニメーションの再生.

                    if(this.action_stand.is_fade_anim) {

                        animation.CrossFade("M01_nekostanding", 0.2f);

                    } else {

                        animation.CrossFade("M01_nekostanding", 0.0f);
                    }

                    this.action_stand.is_fade_anim = true;    
                }
                break;

                case STEP.RUN:
                {
                    animation.CrossFade("M02_nekodash", 0.2f);
                }
                break;

                case STEP.JUMP:
                {
                    Vector3    v = this.GetComponent<Rigidbody>().velocity;

                    v.y = Mathf.Sqrt(2.0f*9.8f*JUMP_HEIGHT_MAX);

                    this.GetComponent<Rigidbody>().velocity = v;

                    //

                    this.action_jump.is_key_released = false;
                    this.action_jump.prevoius_step   = this.step;

                    this.action_jump.launch_velocity_xz = this.GetComponent<Rigidbody>().velocity;
                    this.action_jump.launch_velocity_xz.y = 0.0f;

                    //

                    animation.CrossFade("M03_nekojump", 0.2f);
                    GetComponent<AudioSource>().clip = JUMP_SOUND;
                    GetComponent<AudioSource>().Play();
                }
                break;

                case STEP.MISS:
                {                
                    // 後ろに跳ね返る.

                    Vector3 v = this.GetComponent<Rigidbody>().velocity;

                    v.z *= -0.5f;

                    this.GetComponent<Rigidbody>().velocity = v;
                        
                    // エフェクト
                    this.effect_control.createMissEffect(this);

                    // 鉄板に当たった音 or ふすまに当たった音.
                    //
                    if(this.action_miss.is_steel) {

                        GetComponent<AudioSource>().PlayOneShot(FAILED_STEEL_SOUND);

                    } else {

                        GetComponent<AudioSource>().PlayOneShot(FAILED_FUSUMA_SOUND);
                    }

                    // やられ声.
                    //
                    GetComponent<AudioSource>().PlayOneShot(FAILED_NEKO_SOUND);
                    
                    animation.CrossFade("M03_nekofailed01", 0.2f);

                    this.coli_result.lock_target.enable = false;

                    this.is_fallover = false;
                }
                break;

                case STEP.FREE_MOVE:
                {
                    this.GetComponent<Rigidbody>().useGravity = false;

                    this.GetComponent<Rigidbody>().velocity = Vector3.zero;
                }
                break;

            }

            this.step      = this.next_step;
            this.next_step = STEP.NONE;

            this.step_timer = 0.0f;
        }

        // ---------------------------------------------------------------- //
        // 各状態での実行処理.

        // 左右移動、ジャンプによるローテーション.
        this.rotation_control();

        switch(this.step) {

            case STEP.STAND:
            {
            }
            break;

            case STEP.RUN:
            {
                // 前への加速.

                Vector3    v = this.GetComponent<Rigidbody>().velocity;

                v.z += (RUN_ACCELE)*Time.deltaTime;

                v.z = Mathf.Clamp(v.z, 0.0f, RUN_SPEED_MAX);

                // 左右への平行移動.

                if(this.is_auto_drive) {

                    v = this.side_move_auto_drive(v, 1.0f);

                } else {

                    v = this.side_move(v, 1.0f);
                }

                //

                this.GetComponent<Rigidbody>().velocity = v;
            }
            break;

            case STEP.JUMP:
            {
                Vector3 v = this.GetComponent<Rigidbody>().velocity;

                // ジャンプ中にキーを離したら、上昇速度を減らす.
                // （キーを押す長さでジャンプの高さを制御できるように）.

                do {

                    if(!Input.GetKeyUp(KeyCode.Space)) {
                    
                        break;
                    }

                    // 一度離した後はやらない（連打対策）.
                    if(this.action_jump.is_key_released) {

                        break;
                    }

                    // 下降中はやらない.
                    if(this.GetComponent<Rigidbody>().velocity.y <= 0.0f) {

                        break;
                    }

                    //

                    v.y *= JUMP_KEY_RELEASE_REDUCE;

                    this.GetComponent<Rigidbody>().velocity = v;

                    this.action_jump.is_key_released = true;

                } while(false);

                // 左右への平行移動.
                // （ジャンプ中も多少は制御できるようにしたい）.
                //
                if(this.is_auto_drive) {

                    this.GetComponent<Rigidbody>().velocity = this.side_move_auto_drive(this.GetComponent<Rigidbody>().velocity, SLIDE_ACCEL_SCALE_JUMP);

                } else {

                    this.GetComponent<Rigidbody>().velocity = this.side_move(this.GetComponent<Rigidbody>().velocity, SLIDE_ACCEL_SCALE_JUMP);
                }

                //

                // 組子に当たったときは、穴の中心の方へ誘導する.
                if(this.coli_result.shoji_hit_info.is_enable) {
    
                    //
    
                    v = this.GetComponent<Rigidbody>().velocity;
            
                    if(this.coli_result.lock_target.enable) {

                        v = this.coli_result.lock_target.position  - this.transform.position;
                    }

                    v.z = this.action_jump.launch_velocity_xz.z;
                        
                    this.GetComponent<Rigidbody>().velocity = v;
                }
            }
            break;


            case STEP.MISS:
            {
                GameObject.FindWithTag("MainCamera").transform.SendMessage("nekoFailed");

                // 徐々に減速する.

                Vector3 v = this.GetComponent<Rigidbody>().velocity;

                v.y = 0.0f;

                float    speed_xz = v.magnitude;

                if(this.is_grounded) {    

                    speed_xz -= RUN_SPEED_DECELE_MISS*Time.deltaTime;

                } else {

                    speed_xz -= RUN_SPEED_DECELE_MISS_JUMP*Time.deltaTime;
                }

                speed_xz = Mathf.Max(0.0f, speed_xz);

                v.Normalize();

                v *= speed_xz;

                v.y = this.GetComponent<Rigidbody>().velocity.y;

                this.GetComponent<Rigidbody>().velocity = v;

                do {

                    if(this.is_fallover) {

                        break;
                    }

                    if(!this.is_grounded) {

                        break;
                    }

                    if(animation["M03_nekofailed01"].normalizedTime < 1.0f) {

                        break;
                    }

                    animation.CrossFade("M03_nekofailed02", 0.2f);
                    GetComponent<AudioSource>().clip = FALL_OVER_SOUND;
                    GetComponent<AudioSource>().Play();

                    this.is_fallover = true;

                } while(false);
            }
            break;

            case STEP.FREE_MOVE:
            {
                float    speed = 400.0f;

                Vector3    v = Vector3.zero;
                
                if(Input.GetKey(KeyCode.RightArrow)) {

                    v.x = +speed*Time.deltaTime;
                }
                if(Input.GetKey(KeyCode.LeftArrow)) {

                    v.x = -speed*Time.deltaTime;
                }
                if(Input.GetKey(KeyCode.UpArrow)) {

                    v.y = +speed*Time.deltaTime;
                }
                if(Input.GetKey(KeyCode.DownArrow)) {

                    v.y = -speed*Time.deltaTime;
                }
                if(Input.GetKey(KeyCode.LeftShift)) {

                    v.z = +speed*Time.deltaTime;
                }
                if(Input.GetKey(KeyCode.RightShift)) {

                    v.z = -speed*Time.deltaTime;
                }

                this.GetComponent<Rigidbody>().velocity = v;
            }
            break;

        }

        // ---------------------------------------------------------------- //

        this.is_grounded = false;

        this.coli_result.shoji_hit_info.is_enable = false;

        this.coli_result.hole_hit_infos.clear();

        this.coli_result.obstacle_hit_info.is_enable = false;

        this.previous_velocity = this.GetComponent<Rigidbody>().velocity;

        animation["M02_nekodash"].speed = 4.0f;
    }

    void    OnGUI()
    {
        /*if(this.coli_result.lock_target.enable) {

            GUI.Label(new Rect(10, 10, 100, 20), this.coli_result.lock_target.hole_index.x.ToString() + " " + this.coli_result.lock_target.hole_index.y.ToString());

        } else {

            GUI.Label(new Rect(10, 10, 100, 20), "disable");
        }*/
    }

    // ---------------------------------------------------------------- //
    // コリジョン関連.

    void     OnCollisionStay(Collision other)
    {
        this.on_collision_common(other);
    }
    void     OnCollisionEnter(Collision other)
    {
        this.on_collision_common(other);
    }
    private void    on_collision_common(Collision other)
    {
        // 障子のコリジョンに当たったかを調べる.
        //
        do {

            if(other.gameObject.tag != "Syouji") {

                break;
            }

            ShojiControl    shoji_control = other.gameObject.GetComponent<ShojiControl>();

            if(shoji_control == null) {

                break;
            }

            // 障子のコリジョンにヒットしたことを記録しておく.


            Vector3        position = this.transform.TransformPoint(NekoControl.COLLISION_OFFSET);

            ShojiControl.HoleIndex    hole_index = shoji_control.getClosetHole(position);

            this.coli_result.shoji_hit_info.is_enable = true;
            this.coli_result.shoji_hit_info.hole_index = hole_index;
            this.coli_result.shoji_hit_info.shoji_control = shoji_control;

        } while(false);

        // ふすまにあたった？.
        
        do {
        
            if(other.gameObject.tag != "Obstacle") {
        
                break;
            }
        
            this.coli_result.obstacle_hit_info.is_enable = true;
            this.coli_result.obstacle_hit_info.go        = other.gameObject;
            this.coli_result.obstacle_hit_info.is_steel  = false;

        } while(false);
    }
    
    void     OnTriggerEnter(Collider other)
    {
        this.on_trigger_common(other);
    }
    
    private void    on_trigger_common(Collider other)
    {
        // 穴を通過した？.

        do {

            if(other.gameObject.tag != "Hole") {

                break;
            }


            SyoujiPaperControl    paper_control = other.GetComponent<SyoujiPaperControl>();

            if(paper_control == null) {

                break;
            }

            // 格子のトリガーを通過したことを記録しておく.

            if(paper_control.step == SyoujiPaperControl.STEP.STEEL) {

                // 鉄板の場合は、障害物にあたったことにする.

                this.coli_result.obstacle_hit_info.is_enable = true;
                this.coli_result.obstacle_hit_info.go        = other.gameObject;
                this.coli_result.obstacle_hit_info.is_steel  = true;

            } else {

                // 紙だった場合.
                if(!this.coli_result.hole_hit_infos.full()) {
    
                    NekoColiResult.HoleHitInfo        hole_hit_info;
            
                    hole_hit_info.paper_control = paper_control;
            
                    this.coli_result.hole_hit_infos.push_back(hole_hit_info);
                }
            }

        } while(false);
    }

    // ---------------------------------------------------------------- //

    public void    beginMissAction(bool is_steel)
    {
        this.GetComponent<Rigidbody>().velocity = this.previous_velocity;
        this.action_miss.is_steel = is_steel;

        this.next_step = STEP.MISS;
    }

    // ---------------------------------------------------------------- //

    // 左右移動、ジャンプによるローテーション.
    private void rotation_control()
    {

        // ---------------------------------------------------------------- //
        // 上下のローテーション.
        Quaternion    current = this.transform.GetChild(0).transform.localRotation;
        Quaternion    rot     = current;

        if(this.transform.position.y > 0.0f || this.step == STEP.JUMP) {        
            // ↑処理の順番の都合上、ジャンプの１フレーム目は y == 0.0f なので、.
            //   step も見てジャンプの１フレーム目もここにくるようにする.
    
            rot.x = -this.GetComponent<Rigidbody>().velocity.y/20.0f;
        
            float    rot_x_diff = rot.x - current.x;
            float    rot_x_diff_limit = 2.0f;

            rot_x_diff = Mathf.Clamp(rot_x_diff, -rot_x_diff_limit*Time.deltaTime, rot_x_diff_limit*Time.deltaTime);

            rot.x = current.x + rot_x_diff;

        } else {
        
            rot.x = current.x;
            rot.x *= 0.9f;
        }

        if(this.step == STEP.MISS) {

            rot.x = current.x;

            if(this.is_grounded) {

                rot.x *= 0.9f;
            }
        }

        // ---------------------------------------------------------------- //
        // 左右のローテーション.

        rot.y = 0.0f;    
        
        rot.y = this.GetComponent<Rigidbody>().velocity.x/10.0f;
        
        float    rot_y_diff = rot.y - current.y;
        
        rot_y_diff = Mathf.Clamp(rot_y_diff, -0.015f, 0.015f);
        
        rot.y = current.y + rot_y_diff;

    
        rot.z = 0.0f;

        // ---------------------------------------------------------------- //

        // 子供（モデル）のみを回転する.

        this.transform.GetChild(0).transform.localRotation = Quaternion.identity;
        this.transform.GetChild(0).transform.localPosition = Vector3.zero;

        this.transform.GetChild(0).transform.Translate(COLLISION_OFFSET);
        this.transform.GetChild(0).transform.localRotation *= rot;
        this.transform.GetChild(0).transform.Translate(-COLLISION_OFFSET);
    }

    // 左右への平行移動.
    private    Vector3    side_move(Vector3 velocity, float slide_speed_scale)
    {

        if(Input.GetKey(KeyCode.LeftArrow)) {

            velocity.x -= SLIDE_ACCEL*slide_speed_scale*Time.deltaTime;

        } else if(Input.GetKey(KeyCode.RightArrow)) {

            velocity.x += SLIDE_ACCEL*slide_speed_scale*Time.deltaTime;

        } else {

            // 左右キーがどちらも押されていないときは、速度０に戻る.

            if(velocity.x > 0.0f) {

                velocity.x -= SLIDE_ACCEL*slide_speed_scale*Time.deltaTime;

                velocity.x = Mathf.Max(velocity.x, 0.0f);

            } else {

                velocity.x += SLIDE_ACCEL*slide_speed_scale*Time.deltaTime;

                velocity.x = Mathf.Min(velocity.x, 0.0f);
            }
        }

        velocity.x = Mathf.Clamp(velocity.x, -SLIDE_SPEED_MAX, SLIDE_SPEED_MAX);

        return(velocity);
    }

    // 左右への平行移動（自動運転）.
    private    Vector3    side_move_auto_drive(Vector3 velocity, float slide_speed_scale)
    {
        const float        center_x = 0.0001f;

        if(this.transform.position.x > center_x) {

            velocity.x -= SLIDE_ACCEL*slide_speed_scale*Time.deltaTime;

        } else if(this.transform.position.x < -center_x) {

            velocity.x += SLIDE_ACCEL*slide_speed_scale*Time.deltaTime;

        } else {

            // 左右キーがどちらも押されていないときは、速度０に戻る.

            if(velocity.x > 0.0f) {

                velocity.x -= SLIDE_ACCEL*slide_speed_scale*Time.deltaTime;

                velocity.x = Mathf.Max(velocity.x, 0.0f);

            } else {

                velocity.x += SLIDE_ACCEL*slide_speed_scale*Time.deltaTime;

                velocity.x = Mathf.Min(velocity.x, 0.0f);
            }
        }

        // 真中に近づいてきたら、徐々に横移動が少なくなる（直進に近くなる）ように.
        velocity.x = Mathf.Clamp(velocity.x, -Mathf.Abs(this.transform.position.x), Mathf.Abs(this.transform.position.x));


        velocity.x = Mathf.Clamp(velocity.x, -SLIDE_SPEED_MAX, SLIDE_SPEED_MAX);

        return(velocity);
    }    
    
    // 自動運転開始（クリアー後）.
    public void    beginAutoDrive()
    {
        this.is_auto_drive = true;
    }

}

using UnityEngine;
using System.Collections;

/// <summary>
/// 控制所有的房间(房间模型的移动等)
/// </summary>
public class RoomControl : MonoBehaviour {

    public GameObject    roomPrefab = null;
    public GameObject    shojiPrefab = null;

    private FloorControl[]    rooms;

    // カメラ.
    private GameObject main_camera = null;

    public static float    MODEL_LENGTH   = 15.0f;
    public static float    MODEL_Z_OFFSET = 0.0f;

    public static float    RESTART_Z_OFFSET = 5.0f;        //リスタート位置のオフセット.

    public static int    MODEL_NUM = 3;

    private int        start_model_index = 0;                // いちばん手前にあるモデルのインデックス.

    private LevelControl    level_control;
    private    ShojiControl    shoji_control;                // 障子（ひとつを使いまわす）.
    private    SceneControl    scene_control;

    private int        room_count = 0;                        // 進んだ部屋の数.
    private    bool    is_closed = false;                    // 障子が閉まった？（次の部屋へ進むごとにリセット）.

    // ---------------------------------------------------------------- //
    
    // Sound
    public AudioClip CLOSE_SOUND = null;
    public AudioClip CLOSE_END_SOUND = null;
    
    // ---------------------------------------------------------------- //

    // Use this for initialization
    void Start () {

        this.rooms = new FloorControl[MODEL_NUM];

        for(int i = 0;i < 3;i++) {
    
            this.rooms[i] = (Instantiate(this.roomPrefab) as GameObject).GetComponent<FloorControl>();

            this.rooms[i].transform.position = new Vector3(0.0f, 0.0f, MODEL_Z_OFFSET + (float)i*MODEL_LENGTH);
        }

        this.start_model_index = 0;

        this.rooms[(this.start_model_index + 0)%MODEL_NUM].setOpen();
        this.rooms[(this.start_model_index + 1)%MODEL_NUM].setOpen();
        this.rooms[(this.start_model_index + 2)%MODEL_NUM].setClose();

        this.shoji_control = (Instantiate(this.shojiPrefab) as GameObject).GetComponent<ShojiControl>();

        this.rooms[(this.start_model_index + 0)%MODEL_NUM].attachShouji(this.shoji_control);

        //

        // カメラのインスタンスを探しておく.
        this.main_camera = GameObject.FindGameObjectWithTag("MainCamera");

        this.scene_control = this.main_camera.GetComponent<SceneControl>();

        this.level_control = GameObject.FindGameObjectWithTag("GameController").GetComponent<LevelControl>();
    }

    // Update is called once per frame
    void     Update()
    {
        FloorControl    room = this.rooms[this.start_model_index];

        // 一番後ろのモデルがカメラの後ろに来たら、奥に移動させる.
        //
        if(room.transform.position.z + MODEL_LENGTH < this.main_camera.transform.position.z) {

            // 一番後ろのモデルを奥に移動させる.

            Vector3        new_position = room.transform.position;

            new_position.z += MODEL_LENGTH*MODEL_NUM;

            room.transform.position = new_position;

            //

            this.rooms[(this.start_model_index + 0)%MODEL_NUM].attachShouji(null);

            // 「一番手前にあるモデルのインデックス」を進める.
            //
            this.start_model_index = (this.start_model_index + 1)%MODEL_NUM;


            // 一番手前の部屋　→　障子をアタッチして、開けた状態にしておく.

            if(this.scene_control.step == SceneControl.STEP.GAME) {

                this.rooms[(this.start_model_index + 0)%MODEL_NUM].attachShouji(this.shoji_control);
                this.rooms[(this.start_model_index + 0)%MODEL_NUM].setOpen();
                
            } else {

                this.shoji_control.gameObject.SetActive(false);
            }

            // 二番目の部屋　→　ふすまを開き始める.

            this.rooms[(this.start_model_index + 1)%MODEL_NUM].beginOpen();

            // 三番目番目の部屋　→　ふすまが閉めきった状態にする.

            this.rooms[(this.start_model_index + 2)%MODEL_NUM].setClose();

            // 何度も通過した穴を鉄板にする.

            foreach(var paper_control in this.shoji_control.papers) {

                if(this.level_control.getChangeSteelCount() > 0) {

                    if(paper_control.through_count >= this.level_control.getChangeSteelCount()) {

                        paper_control.beginSteel();
                    }
                }
            }

            //

            this.room_count++;
            this.is_closed = false;
        }

        // カメラが近づいたら、閉める.
        //
        // 本当はプレイヤーを見るべきだけど、部屋モデルのリピート処理がカメラを.
        // みている関係上、こちらもカメラを見る.

        float    close_distance = MODEL_LENGTH - this.level_control.getCloseDistance();

        if(room.transform.position.z + close_distance < this.main_camera.transform.position.z) {

            do {

                if(this.is_closed) {

                    break;
                }

                // スタート直後は閉まらないようにする.
                if(this.room_count < 1) {

                    break;
                }

                // 障子を閉める.
    
                if(this.scene_control.step == SceneControl.STEP.GAME) {
    
                    FloorControl.CLOSING_PATTERN_TYPE    type;
                    bool                                is_flip;
                    FloorControl.ClosingPatternParam    param;

                    this.level_control.getClosingPattern(out type, out is_flip, out param);

                    this.rooms[(this.start_model_index + 0)%MODEL_NUM].setClosingPatternType(type, is_flip, param);
                    this.rooms[(this.start_model_index + 0)%MODEL_NUM].beginCloseShoji();
                }

                this.is_closed = true;

            } while(false);
        }

    #if false
        // デバッグ機能.
        // フルキーの数字キーで、障子の登場パターンを再生する.

        for(int i = (int)KeyCode.Alpha1;i <= (int)KeyCode.Alpha9;i++) {

            if(Input.GetKeyDown((KeyCode)i)) {

                FloorControl.CLOSING_PATTERN_TYPE    type = (FloorControl.CLOSING_PATTERN_TYPE)(i - (int)KeyCode.Alpha1);

                bool    is_flip = Input.GetKey(KeyCode.RightShift);

                this.rooms[(this.start_model_index + 0)%MODEL_NUM].attachShouji(this.shoji_control);
                this.rooms[(this.start_model_index + 0)%MODEL_NUM].setClosingPatternType(type, is_flip);
                this.rooms[(this.start_model_index + 0)%MODEL_NUM].beginCloseShoji();
            }
        }
    #endif
    }

    public void    onRestart()
    {
        this.room_count = 0;
        this.is_closed = false;

        this.rooms[(this.start_model_index + 0)%MODEL_NUM].attachShouji(this.shoji_control);
        this.rooms[(this.start_model_index + 0)%MODEL_NUM].setOpen();
        this.rooms[(this.start_model_index + 1)%MODEL_NUM].setOpen();
        this.rooms[(this.start_model_index + 2)%MODEL_NUM].setClose();
    }

    // ミスした後のリスタート位置を取得する.
    public Vector3    getRestartPosition()
    {
        Vector3    position;

        position = this.rooms[this.start_model_index].transform.position;

        position.z += RESTART_Z_OFFSET;

        return(position);
    }

    // 紙ののこり枚数を取得する.
    public int    getPaperNum()
    {
        return(this.shoji_control.getPaperNum());
    }
}

using UnityEngine;
using System.Collections;

/// <summary>
/// 游戏流程管理
/// </summary>
public class SceneControl : MonoBehaviour {

    public enum STEP {

        NONE = -1,

        GAME = 0,            // ゲーム中.
        GAMEOVER,            // ゲームオーバー.
        CLEAR,                // ゲームクリアー.

        NUM,
    };

    public STEP            step      = STEP.NONE;
    public STEP            next_step = STEP.NONE;
    public float        step_timer = 0.0f;

    // ---------------------------------------------------------------- //

    private int    combo_count = 0;        // コンボカウント　連続して紙をやぶった回数.
        
    // Life Setting
    public Texture2D LifeTexture = null;    
    public static int init_lifecnt = 5;
    public static int lifecnt = init_lifecnt;

    public Texture2D FailedTexture = null;
    public Texture2D Combo01Texture = null;
    public Texture2D Combo02Texture = null;
    public Texture2D EndTexture = null;
    
    private float TextureWidth  = 0.0f;
    private float TextureHeight = 0.0f;
    private float TextureScale = 200.0f;

    private float TextureX  = 10.0f;
    private float TextureY = 480.0f;
    private float TexturePosScale = 600.0f;
    
    // ---------------------------------------------------------------- //

    public bool        clearflg = false;            // 「おしまい」表示中？.
    public float    clear_timer = 0.0f;

    public enum COMBO {

        FAILED = -1,
        NORMAL = 0,
        
        CHAIN01,
        CHAIN02,
    };

    public COMBO combo = COMBO.NORMAL;

    // ---------------------------------------------------------------- //
    // Audio
    public AudioClip COMBO_SOUND_01 = null;
    public AudioClip COMBO_SOUND_02 = null;
    public AudioClip COMBO_SOUND_03 = null;
    
    public AudioClip CLEAR_SOUND = null;
    public AudioClip CLEAR_NEKO_SOUND = null;
    public AudioClip CLEAR_LOOP_SOUND = null;
    public AudioClip GAMEOVER_SOUND = null;
    public AudioClip GAMEOVER_NEKO_SOUND = null;

    public NekoControl    neko_control = null;
    public RoomControl    room_control = null;

    // ---------------------------------------------------------------- //
    // Syouji Setting
    public Transform syouji = null;
    public Transform syouji_paper = null;
    public GameObject syouji_steel = null;
    private int SyoujiCnt = 0;
    
    // ---------------------------------------------------------------- //

    // Use this for initialization
    void Start () {

        this.neko_control = GameObject.FindGameObjectWithTag("NekoPlayer").GetComponent<NekoControl>();

        this.room_control = GameObject.FindGameObjectWithTag("RoomControl").GetComponent<RoomControl>();

        this.clearflg = false;
    }
    
    // Update is called once per frame
    void Update () {

        this.step_timer += Time.deltaTime;

        // ---------------------------------------------------------------- //
        // 次の状態に移るかどうかを、チェックする.

        if(this.next_step == STEP.NONE) {

            switch(this.step) {
    
                case STEP.NONE:
                {
                    this.next_step = STEP.GAME;
                }
                break;

                case STEP.GAME:
                {
                    int        shoji_num = this.getPaperNum();

                    if(shoji_num == 0) {

                        this.next_step = STEP.CLEAR;
                    }

                    if(this.getLifeCount() <= 0) {

                        this.next_step = STEP.GAMEOVER;
                    }
                }
                break;
            }
        }

        // ---------------------------------------------------------------- //
        // 状態が遷移したときの初期化.

        if(this.next_step != STEP.NONE) {

            switch(this.next_step) {
    
                case STEP.GAME:
                {
                    this.clearComboCount();
                    this.clear_timer = 0.0f;
                    lifecnt = init_lifecnt;
                }
                break;

                case STEP.CLEAR:
                {
                    // 自動運転開始.
                    this.neko_control.beginAutoDrive();
                    StartCoroutine("gameClear");
                }
                break;

                case STEP.GAMEOVER:
                {
                    // 「おしまい」をすぐに表示.
                    this.clearflg = true;
                }
                break;
            }

            this.step      = this.next_step;
            this.next_step = STEP.NONE;

            this.step_timer = 0.0f;
        }

        // ---------------------------------------------------------------- //
        // 各状態での実行処理.

        switch(this.step) {

            case STEP.CLEAR:
            {
                if(!this.clearflg) {

                    // 一定時間たったら、「おしまい」を自動的に表示.
                    if(this.step_timer > CLEAR_NEKO_SOUND.length + CLEAR_SOUND.length + CLEAR_LOOP_SOUND.length) {

                        this.clearflg = true;
                    }
                }
            }
            break;
            
        }

        // ---------------------------------------------------------------- //
    }

    
    void OnGUI () {

        if(!LifeTexture) {
            
            Debug.LogError("A Texture is not assigned.");
            return;
        }

        for ( int i = 0; i < lifecnt - 1; i++ ) {
        
            GUI.Label(new Rect(10, 4*Screen.height/5-25*i, LifeTexture.width/2, LifeTexture.height/2), LifeTexture);
            
        }
        
        if ( lifecnt > 0 ) {
            
            switch(this.combo) {
    
                case COMBO.FAILED:
                {
                    this.TextureWidth  -= this.TextureScale*Time.deltaTime;
                    this.TextureWidth   = Mathf.Clamp(this.TextureWidth, FailedTexture.width/8, Combo02Texture.width/6);
                    this.TextureHeight -= this.TextureScale*Time.deltaTime;
                    this.TextureHeight  = Mathf.Clamp(this.TextureHeight, FailedTexture.height/8, Combo02Texture.height/6);

                    this.TextureX += this.TexturePosScale*Time.deltaTime;
                    this.TextureX  = Mathf.Clamp(this.TextureX, 0, 10);
                    this.TextureY += this.TexturePosScale*Time.deltaTime;
                    this.TextureY  = Mathf.Clamp(this.TextureY, 4*Screen.height/5-35*(lifecnt - 1), 4*Screen.height/5-25*(lifecnt - 1));
                
                    GUI.Label(new Rect(this.TextureX, this.TextureY, this.TextureWidth, this.TextureHeight), FailedTexture);
                }
                break;

                case COMBO.NORMAL:
                {
                    this.TextureWidth  -= this.TextureScale*Time.deltaTime;
                    this.TextureWidth   = Mathf.Clamp(this.TextureWidth, LifeTexture.width/2, Combo02Texture.width/6);
                    this.TextureHeight -= this.TextureScale*Time.deltaTime;
                    this.TextureHeight  = Mathf.Clamp(this.TextureHeight, LifeTexture.height/2, Combo02Texture.height/6);

                    this.TextureX += this.TexturePosScale*Time.deltaTime;
                    this.TextureX  = Mathf.Clamp(this.TextureX, 0, 10);
                    this.TextureY += this.TexturePosScale*Time.deltaTime;
                    this.TextureY  = Mathf.Clamp(this.TextureY, 4*Screen.height/5-35*(lifecnt - 1), 4*Screen.height/5-25*(lifecnt - 1));
                
                    GUI.Label(new Rect(this.TextureX, this.TextureY, this.TextureWidth, this.TextureHeight), LifeTexture);
                }
                break;

                case COMBO.CHAIN01:
                {
                    this.TextureWidth  += this.TextureScale*Time.deltaTime;
                    this.TextureWidth   = Mathf.Clamp(this.TextureWidth, LifeTexture.width/2, Combo01Texture.width/6);
                    this.TextureHeight += this.TextureScale*Time.deltaTime;
                    this.TextureHeight  = Mathf.Clamp(this.TextureHeight, LifeTexture.height/2, Combo01Texture.height/6);

                    this.TextureX -= this.TexturePosScale*Time.deltaTime;
                    this.TextureX  = Mathf.Clamp(this.TextureX, 7, 10);
                    this.TextureY -= this.TexturePosScale*Time.deltaTime;
                    this.TextureY  = Mathf.Clamp(this.TextureY, 4*Screen.height/5-21*lifecnt, 4*Screen.height/5-14*lifecnt);
                
                    GUI.Label(new Rect(this.TextureX, this.TextureY, this.TextureWidth, this.TextureHeight), Combo01Texture);
                }
                break;

                case COMBO.CHAIN02:
                {
                    this.TextureWidth  += this.TextureScale*Time.deltaTime;
                    this.TextureWidth   = Mathf.Clamp(this.TextureWidth, Combo01Texture.width/6, Combo02Texture.width/4);
                    this.TextureHeight += this.TextureScale*Time.deltaTime;
                    this.TextureHeight  = Mathf.Clamp(this.TextureHeight, Combo01Texture.height/6, Combo02Texture.height/4);

                    this.TextureX -= this.TexturePosScale*Time.deltaTime;
                    this.TextureX  = Mathf.Clamp(this.TextureX, 0, 7);
                    this.TextureY -= this.TexturePosScale*Time.deltaTime;
                    this.TextureY  = Mathf.Clamp(this.TextureY, 4*Screen.height/5-28*lifecnt, 4*Screen.height/5-24*lifecnt);

                    GUI.Label(new Rect(this.TextureX, this.TextureY, this.TextureWidth, this.TextureHeight), Combo02Texture);
                }
                break;
            }
        }

        // Count SyoujiPaper from Tags
        SyoujiCnt = this.getPaperNum();
        
        if((SyoujiCnt <= 0) || (lifecnt <=0)) {

            if ( Input.GetMouseButton(0) ) {
    
                this.clearflg = true;

            }

            if (this.clearflg) {
    
                this.clear_timer += Time.deltaTime;
    
                GUI.Label(new Rect(64, 112, EndTexture.width, EndTexture.height), EndTexture);

                if ( (Input.GetMouseButton(0)) && (clear_timer > 1.0f)) {

                    Application.LoadLevel("TitleScene");
                }
            }
        }

        //
    }
    
    void applyDamage(int damage) {

        this.clearComboCount();
        lifecnt -= damage;
        
        if ( lifecnt <= 0 ) {

            StartCoroutine("gameOver");
        }
    }
    
    void nekoFailed() {

        this.combo = COMBO.FAILED;
    }

    public int getLifeCount()
    {
        return(SceneControl.lifecnt);
    }

    // 紙の残り枚数を取得する.
    public int getPaperNum()
    {
        return(this.room_control.getPaperNum());
    }

    // コンボカウントプラス.
    public void    addComboCount()
    {
        this.combo_count++;
        
        switch(this.combo_count) {
            
            case 0:
            {
                GetComponent<AudioSource>().clip = COMBO_SOUND_01;
            }
            break;

            case 1:
            {
                GetComponent<AudioSource>().clip = COMBO_SOUND_01;
            }
            break;

            case 2:
            {
                GetComponent<AudioSource>().clip = COMBO_SOUND_02;
                this.combo = COMBO.CHAIN01;
            }
            break;

            default:
            {
                GetComponent<AudioSource>().clip = COMBO_SOUND_03;
                this.combo = COMBO.CHAIN02;
            }
            break;

        }
        
        GetComponent<AudioSource>().Play();
    }

    // コンボカウントを０にする.
    public void    clearComboCount()
    {
        this.combo_count = 0;
        this.combo = COMBO.NORMAL;
    }
    
    private IEnumerator gameClear()
    {
        GetComponent<AudioSource>().clip = CLEAR_NEKO_SOUND;
        GetComponent<AudioSource>().Play();

        yield return new WaitForSeconds(CLEAR_NEKO_SOUND.length);
        GetComponent<AudioSource>().clip = CLEAR_SOUND;
        GetComponent<AudioSource>().Play();

        yield return new WaitForSeconds(CLEAR_SOUND.length);
        GetComponent<AudioSource>().clip = CLEAR_LOOP_SOUND;
        GetComponent<AudioSource>().loop = true;
        GetComponent<AudioSource>().Play();
    }
    
    private IEnumerator gameOver()
    {
        GetComponent<AudioSource>().clip = GAMEOVER_NEKO_SOUND;
        GetComponent<AudioSource>().Play();

        yield return new WaitForSeconds(GAMEOVER_NEKO_SOUND.length);
        GetComponent<AudioSource>().clip = GAMEOVER_SOUND;
        GetComponent<AudioSource>().Play();
    }
    
}

using UnityEngine;
using System.Collections;

/// <summary>
/// 控制窗户
/// </summary>
public class ShojiControl:MonoBehaviour {

    /// <summary>
    /// 洞索引
    /// </summary>
    public struct HoleIndex {
        /// <summary>
        /// x
        /// </summary>
        public int x;
        /// <summary>
        /// y
        /// </summary>
        public int y;

    };

    /// <summary>
    /// 初始x位置
    /// </summary>
    public float init_x = 0.0f;
    /// <summary>
    /// 初始y位置
    /// </summary>
    public float init_y = 2.0f;
    /// <summary>
    /// 初始z位置
    /// </summary>
    public float init_z = 5.0f;

    // 床の幅（Z方向）.
    public static float WIDTH = 15.0f;

    // プレイヤーとの距離 (DIST < WIDTH).
    public float DIST = 10.0f;

    // 自オブジェクト移動距離.
    public static float MOVE = 0.1f;

    // 自オブジェクトニュートラルポジション.
    public Vector3 neutral_position;

    public GameObject paperPrefab;

    /// <summary>
    /// 窗户纸二维数组
    /// </summary>
    public SyoujiPaperControl[,] papers;

    /// <summary>
    /// 窗户纸x轴大小
    /// </summary>
    public static float TILE_SIZE_X = 0.85f;
    /// <summary>
    /// 窗户纸y轴大小
    /// </summary>
    public static float TILE_SIZE_Y = 0.94f;
    /// <summary>
    /// 窗户纸原始x
    /// </summary>
    public static float TILE_ORIGIN_X = -0.85f;
    /// <summary>
    /// 窗户纸原始y
    /// </summary>
    public static float TILE_ORIGIN_Y = 1.92f;

    /// <summary>
    /// x轴上窗户纸数量
    /// </summary>
    public static int TILE_NUM_X = 3;
    /// <summary>
    /// y轴上窗户纸数量
    /// </summary>
    public static int TILE_NUM_Y = 3;

    /// <summary>
    /// 窗户纸数量
    /// </summary>
    public int paper_num = TILE_NUM_X * TILE_NUM_Y;


    void Start() {

        this.neutral_position = this.transform.position;

        this.papers = new SyoujiPaperControl[TILE_NUM_X,TILE_NUM_Y];

        for(int x = 0;x < TILE_NUM_X;x++) {
            for(int y = 0;y < TILE_NUM_Y;y++) {
                //实例化窗户纸预设
                GameObject go = Instantiate(this.paperPrefab) as GameObject;
                go.transform.parent = this.transform;

                //根据纸的索引计算实际显示的位置
                Vector3 position = go.transform.localPosition;
                position.x = TILE_ORIGIN_X + x * TILE_SIZE_X;
                position.y = TILE_ORIGIN_Y + y * TILE_SIZE_Y;
                position.z = 0.0f;
                go.transform.localPosition = position;

                //设置窗户纸的控制脚本
                SyoujiPaperControl paper_control = go.GetComponent<SyoujiPaperControl>();
                paper_control.shoji_control = this;
                paper_control.hole_index.x = x;
                paper_control.hole_index.y = y;

                this.papers[x,y] = paper_control;
            }
        }
        this.paper_num = this.papers.Length;
    }

    void Update() {

    }

    /// <summary>
    /// 窗户纸被破坏
    /// </summary>
    public void onPaperBreak() {
        //窗户纸数量减1
        this.paper_num--;
        //保证窗户纸数量不小于0
        this.paper_num = Mathf.Max(0,this.paper_num);

        // 空振りカウンター（破れた後に通過した回数）をリセットする.
        //
        // 1.紙Aをやぶる
        // 2.紙Aを通過（紙Aの空振りカウンターが増加）
        // 3.紙Bをやぶる
        // 4.紙Bを通過　←このタイミングで紙Aが鉄板化してしまうことがあるので.

        for(int x = 0;x < TILE_NUM_X;x++) {

            for(int y = 0;y < TILE_NUM_Y;y++) {

                this.papers[x,y].resetThroughCount();
            }
        }
    }

    // 紙の残り枚数を取得する.
    public int getPaperNum() {
        return (this.paper_num);
    }

    // 『格子の穴』インデックスが有効？.
    public bool isValidHoleIndex(HoleIndex hole_index) {
        bool ret = false;

        do {

            ret = false;

            if(hole_index.x < 0 || TILE_NUM_X <= hole_index.x) {

                break;
            }
            if(hole_index.y < 0 || TILE_NUM_Y <= hole_index.y) {

                break;
            }

            ret = true;

        } while(false);

        return (ret);
    }

    // いちばん近い『格子の穴』を取得する.
    public HoleIndex getClosetHole(Vector3 position) {
        HoleIndex hole_index;

        position = this.transform.InverseTransformPoint(position);

        hole_index.x = Mathf.RoundToInt((position.x - TILE_ORIGIN_X) / TILE_SIZE_X);
        hole_index.y = Mathf.RoundToInt((position.y - TILE_ORIGIN_Y) / TILE_SIZE_Y);

        return (hole_index);
    }

    // 『格子の穴』の位置座標を取得する.
    public Vector3 getHoleWorldPosition(int hole_pos_x,int hole_pos_y) {
        Vector3 position;

        position.x = (float)hole_pos_x * TILE_SIZE_X + TILE_ORIGIN_X;
        position.y = (float)hole_pos_y * TILE_SIZE_Y + TILE_ORIGIN_Y;
        position.z = 0.0f;

        position = this.transform.TransformPoint(position);

        return (position);
    }

}

using UnityEngine;
using System.Collections;

/// <summary>
/// 窗户,拉门的共通处理
/// </summary>
public class ShutterControl:MonoBehaviour {

    /// <summary>
    /// 设置x位置
    /// </summary>
    public void setX(float x) {
        Vector3 position = this.transform.localPosition;
        position.x = x;
        this.transform.localPosition = position;
    }
}

//using UnityEngine;
using System.Collections;

// std::vector っぽい配列（ただしサイズは固定、値型じゃないとだめかも）.
public class StaticArray<T> {


    public StaticArray(int max_num)
    {
        this.entity = new T[max_num];

        this.num_max     = max_num;
        this.num_current = 0;

    }

    //

    public void        push_back(T x)
    {
        if(this.num_current < this.num_max) {

            this.entity[this.num_current++] = x;
        }
    }
    public int        size()
    {
        return(this.num_current);
    }
    public int        capacity()
    {
        return(this.num_max);
    }
    public bool        full()
    {
        return(this.num_current >= this.num_max);
    }

    public void        resize(int size)
    {
        this.num_current = size;
    }
    public void        clear()
    {
        this.resize(0);
    }

    public void        erase_by_index(int index)
    {
        for(int i = index;i < this.num_current - 1;i++) {

            this.entity[i] = this.entity[i + 1];
        }

        this.num_current--;
    }

    public void        swap(int i, int j)
    {
        T    temp;

        temp           = this.entity[i];
        this.entity[i] = this.entity[j];
        this.entity[j] = temp;
    }

    public T    this[int i]
    {
        get { return(this.entity[i]); }
        set { this.entity[i] = value; }
    } 
    public IEnumerator GetEnumerator()
    {
        int        i = 0;

        for(i = 0;i < this.num_max;i++) {

            yield return(this.entity[i]);
        }
    }

    private int        num_max;
    private int        num_current;

    private T[]        entity;
};

using UnityEngine;
using System.Collections;

/// <summary>
/// 播放猫的脚步声
/// </summary>
public class StepSoundControl:MonoBehaviour {

    /// <summary>
    /// 行走声音1
    /// </summary>
    public AudioClip stepSE1 = null;
    /// <summary>
    /// 行走声音2
    /// </summary>
    public AudioClip stepSE2 = null;

    /// <summary>
    /// 当前行走声音
    /// </summary>
    public int step_sound_sel = 0;

    void Start() {
        //给动画剪辑添加播放声音事件
        AnimationEvent ev = new AnimationEvent();
        ev.time = this.GetComponent<Animation>()["M02_nekodash"].clip.length / 2.0f; ;
        ev.functionName = "PlayStepSound";
        this.GetComponent<Animation>()["M02_nekodash"].clip.AddEvent(ev);
    }

    /// <summary>
    /// 播放声音
    /// </summary>
    public void PlayStepSound(AnimationEvent ev) {
        if(this.step_sound_sel == 0) {
            this.GetComponent<AudioSource>().PlayOneShot(this.stepSE1);
        } else {
            this.GetComponent<AudioSource>().PlayOneShot(this.stepSE2);
        }
        this.step_sound_sel = (this.step_sound_sel + 1) % 2;
    }
}

using UnityEngine;
using System.Collections;

/// <summary>
/// 控制单张窗户纸(状态[普通/破损/铁板]管理等)
/// </summary>
public class SyoujiPaperControl:MonoBehaviour {

    /// <summary>
    /// 木窗纸状态
    /// </summary>
    public enum STEP {
        /// <summary>
        /// 默认
        /// </summary>
        NONE = -1,
        /// <summary>
        /// 纸
        /// </summary>
        PAPER = 0,
        /// <summary>
        /// 损坏
        /// </summary>
        BROKEN,
        /// <summary>
        /// 铁
        /// </summary>
        STEEL,
    };

    /// <summary>
    /// 当前状态
    /// </summary>
    public STEP step = STEP.NONE;
    /// <summary>
    /// 下一个状态
    /// </summary>
    public STEP next_step = STEP.NONE;
    /// <summary>
    /// 状态计时器
    /// </summary>
    public float step_timer = 0.0f;

    /// <summary>
    /// 流程管理
    /// </summary>
    private SceneControl scene_control = null;
    /// <summary>
    /// 窗户控制
    /// </summary>
    public ShojiControl shoji_control = null;

    /// <summary>
    /// 在木窗中的洞索引
    /// </summary>
    public ShojiControl.HoleIndex hole_index;

    /// <summary>
    /// 纸
    /// </summary>
    public GameObject paper_object = null;
    /// <summary>
    /// 破坏的纸
    /// </summary>
    public GameObject broken_object = null;
    /// <summary>
    /// 铁
    /// </summary>
    public GameObject steel_object = null;

    /// <summary>
    /// 成功穿过的声音
    /// </summary>
    public AudioClip SUCCESS_SOUND = null;

    /// <summary>
    /// 穿过的次数
    /// </summary>
    public int through_count = 0;

    void Start() {
        //查找场景管理
        this.scene_control = GameObject.FindWithTag("MainCamera").GetComponent<SceneControl>();
        //设置子物体
        for(int i = 0;i < this.transform.childCount;i++) {
            GameObject child = this.transform.GetChild(i).gameObject;
            switch(child.tag) {
            case "SyoujiPaper": {
                    this.paper_object = child;
                }
                break;
            case "SyoujiPaperBroken": {
                    this.broken_object = child;
                }
                break;
            case "SyoujiSteel": {
                    this.steel_object = child;
                }
                break;
            }
        }

        this.paper_object.SetActive(false);
        this.broken_object.SetActive(false);
        this.steel_object.SetActive(false);

        //设置下一个状态为纸
        this.next_step = STEP.PAPER;
    }

    void Update() {
        //计时器加上本帧时间
        this.step_timer += Time.deltaTime;

        //根据下一个状态设置 子物体的显隐
        if(this.next_step != STEP.NONE) {
            switch(this.next_step) {
            case STEP.PAPER: {
                    this.paper_object.SetActive(true);
                    this.broken_object.SetActive(false);
                    this.steel_object.SetActive(false);
                }
                break;
            case STEP.BROKEN: {
                    this.paper_object.SetActive(false);
                    this.broken_object.SetActive(true);
                    this.steel_object.SetActive(false);
                    //播放成功声音
                    this.GetComponent<AudioSource>().PlayOneShot(SUCCESS_SOUND);
                }
                break;
            case STEP.STEEL: {
                    this.paper_object.SetActive(false);
                    this.broken_object.SetActive(false);
                    this.steel_object.SetActive(true);
                }
                break;
            }

            //当前状态设为下一个状态
            this.step = this.next_step;
            //重置下一个状态
            this.next_step = STEP.NONE;
            //重置状态计时器
            this.step_timer = 0.0f;
        }
    }

    /// <summary>
    /// 铁状态
    /// </summary>
    public void beginSteel() {
        this.next_step = STEP.STEEL;
    }

    /// <summary>
    /// 是否是铁
    /// </summary>
    public bool isSteel() {
        bool ret;
        ret = (this.step == STEP.STEEL);
        return (ret);
    }

    /// <summary>
    /// 重置穿越次数
    /// </summary>
    public void resetThroughCount() {
        this.through_count = 0;
    }

    /// <summary>
    /// 处理玩家碰撞
    /// </summary>
    public void onPlayerCollided() {
        //判断当前状态
        switch(this.step) {
        //纸
        case STEP.PAPER: {
                //下一个状态为破坏的纸
                this.next_step = STEP.BROKEN;
                //场景管理添加连击
                this.scene_control.addComboCount();
                //木窗控制调用纸被破坏事件
                this.shoji_control.onPaperBreak();
                //创建木窗破坏特效
                this.scene_control.neko_control.effect_control.createBreakEffect(this,this.scene_control.neko_control);
            }
            break;
        //破坏的纸
        case STEP.BROKEN: {
                //添加穿过次数
                this.through_count++;
                //场景控制 清空连击数
                this.scene_control.clearComboCount();
            }
            break;
        }
    }
}

using UnityEngine;
using System.Collections;

/// <summary>
/// 主题画面
/// </summary>
public class TitleControl:MonoBehaviour {
    /// <summary>
    /// 标题纹理
    /// </summary>
    public Texture2D TitleTexture = null;
    /// <summary>
    /// 简单纹理
    /// </summary>
    public Texture2D TitleEasy = null;
    /// <summary>
    /// 普通纹理
    /// </summary>
    public Texture2D TitleNormal = null;
    /// <summary>
    /// 难纹理
    /// </summary>
    public Texture2D TitleHard = null;

    /// <summary>
    /// 是否按下play按钮
    /// </summary>
    private bool PlayButtonPushed = false;

    void Start() {
        PlayButtonPushed = false;
    }

    void Update() {

    }

    void OnGUI() {
        //没有标题,debug
        if(!TitleTexture) {
            Debug.LogError("Assign a Texture in the inspector.");
            return;
        }
        //画标题纹理
        GUI.DrawTexture(new Rect(0,0,TitleTexture.width,TitleTexture.height),TitleTexture);

        //简单按钮
        if(GUI.Button(new Rect(0,3 * Screen.height / 4 - TitleEasy.height / 2 + 40,TitleEasy.width,TitleEasy.height),TitleEasy,GUI.skin.label)) {
            if(!PlayButtonPushed) {
                PlayButtonPushed = true;
                GlobalParam.GetInstance().SetMode(0);
                Application.LoadLevel("GameScene");
            }
        }
        //正常按钮
        if(GUI.Button(new Rect(Screen.width / 2 - TitleNormal.width / 2,3 * Screen.height / 4 - TitleNormal.height / 2 + 40,TitleNormal.width,TitleNormal.height),TitleNormal,GUI.skin.label)) {
            if(!PlayButtonPushed) {
                PlayButtonPushed = true;
                GlobalParam.GetInstance().SetMode(1);
                Application.LoadLevel("GameScene");
            }
        }
        //难按钮
        if(GUI.Button(new Rect(Screen.width - TitleHard.width,3 * Screen.height / 4 - TitleHard.height / 2 + 40,TitleHard.width,TitleHard.height),TitleHard,GUI.skin.label)) {
            if(!PlayButtonPushed) {
                PlayButtonPushed = true;
                GlobalParam.GetInstance().SetMode(2);
                Application.LoadLevel("GameScene");
            }
        }
    }

}

视频:https://pan.baidu.com/s/1geBDjJP

项目:https://pan.baidu.com/s/1eSooRWA