Esempio n. 1
0
 public void efInit()
 {
     this.curKeyFrameIdx_ = this.startKeyFrameIdx_;
     this.curKey_FrameCt  = 0;
     this.curKey_DelayCt  = 0;
     this.curKey_FrameMax = (int)this.getCurKey_FrameMax();
     this.curKey_DelayMax = (int)this.getCurKey_DelayMax();
     this.curFrameValue_  = this.keyFrame_[this.curKeyFrameIdx_].Clone();
 }
 private void Update()
 {
     if (!this.fadeEfcStart_)
     {
         this.fadeEfcBase_.efStart();
         this.fadeEfcStart_ = true;
     }
     if (!this.fadeEfcBase_.efIsEnd())
     {
         EFFECT_BASE_KEY_FRAME curFrameValue = this.fadeEfcBase_.getCurFrameValue();
         this.EfcColorW.a     = curFrameValue.col_a * GUIFadeControll.alphaScale;
         this.fadeImage.color = this.EfcColorW;
         if (!GUIFadeControll.actionStop)
         {
             this.fadeEfcBase_.efUpdate();
         }
         if (this.fadeEfcBase_.efGetCurKeyFrameIdx() == 1 && !this.isLoaded)
         {
             if (this.isBarrier)
             {
                 GUIManager.HideBarrier();
             }
             if (!GUIFadeControll.isExecuteFadeIn)
             {
                 if (GUIFadeControll.fadeAction != null)
                 {
                     GUIFadeControll.actionStop = true;
                     GUIFadeControll.fadeAction(0);
                 }
                 else
                 {
                     GUIFadeControll.LoadGUIAll();
                 }
             }
             else
             {
                 GUIFadeControll.actionStop = true;
                 if (GUIFadeControll.fadeAction != null)
                 {
                     GUIFadeControll.fadeAction(0);
                 }
                 GUIFadeControll.LoadGUIAll();
             }
             this.isLoaded = true;
         }
     }
     else
     {
         if (GUIFadeControll.fadeEndAction != null)
         {
             GUIFadeControll.fadeEndAction(0);
         }
         UnityEngine.Object.Destroy(base.gameObject);
         GUIFadeControll.fadeEnd = true;
     }
 }
Esempio n. 3
0
 private void updateFrame()
 {
     if (this.start_)
     {
         if (this.curKey_FrameCt == this.curKey_FrameMax)
         {
             this.curKeyFrameIdx_++;
             if (this.curKeyFrameIdx_ == this.keyFrameNum_ - 1)
             {
                 if (this.loopEna_)
                 {
                     this.curLoopCt_++;
                     if (this.loopCt_ == 0)
                     {
                         this.efInit();
                     }
                     else if (this.curLoopCt_ == this.loopCt_)
                     {
                         this.curLoopCt_ = 0;
                         this.efInit();
                         this.efStop();
                     }
                     else
                     {
                         this.efInit();
                     }
                 }
                 else
                 {
                     this.efInit();
                     this.efStop();
                 }
             }
             else
             {
                 this.curKey_FrameCt  = 0;
                 this.curKey_FrameMax = (int)this.getCurKey_FrameMax();
                 this.curKey_DelayCt  = 0;
                 this.curKey_DelayMax = (int)this.getCurKey_DelayMax();
                 this.curFrameValue_  = this.keyFrame_[this.curKeyFrameIdx_].Clone();
             }
         }
         else if (this.curLoopCt_ > 0 || this.curKey_DelayCt >= this.curKey_DelayMax)
         {
             this.curKey_FrameCt++;
         }
         else
         {
             this.curKey_DelayCt++;
         }
     }
 }
Esempio n. 4
0
    public static EFFECT_BASE_KEY_FRAME[] GetStar00Keys(float ctx, float cty)
    {
        EFFECT_BASE_KEY_FRAME[] array = new EFFECT_BASE_KEY_FRAME[2];
        float      num      = 300f * UnityEngine.Random.value + 10f;
        float      x        = num / 3f;
        Vector3    point    = new Vector3(num, 0f, 0f);
        Vector3    point2   = new Vector3(x, 0f, 0f);
        Quaternion rotation = Quaternion.Euler(0f, 0f, 360f * UnityEngine.Random.value);

        point    = rotation * point;
        point2   = rotation * point2;
        array[0] = new EFFECT_BASE_KEY_FRAME
        {
            move_type_x     = EFCB_TYPE.EFCB_LINEAR,
            move_type_y     = EFCB_TYPE.EFCB_LINEAR,
            move_type_scl_x = EFCB_TYPE.EFCB_LINEAR,
            move_type_scl_y = EFCB_TYPE.EFCB_LINEAR,
            move_type_rot_z = EFCB_TYPE.EFCB_LINEAR,
            move_type_rot_x = EFCB_TYPE.EFCB_LINEAR,
            move_type_rot_y = EFCB_TYPE.EFCB_LINEAR,
            move_type_col   = EFCB_TYPE.EFCB_LINEAR,
            ctr_x           = point2.x,
            ctr_y           = point2.y,
            scl_x           = 1f,
            scl_y           = 1f,
            rot_z           = 0f,
            rot_x           = 0f,
            rot_y           = 0f,
            col_r           = 1f,
            col_g           = 1f,
            col_b           = 1f,
            col_a           = 1f,
            time            = 0f,
            delay           = 0f
        };
        array[1] = new EFFECT_BASE_KEY_FRAME
        {
            move_type_x     = EFCB_TYPE.EFCB_LINEAR,
            move_type_y     = EFCB_TYPE.EFCB_LINEAR,
            move_type_scl_x = EFCB_TYPE.EFCB_LINEAR,
            move_type_scl_y = EFCB_TYPE.EFCB_LINEAR,
            move_type_rot_z = EFCB_TYPE.EFCB_LINEAR,
            move_type_rot_x = EFCB_TYPE.EFCB_LINEAR,
            move_type_rot_y = EFCB_TYPE.EFCB_LINEAR,
            move_type_col   = EFCB_TYPE.EFCB_LINEAR,
            ctr_x           = point.x,
            ctr_y           = point.y,
            scl_x           = 1f,
            scl_y           = 1f,
            rot_z           = 0f,
            rot_x           = 0f,
            rot_y           = 0f,
            col_r           = 1f,
            col_g           = 1f,
            col_b           = 1f,
            col_a           = 0f,
            time            = 2.4f,
            delay           = 0f
        };
        return(array);
    }
Esempio n. 5
0
 public void efAddKeyFrame(EFFECT_BASE_KEY_FRAME KF)
 {
     this.keyFrame_[this.keyFrameNum_] = KF.Clone();
     this.keyFrameNum_++;
 }
Esempio n. 6
0
    private void updateValue()
    {
        EFFECT_BASE_KEY_FRAME effect_BASE_KEY_FRAME  = this.keyFrame_[this.curKeyFrameIdx_];
        EFFECT_BASE_KEY_FRAME effect_BASE_KEY_FRAME2 = this.keyFrame_[this.curKeyFrameIdx_ + 1];
        EFFECT_BASE_KEY_FRAME effect_BASE_KEY_FRAME3 = this.curFrameValue_;
        float curKey_NormalizedTime = this.getCurKey_NormalizedTime();
        float num = 0f;

        switch (effect_BASE_KEY_FRAME.move_type_x)
        {
        case EFCB_TYPE.EFCB_LINEAR:
            num = this.EFC_LNR_01(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.ctr_x - effect_BASE_KEY_FRAME.ctr_x);
            break;

        case EFCB_TYPE.EFCB_FALL_01:
            num = this.EFC_FALL_01(curKey_NormalizedTime, 2) * (effect_BASE_KEY_FRAME2.ctr_x - effect_BASE_KEY_FRAME.ctr_x);
            break;

        case EFCB_TYPE.EFCB_FALL_10:
            num = this.EFC_FALL_10(curKey_NormalizedTime, 2) * (effect_BASE_KEY_FRAME2.ctr_x - effect_BASE_KEY_FRAME.ctr_x);
            break;

        case EFCB_TYPE.EFCB_SIN_01:
            num = this.EFC_SIN_01(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.ctr_x - effect_BASE_KEY_FRAME.ctr_x);
            break;

        case EFCB_TYPE.EFCB_SIN_10:
            num = this.EFC_SIN_10(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.ctr_x - effect_BASE_KEY_FRAME.ctr_x);
            break;

        case EFCB_TYPE.EFCB_SPRING_01:
            num = this.EFC_FALL_01(curKey_NormalizedTime, 3) * (effect_BASE_KEY_FRAME2.ctr_x - effect_BASE_KEY_FRAME.ctr_x);
            break;

        case EFCB_TYPE.EFCB_SPRING_10:
            num = this.EFC_FALL_10(curKey_NormalizedTime, 3) * (effect_BASE_KEY_FRAME2.ctr_x - effect_BASE_KEY_FRAME.ctr_x);
            break;

        case EFCB_TYPE.EFCB_BOMB_01:
            num = this.EFC_BOMB_01(curKey_NormalizedTime, 0.2f) * (effect_BASE_KEY_FRAME2.ctr_x - effect_BASE_KEY_FRAME.ctr_x);
            break;
        }
        effect_BASE_KEY_FRAME3.ctr_x = effect_BASE_KEY_FRAME.ctr_x + num;
        switch (effect_BASE_KEY_FRAME.move_type_y)
        {
        case EFCB_TYPE.EFCB_LINEAR:
            num = this.EFC_LNR_01(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.ctr_y - effect_BASE_KEY_FRAME.ctr_y);
            break;

        case EFCB_TYPE.EFCB_FALL_01:
            num = this.EFC_FALL_01(curKey_NormalizedTime, 2) * (effect_BASE_KEY_FRAME2.ctr_y - effect_BASE_KEY_FRAME.ctr_y);
            break;

        case EFCB_TYPE.EFCB_FALL_10:
            num = this.EFC_FALL_10(curKey_NormalizedTime, 2) * (effect_BASE_KEY_FRAME2.ctr_y - effect_BASE_KEY_FRAME.ctr_y);
            break;

        case EFCB_TYPE.EFCB_SIN_01:
            num = this.EFC_SIN_01(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.ctr_y - effect_BASE_KEY_FRAME.ctr_y);
            break;

        case EFCB_TYPE.EFCB_SIN_10:
            num = this.EFC_SIN_10(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.ctr_y - effect_BASE_KEY_FRAME.ctr_y);
            break;

        case EFCB_TYPE.EFCB_SPRING_01:
            num = this.EFC_FALL_01(curKey_NormalizedTime, 3) * (effect_BASE_KEY_FRAME2.ctr_y - effect_BASE_KEY_FRAME.ctr_y);
            break;

        case EFCB_TYPE.EFCB_SPRING_10:
            num = this.EFC_FALL_10(curKey_NormalizedTime, 3) * (effect_BASE_KEY_FRAME2.ctr_y - effect_BASE_KEY_FRAME.ctr_y);
            break;

        case EFCB_TYPE.EFCB_BOMB_01:
            num = this.EFC_BOMB_01(curKey_NormalizedTime, 0.2f) * (effect_BASE_KEY_FRAME2.ctr_y - effect_BASE_KEY_FRAME.ctr_y);
            break;
        }
        effect_BASE_KEY_FRAME3.ctr_y = effect_BASE_KEY_FRAME.ctr_y + num;
        switch (effect_BASE_KEY_FRAME.move_type_scl_x)
        {
        case EFCB_TYPE.EFCB_LINEAR:
            num = this.EFC_LNR_01(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.scl_x - effect_BASE_KEY_FRAME.scl_x);
            break;

        case EFCB_TYPE.EFCB_FALL_01:
            num = this.EFC_FALL_01(curKey_NormalizedTime, 2) * (effect_BASE_KEY_FRAME2.scl_x - effect_BASE_KEY_FRAME.scl_x);
            break;

        case EFCB_TYPE.EFCB_FALL_10:
            num = this.EFC_FALL_10(curKey_NormalizedTime, 2) * (effect_BASE_KEY_FRAME2.scl_x - effect_BASE_KEY_FRAME.scl_x);
            break;

        case EFCB_TYPE.EFCB_SIN_01:
            num = this.EFC_SIN_01(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.scl_x - effect_BASE_KEY_FRAME.scl_x);
            break;

        case EFCB_TYPE.EFCB_SIN_10:
            num = this.EFC_SIN_10(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.scl_x - effect_BASE_KEY_FRAME.scl_x);
            break;

        case EFCB_TYPE.EFCB_SPRING_01:
            num = this.EFC_FALL_01(curKey_NormalizedTime, 3) * (effect_BASE_KEY_FRAME2.scl_x - effect_BASE_KEY_FRAME.scl_x);
            break;

        case EFCB_TYPE.EFCB_SPRING_10:
            num = this.EFC_FALL_10(curKey_NormalizedTime, 3) * (effect_BASE_KEY_FRAME2.scl_x - effect_BASE_KEY_FRAME.scl_x);
            break;

        case EFCB_TYPE.EFCB_BOMB_01:
            num = this.EFC_BOMB_01(curKey_NormalizedTime, 0.2f) * (effect_BASE_KEY_FRAME2.scl_x - effect_BASE_KEY_FRAME.scl_x);
            break;
        }
        effect_BASE_KEY_FRAME3.scl_x = effect_BASE_KEY_FRAME.scl_x + num;
        switch (effect_BASE_KEY_FRAME.move_type_scl_y)
        {
        case EFCB_TYPE.EFCB_LINEAR:
            num = this.EFC_LNR_01(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.scl_y - effect_BASE_KEY_FRAME.scl_y);
            break;

        case EFCB_TYPE.EFCB_FALL_01:
            num = this.EFC_FALL_01(curKey_NormalizedTime, 2) * (effect_BASE_KEY_FRAME2.scl_y - effect_BASE_KEY_FRAME.scl_y);
            break;

        case EFCB_TYPE.EFCB_FALL_10:
            num = this.EFC_FALL_10(curKey_NormalizedTime, 2) * (effect_BASE_KEY_FRAME2.scl_y - effect_BASE_KEY_FRAME.scl_y);
            break;

        case EFCB_TYPE.EFCB_SIN_01:
            num = this.EFC_SIN_01(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.scl_y - effect_BASE_KEY_FRAME.scl_y);
            break;

        case EFCB_TYPE.EFCB_SIN_10:
            num = this.EFC_SIN_10(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.scl_y - effect_BASE_KEY_FRAME.scl_y);
            break;

        case EFCB_TYPE.EFCB_SPRING_01:
            num = this.EFC_FALL_01(curKey_NormalizedTime, 3) * (effect_BASE_KEY_FRAME2.scl_y - effect_BASE_KEY_FRAME.scl_y);
            break;

        case EFCB_TYPE.EFCB_SPRING_10:
            num = this.EFC_FALL_10(curKey_NormalizedTime, 3) * (effect_BASE_KEY_FRAME2.scl_y - effect_BASE_KEY_FRAME.scl_y);
            break;

        case EFCB_TYPE.EFCB_BOMB_01:
            num = this.EFC_BOMB_01(curKey_NormalizedTime, 0.2f) * (effect_BASE_KEY_FRAME2.scl_y - effect_BASE_KEY_FRAME.scl_y);
            break;
        }
        effect_BASE_KEY_FRAME3.scl_y = effect_BASE_KEY_FRAME.scl_y + num;
        switch (effect_BASE_KEY_FRAME.move_type_rot_z)
        {
        case EFCB_TYPE.EFCB_LINEAR:
            num = this.EFC_LNR_01(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.rot_z - effect_BASE_KEY_FRAME.rot_z);
            break;

        case EFCB_TYPE.EFCB_FALL_01:
            num = this.EFC_FALL_01(curKey_NormalizedTime, 2) * (effect_BASE_KEY_FRAME2.rot_z - effect_BASE_KEY_FRAME.rot_z);
            break;

        case EFCB_TYPE.EFCB_FALL_10:
            num = this.EFC_FALL_10(curKey_NormalizedTime, 2) * (effect_BASE_KEY_FRAME2.rot_z - effect_BASE_KEY_FRAME.rot_z);
            break;

        case EFCB_TYPE.EFCB_SIN_01:
            num = this.EFC_SIN_01(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.rot_z - effect_BASE_KEY_FRAME.rot_z);
            break;

        case EFCB_TYPE.EFCB_SIN_10:
            num = this.EFC_SIN_10(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.rot_z - effect_BASE_KEY_FRAME.rot_z);
            break;

        case EFCB_TYPE.EFCB_SPRING_01:
            num = this.EFC_FALL_01(curKey_NormalizedTime, 3) * (effect_BASE_KEY_FRAME2.rot_z - effect_BASE_KEY_FRAME.rot_z);
            break;

        case EFCB_TYPE.EFCB_SPRING_10:
            num = this.EFC_FALL_10(curKey_NormalizedTime, 3) * (effect_BASE_KEY_FRAME2.rot_z - effect_BASE_KEY_FRAME.rot_z);
            break;

        case EFCB_TYPE.EFCB_BOMB_01:
            num = this.EFC_BOMB_01(curKey_NormalizedTime, 0.2f) * (effect_BASE_KEY_FRAME2.rot_z - effect_BASE_KEY_FRAME.rot_z);
            break;
        }
        effect_BASE_KEY_FRAME3.rot_z = effect_BASE_KEY_FRAME.rot_z + num;
        switch (effect_BASE_KEY_FRAME.move_type_rot_x)
        {
        case EFCB_TYPE.EFCB_LINEAR:
            num = this.EFC_LNR_01(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.rot_x - effect_BASE_KEY_FRAME.rot_x);
            break;

        case EFCB_TYPE.EFCB_FALL_01:
            num = this.EFC_FALL_01(curKey_NormalizedTime, 2) * (effect_BASE_KEY_FRAME2.rot_x - effect_BASE_KEY_FRAME.rot_x);
            break;

        case EFCB_TYPE.EFCB_FALL_10:
            num = this.EFC_FALL_10(curKey_NormalizedTime, 2) * (effect_BASE_KEY_FRAME2.rot_x - effect_BASE_KEY_FRAME.rot_x);
            break;

        case EFCB_TYPE.EFCB_SIN_01:
            num = this.EFC_SIN_01(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.rot_x - effect_BASE_KEY_FRAME.rot_x);
            break;

        case EFCB_TYPE.EFCB_SIN_10:
            num = this.EFC_SIN_10(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.rot_x - effect_BASE_KEY_FRAME.rot_x);
            break;

        case EFCB_TYPE.EFCB_SPRING_01:
            num = this.EFC_FALL_01(curKey_NormalizedTime, 3) * (effect_BASE_KEY_FRAME2.rot_x - effect_BASE_KEY_FRAME.rot_x);
            break;

        case EFCB_TYPE.EFCB_SPRING_10:
            num = this.EFC_FALL_10(curKey_NormalizedTime, 3) * (effect_BASE_KEY_FRAME2.rot_x - effect_BASE_KEY_FRAME.rot_x);
            break;

        case EFCB_TYPE.EFCB_BOMB_01:
            num = this.EFC_BOMB_01(curKey_NormalizedTime, 0.2f) * (effect_BASE_KEY_FRAME2.rot_x - effect_BASE_KEY_FRAME.rot_x);
            break;
        }
        effect_BASE_KEY_FRAME3.rot_x = effect_BASE_KEY_FRAME.rot_x + num;
        switch (effect_BASE_KEY_FRAME.move_type_rot_y)
        {
        case EFCB_TYPE.EFCB_LINEAR:
            num = this.EFC_LNR_01(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.rot_y - effect_BASE_KEY_FRAME.rot_y);
            break;

        case EFCB_TYPE.EFCB_FALL_01:
            num = this.EFC_FALL_01(curKey_NormalizedTime, 2) * (effect_BASE_KEY_FRAME2.rot_y - effect_BASE_KEY_FRAME.rot_y);
            break;

        case EFCB_TYPE.EFCB_FALL_10:
            num = this.EFC_FALL_10(curKey_NormalizedTime, 2) * (effect_BASE_KEY_FRAME2.rot_y - effect_BASE_KEY_FRAME.rot_y);
            break;

        case EFCB_TYPE.EFCB_SIN_01:
            num = this.EFC_SIN_01(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.rot_y - effect_BASE_KEY_FRAME.rot_y);
            break;

        case EFCB_TYPE.EFCB_SIN_10:
            num = this.EFC_SIN_10(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.rot_y - effect_BASE_KEY_FRAME.rot_y);
            break;

        case EFCB_TYPE.EFCB_SPRING_01:
            num = this.EFC_FALL_01(curKey_NormalizedTime, 3) * (effect_BASE_KEY_FRAME2.rot_y - effect_BASE_KEY_FRAME.rot_y);
            break;

        case EFCB_TYPE.EFCB_SPRING_10:
            num = this.EFC_FALL_10(curKey_NormalizedTime, 3) * (effect_BASE_KEY_FRAME2.rot_y - effect_BASE_KEY_FRAME.rot_y);
            break;

        case EFCB_TYPE.EFCB_BOMB_01:
            num = this.EFC_BOMB_01(curKey_NormalizedTime, 0.2f) * (effect_BASE_KEY_FRAME2.rot_y - effect_BASE_KEY_FRAME.rot_y);
            break;
        }
        effect_BASE_KEY_FRAME3.rot_y = effect_BASE_KEY_FRAME.rot_y + num;
        switch (effect_BASE_KEY_FRAME.move_type_col)
        {
        case EFCB_TYPE.EFCB_LINEAR:
            num = this.EFC_LNR_01(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.col_r - effect_BASE_KEY_FRAME.col_r);
            break;

        case EFCB_TYPE.EFCB_FALL_01:
            num = this.EFC_FALL_01(curKey_NormalizedTime, 2) * (effect_BASE_KEY_FRAME2.col_r - effect_BASE_KEY_FRAME.col_r);
            break;

        case EFCB_TYPE.EFCB_FALL_10:
            num = this.EFC_FALL_10(curKey_NormalizedTime, 2) * (effect_BASE_KEY_FRAME2.col_r - effect_BASE_KEY_FRAME.col_r);
            break;

        case EFCB_TYPE.EFCB_SIN_01:
            num = this.EFC_SIN_01(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.col_r - effect_BASE_KEY_FRAME.col_r);
            break;

        case EFCB_TYPE.EFCB_SIN_10:
            num = this.EFC_SIN_10(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.col_r - effect_BASE_KEY_FRAME.col_r);
            break;

        case EFCB_TYPE.EFCB_SPRING_01:
            num = this.EFC_FALL_01(curKey_NormalizedTime, 3) * (effect_BASE_KEY_FRAME2.col_r - effect_BASE_KEY_FRAME.col_r);
            break;

        case EFCB_TYPE.EFCB_SPRING_10:
            num = this.EFC_FALL_10(curKey_NormalizedTime, 3) * (effect_BASE_KEY_FRAME2.col_r - effect_BASE_KEY_FRAME.col_r);
            break;

        case EFCB_TYPE.EFCB_BOMB_01:
            num = this.EFC_BOMB_01(curKey_NormalizedTime, 0.2f) * (effect_BASE_KEY_FRAME2.col_r - effect_BASE_KEY_FRAME.col_r);
            break;
        }
        effect_BASE_KEY_FRAME3.col_r = effect_BASE_KEY_FRAME.col_r + num;
        switch (effect_BASE_KEY_FRAME.move_type_col)
        {
        case EFCB_TYPE.EFCB_LINEAR:
            num = this.EFC_LNR_01(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.col_g - effect_BASE_KEY_FRAME.col_g);
            break;

        case EFCB_TYPE.EFCB_FALL_01:
            num = this.EFC_FALL_01(curKey_NormalizedTime, 2) * (effect_BASE_KEY_FRAME2.col_g - effect_BASE_KEY_FRAME.col_g);
            break;

        case EFCB_TYPE.EFCB_FALL_10:
            num = this.EFC_FALL_10(curKey_NormalizedTime, 2) * (effect_BASE_KEY_FRAME2.col_g - effect_BASE_KEY_FRAME.col_g);
            break;

        case EFCB_TYPE.EFCB_SIN_01:
            num = this.EFC_SIN_01(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.col_g - effect_BASE_KEY_FRAME.col_g);
            break;

        case EFCB_TYPE.EFCB_SIN_10:
            num = this.EFC_SIN_10(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.col_g - effect_BASE_KEY_FRAME.col_g);
            break;

        case EFCB_TYPE.EFCB_SPRING_01:
            num = this.EFC_FALL_01(curKey_NormalizedTime, 3) * (effect_BASE_KEY_FRAME2.col_g - effect_BASE_KEY_FRAME.col_g);
            break;

        case EFCB_TYPE.EFCB_SPRING_10:
            num = this.EFC_FALL_10(curKey_NormalizedTime, 3) * (effect_BASE_KEY_FRAME2.col_g - effect_BASE_KEY_FRAME.col_g);
            break;

        case EFCB_TYPE.EFCB_BOMB_01:
            num = this.EFC_BOMB_01(curKey_NormalizedTime, 0.2f) * (effect_BASE_KEY_FRAME2.col_g - effect_BASE_KEY_FRAME.col_g);
            break;
        }
        effect_BASE_KEY_FRAME3.col_g = effect_BASE_KEY_FRAME.col_g + num;
        switch (effect_BASE_KEY_FRAME.move_type_col)
        {
        case EFCB_TYPE.EFCB_LINEAR:
            num = this.EFC_LNR_01(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.col_b - effect_BASE_KEY_FRAME.col_b);
            break;

        case EFCB_TYPE.EFCB_FALL_01:
            num = this.EFC_FALL_01(curKey_NormalizedTime, 2) * (effect_BASE_KEY_FRAME2.col_b - effect_BASE_KEY_FRAME.col_b);
            break;

        case EFCB_TYPE.EFCB_FALL_10:
            num = this.EFC_FALL_10(curKey_NormalizedTime, 2) * (effect_BASE_KEY_FRAME2.col_b - effect_BASE_KEY_FRAME.col_b);
            break;

        case EFCB_TYPE.EFCB_SIN_01:
            num = this.EFC_SIN_01(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.col_b - effect_BASE_KEY_FRAME.col_b);
            break;

        case EFCB_TYPE.EFCB_SIN_10:
            num = this.EFC_SIN_10(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.col_b - effect_BASE_KEY_FRAME.col_b);
            break;

        case EFCB_TYPE.EFCB_SPRING_01:
            num = this.EFC_FALL_01(curKey_NormalizedTime, 3) * (effect_BASE_KEY_FRAME2.col_b - effect_BASE_KEY_FRAME.col_b);
            break;

        case EFCB_TYPE.EFCB_SPRING_10:
            num = this.EFC_FALL_10(curKey_NormalizedTime, 3) * (effect_BASE_KEY_FRAME2.col_b - effect_BASE_KEY_FRAME.col_b);
            break;

        case EFCB_TYPE.EFCB_BOMB_01:
            num = this.EFC_BOMB_01(curKey_NormalizedTime, 0.2f) * (effect_BASE_KEY_FRAME2.col_b - effect_BASE_KEY_FRAME.col_b);
            break;
        }
        effect_BASE_KEY_FRAME3.col_b = effect_BASE_KEY_FRAME.col_b + num;
        switch (effect_BASE_KEY_FRAME.move_type_col)
        {
        case EFCB_TYPE.EFCB_LINEAR:
            num = this.EFC_LNR_01(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.col_a - effect_BASE_KEY_FRAME.col_a);
            break;

        case EFCB_TYPE.EFCB_FALL_01:
            num = this.EFC_FALL_01(curKey_NormalizedTime, 2) * (effect_BASE_KEY_FRAME2.col_a - effect_BASE_KEY_FRAME.col_a);
            break;

        case EFCB_TYPE.EFCB_FALL_10:
            num = this.EFC_FALL_10(curKey_NormalizedTime, 2) * (effect_BASE_KEY_FRAME2.col_a - effect_BASE_KEY_FRAME.col_a);
            break;

        case EFCB_TYPE.EFCB_SIN_01:
            num = this.EFC_SIN_01(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.col_a - effect_BASE_KEY_FRAME.col_a);
            break;

        case EFCB_TYPE.EFCB_SIN_10:
            num = this.EFC_SIN_10(curKey_NormalizedTime) * (effect_BASE_KEY_FRAME2.col_a - effect_BASE_KEY_FRAME.col_a);
            break;

        case EFCB_TYPE.EFCB_SPRING_01:
            num = this.EFC_FALL_01(curKey_NormalizedTime, 3) * (effect_BASE_KEY_FRAME2.col_a - effect_BASE_KEY_FRAME.col_a);
            break;

        case EFCB_TYPE.EFCB_SPRING_10:
            num = this.EFC_FALL_10(curKey_NormalizedTime, 3) * (effect_BASE_KEY_FRAME2.col_a - effect_BASE_KEY_FRAME.col_a);
            break;

        case EFCB_TYPE.EFCB_BOMB_01:
            num = this.EFC_BOMB_01(curKey_NormalizedTime, 0.2f) * (effect_BASE_KEY_FRAME2.col_a - effect_BASE_KEY_FRAME.col_a);
            break;
        }
        effect_BASE_KEY_FRAME3.col_a = effect_BASE_KEY_FRAME.col_a + num;
    }