ylsj/Assets/Scripts/Core/Client/Battle/BattleFighting/Fighter.cs

using UnityEngine;
using System.Collections;
using UnityEngine.UI;
using System.Collections.Generic;
using System;

namespace YLBattle
{
    /// <summary>
    /// 战斗中角色
    /// </summary>
    public class Fighter : MonoBehaviour
    {
        #region 操作
        /// <summary>
        /// 外部交互
        /// </summary>
        private IBattleGlobalOper mGlobalOper = null;

        /// <summary>
        /// 战场数据交互
        /// </summary>
        public IBattleGlobalOper GlobalOper
        {
            get { return mGlobalOper; }
        }

        /// <summary>
        /// 
        /// </summary>
        private DragonBones.UnityArmatureComponent pmDragonBone = null;

        /// <summary>
        /// 状态机
        /// </summary>
        public DragonBones.UnityArmatureComponent mDragonBone
        {
            get { return pmDragonBone; }
        }

        #endregion

        #region FighterData
        /// <summary>
        /// 是否死亡
        /// </summary>
        public bool IsDead = false;

        /// <summary>
        /// 编号ID
        /// </summary>
        private string pmID = string.Empty;

        /// <summary>
        /// 编号ID
        /// </summary>
        public string mID
        {
            get
            {
                return pmID;
            }

            set
            {
                pmID = value;
            }
        }

        /// <summary>
        /// 模版ID
        /// </summary>
        private string pmTID = string.Empty;

        /// <summary>
        /// 模版ID
        /// </summary>
        public string mTID
        {
            get
            {
                return pmTID;
            }

            set
            {
                pmTID = value;
            }
        }

        /// <summary>
        /// 等级
        /// </summary>
        private int pmLevel = 0;

        /// <summary>
        /// 等级
        /// </summary>
        public int mLevel
        {
            get { return pmLevel; }
        }


        /// <summary>
        /// 
        /// </summary>
        private string pmDragonName = "";

        /// <summary>
        /// 
        /// </summary>
        public string mDragonName
        {
            get { return pmDragonName; }
        }
        /// <summary>
        /// 所属阵营
        /// </summary>
        private EBattleTeam pmTeam = EBattleTeam.NONE;

        /// <summary>
        /// 所属阵营
        /// </summary>
        public EBattleTeam mTeam
        {
            get
            {
                return pmTeam;
            }

            set
            {
                pmTeam = value;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        private int pmSeat = 0;

        /// <summary>
        /// 占位
        /// </summary>
        public int mSeat
        {
            get { return pmSeat; }
        }

        private int pmHeight = 0;

        /// <summary>
        /// 身高
        /// </summary>
        public int mHeight
        {
            get { return pmHeight; }
        }

        /// <summary>
        /// 
        /// </summary>
        private Vector3 pmbodyCenterPos = Vector3.zero;

        /// <summary>
        /// 
        /// </summary>
        public Vector3 mBodyCenterPos
        {
            get
            {
                if (mTeam == EBattleTeam.REDTEAM)
                {
                    this.pmbodyCenterPos = GetScreenVector3(this.pmbodyCenterPoint.position);
                    this.pmbodyCenterPos.z = 0;
                }
                if (mTeam == EBattleTeam.BLUETEAM)
                {
                    float posX = this.mGlobalOper.GetFighterProperty(mID, EBattleProperty.POSX);
                    float posY = this.mGlobalOper.GetFighterProperty(mID, EBattleProperty.POSY);
                    pmbodyCenterPos = new Vector3(posX, posY, 0);
                }
                return pmbodyCenterPos;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        private Vector3 pmbodyRootPos = Vector3.zero;

        /// <summary>
        /// 
        /// </summary>
        public Vector3 mBodyRootPos
        {
            get
            {
                if (mTeam == EBattleTeam.REDTEAM)
                {
                    this.pmbodyRootPos = GetScreenVector3(this.pmbodyRootPoint.position);
                    this.pmbodyRootPos.z = 0;
                }
                if (mTeam == EBattleTeam.BLUETEAM)
                {
                    float posX = this.mGlobalOper.GetFighterProperty(mID, EBattleProperty.POSX);
                    float posY = this.mGlobalOper.GetFighterProperty(mID, EBattleProperty.POSY);
                    pmbodyRootPos = new Vector3(posX, posY, 0);
                }
                return pmbodyRootPos;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        private Transform pmbodyCenterPoint = null;

        /// <summary>
        /// 
        /// </summary>
        public Transform mBodyCenterPoint
        {
            get
            {
                if (pmbodyCenterPoint == null)
                {
                    LogHelper.LogError("没有找到发射点 TID=" + pmTID);
                    pmbodyCenterPoint = transform;
                }

                return pmbodyCenterPoint;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        private Transform pmbodyRootPoint = null;

        /// <summary>
        /// 
        /// </summary>
        public string mNormalSound { get; set; }

        /// <summary>
        /// 
        /// </summary>
        public string mSkillSound { get; set; }

        /// <summary>
        /// 
        /// </summary>
        public string mBeattackSound { get; set; }

        /// <summary>
        /// 
        /// </summary>
        private RenderTexture pmBodyImage = null;

        /// <summary>
        /// 红队
        /// </summary>
        private MeshRenderer pmRedBody;

        /// <summary>
        /// 红队
        /// </summary>
        private MeshRenderer pmRedBodyGray;

        /// <summary>
        /// 蓝队
        /// </summary>
        private RawImage pmBlueBody;

        /// <summary>
        /// 
        /// </summary>
        //private GameObject pmRedSelectFlag = null;

        /// <summary>
        /// 动画机
        /// </summary>
        private Animator pmAnimator = null;

        /// <summary>
        /// 
        /// </summary>
        public Animator mBodyAnimator
        {
            get
            {
                if (this.pmAnimator == null)
                {
                    pmAnimator = this.pmRedBody.GetComponent<Animator>();
                }
                return pmAnimator;
            }
        }

        /// <summary>
        /// 动画机
        /// </summary>
        private Animator pmGrayAnimator = null;
        /// <summary>
        /// 
        /// </summary>
        public Animator mGrayAnimator
        {
            get
            {
                if (this.pmGrayAnimator == null)
                {
                    pmGrayAnimator = this.pmRedBodyGray.GetComponent<Animator>();
                }
                return pmGrayAnimator;
            }
        }
        /// <summary>
        /// 是否外部调用龙骨动画（暴击状态时，tip调用了龙骨动画，所以不能随意修改（如被攻击恢复....)
        /// </summary>
        private bool IsOutInvokeDragon = false;

        /// <summary>
        /// 外部调用订阅事件
        /// </summary>
        private Action mOutInvokeCallBack = null;


        /// <summary>
        /// 
        /// </summary>
        private GameObject mLianjiEffect = null;

        /// <summary>
        /// 当前连击点击状态
        /// </summary>
        private bool mLianjiState = false;
        #endregion

        /// <summary>
        /// 获取属性
        /// </summary>
        /// <param name="tp">属性</param>
        /// <returns>属性值</returns>
        public float GetProperty(EBattleProperty tp)
        {
            return this.mGlobalOper.GetFighterProperty(mID, tp);
        }

        /// <summary>
        /// 设置实例信息
        /// </summary>
        /// <param name="_id">实例ID</param>
        /// <param name="_strTid">模板ID</param>
        /// <param name="_eTeam">队列</param>
        /// <param name="_intSeat">占位（敌方和己方不同，注意场景中的实际占位）</param>
        /// <param name="mBFM">战场交换器</param>
        internal void SetInfo(string _id, string _strTid, EBattleTeam _eTeam, int _intSeat, IBattleGlobalOper mBFM, string _sounds, string _dragonName)
        {
            this.pmID = _id;
            this.pmTeam = _eTeam;
            this.pmTID = _strTid;
            this.pmSeat = _intSeat;
            this.mGlobalOper = mBFM;
            this.pmLevel = (int)mBFM.GetFighterProperty(_id, EBattleProperty.LEVEL);
            this.pmHeight = (int)mBFM.GetFighterProperty(_id, EBattleProperty.HEIGHT);
            string[] sounds = _sounds.Split(',');
            this.mNormalSound = sounds[0];
            this.mSkillSound = sounds[1];
            this.mBeattackSound = sounds[2];
            this.pmDragonName = _dragonName;
            this.gameObject.AddComponent<BUI_LookAtTarget>();
            ///蓝队位置
            if (this.mTeam == EBattleTeam.BLUETEAM)
            {
                this.transform.localPosition = new Vector3(this.transform.localPosition.x,
                    this.transform.localPosition.y + 1500 / 2 - pmHeight / 2 / 2,
                    this.transform.localPosition.z);
            }
            ///被攻击位置
            if (this.mTeam == EBattleTeam.BLUETEAM)
            {
                this.pmbodyCenterPoint = this.transform.Find("BeAttackCenter");
                this.pmbodyCenterPoint.localPosition = new Vector3(0, -1500 / 2 + pmHeight * 1.0f / 7.1f, 0);

                this.pmbodyRootPoint = this.transform.Find("BeAttackRoot");
                this.pmbodyRootPoint.localPosition = new Vector3(0, -1500 / 2 + pmHeight * 1.0f / 7.1f, 0); ;
            }
            else
            {
                this.pmbodyCenterPoint = this.transform.Find("BeAttackCenter");
                this.pmbodyCenterPoint.localPosition = new Vector3(0, -1500 / 100 / 3.5f + pmHeight / 100 / 7.1f, 0);

                this.pmbodyRootPoint = this.transform.Find("BeAttackRoot");
                ///红队存在于3D场景中，摄像机有Y轴的倾斜，所以Y轴偏上，这里做一个修正
                float offsetY = 0f;
                this.pmbodyRootPoint.localPosition = new Vector3(0, -1500 / 100 / 2 - offsetY, 0);
                //this.pmRedSelectFlag = this.transform.Find("SelectFlag").gameObject;
                //this.pmRedSelectFlag.SetActive(false);

            }
            ///初始化位置（蓝队以UI位置为最终点，但是出场时UI为出现，因此在这里初始第一版位置）
            //if (_eTeam == EBattleTeam.BLUETEAM)
            //{
            //    Vector3 pos = GetScreenVector3(pmbodyRootPoint.position);
            //    this.mGlobalOper.ModifyFighterPosition(mID, pos.x, pos.y);
            //    Debug.Log(this.pmID + "/" + pos.ToString());
            //}
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="_dragonboneCont"></param>
        /// <param name="rt"></param>
        public void SetDragonBone(DragonBones.UnityArmatureComponent _dragonboneCont, RenderTexture rt)
        {
            this.pmDragonBone = _dragonboneCont;
            this.pmBodyImage = rt;

            if (this.pmTeam == EBattleTeam.BLUETEAM)
            {
                this.pmBlueBody = transform.Find("RawImageBody").GetComponent<RawImage>();

                this.pmBlueBody.texture = this.pmBodyImage;
                this.pmBlueBody.enabled = false;

                this.pmDragonBone.gameObject.SetActive(false);
                this.pmDragonBone.enabled = false;

            }
            if (this.pmTeam == EBattleTeam.REDTEAM)
            {
                this.pmRedBody = transform.Find("PlaneBody").GetComponent<MeshRenderer>();
                this.pmRedBody.material.mainTexture = this.pmBodyImage;
                this.pmRedBodyGray = transform.Find("PlaneBodyGray").GetComponent<MeshRenderer>();
                this.pmRedBodyGray.material.mainTexture = this.pmBodyImage;
                this.pmRedBodyGray.transform.localPosition = new Vector3(0, 0, -0.01f);
                this.pmRedBodyGray.gameObject.SetActive(false);
            }

            if (!this.pmDragonBone.HasEventListener(DragonBones.EventObject.COMPLETE))
            {
                ////监听动画完成事件
                this.pmDragonBone.AddEventListener(DragonBones.EventObject.COMPLETE, OnDragonBoneAnimation_COMPLETE);
            }
            ///循环事件别删除，部分动画是循环的，比如攻击，程序这强制执行修正
            if (!this.pmDragonBone.HasEventListener(DragonBones.EventObject.LOOP_COMPLETE))
            {
                ////监听动画完成事件
                this.pmDragonBone.AddEventListener(DragonBones.EventObject.LOOP_COMPLETE, OnDragonBoneAnimation_LOOP_COMPLETE);
            }

            if (this.mTeam == EBattleTeam.REDTEAM)
            {
                this.pmDragonBone.animation.Play("Idle", 0);
            }

        }

        /// <summary>
        /// sence坐标转屏幕坐标（red转ui）
        /// </summary>
        /// <param name="orgPos"></param>
        /// <returns></returns>
        private Vector3 GetScreenVector3(Vector3 orgPos)
        {
            Vector3 trgPos = Vector3.zero;

            Vector3 sencePos = CameraManager.Instance.SenceCamara.WorldToScreenPoint(orgPos);
            trgPos = CameraManager.Instance.SenceUICamera.ScreenToWorldPoint(sencePos);

            return trgPos;
        }

        ///// <summary>
        ///// 参考2
        ///// </summary>
        ///// <returns></returns>
        //Vector2 MonoWorldToUGUI(Vector3 orgPos)
        //{
        //    Vector2 pos;
        //    Vector3 screenPos = CameraManager.Instance.SenceCamara.WorldToScreenPoint(orgPos);
        //    RectTransformUtility.ScreenPointToLocalPointInRectangle(mMng.MeCanvas.GetComponent<RectTransform>(),
        //        screenPos, CameraManager.Instance.SenceUICamera, out pos);
        //    return pos;
        //}


        /// <summary>
        /// 
        /// </summary>
        /// <param name="_bol"></param>
        /// <param name="_strAniName"></param>
        /// <param name="ac"></param>
        public void SetActiveBodyTexture(bool _bol, string _strAniName = "", Action ac = null)
        {
            this.IsOutInvokeDragon = _bol;

            if (mTeam == EBattleTeam.BLUETEAM)
            {
                this.pmDragonBone.gameObject.SetActive(_bol);
                this.pmDragonBone.enabled = _bol;
                //this.pmBlueBody.enabled = _bol;
            }

            if (_bol && _strAniName.Length > 0)
            {
                this.mOutInvokeCallBack = ac;
                this.PlayDragonAnimation(_strAniName, true);
            }

        }

        /// <summary>
        /// 播放动画
        /// </summary>
        /// <param name="aniName">动画名称</param>
        /// <param name="isForce">是否强制播放</param>
        /// <param name="_loop">是否循环播放</param>
        private void PlayDragonAnimation(string aniName, bool isForce, int _loop = 1)
        {
            if (isForce)
            {
                this.mDragonBone.animation.Play(aniName, aniName == "Idle" ? 0 : 1);
                return;
            }

            if (this.mDragonBone.animation.lastAnimationName == aniName)
            {
                return;
            }

            this.mDragonBone.animation.Play(aniName, aniName == "Idle" ? 0 : _loop);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="type"></param>
        /// <param name="eventObject"></param>
        public void OnDragonBoneAnimation_LOOP_COMPLETE(string type, DragonBones.EventObject eventObject)
        {
            switch (eventObject.animationState.name)
            {
                case "Attack":

                    if (mTeam == EBattleTeam.REDTEAM)
                    {
                        this.PlayDragonAnimation("Idle", false);
                    }
                    break;
                case "Beattack":

                    if (mTeam == EBattleTeam.REDTEAM)
                    {
                        this.PlayDragonAnimation("Idle", false);
                    }

                    break;
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="type"></param>
        /// <param name="eventObject"></param>
        public void OnDragonBoneAnimation_COMPLETE(string type, DragonBones.EventObject eventObject)
        {
            switch (eventObject.animationState.name)
            {
                case "Attack":

                    if (mTeam == EBattleTeam.REDTEAM)
                    {
                        this.PlayDragonAnimation("Idle", false);


                    }

                    if (mOutInvokeCallBack != null)
                    {
                        this.mOutInvokeCallBack.Invoke();
                        this.mOutInvokeCallBack = null;
                        this.PlayDragonAnimation("Idle", false);
                    }
                    /// SetActiveBodyTexture关闭触发会让IsOutInvokeDragon=false,使动画归位
                    //if (this.IsOutInvokeDragon)
                    //{
                    //    ///如果是蓝队正对一下情况，会影响必杀全身像的显示
                    //    return;
                    //}
                    //this.pmDragonBone.gameObject.SetActive(false);
                    //this.pmDragonBone.enabled = false;


                    break;
                case "Beattack":

                    if (mTeam == EBattleTeam.REDTEAM)
                    {
                        this.PlayDragonAnimation("Idle", false);
                    }

                    break;
            }
        }

        /// <summary>
        /// 攻击
        /// </summary>
        /// <param name="skill">技能ID</param>
        /// <param name="_atkactiontype">技能攻击动作 0=无动作 1=攻击动作</param>
        internal void SetAttack(string skill, int _atkactiontype)
        {
            /**
             * 音效
             */
            //Debug.Log("##################################普通攻击动作播放时加音效（跟着人属性走）#########################");
            ////AudioManager.Instance.PlayHeroSound(mTID, this.mAttackSound, ESoundType.HERO_ATTACK);

            if (_atkactiontype != 0)
            {
                if (this.mTeam == EBattleTeam.BLUETEAM)
                {
                    //this.pmDragonBone.gameObject.SetActive(true);
                    //this.pmDragonBone.enabled = true;
                    //this.PlayDragonAnimation("Attack", true);
                }
                else
                {
                    this.PlayDragonAnimation("Attack", true);
                }
            }

            this.mGlobalOper.OnCastBullet(mID, skill);

        }

        private bool isLianjiEffectLoad = false;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="_bol"></param>
        public void SetLianjiEffect(bool _bol)
        {
            if (isLianjiEffectLoad == false)
            {
                isLianjiEffectLoad = true;
                SkillControl.Instance.createPosEffect("UI_SKILL_LianjiFiger", this.mBodyCenterPos, (obj) =>
                {
                    this.mLianjiEffect = obj;
                    this.mLianjiEffect.SetActive(true);
                    this.mLianjiEffect.transform.position = this.mBodyCenterPos;
                });
                return;
            }

            if (this.mLianjiEffect == null)
            {
                return;
            }

            if (_bol)
            {
                this.mLianjiEffect.SetActive(true);
                this.mLianjiEffect.transform.position = this.mBodyCenterPos;
            }
            else
            {
                this.mLianjiEffect.SetActive(false);
            }

        }

        /// <summary>
        /// 清理特效
        /// </summary>
        public void ClearLianjiEffect()
        {
            if (this.mLianjiEffect != null)
            {
                Destroy(this.mLianjiEffect);
                this.mLianjiEffect = null;
            }
        }

        public void SetBeSelect()
        {
            //this.pmRedSelectFlag.SetActive(true);
        }

        public void SetBeForget()
        {
            //this.pmRedSelectFlag.SetActive(false);
        }

        /// <summary>
        /// 受伤
        /// </summary>
        internal void SetHit()
        {
            string strId = this.mTID.Substring(0, 3);
            /**
             * 101开头是角色，202开头是boss
             * 只有这两类有被攻击动画
             * 其他小怪，用闪动Animator攻击动画
             */
            if (strId == "101" || strId == "202")
            {
                this.PlayDragonAnimation("Beattack", true, 1);
            }
            //else
            {
                this.mBodyAnimator.Play("BeAttack");
                Invoke("RetsetHitColor", 0.4f);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        void RetsetHitColor()
        {
            //Debug.Log(mID+ " RetsetHitColor");
            if (this.IsOutInvokeDragon)
            {
                ///如果是蓝队正对一下情况，会影响必杀全身像的显示
                return;
            }
            this.mBodyAnimator.Play("Idle");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="_force"></param>
        internal void SetIdle(bool _force)
        {

            if (this.IsOutInvokeDragon)
            {
                ///如果是蓝队正对一下情况，会影响必杀全身像的显示
                return;
            }

            ///攻击状态，则不强制转化Idle,完整播放，待攻击动画播放完毕后，再由事件返回idle
            if (_force)
            {
                this.PlayDragonAnimation("Idle", true);
            }
            else
            {
                if (this.mTeam == EBattleTeam.BLUETEAM)
                {
                    this.pmDragonBone.gameObject.SetActive(false);
                    this.pmDragonBone.enabled = false;
                }
            }
        }

        /// <summary>
        /// 死亡
        /// </summary>
        internal void SetDead()
        {
            this.IsDead = true;
            this.ClearLianjiEffect();
            this.pmDragonBone.RemoveEventListener(DragonBones.EventObject.COMPLETE, OnDragonBoneAnimation_COMPLETE);
        }

        /// <summary>
        /// 出场
        /// </summary>
        internal void SetArrival()
        {
            if (this.mTeam == EBattleTeam.REDTEAM)
            {
                this.pmDragonBone.gameObject.SetActive(true);
                this.pmDragonBone.enabled = true;
                gameObject.SetActive(true);
            }
            else
            {
                this.pmDragonBone.gameObject.SetActive(false);
                this.pmDragonBone.enabled = false;
            }

        }

        /// <summary>
        /// 隐身~
        /// </summary>
        internal void SetHidden()
        {
            this.pmDragonBone.gameObject.SetActive(false);
            gameObject.SetActive(false);
        }

        /// <summary>
        /// （红队）隐身
        /// </summary>
        internal void SetDisapper()
        {
            this.pmRedBody.gameObject.SetActive(false);
            this.pmRedBodyGray.gameObject.SetActive(true);
            this.mGrayAnimator.Play("Die");
            Invoke("LateDisapper", 0.5f);
        }

        /// <summary>
        /// 延迟删除
        /// </summary>
        void LateDisapper()
        {
            FightingManager.Instance.DeleteOneFighter(mID);
        }

        /// <summary>
        /// 变亮
        /// </summary>
        internal void SetLight()
        {
            //this.pmRedBody.gameObject.SetActive(true);
            this.mGrayAnimator.Play("Show");
            this.pmRedBodyGray.gameObject.SetActive(false);

        }


        /// <summary>
        ///  变暗
        /// </summary>
        internal void SetDark()
        {
            //this.pmRedBody.gameObject.SetActive(false);
            this.pmRedBodyGray.gameObject.SetActive(true);
            this.mGrayAnimator.Play("Dark");

        }

        /// <summary>
        /// 查找Transform
        /// </summary>
        /// <param name="name">名称</param>
        /// <returns>Transform</returns>
        public Transform FindTransform(string name)
        {
            Transform[] trans = this.transform.GetComponentsInChildren<Transform>();
            for (int i = 0; i < trans.Length; i++)
            {
                if (trans[i].name == name)
                {
                    return trans[i];
                }
            }

            return null;
        }
    }

}