Main/Assets/Editor/DIY/SkillEditor/EditorSkillObject.cs

using Thousandto.Code.Logic;
using Thousandto.Code.Logic.WarningField;
using Thousandto.Core.Asset;
using Thousandto.Core.Base;
using Thousandto.SkillEditor;
using Thousandto.SkillEditor.DIY;
using Thousandto.SkillEditor.Support;
using System;
using System.Collections.Generic;
using System.IO;
using System.Text.RegularExpressions;
using UnityEditor;
using UnityEngine;

namespace Thousandto.SkillEditor.DIY
{
    //技能召唤物
    public class EditorSkillObject : EditorBaseObject
    {
        public EditorEntity Owner { get; private set; }
        public PlaySkillObjectEventInfo EventInfo { get; private set; }
        public SkillVisualInfo VisualInfo { get; private set; }
        public List<SkillEditorBaseEvent> EventList { get; private set; }
        public bool IsFinish { get; private set; }
        public int CurFrame { get; private set; }
        public float FrameTimer { get; private set; }
        public const float OneFrameTime = 1f / 30f;
        public EditorEntity LockEntity { get; private set; }
        public float CurMoveSpeed { get; private set; }

        private Vector3 _fixMoveDir = Vector3.zero;

        public EditorSkillObject(EditorEntity owner, PlaySkillObjectEventInfo eventInfo) :
            base(new GameObject("[EditorSkillObject]"), EditorObjType.SkillObj)
        {
            Owner = owner;
            EventInfo = eventInfo;
            var pos = Vector3.zero;

            LockEntity = null;
            if (EventInfo.MoveType == SkillObjMoveType.FixDirMove)
            {
                _fixMoveDir = owner.RootTrans.forward;
                _fixMoveDir.y = 0f;
                if (EventInfo.FixDirOffsetAngle != 0)
                {
                    _fixMoveDir = Quaternion.AngleAxis(EventInfo.FixDirOffsetAngle, Vector3.up) * _fixMoveDir;
                    _fixMoveDir.y = 0f;
                    _fixMoveDir = _fixMoveDir.normalized;
                }
            }
            else if(EventInfo.MoveType == SkillObjMoveType.LockMove)
            {
                LockEntity = SkillEditorScene.FindMainTarget(Owner);
            }

            if (EventInfo.PosType == 0)
            {
                pos = Owner.Position;
            }
            else
            {
                var target = LockEntity != null ? LockEntity : SkillEditorScene.FindMainTarget(Owner);
                if (target != null)
                {
                    if (Vector3.SqrMagnitude(target.Position - Owner.Position) <= EventInfo.MaxDis * EventInfo.MaxDis)
                    {
                        pos = target.Position;
                    }
                    else
                    {
                        var dir = (target.Position - Owner.Position);
                        dir.y = 0f;
                        pos = Owner.Position + dir.normalized * EventInfo.MaxDis;
                    }
                }
                else
                {
                    pos = Owner.Position + Owner.RootTrans.forward * EventInfo.MaxDis;
                }
            }
            pos.y = 0f;
            RootTrans.position = pos;

            VisualInfo = SkillEditorData.FindSkill(EventInfo.SkillName);

            EventList = new List<SkillEditorBaseEvent>(VisualInfo.DataList.Count);
            for (int i = 0; i < VisualInfo.DataList.Count; ++i)
            {
                if (!VisualInfo.DataList[i].IsEnable)
                    continue;

                var newEvent = NewEvent(VisualInfo.DataList[i]);
                if (newEvent != null)
                {
                    EventList.Add(newEvent);
                }
            }
            CurMoveSpeed = EventInfo.MoveSpeed;
        }

        private SkillEditorBaseEvent NewEvent(SkillBaseEventInfo info)
        {
            switch (info.EventType)
            {
                case SkillEventDefine.PlayVfx:               //播放特效
                    return new EditorPlayVfxEvent(VisualInfo, info, this);
                case SkillEventDefine.PlaySfx:               //播放音效
                    return new EditorPlaySFXEvent(VisualInfo, info, this);
                case SkillEventDefine.PlayHit:               //播放产生伤害事件
                    return new EditorPlayHitEvent(VisualInfo, info, this);
                case SkillEventDefine.PlayCameraShake:
                    return new EditorPlayCameraShakeEvent(VisualInfo, info, this);
                case SkillEventDefine.PlayBlur:
                    return new EditorPlayBlurEvent(VisualInfo, info, this);
            }
            return null;
        }

        public void Start()
        {
            IsFinish = false;
            CurFrame = 0;
            FrameTimer = 0f;
            DoEvent(CurFrame);
        }

        public void Stop()
        {
            IsFinish = true;
            for (int i = 0; i < EventList.Count; ++i)
            {
                EventList[i].Stop();
            }
            GameObject.DestroyImmediate(RootGo);
        }

        public void Update(float dt)
        {
            if (IsFinish)
                return;

            for (int i = 0; i < EventList.Count; ++i)
            {
                EventList[i].Update(dt);
            }

            FrameTimer += dt;
            while (FrameTimer >= OneFrameTime)
            {
                ++CurFrame;
                FrameTimer -= OneFrameTime;
                DoEvent(CurFrame);
            }

            switch (EventInfo.MoveType)
            {
                case SkillObjMoveType.FixDirMove:
                    {
                        CurMoveSpeed += EventInfo.MoveAddSpeed * dt;
                        Position += _fixMoveDir * dt * CurMoveSpeed;
                        RootTrans.forward = _fixMoveDir;
                    }
                    break;
                case SkillObjMoveType.LockMove:
                    {
                        if (LockEntity != null)
                        {
                            CurMoveSpeed += EventInfo.MoveAddSpeed * dt;
                            var dir = LockEntity.Position - Position;
                            dir.y = 0f;
                            RootTrans.forward = dir;
                            Position += dir.normalized * dt * CurMoveSpeed;
                        }
                    }
                    break;
            }

            if (CurFrame >= VisualInfo.FrameCount)
            {
                //技能结束
                Stop();
            }
        }

        private void DoEvent(int frame)
        {
            for (int i = 0; i < EventList.Count; ++i)
            {
                EventList[i].FrameUpdate(frame);
                if (EventList[i].BaseEventInfo.EventFrame == frame)
                {
                    EventList[i].Enter();
                }
            }
        }
    }
}