Пример #1
0
    void OnEscapeHandle()
    {
        if (isStopped)
        {
            if (head.IsPlaying("Run"))
            {
                head.Play("Idle");
                body.Play("Idle");
                horse.Play("Idle");
            }
            return;
        }

        if (!head.IsPlaying("Run"))
        {
            head.Play("Run");
            body.Play("Run");
            horse.Play("Run");
        }
        SoundController.Instance.PlaySound3D("00021", transform.position);

        if (side == WarSceneController.WhichSide.Left)
        {
            transform.localPosition = new Vector3(transform.localPosition.x - runSpeed * Time.deltaTime * 0.6f,
                                                  transform.localPosition.y, transform.localPosition.z);

            if (transform.localPosition.x <= -WarSceneController.manPosMaxX + WarSceneController.locationStepX)
            {
                Destroy(gameObject);
                warCtrl.OnWarResult(WarSceneController.WhichSide.Left, true);
            }
            else if (transform.localPosition.x <= -WarSceneController.manPosMaxX + 100)
            {
                float transparent = (transform.localPosition.x + WarSceneController.manPosMaxX) / 100f;
                head.GetComponent <exSprite>().color  = new Color(1, 1, 1, transparent);
                body.GetComponent <exSprite>().color  = new Color(1, 1, 1, transparent);
                horse.GetComponent <exSprite>().color = new Color(1, 1, 1, transparent);
            }
        }
        else
        {
            transform.localPosition = new Vector3(transform.localPosition.x + runSpeed * Time.deltaTime * 0.6f,
                                                  transform.localPosition.y, transform.localPosition.z);

            if (transform.localPosition.x >= WarSceneController.manPosMaxX - WarSceneController.locationStepX)
            {
                Destroy(gameObject);
                warCtrl.OnWarResult(WarSceneController.WhichSide.Right, true);
            }
            else if (transform.localPosition.x >= WarSceneController.manPosMaxX - 100)
            {
                float transparent = (WarSceneController.manPosMaxX - transform.localPosition.x) / 100f;
                head.GetComponent <exSprite>().color  = new Color(1, 1, 1, transparent);
                body.GetComponent <exSprite>().color  = new Color(1, 1, 1, transparent);
                horse.GetComponent <exSprite>().color = new Color(1, 1, 1, transparent);
            }
        }
    }
Пример #2
0
    // ------------------------------------------------------------------
    // Desc:
    // ------------------------------------------------------------------

    public override void OnInspectorGUI()
    {
        exSprite sprite             = editSpAnim.GetComponent <exSprite>();
        bool     checkDefaultSprite = (sprite != null) && string.IsNullOrEmpty(sprite.textureGUID);

        EditorGUIUtility.LookLikeInspector();
        EditorGUILayout.Space();
        EditorGUI.indentLevel = 1;

        // ========================================================
        // Play Automatically
        // ========================================================

        editSpAnim.playAutomatically = EditorGUILayout.Toggle("Play Automatically", editSpAnim.playAutomatically);

        // ========================================================
        // Default Animation
        // ========================================================

        GUILayout.BeginHorizontal();
        editSpAnim.defaultAnimation = (exSpriteAnimClip)EditorGUILayout.ObjectField("Default Animation"
                                                                                    , editSpAnim.defaultAnimation
                                                                                    , typeof(exSpriteAnimClip)
                                                                                    , false
                                                                                    );
        if (GUILayout.Button("Edit...", GUILayout.Width(40), GUILayout.Height(15)))
        {
            exSpriteAnimClipEditor editor = exSpriteAnimClipEditor.NewWindow();
            editor.Edit(editSpAnim.defaultAnimation);
        }
        if (editSpAnim.defaultAnimation != null)
        {
            int idx = editSpAnim.animations.IndexOf(editSpAnim.defaultAnimation);
            if (idx == -1)
            {
                editSpAnim.animations.Add(editSpAnim.defaultAnimation);
            }
        }
        GUILayout.EndHorizontal();

        // ========================================================
        // Animations
        // ========================================================

        Rect lastRect = new Rect(0, 0, 1, 1);
        Rect dropRect = new Rect(0, 0, 1, 1);

        EditorGUI.indentLevel = 0;
        showAnimations        = EditorGUILayout.Foldout(showAnimations, "Animations");
        if (showAnimations)
        {
            EditorGUI.indentLevel = 2;
            // int count = EditorGUILayout.IntField ( "Size", editSpAnim.animations.Count );
            int count = exEditorHelper.IntField("Size", editSpAnim.animations.Count);
            lastRect        = GUILayoutUtility.GetLastRect();
            dropRect.height = lastRect.yMax - dropRect.y;
            count           = Mathf.Max(count, 0);

            if (count != editSpAnim.animations.Count)
            {
                //
                if (count > editSpAnim.animations.Count)
                {
                    int num = count - editSpAnim.animations.Count;
                    for (int i = 0; i < num; ++i)
                    {
                        editSpAnim.animations.Add(null);
                    }
                }
                else
                {
                    editSpAnim.animations.RemoveRange(count, editSpAnim.animations.Count - count);
                }

                //
                GUI.changed = true;
            }

            int idxRemoved = -1;
            for (int i = 0; i < editSpAnim.animations.Count; ++i)
            {
                GUILayout.BeginHorizontal();
                editSpAnim.animations[i] =
                    (exSpriteAnimClip)EditorGUILayout.ObjectField("[" + i + "]"
                                                                  , editSpAnim.animations[i]
                                                                  , typeof(exSpriteAnimClip)
                                                                  , false
                                                                  );
                if (GUILayout.Button("-", GUILayout.Width(15), GUILayout.Height(15)))
                {
                    idxRemoved = i;
                }
                if (GUILayout.Button("Edit...", GUILayout.Width(40), GUILayout.Height(15)))
                {
                    exSpriteAnimClipEditor editor = exSpriteAnimClipEditor.NewWindow();
                    editor.Edit(editSpAnim.animations[i]);
                }
                // TODO: I think we can instantiate animation state {
                // EditorGUI.indentLevel += 1;
                // // TODO:
                // EditorGUI.indentLevel -= 1;
                // } TODO end
                GUILayout.EndHorizontal();
            }

            // if we have item to remove
            if (idxRemoved != -1)
            {
                exSpriteAnimClip animClip = editSpAnim.animations[idxRemoved];
                editSpAnim.animations.RemoveAt(idxRemoved);
                if (animClip == editSpAnim.defaultAnimation)
                {
                    editSpAnim.defaultAnimation = null;
                }
            }

            EditorGUI.indentLevel = 1;
            EditorGUILayout.Space();

            lastRect        = GUILayoutUtility.GetLastRect();
            dropRect.x      = lastRect.x + 30;
            dropRect.y      = lastRect.yMax;
            dropRect.width  = lastRect.xMax - 30 - 4;
            dropRect.height = 20;

            exEditorHelper.DrawRect(dropRect, new Color(0.2f, 0.2f, 0.2f, 1.0f), new Color(0.5f, 0.5f, 0.5f, 1.0f));
            GUILayout.Space(20);

            // ========================================================
            // drag and drop
            // ========================================================

            if (dropRect.Contains(Event.current.mousePosition))
            {
                if (Event.current.type == EventType.DragUpdated)
                {
                    // Show a copy icon on the drag
                    foreach (Object o in DragAndDrop.objectReferences)
                    {
                        if (o is exSpriteAnimClip)
                        {
                            DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
                            break;
                        }
                    }
                }
                else if (Event.current.type == EventType.DragPerform)
                {
                    DragAndDrop.AcceptDrag();
                    foreach (Object o in DragAndDrop.objectReferences)
                    {
                        if (o is exSpriteAnimClip)
                        {
                            editSpAnim.animations.Add(o as exSpriteAnimClip);
                        }
                    }
                    GUI.changed = true;
                }
            }
        }
        EditorGUILayout.Space();

        // TODO: FIXME {
        // ========================================================
        //
        // ========================================================

        if (checkDefaultSprite &&
            editSpAnim.animations.Count > 0 &&
            editSpAnim.animations[0] != null &&
            editSpAnim.animations[0].frameInfos.Count > 0)
        {
            exSpriteAnimClip.FrameInfo fi = editSpAnim.animations[0].frameInfos[0];
            sprite.textureGUID = fi.textureGUID;
            sprite.SetSprite(fi.atlas, fi.index);
            sprite.Build();
        }
        // } TODO end

        // ========================================================
        // set dirty if anything changed
        // ========================================================

        if (GUI.changed)
        {
            EditorUtility.SetDirty(editSpAnim);
        }
    }
Пример #3
0
    // Update is called once per frame
    void Update()
    {
        if (WarSceneController.isGamePause)
        {
            return;
        }

        if (WarSceneController.state == WarSceneController.State.Beginning ||
            WarSceneController.state == WarSceneController.State.Menu ||
            WarSceneController.state == WarSceneController.State.End ||
            WarSceneController.state == WarSceneController.State.Assault)
        {
            return;
        }

        if (state == State.Dead)
        {
            OnDyingHandler();
            return;
        }

        if (isMagicLock)
        {
            timeCoolDownTick -= Time.deltaTime;
            if (timeCoolDownTick <= 0)
            {
                isMagicLock      = false;
                timeCoolDownTick = 0;
                anim.Resume();
            }
            return;
        }

        if (isParrying)
        {
            OnParryHandler();
        }

        if (isFighting)
        {
            OnFightingAct();
            return;
        }

        if (timeCoolDownTick > 0)
        {
            timeCoolDownTick -= Time.deltaTime;
            if (timeCoolDownTick <= 0)
            {
                timeCoolDownTick = 0;
            }
            else
            {
                return;
            }
        }

        if (isFighting || isParrying)
        {
            return;
        }

        switch (state)
        {
        case State.Idle:
        {
            if (!anim.IsPlaying("Idle"))
            {
                anim.Play("Idle");
            }

            if (CheckCanFight())
            {
                return;
            }

            RangeSolidersFightCheck();
        }
        break;

        case State.Running:
        {
            if (!anim.IsPlaying("Run"))
            {
                anim.Play("Run");
            }

            if (WarSceneController.state == WarSceneController.State.Dead)
            {
                SetRandomRun(transform.localPosition, false);
                return;
            }

            if (targetEnemy != null &&
                ((side == WarSceneController.WhichSide.Left && transform.localPosition.x - targetEnemy.localPosition.x > -100) ||
                 side == WarSceneController.WhichSide.Right && transform.localPosition.x - targetEnemy.localPosition.x < 100))
            {
                Vector3 posBK     = transform.localPosition;
                Vector3 targetPos = Vector3.zero;

                if (transform.localPosition.x > targetEnemy.localPosition.x)
                {
                    targetPos = new Vector3(targetEnemy.localPosition.x + hitDistance - locationStepX,
                                            targetEnemy.localPosition.y, targetEnemy.localPosition.z);
                }
                else
                {
                    targetPos = new Vector3(targetEnemy.localPosition.x - hitDistance + locationStepX,
                                            targetEnemy.localPosition.y, targetEnemy.localPosition.z);
                }

                int x = (int)((targetPos.x + manPosMaxX) / locationStepX);
                int y = (int)((targetPos.y + manPosMaxY) / locationStepY);
                if (warCtrl.GetLocationFlag(x, y) != 0 && warCtrl.GetLocationFlag(x, y) != index)
                {
                    SetRandomRun(targetPos, false);
                    return;
                }

                transform.localPosition = Vector3.MoveTowards(transform.localPosition,
                                                              targetPos, runSpeed * Time.deltaTime);

                if ((transform.localPosition.x > posBK.x && transform.localScale.x > 0) ||
                    (transform.localPosition.x < posBK.x && transform.localScale.x < 0))
                {
                    transform.localScale = new Vector3(-transform.localScale.x, transform.localScale.y, transform.localScale.z);
                }

                if (transform.localPosition == targetPos)
                {
                    if (isEnemyGeneral == false ||
                        (side == WarSceneController.WhichSide.Left && (transform.localPosition.x > targetEnemy.localPosition.x ||
                                                                       (transform.localPosition.x < targetEnemy.localPosition.x &&
                                                                        Vector3.Distance(warCtrl.leftGeneral.transform.localPosition, warCtrl.rightGeneral.transform.localPosition) > 200))) ||
                        (side == WarSceneController.WhichSide.Right && (transform.localPosition.x < targetEnemy.localPosition.x ||
                                                                        (transform.localPosition.x > targetEnemy.localPosition.x &&
                                                                         Vector3.Distance(warCtrl.leftGeneral.transform.localPosition, warCtrl.rightGeneral.transform.localPosition) > 200))))
                    {
                        CheckCanFight();
                    }
                    else
                    {
                        SetRandomRun(targetPos, false);
                    }
                }
            }
            else
            {
                Vector3 pos = transform.localPosition;

                if (side == WarSceneController.WhichSide.Left)
                {
                    pos = new Vector3(pos.x + runSpeed * Time.deltaTime, pos.y, pos.z);
                    if (transform.localScale.x > 0)
                    {
                        transform.localScale = new Vector3(-transform.localScale.x, transform.localScale.y, transform.localScale.z);
                    }
                }
                else
                {
                    pos = new Vector3(pos.x - runSpeed * Time.deltaTime, pos.y, pos.z);
                    if (transform.localScale.x < 0)
                    {
                        transform.localScale = new Vector3(-transform.localScale.x, transform.localScale.y, transform.localScale.z);
                    }
                }

                pos.x = Mathf.Clamp(pos.x, -WarSceneController.manPosMaxX + 100, WarSceneController.manPosMaxX - 100);
                transform.localPosition = pos;
            }

            RangeSolidersFightCheck();
        }
        break;

        case State.RandomRun:
        {
            if (!anim.IsPlaying("Run"))
            {
                anim.Play("Run");
            }

            transform.localPosition = Vector3.MoveTowards(transform.localPosition,
                                                          targetPosition, runSpeed * Time.deltaTime);
            if (transform.localPosition == targetPosition)
            {
                if (!isOnRandomRun)
                {
                    SetRun();
                }
                else
                {
                    SetRandomRun(randomRunPos, true);
                }
            }
        }
        break;

        case State.MovingBack:
        {
            if (!anim.IsPlaying("Run"))
            {
                anim.Play("Run");
            }

            Vector3 pos = transform.localPosition;
            if (side == WarSceneController.WhichSide.Left)
            {
                pos = new Vector3(pos.x - runSpeed * Time.deltaTime, pos.y, pos.z);
            }
            else
            {
                pos = new Vector3(pos.x + runSpeed * Time.deltaTime, pos.y, pos.z);
            }

            pos.x = Mathf.Clamp(pos.x, -WarSceneController.manPosMaxX + 100, WarSceneController.manPosMaxX - 100);
            transform.localPosition = pos;
        }
        break;

        case State.Escape:
            if (!anim.IsPlaying("Run"))
            {
                anim.Play("Run");
            }

            if (side == WarSceneController.WhichSide.Left)
            {
                transform.localPosition = new Vector3(transform.localPosition.x - runSpeed * Time.deltaTime,
                                                      transform.localPosition.y, transform.localPosition.z);

                if (transform.localPosition.x <= -WarSceneController.manPosMaxX + WarSceneController.locationStepX)
                {
                    Destroy(gameObject);
                    Destroy(mapPoint.gameObject);
                }
                else if (transform.localPosition.x <= -WarSceneController.manPosMaxX + 100)
                {
                    float transparent = (transform.localPosition.x + WarSceneController.manPosMaxX) / 100f;
                    anim.GetComponent <exSprite>().color = new Color(1, 1, 1, transparent);
                }
            }
            else
            {
                transform.localPosition = new Vector3(transform.localPosition.x + runSpeed * Time.deltaTime,
                                                      transform.localPosition.y, transform.localPosition.z);

                if (transform.localPosition.x >= WarSceneController.manPosMaxX - WarSceneController.locationStepX)
                {
                    Destroy(gameObject);
                    Destroy(mapPoint.gameObject);
                }
                else if (transform.localPosition.x >= WarSceneController.manPosMaxX - 100)
                {
                    float transparent = (WarSceneController.manPosMaxX - transform.localPosition.x) / 100f;
                    anim.GetComponent <exSprite>().color = new Color(1, 1, 1, transparent);
                }
            }
            break;
        }

        CheckLocationState();
    }
Пример #4
0
    void OnDyingHandler()
    {
        float upSpeed = 80;

        float horseSpeed  = runSpeed;
        float weaponSpeed = 80;
        float bodySpeed   = 60;

        if (side == WarSceneController.WhichSide.Left)
        {
            horseSpeed = -runSpeed;
        }

        horse.transform.localPosition = new Vector3(horse.transform.localPosition.x + horseSpeed * Time.deltaTime,
                                                    horse.transform.localPosition.y, horse.transform.localPosition.z);

        switch (dieWeaponStep)
        {
        case 0:
            dieTimeTick1 += Time.deltaTime;
            if (dieTimeTick1 < 0.5f)
            {
                weapon.transform.localPosition = new Vector3(weapon.transform.localPosition.x + weaponSpeed * Time.deltaTime,
                                                             weapon.transform.localPosition.y + upSpeed * 2 * Time.deltaTime, weapon.transform.localPosition.z);
            }
            else
            {
                dieTimeTick1  = 0;
                dieWeaponStep = 1;
            }
            break;

        case 1:
            dieTimeTick1 += Time.deltaTime;
            if (dieTimeTick1 < 0.5f)
            {
                weapon.transform.localPosition = new Vector3(weapon.transform.localPosition.x + weaponSpeed * Time.deltaTime,
                                                             weapon.transform.localPosition.y + Mathf.Lerp(upSpeed * 2, 0, dieTimeTick1 * 2) * Time.deltaTime, weapon.transform.localPosition.z);
            }
            else
            {
                dieTimeTick1  = 0;
                dieWeaponStep = 2;
            }
            break;

        case 2:
            dieTimeTick1 += Time.deltaTime;
            if (dieTimeTick1 < 0.5f)
            {
                weapon.transform.localPosition = new Vector3(weapon.transform.localPosition.x + weaponSpeed * Time.deltaTime,
                                                             weapon.transform.localPosition.y - Mathf.Lerp(0, upSpeed * 2, dieTimeTick1 * 2) * Time.deltaTime, weapon.transform.localPosition.z);
            }
            else
            {
                dieTimeTick1  = 0;
                dieWeaponStep = 3;
            }
            break;

        case 3:
            dieTimeTick1 += Time.deltaTime;
            if (dieTimeTick1 < 0.5f)
            {
                weapon.transform.localPosition = new Vector3(weapon.transform.localPosition.x + weaponSpeed * Time.deltaTime,
                                                             weapon.transform.localPosition.y - upSpeed * Time.deltaTime, weapon.transform.localPosition.z);
                weapon.GetComponent <exSprite>().color = new Color(1, 1, 1, 1 - dieTimeTick1 * 2);
            }
            else
            {
                dieTimeTick1  = 0;
                dieWeaponStep = 5;
            }
            break;
        }

        switch (dieBodyStep)
        {
        case 0:
            dieTimeTick2 += Time.deltaTime;
            if (dieTimeTick2 < 0.25f)
            {
                head.transform.localPosition = new Vector3(head.transform.localPosition.x + bodySpeed * Time.deltaTime,
                                                           head.transform.localPosition.y + Mathf.Lerp(upSpeed, 0, dieTimeTick2 * 4) * Time.deltaTime, head.transform.localPosition.z);
                body.transform.localPosition = head.transform.localPosition;
            }
            else
            {
                dieTimeTick2 = 0;
                dieBodyStep  = 1;
            }
            break;

        case 1:
            dieTimeTick2 += Time.deltaTime;
            if (dieTimeTick2 < 0.25f)
            {
                head.transform.localPosition = new Vector3(head.transform.localPosition.x + bodySpeed * Time.deltaTime,
                                                           head.transform.localPosition.y - Mathf.Lerp(0, upSpeed, dieTimeTick2 * 4) * Time.deltaTime, head.transform.localPosition.z);
                body.transform.localPosition = head.transform.localPosition;
            }
            else
            {
                dieTimeTick2 = 0;
                dieBodyStep  = 2;
            }
            break;

        case 2:
            dieTimeTick2 += Time.deltaTime;
            if (dieTimeTick2 < 0.5f)
            {
                head.transform.localPosition = new Vector3(head.transform.localPosition.x + bodySpeed * Time.deltaTime,
                                                           head.transform.localPosition.y - upSpeed * Time.deltaTime, head.transform.localPosition.z);
                body.transform.localPosition = head.transform.localPosition;
            }
            else
            {
                dieTimeTick2 = 0;
                dieBodyStep  = 3;

                head.SetFrame("Dead", 1);
                body.SetFrame("Dead", 1);
            }
            break;

        case 3:
            dieTimeTick2 += Time.deltaTime;
            if (dieTimeTick2 < 0.2f)
            {
                head.transform.localPosition = new Vector3(head.transform.localPosition.x + bodySpeed * Time.deltaTime,
                                                           head.transform.localPosition.y + Mathf.Lerp(upSpeed, 0, dieTimeTick2 * 5) * Time.deltaTime, head.transform.localPosition.z);
                body.transform.localPosition = head.transform.localPosition;
            }
            else
            {
                dieTimeTick2 = 0;
                dieBodyStep  = 4;
            }
            break;

        case 4:
            dieTimeTick2 += Time.deltaTime;
            if (dieTimeTick2 < 0.2f)
            {
                head.transform.localPosition = new Vector3(head.transform.localPosition.x + bodySpeed * Time.deltaTime,
                                                           head.transform.localPosition.y - Mathf.Lerp(0, upSpeed, dieTimeTick2 * 5) * Time.deltaTime, head.transform.localPosition.z);
                body.transform.localPosition = head.transform.localPosition;
            }
            else
            {
                dieTimeTick2 = 0;
                dieBodyStep  = 5;

                head.SetFrame("Dead", 2);
                body.SetFrame("Dead", 2);
            }
            break;

        case 5:
            dieTimeTick2 += Time.deltaTime;
            if (dieTimeTick2 < 0.1f)
            {
                head.transform.localPosition = new Vector3(head.transform.localPosition.x + bodySpeed * Time.deltaTime,
                                                           head.transform.localPosition.y + Mathf.Lerp(upSpeed, 0, dieTimeTick2 * 10) * Time.deltaTime, head.transform.localPosition.z);
                body.transform.localPosition = head.transform.localPosition;
            }
            else
            {
                dieTimeTick2 = 0;
                dieBodyStep  = 6;
            }
            break;

        case 6:
            dieTimeTick2 += Time.deltaTime;
            if (dieTimeTick2 < 0.1f)
            {
                head.transform.localPosition = new Vector3(head.transform.localPosition.x + bodySpeed * Time.deltaTime,
                                                           head.transform.localPosition.y - Mathf.Lerp(0, upSpeed, dieTimeTick2 * 10) * Time.deltaTime, head.transform.localPosition.z);
                body.transform.localPosition = head.transform.localPosition;
            }
            else
            {
                dieTimeTick2 = 0;
                dieBodyStep  = 7;
            }
            break;

        case 7:
            dieTimeTick2 += Time.deltaTime;
            if (dieTimeTick2 < 1f)
            {
                head.GetComponent <exSprite>().color = new Color(1, 1, 1, 1 - dieTimeTick2);
                body.GetComponent <exSprite>().color = new Color(1, 1, 1, 1 - dieTimeTick2);
            }
            else
            {
                dieTimeTick2 = 0;
                dieBodyStep  = 8;
                warCtrl.OnWarResult(side, false);
            }
            break;
        }
    }