// ***********************************************************************
// Assembly         : Game
// Author           : Kimch
// Created          : 2021-01-09
// Description      :
// Last Modified By : 
// Last Modified On : 
// ***********************************************************************
// <copyright file= "EntityPlayer" company="Kunpo"></copyright>
// <summary></summary>
// ***********************************************************************

using CodeStage.AntiCheat.ObscuredTypes;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace G
{
    public enum WeaponKind
    {
        blade = 1,
        dual,
        spear,
        bow,
        staff,
        magic,
    }

    /// <summary>
    /// 类功能描述
    /// </summary>
    partial class EntityPlayer
    {


        #region Field

        /// <summary>
        /// 
        /// </summary>
        private float _attackSpeed;
        /// <summary>
        /// 
        /// </summary>
        private float _attackSpeedOrigin = 1.5f;
        /// <summary>
        /// 
        /// </summary>
        private float _moveSpeed;
        /// <summary>
        /// 
        /// </summary>
        private float _moveSpeedOrigin = 0.5f;

        private int _weaponKind;
        private string _weaponMesh;
        private int _weaponQuality;

        private float _weaponAttackRange;

        private int _specialKind;
        private int _specialKindOrigin;
        private int _specialAmount;

        private Vector3 _colliderCenter;
        private float _colliderRadius;
        private Vector3 _colliderDodge;

        #endregion

        #region Property

        /// <summary>
        /// 技能值
        /// </summary>
        public float sp
        {
            get;
            private set;
        }

        /// <summary>
        /// 
        /// </summary>
        public float maxSp
        {
            get;
            private set;
        }

        public float attackSpeed
        {
            get { return _attackSpeed; }
        }

        public int deathCount
        {
            get;
            set;
        }

        #endregion

        #region Method

        /// <summary>
        /// 设置角色数值
        /// </summary>
        public void InitValue()
        {
            //
            SyncValue(true);

            InvokeRepeating(nameof(HpRecover), 1f, 1f);
            InvokeRepeating(nameof(SpRecover), 5f, 5f);
        }

        /// <summary>
        /// 同步所有数值
        /// </summary>
        public void SyncValue(bool reset = false)
        {
            SyncPlayer();
            SyncWeapon();
            if (reset)
                SyncPet();
            SyncBuff();

            SyncHp();
            SyncMoveSpeed();
            SyncAttackSpeed();

            SyncSkillValue();
            SetWeapon(!reset);
        }

        /// <summary>
        /// 同步角色属性
        /// </summary>
        private void SyncPlayer()
        {
            if (!GameLevel.Instance.infinityMode)
            {
                var combatAttributes = PlayerProxy.Instance.combatAttributes;
                for (int i = combatAttributes.Length - 1; i >= 0; i--)
                {
                    var attribute = combatAttributes[i];
                    if (attribute.value > 0)
                    {
                        SetOriginValue(attribute.id, attribute.value);
                    }
                }
            }
            else
            {
                var chaLevel = Mathf.Clamp(GameLevel.Instance.curStageIndex, 1, PlayerProxy.Instance.gradeMax);
                var chaLevelItem = ItemProxy.Instance.GetStaticItem<ItemChaLevel>(chaLevel);
                if (chaLevelItem != null)
                {
                    var initAttributes = chaLevelItem.endlessAttributes;
                    for (int i = 0; i < initAttributes.Length; i++)
                    {
                        var atValue = initAttributes[i][1] * (1f + chaLevel * 0.01f);
                        SetOriginValue(initAttributes[i][0], (int)atValue);
                    }
                }
                else
                {
                    var cha = PlayerProxy.Instance.GetCurrentCha();
                    if (cha != null)
                    {
                        var initAttributes = cha.endlessAttributes;
                        for (int i = 0; i < initAttributes.Length; i++)
                        {
                            SetOriginValue(initAttributes[i][0], initAttributes[i][1]);
                        }
                    }
                }
            }
        }

        private void SyncPet()
        {
            var battlePet = PetProxy.Instance.battlePet;
            if (battlePet != null)
            {
                var validSkills = new Dictionary<int, PetProxy.PetSkillInfo>();
                var skills = battlePet.CheckSkill();
                for (int i = 0; i < skills.Count; i++)
                {
                    var skill = battlePet.skills[i];
                    if (skill != null && skill.isUnlock)
                    {
                        var validId = skill.id;
                        if (validId > 100)
                        {
                            validId -= 100;
                        }
                        if (!validSkills.ContainsKey(validId))
                        {
                            validSkills.Add(validId, skill);
                        }
                    }
                }

                foreach (var skillKV in validSkills)
                {
                    var skillValues = skillKV.Value.item.values;
                    switch (skillKV.Key)
                    {
                        case 2:
                        case 5:
                        case 6:
                        case 7:
                        case 9:
                        case 10:
                        case 12:
                        case 14:
                        case 17:
                        case 21:
                        case 24:
                            if (skillValues != null)
                            {
                                for (int i = 0; i < skillValues.Length; i++)
                                {
                                    var skillValue = skillValues[i];
                                    AddExtraValue(skillValue[0], skillValue[1]);
                                }
                            }
                            break;
                        case 22:
                            if (skillValues != null && skillValues.Length > 1)
                            {
                                for (int i = 1; i < skillValues.Length; i++)
                                {
                                    var skillValue = skillValues[i];
                                    AddExtraValue(skillValue[0], skillValue[1]);
                                }
                            }
                            break;
                        case 25:
                            if (skillValues != null && skillValues.Length > 0)
                            {
                                var skillValue = skillValues[0];
                                AddExtraValue(skillValue[0], skillValue[1]);
                            }
                            break;
                        case 8:
                            if (skillValues != null && skillValues.Length > 1)
                            {
                                var skillValue = skillValues[0];
                                _deathRebornRate = skillValue[1];
                                skillValue = skillValues[1];
                                _deathRebornHpRate = skillValue[1];
                            }
                            _deathReborn = 1;
                            break;
                        case 13:
                            if (skillValues != null && skillValues.Length > 1)
                            {
                                var skillValue = skillValues[0];
                                _deathInvincRate = skillValue[1];
                                skillValue = skillValues[1];
                                _deathInvincSecond = skillValue[1];
                            }
                            _deathInvinc = 1;
                            break;
                        case 18:
                            if (skillValues != null && skillValues.Length >= 2)
                            {
                                var skillValue = skillValues[0];
                                _moveSpeedOrigin *= (1f + skillValue[1] * 0.01f);
                                skillValue = skillValues[1];
                                AddExtraValue(skillValue[0], skillValue[1]);
                            }
                            break;
                        case 20:
                            if (skillValues != null && skillValues.Length > 0)
                            {
                                var skillValue = skillValues[0];
                                _moveSpeedOrigin *= (1f + skillValue[1] * 0.01f);
                            }
                            break;
                    }
                }
            }
        }

        private void SyncWeapon()
        {
            var weapon = PlayerProxy.Instance.GetCurWeapon();
            if (weapon != null)
            {
                var weaponItem = weapon.weaponItem;
                _moveSpeedOrigin = weaponItem.moveSpeed;
                _attackSpeedOrigin = weaponItem.attackSpeed;

                _weaponKind = weapon.weaponKind;

                _weaponMesh = weapon.assets;
                _weaponQuality = weapon.quality;
                _specialKind = weapon.elementIndex;
                _specialAmount = GetCurrentValue(weapon.elementId) / 100;
            }
        }

        /// <summary>
        /// 同步
        /// </summary>
        private void SyncBuff()
        {

        }

        public void SyncHp(bool onlyValue = false)
        {
            int source = this.sourceTotalHp;

            var add = source - maxHp;
            maxHp = Mathf.Max(0, source);
            curHp = Mathf.Clamp(curHp + add, 0, maxHp);

            if (!onlyValue)
            {
                UpdateHpBar();
            }
        }

        public void SyncSkillValue()
        {
            scriptSkill.SetSkill(sourceTotalAttack, attackOrigin, 0);
        }

        public void SyncMoveSpeed()
        {
            _moveSpeed = _moveSpeedOrigin;
        }

        public void SyncAttackSpeed()
        {
            _attackSpeed = _attackSpeedOrigin * (Mathf.Min(60, GetCurrentValue(CombatAttributeId.AttackSpeed)) * 0.01f + 1f);
            SetFloat(Hash_Speed_Attack, _attackSpeed);
        }

        /// <summary>
        /// 
        /// </summary>
        private void SetWeapon(bool change)
        {
            switch ((WeaponKind)_weaponKind)
            {
                case WeaponKind.blade:
                    {
                        _colliderCenter = new Vector3(0f, 0.05f, 0.17f);
                        _colliderRadius = 0.13f;
                        _weaponAttackRange = 0.3f;//0.13+0.17
                                                  //ef_swing1.localScale = new Vector3(1.6f, 2f, 2f);
                        break;
                    }
                case WeaponKind.dual:
                    {
                        _colliderCenter = new Vector3(0f, 0.05f, 0.16f);
                        _colliderRadius = 0.13f;
                        _weaponAttackRange = 0.28f;//0.13+0.16
                                                   //ef_swing1.localScale = new Vector3(1.3f, 1.7f, 1.7f);
                                                   //_attackSpeed -= 0.02f;
                        break;
                    }
                case WeaponKind.spear:
                    {
                        _colliderCenter = new Vector3(0f, 0.05f, 0.2f);
                        _colliderRadius = 0.15f;
                        _weaponAttackRange = 0.35f;//0.15+0.2
                                                   //if (!isGeneral)
                                                   //{
                                                   //	ef_swing1.localScale = new Vector3(2f, 2.6f, 2.6f);
                                                   //}
                                                   //else
                                                   //{
                                                   //	ef_swing1.localScale = new Vector3(1.6f, 2f, 2f);
                                                   //}
                        break;
                    }
                case WeaponKind.bow:
                    {
                        _colliderCenter = new Vector3(0f, 0.05f, 0.25f);
                        _colliderRadius = 0.15f;
                        //_attackSpeed += 0.02f;
                        break;
                    }
                case WeaponKind.staff:
                    {
                        _colliderCenter = new Vector3(0f, 0.05f, 0.2f);
                        _colliderRadius = 0.15f;
                        //_attackSpeed -= 0.02f;
                        break;
                    }
                case WeaponKind.magic:
                    {
                        _colliderCenter = new Vector3(0f, 0.05f, 0.25f);
                        _colliderRadius = 0.15f;
                        //ef_swing1.localScale = new Vector3(1.6f, 2f, 2f);
                        //_attackSpeed += 0.04f;
                        break;
                    }
            }

            scriptAttack.SetWeapon(_weaponKind, _specialKind, _specialAmount);

            //collider_center = new Vector3(0f, 0.05f, 0.1f);
            //collider_radius = 0.735f;

            scriptWeapon.SetStageWeapon(_weaponMesh, _weaponKind, _weaponQuality, _specialKind);
            if (change)
            {
                PlayAnimation(Hash_Land_Change_Weapon);
                scriptWeapon.SwitchWepon(-1, 0, 0.2f, 0f);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        private void HpRecover()
        {
            var value = this.GetCurrentValue(CombatAttributeId.HpRecover);
            var percent = this.GetCurrentValue(CombatAttributeId.HpRecoverPercent);
            if (value > 0 || percent > 0)
            {
                Heal(value, percent);
                Sk_Heal();
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public void SpRecover()
        {
            SpCharge(5f);
        }

        /// <summary>
        /// 每关血量恢复
        /// </summary>
        private void HpRecoverStage()
        {
            var value = this.GetCurrentValue(CombatAttributeId.StageHpRecover);
            var percent = this.GetCurrentValue(CombatAttributeId.StageHpRecoverPercent);
            if (value > 0 || percent > 0)
            {
                Heal(value, percent);
                Sk_Heal();
            }
        }

        #endregion

        private bool noeagle;
        private int _autoFindRate;

        public float dashTimer = 3f;

        /// <summary>
        /// 移速提升
        /// </summary>
        /// <param name="amount"></param>
        public void MoveSpeedUp(float amount)
        {
            _moveSpeed = amount;
            _moveSpeedOrigin = amount;

            if (_animator)
            {
                _animator.SetFloat(Hash_Speed_Move, amount * 1.25f);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="value"></param>
        /// <param name="percent"></param>
        public void HpUp(int value, int percent)
        {
            Heal(value, percent);
            UI_Ingame.Instance.ShowEffect("UI_fx_BattleBuff03");
            //GlobalNotifier.PostNotification(GlobalDefine.EVENT_SHOW_EFFECT, "UI_fx_BattleBuff03", "buff");
        }

        /// <summary>
        /// 攻击提升
        /// </summary>
        /// <param name="factor"></param>
        public void AttackUp(int value, int percent)
        {
            AttributeUp((int)CombatAttributeId.Attack, value, percent);
        }

        /// <summary>
        /// 
        /// </summary>
        public void DefenceUp(int value, int percent)
        {
            AttributeUp((int)CombatAttributeId.Defence, value, percent);
        }

        /// <summary>
        /// 属性提升
        /// </summary>
        /// <param name="id"></param>
        /// <param name="value"></param>
        /// <param name="percent"></param>
        public void AttributeUp(int id, int value, int percent)
        {
            int add = value + GetOriginValue(id) * percent / 100;
            AddExtraValue(id, add);

            switch ((CombatAttributeId)id)
            {
                case CombatAttributeId.Hp:
                    SyncHp();
                    UI_Ingame.Instance.ShowEffect("UI_fx_BattleBuff04");
                    //GlobalNotifier.PostNotification(GlobalDefine.EVENT_SHOW_EFFECT, "UI_fx_BattleBuff04", "buff");
                    break;
                case CombatAttributeId.Attack:
                    UI_Ingame.Instance.ShowEffect("UI_fx_BattleBuff02");
                    //GlobalNotifier.PostNotification(GlobalDefine.EVENT_SHOW_EFFECT, "UI_fx_BattleBuff02", "buff");
                    break;
                case CombatAttributeId.Defence:
                    UI_Ingame.Instance.ShowEffect("UI_fx_BattleBuff01");
                    //GlobalNotifier.PostNotification(GlobalDefine.EVENT_SHOW_EFFECT, "UI_fx_BattleBuff01", "buff");
                    break;
                case CombatAttributeId.EvasionRate:
                    UI_Ingame.Instance.ShowEffect("UI_fx_BattleBuff05");
                    //GlobalNotifier.PostNotification(GlobalDefine.EVENT_SHOW_EFFECT, "UI_fx_BattleBuff05", "buff");
                    break;
                case CombatAttributeId.CritRate:
                    UI_Ingame.Instance.ShowEffect("UI_fx_BattleBuff06");
                    //GlobalNotifier.PostNotification(GlobalDefine.EVENT_SHOW_EFFECT, "UI_fx_BattleBuff06", "buff");
                    break;
                case CombatAttributeId.AttackSpeed:
                    UI_Ingame.Instance.ShowEffect("UI_fx_BattleBuff07");
                    SyncAttackSpeed();
                    break;
            }
            scriptEffect.pt_skill_up.gameObject.SetActive(true);
        }

        /// <summary>
        /// 
        /// </summary>
        public void ResetAtk()
        {
            //if (!isGeneral)
            //{
            //	attack = attackOrigin;
            //	hitrate = hitrateOrigin;
            //}
            //else
            //{
            //	attack = g_atk;
            //	hitrate = 100;
            //}
        }

        public void ResetDef()
        {
            //defence = defenceOrigin;
        }

        public void ResetPower()
        {
            if (!isGeneral && _exStart)
            {
                script_ui.ResetPower();

                _pressDelay = 0f;
                _prevTouchPosistion = _currTouchPosistion;
                _exStart = false;
                _scriptSwingEx2.SwingOff();
                SetTrigger(Hash_Cancel_Attack);

                GlobalNotifier.PostNotification(GlobalDefine.EVENT_HOLD_STATE, 0F);
                //PlayInAttackLayer(Hash_None);
                //CrossFade("evade");
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="a"></param>
        public void SpCharge(float a)
        {
            sp = Mathf.Min(sp + a, maxSp);
            script_ui.StatUpdate_sp(sp);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="extraCritical">暴击(>=0)</param>
        public void RndAtk(int extraCritical, int extraDamage = 0, float extraDamagePercent = 0f)
        {
            float tmpDamage = this.sourceTotalAttack;
            if (extraCritical >= 0 && GlobalUtils.RndHundred < (this.sourceTotalCriticalRate + extraCritical))
            {
                scriptEffect.CriticalText();
                tmpDamage = (2f + criticalDamage * 0.01f) * tmpDamage;
                this.critDamage = 1;
            }
            else
            {
                this.critDamage = 0;
            }

            tmpDamage += tmpDamage * extraDamagePercent * 0.01f;
            tmpDamage += extraDamage;

            this.damage = (int)tmpDamage;
        }

        public void ChangeCharacter(int _weapon_kind)
        {
        }

        /// <summary>
        /// 增加经验
        /// </summary>
        /// <param name="amount"></param>
        public void GainExp(float amount)
        {
            scriptEffect.PlayEffect("pt_lvup");

            return;
        }

        /// <summary>
        /// 获取物品
        /// </summary>
        /// <param name="id"></param>
        /// <param name="level"></param>
        public void GetItem(int id, int level)
        {
            var prop = ItemProxy.Instance.GetStaticItem<ItemProp>(id);
            if (prop == null)
            {
                return;
            }

            scriptEffect.ShowGetItemEffect();
            scriptSound.PlaySoundOneShot(scriptSound.sndGetItem);

            if (prop.isWeaponOrEquipment)
            {
                var equipment = GameLevel.Instance.CollectEquipment(prop.id);
                if (equipment != null)
                    UI_Ingame.Instance.GainEquipment(equipment);
                return;
            }
            else if (prop.type == Item.Type.Money)
            {
                int money = level;
                if (id == Item.Id.kCoin)
                {
                    money = level + level * coinBoost / 100;
                }
                UI_Ingame.Instance.GainMoney(id, money);
                GameLevel.Instance.CollecMoney(id, money);
            }
            else if (prop.type == Item.Type.Prop)//新加道具类型2的获取
            {
                GameLevel.Instance.CollecMoney(id, level);
            }
            else if (prop.type == Item.Type.Gem)
            {
                GameLevel.Instance.CollecGem(id, level);
            }
            else if (prop.type == 5)
            {
                MissionProxy.Instance.OnEvent(MissionProxy.累计获得指定道具, 1, prop.id);
#if !UNITY_WEBGL && UNITY_EDITOR
                if (!KGMOptions.Instance.自动挂机)
                    KUIWindow.OpenWindow<UI.GetKungfuBox>(prop);
#else
                KUIWindow.OpenWindow<UI.GetKungfuBox>(prop);
#endif
            }
            else if (prop.type == 11)
            {
                MissionProxy.Instance.OnEvent(MissionProxy.累计获得指定道具, 1, prop.id);
#if !UNITY_WEBGL && UNITY_EDITOR
                if (!KGMOptions.Instance.自动挂机)
                {
                    var book = ItemProxy.Instance.GetStaticItem<ItemBook>(level);
                    KUIWindow.OpenWindow<UI.GetBookBox>(book);
                }
#else
                var book = ItemProxy.Instance.GetStaticItem<ItemBook>(level);
                KUIWindow.OpenWindow<UI.GetBookBox>(book);
#endif
            }
            else if (prop.type == 7)
            {
                MissionProxy.Instance.OnEvent(MissionProxy.累计获得指定道具, 1, prop.id);
                KUIWindow.OpenWindow<UI.GetBookBox>(prop);
            }
            GlobalNotifier.PostNotification(GlobalDefine.EVENT_INGAME_GET_ITEM, prop, "prop");
        }

        public void Heal(int a, int percent)
        {
            if (curHp >= maxHp)
            {
                curHp = maxHp;
                return;
            }

            int add = a + maxHp * percent / 100;
            curHp = Mathf.Min(curHp + add, maxHp);

            _skHealTime = 1f;
            scriptEffect.pt_heal.gameObject.SetActive(true);

            //if (isGeneral)
            //{
            //	g_hp = curHp;
            //}
            //else
            //{
            //	_chaHp = curHp;
            //}

            UpdateHpBar();
        }

        private float _skHealTime;
        public void Sk_Heal()
        {
            _skHealTime -= 1f;
            if (_skHealTime < 0f)
                scriptEffect.pt_heal.gameObject.SetActive(false);
        }


        #region Field

        private readonly ObscuredVector3Int[] _values = new ObscuredVector3Int[(int)CombatAttributeId.kMax];

        /// <summary>
        /// 防御破坏
        /// </summary>
        private int _guardBreak;

        #endregion

        #region Property

        /// <summary>
        /// 
        /// </summary>
        public int sourceTotalHp
        {
            get
            {
                int fixedV = GetCurrentValue(CombatAttributeId.Hp);
                int percentV = GetCurrentValue(CombatAttributeId.HpPercent);
                return fixedV + Mathf.CeilToInt(fixedV * percentV * 0.01f);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public int sourceTotalAttack
        {
            get
            {
                int fixedV = GetCurrentValue(CombatAttributeId.Attack);
                int percentV = GetCurrentValue(CombatAttributeId.AttackPercent);
                return fixedV + Mathf.CeilToInt(fixedV * percentV * 0.01f);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public int sourceTotalDefence
        {
            get
            {
                int fixedV = GetCurrentValue(CombatAttributeId.Defence);
                int percentV = GetCurrentValue(CombatAttributeId.DefencePercent);
                return fixedV + Mathf.CeilToInt(fixedV * percentV * 0.01f);
            }
        }

        /// <summary>
        /// 命中率
        /// </summary>
        public int sourceTotalHitRate
        {
            get
            {
                int fixedV = GetCurrentValue(CombatAttributeId.Hit);
                int rateV = GetCurrentValue(CombatAttributeId.HitRate);
                return rateV + Mathf.CeilToInt(fixedV * 0.01f);
            }
        }

        /// <summary>
        /// 闪避率
        /// </summary>
        public int sourceTotalEvasionRate
        {
            get
            {
                int fixedV = GetCurrentValue(CombatAttributeId.Evasion);
                int rateV = GetCurrentValue(CombatAttributeId.EvasionRate);
                return rateV + Mathf.CeilToInt(fixedV * 0.01f);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public int sourceTotalCriticalRate
        {
            get
            {
                int fixedV = GetCurrentValue(CombatAttributeId.Crit);
                int rateV = GetCurrentValue(CombatAttributeId.CritRate);
                return rateV + Mathf.CeilToInt(fixedV * 0.01f);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public int criticalDamage
        {
            get => GetCurrentValue(CombatAttributeId.CritDamageRate);
            set => SetExtraValue(CombatAttributeId.CritDamageRate, value);
        }

        /// <summary>
        /// 格挡
        /// </summary>
        public int block
        {
            get => GetCurrentValue(CombatAttributeId.BlockRate);
            set => SetExtraValue(CombatAttributeId.BlockRate, value);
        }

        /// <summary>
        /// 抵挡
        /// </summary> 
        public int resist
        {
            get => GetCurrentValue(CombatAttributeId.BlockResistRate);
            set => SetExtraValue(CombatAttributeId.BlockResistRate, value);
        }

        /// <summary>
        /// 
        /// </summary>
        public int reduceCd
        {
            get => Mathf.Min(40, GetCurrentValue(CombatAttributeId.Cooldown));
            set => SetExtraValue(CombatAttributeId.Cooldown, value);
        }

        /// <summary>
        /// 
        /// </summary>
        public int 伤害加深百分比
        {
            get => Mathf.Min(40, GetCurrentValue(CombatAttributeId.伤害加深百分比));
        }

        public int 忽视防御固定值
        {
            get => GetCurrentValue(CombatAttributeId.忽视防御固定值);
        }

        public int 忽视防御百分比
        {
            get => Mathf.Min(40, GetCurrentValue(CombatAttributeId.忽视防御百分比));
        }

        /// <summary>
        /// 
        /// </summary>
        public int hpMaxOrigin
        {
            get => GetOriginValue(CombatAttributeId.Hp);
        }

        /// <summary>
        /// 
        /// </summary>
        public int attackOrigin
        {
            get => GetOriginValue(CombatAttributeId.Attack);
        }

        /// <summary>
        /// 
        /// </summary>
        public int hitrateOrigin
        {
            get => GetOriginValue(CombatAttributeId.HitRate);
        }

        /// <summary>
        /// 
        /// </summary>
        public int defenceOrigin
        {
            get => GetOriginValue(CombatAttributeId.Defence);
        }

        /// <summary>
        /// 
        /// </summary>
        public int coinBoost
        {
            get => GetCurrentValue(CombatAttributeId.CoinDropAdd);
        }

        /// <summary>
        /// 
        /// </summary>
        public int dropBoost
        {
            get => GetCurrentValue(CombatAttributeId.稀有装备掉落);
        }

        #endregion

        #region Method

        /// <summary>
        /// 
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public int GetCurrentValue(CombatAttributeId id)
        {
            return _values[(int)id].xyz;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public int GetCurrentValue(int id)
        {
            return _values[id].xyz;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="id"></param>
        /// <param name="value"></param>
        public void SetExtraValue(CombatAttributeId id, int value)
        {
            _values[(int)id].y = value;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="id"></param>
        /// <param name="value"></param>
        public void SetExtraValue(int id, int value)
        {
            _values[id].y = value;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="id"></param>
        /// <param name="value"></param>
        public void AddExtraValue(CombatAttributeId id, int value)
        {
            _values[(int)id].y += value;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="id"></param>
        /// <param name="value"></param>
        public void AddExtraValue(int id, int value)
        {
            _values[id].y += value;
        }

        /// <summary>
        /// 临时
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public int GetTemporaryValue(int id)
        {
            return _values[id].z;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="id"></param>
        /// <param name="value"></param>
        public void SetTemporaryValue(CombatAttributeId id, int value)
        {
            _values[(int)id].z = value;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="id"></param>
        /// <param name="value"></param>
        public void SetTemporaryValue(int id, int value)
        {
            _values[id].z = value;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="id"></param>
        /// <param name="value"></param>
        public void AddTemporaryValue(int id, int value)
        {
            _values[id].z += value;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public int GetOriginValue(CombatAttributeId id)
        {
            return _values[(int)id].x;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public int GetOriginValue(int id)
        {
            return _values[id].x;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="id"></param>
        /// <param name="value"></param>
        public void SetOriginValue(CombatAttributeId id, int value)
        {
            _values[(int)id].x = value;// 
        }

        public void SetOriginValue(int id, int value)
        {
            _values[id].x = value;// 
        }

        #endregion
    }
}