using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

/// <summary>
/// 角色[游戏数据]
/// </summary>
public class GameHeroVo
{
    /// <summary>
    /// 是否是我自己的英雄 Ps. 本字段为本地字段,未同步到网络.   
    /// 是我的= true, 其他人的= false
    /// </summary>
    public bool IsMyOwnerHero = false;

    /// <summary>
    /// 唯一ID
    /// </summary>
    public string uid { get; set; } = "0";

    /// <summary>
    ///  模板数据id
    /// </summary>
    public string typeId { get; set; }

    /// <summary>
    ///当前的经验(角色吃经验丹获得经验从而使level值成长.)
    /// </summary>
    public int xp { get; set; }
    /// <summary>
    /// 当前等级进展，累计的总经验
    /// </summary>  
    public int maxXp
    {
        get
        {
            
            if (this.starLimitLv == this.level)
            {
                return xp;
            }

            var lvMo = GameConfigData.Ins.Gethero_levelexpMo(this.level + 1);
            if (null != lvMo)
            {
                return lvMo.requiredExp;
            }
            return GameConfigData.Ins.Gethero_levelexpMo(this.level).requiredExp;
        }

    }

    /// <summary>
    /// 当前等级(level值决定了其他属性如hp, phyAtk,等的成长(公式))
    /// </summary>
    public int level { get; set; } = 1;

    /// <summary>
    /// 品阶(S A B C D)(品阶可以通过吃碎片成长)
    /// </summary>
    public string grade { get; set; } = "D";

    /// <summary>
    /// 武器数据引用
    /// </summary>
    internal GameCollectEquips EquipRef;
    /// <summary>
    /// 言灵数据引用
    /// </summary>
    internal GameCollectYanling YanlingRef;

    #region 扩展功能标签
    /// <summary>
    /// 判断自己是否是队长
    /// </summary>
    public bool IsTeamLeader => UserProxy.Instance.player.heroTeamConfig.teamDic.Values.ToList().Exists(team => team.CurTeamLeaderUID == this.uid);

    /// <summary>
    /// 判断自己是否已经有战队了
    /// </summary>
    public bool IsInTeam => int.Parse(this.uid) > 0 && UserProxy.Instance.player.heroTeamConfig.teamDic.Values.ToList().Exists(team => team.heros.Contains(this.uid));

    /// <summary>
    /// 是否可升级, 玩家等级限制英雄等级
    /// </summary>
    /// <returns></returns>
    public bool HeroCanLevelUp => this.level < (sm_playerlevel.getUserLvById(UserProxy.Instance.player.baseInfo.level)?.hero_max_level ?? 15); // 找不到配置数据, 默认最大15级

    /// <summary>
    ///  英雄的模板数据源
    /// </summary>
    public sm_hero mo => sm_hero.GetMoByID(this.typeId);

    #endregion


    #region 技能
    // UNDONE : 技能部分梳理好,补充这里 -- 王刚 2019年12月4日
    // 原来  : 普通技能, 手动1, 手动2, 被动技能和队长技能.
    // 新的  : 普攻、必杀、被动、闪避、队长技
    /// <summary>
    /// 技能等级信息记录
    /// key  为技能ID,value为技能对应的等级
    /// </summary>
    [Obsolete("旧技能信息", true)]
    public Dictionary<string, int> skillDic = new Dictionary<string, int>();

    /// <summary>
    /// 子技能列表(子技能id)
    /// </summary>
    public Dictionary<int, List<int>> subSkills = new Dictionary<int, List<int>>();

    /// <summary>
    /// 查询可解锁技能列表
    /// </summary>
    /// <returns></returns>
    public List<sm_subSkill> GetUnlockAbleSkills(int mainSkillId)
    {
        var li = new List<sm_subSkill>();
        var ssl = sm_subSkill.GetSubSkillsByMainSkillId(mainSkillId)           // 取主技能对应的子技能集合  
            .Where(sm => sm.level == 1);                                       // 未解锁,限定为1级技能
        foreach (var sm in ssl)
        {
            bool find = false;
            if (this.subSkills.ContainsKey(mainSkillId))                       // 防御
            {
                var itor_sm = sm;
                if (this.subSkills[mainSkillId].Contains(itor_sm.subSkillId))
                {
                    find = true;
                }
                else
                {
                    while (itor_sm.nextLevel_Id > 0)
                    {                                                         // 整个链条上的id都判断一遍
                        if (this.subSkills[mainSkillId].Contains(itor_sm.nextLevel_Id))
                        {
                            find = true;
                            break;
                        }
                        itor_sm = sm_subSkill.GetMoById(itor_sm.nextLevel_Id);
                    }
                }
            }
            if (!find && sm.canUnlock(this))                                   // 英雄子技能列表中不包含的id判定为待解锁状态
            {
                li.Add(sm);
            }
        }
        return li;
    }

    /// <summary>
    /// 查询可升级子技能
    /// </summary>
    /// <returns></returns>
    public List<sm_subSkill> GetUpdateAbleSkills(int mainSkillId)
    {
        var li = new List<sm_subSkill>();
        if (this.subSkills.ContainsKey(mainSkillId))
        {
            foreach (var id in this.subSkills[mainSkillId])
            {
                var sk = sm_subSkill.GetMoById(id);
                if (sk.canUpgrade(this))
                {
                    li.Add(sk);
                }
            }
        }

        return li;
    }

    /// <summary>
    /// 取一个主技能底下的所有子技能
    /// </summary>
    /// <param name="mainSkillId"></param>
    /// <returns></returns>
    public List<sm_subSkill> GetSubSkills(int mainSkillId)
    {
        var li = new List<sm_subSkill>();
        var ssl = sm_subSkill.GetSubSkillsByMainSkillId(mainSkillId)           // 取主技能对应的子技能集合  
            .Where(sm => sm.level == 1);                                       // 未解锁,限定为1级技能
        foreach (var sm in ssl)
        {
            bool find = false;
            if (this.subSkills.ContainsKey(mainSkillId))                       // 防御
            {
                var itor_sm = sm;
                if (this.subSkills[mainSkillId].Contains(itor_sm.subSkillId))
                {
                    find = true;
                    li.Add(sm);
                    continue;
                }
                else
                {
                    while (itor_sm.nextLevel_Id > 0)
                    {                                                         // 整个链条上的id都判断一遍
                        if (this.subSkills[mainSkillId].Contains(itor_sm.nextLevel_Id))
                        {
                            find = true;
                            break;
                        }
                        itor_sm = sm_subSkill.GetMoById(itor_sm.nextLevel_Id);
                    }
                }
            }
            if (!find)                                                        // 英雄子技能列表中不包含的id判定为待解锁状态
            {
                li.Add(sm);
            }
        }
        return li;
    }
    /// <summary>
    /// 队长技
    /// </summary>
    /// <returns></returns>
    public sm_skill SkillLeader()
    {
        return sm_skill.GetMoByID(int.Parse(this.mo.skill_leader));
    }

    /// <summary>
    /// 普通攻击技能
    /// </summary>
    /// <returns></returns>
    public sm_skill SkillNormal()
    {
        return sm_skill.GetMoByID(int.Parse(this.mo.GetNormalSkills()[0]));
        //return sm_skill.GetMoByID(int.Parse(this.mo.skill_normal));
    }

    /// <summary>
    /// 必杀技
    /// </summary>
    /// <returns></returns>
    public sm_skill SkillBisha()
    {
        return sm_skill.GetMoByID(int.Parse(this.mo.skill_bisha));
    }

    /// <summary>
    /// 闪避/冲刺
    /// </summary>
    /// <returns></returns>
    public sm_skill SkillShanbi()
    {
        return sm_skill.GetMoByID(int.Parse(this.mo.skill_shanbi));
    }

    /// <summary>
    /// 被动技
    /// </summary>
    /// <returns></returns>
    public sm_skill SkillBeidong()
    {
        return sm_skill.GetMoByID(int.Parse(this.mo.skill_beidong));
    }

    #endregion

    /*  一个英雄 有3个装备槽: waepon、armor、ring */
    #region 装备
    /// <summary>
    ///  英雄的装备信息
    ///  key = [waepon. armor. ring]
    ///  value = 装备UID
    /// </summary>
    public Dictionary<string, HeroGameVo_Equip> equips = new Dictionary<string, HeroGameVo_Equip>();

    /// <summary>
    /// 拉取本英雄可用的装备列表
    /// </summary>
    /// <returns></returns>
    public List<UserEquipmentVo> UsableWeapons()
    {
        return UserProxy.Instance.player.collectEquip.FindUseableEquips(int.Parse(this.typeId));
    }

    #endregion

    /*  一个英雄 有3个言灵槽: left:1、middle:2、right:3 */
    #region 言灵
    /// <summary>
    ///  英雄的言灵信息 (暂时先用字符串吧,优化的时候再说(王刚2020年1月2日18:50:53))
    ///  key = [1. 2. 3]
    /// </summary>
    public Dictionary<int, HeroGameVo_Yanling> yanling = new Dictionary<int, HeroGameVo_Yanling>();
    /// <summary>
    /// 英雄的言灵信息---新的 2021.6.22
    /// </summary>
    public Dictionary<int, UserYanlingVo> hero_yanling
    {
        get
        {
            Dictionary<int, UserYanlingVo> dic = new Dictionary<int, UserYanlingVo>();

            foreach (KeyValuePair<int, HeroGameVo_Yanling> kv in this.yanling)
            {

                if (UserProxy.Instance.player.collectYanling.items.ContainsKey(kv.Value.itemuid))
                {
                    UserYanlingVo vo = UserProxy.Instance.player.collectYanling.items[kv.Value.itemuid];
                    dic[kv.Key] = vo;
                }
                else
                {
                    UserYanlingVo vo = new UserYanlingVo();
                    dic[kv.Key] = vo;
                }
            }

            return dic;
        }
    }

    /// <summary>
    /// 拉取本英雄可用的言灵列表
    /// </summary>
    /// <returns></returns>
    public List<UserYanlingVo> UsableYanling()
    {
        return UserProxy.Instance.player.collectYanling.FindUseableYanlings(int.Parse(this.typeId));
    }

    /// <summary>
    /// 当前英雄装配的言灵套系属性加成
    /// </summary>
    public List<yanlingComposeDataVo> hero_yanlingComposeAttr
    {
        get
        {
            List<yanlingComposeDataVo> list = new List<yanlingComposeDataVo>();

            List<int> cIdList = new List<int>();
            foreach (KeyValuePair<int, UserYanlingVo> kv in this.hero_yanling)
            {
                if (kv.Value.typeId == null)
                {
                    continue;
                }

                int id = kv.Value.nMo.GetYanlingExt().composeId;
                cIdList.Add(id);
            }

            if (cIdList.Count == 0)
            {
                return list;
            }

            int count = 0;
            int composeId = 0;
            foreach (var item in cIdList.GroupBy(c => c))
            {
                int n = item.Count();
                if (count < n)
                {
                    count = n;
                    composeId = item.Key;
                }
            }

            if (composeId == 0)
            {
                return list;
            }

            if (count <= 1)
            {
                return list;
            }

            sm_yanling_compose mo = GameConfigData.Ins.Getyanling_composeMo(composeId);
            if (mo == null)
            {
                return list;
            }

            string[] twoList = mo.two_compose.Split(',');
            int attrType = int.Parse(twoList[0]);

            yanlingComposeDataVo vo = new yanlingComposeDataVo();
            vo.composeId = composeId;
            vo.isShow = false;
            if (count >= 2)
            {
                vo.isShow = true;
            }
            vo.attr = (EHeroAddProperties)attrType;
            vo.desc = mo.two_desc;
            vo.attrName = mo.name;
            vo.type = int.Parse(twoList[1]);
            vo.val = int.Parse(twoList[2]);
            list.Add(vo);

            //sm_yanling_compose newMo = GameConfigData.Ins.Getyanling_composeMo(composeId);
            string[] threeList = mo.three_compose.Split(',');
            int attrType_3 = int.Parse(threeList[0]);
            yanlingComposeDataVo vo_3 = new yanlingComposeDataVo();
            vo_3.composeId = composeId;
            vo_3.isShow = false;
            if (count >= 3)
            {
                vo_3.isShow = true;
            }
            vo_3.attr = (EHeroAddProperties)attrType_3;
            vo_3.desc = mo.three_desc;
            vo_3.attrName = mo.name;
            vo_3.type = int.Parse(threeList[1]);
            vo_3.val = int.Parse(threeList[2]);
            list.Add(vo_3);

            return list;
        }
    }

    public string yanlingComseName
    {
        get
        {
            if (this.hero_yanlingComposeAttr.Count == 0)
            {
                return "";
            }

            if (this.hero_yanlingComposeAttr[0].composeId == 0)
            {
                return "";
            }

            sm_yanling_compose mo = GameConfigData.Ins.Getyanling_composeMo(this.hero_yanlingComposeAttr[0].composeId);
            if (mo == null)
            {
                return "";
            }

            return mo.name;
        }
    }
    #endregion
    #region 过时

    /// <summary>
    /// 英雄锁定状态()
    /// true=  被锁定
    /// false = 未锁定
    /// </summary>
    [Obsolete("")]
    public bool isLocked { get; set; }

    /// <summary>
    /// 当前等阶 默认是0--------这个应该是废弃的-----2022-7-13最新注释:这个字段最开始应该是星级，后来升星功能改变用curStar字段了
    /// 这个字段是废弃的
    /// 0  1  2  3  4  5
    /// 绿 蓝 红 紫 橙
    /// </summary>
    [Obsolete("新规划只有等级和等阶两个强化 维度 ")]
    public int strengthLevel { get; set; }

    /// <summary>
    /// //升星
    /// 当前星级 默认是0星
    /// </summary>
    public int curStar { get; set; }

    /// <summary>
    /// 默认的当前神血等级
    /// 默认是0
    /// 最大是9 ～～～
    /// </summary>
    [Obsolete("新规划只有等级和等阶两个强化 维度 ")]
    public int curBloodId { get; set; }

    /// <summary>
    /// 当前星级限制的等级
    /// </summary>
    public int starLimitLv
    {
        get
        {
            sm_heroextra_level_tupo mo = sm_heroextra_level_tupo.GetMoById(int.Parse(this.typeId), this.curStar);
            if (mo == null)
            {
                return 0;
            }

            return mo.promoteLv;
        }
    }
    /// <summary>
    /// 突破的玩家等级限制
    /// </summary>
    public int userLimitLv
    {
        get
        {
            if (this.curStar >= 5)
            {
                return 0;
            }
            sm_heroextra_level_tupo mo = sm_heroextra_level_tupo.GetMoById(int.Parse(this.typeId), this.curStar + 1);
            return mo.userlvLimit;
        }
    }

    /// <summary>
    /// 是不是升级按钮 true：是
    /// </summary>
    public bool isUpgrade
    {
        get
        {
            if (this.curStar >= 5)
            {
                return true;
            }
            //&& UserProxy.Instance.player.baseInfo.level >= sm_heroextra_level_tupo.GetMoById(int.Parse(this.typeId), this.curStar + 1).userlvLimit
            if (this.level >= this.starLimitLv)
            {
                return false;
            }
            return true;
        }
    }
    /// <summary>
    /// 消耗的道具----突破
    /// </summary>
    public List<ItemVo> costItem_tupo
    {
        get
        {
            List<ItemVo> list = new List<ItemVo>();
            if (this.curStar >= 5)
            {
                return list;
            }

            sm_heroextra_level_tupo mo = sm_heroextra_level_tupo.GetMoById(int.Parse(this.typeId), this.curStar + 1);

            string[] sList = mo.costItems.Split(';');
            foreach (string item in sList)
            {
                string[] str = item.Split(',');
                ItemVo vo = new ItemVo();
                vo.typeId = str[0];
                vo.count = int.Parse(str[1]);
                list.Add(vo);
            }

            ItemVo itVo = new ItemVo();
            itVo.typeId = mo.segID.ToString();
            itVo.count = mo.segNum;
            list.Add(itVo);

            return list;
        }
    }
    /// <summary>
    /// 升级消耗道具
    /// </summary>
    public List<ItemVo> costItem_up
    {
        get
        {
            List<ItemVo> list = new List<ItemVo>();
            Dictionary<int, sm_item_stones> item_stonesMo = GameConfigData.Ins.item_stones;
            Dictionary<string, ItemVo> cDic = UserProxy.Instance.player.collectItem.collectItemDic;
            foreach (KeyValuePair<int, sm_item_stones> kv in item_stonesMo)
            {
                if (cDic.ContainsKey(kv.Key.ToString()))
                {
                    list.Add(cDic[kv.Key.ToString()]);
                }
            }

            return list;
        }
    }

    /// <summary>
    /// 当前金币值
    /// </summary>
    public int curGold
    {
        get
        {
            return UserProxy.Instance.player.baseInfo.gold;
        }
    }
    /// <summary>
    /// 突破需要的金币
    /// </summary>
    public int costGold_tupo
    {
        get
        {
            if (this.curStar >= 5)
            {
                return 0;
            }
            sm_heroextra_level_tupo mo = sm_heroextra_level_tupo.GetMoById(int.Parse(this.typeId), this.curStar + 1);

            return mo.gold;
        }
    }

    /// <summary>
    /// 唤灵师星级限制的等级下的经验最大值
    /// </summary>
    public int lvLimitMaxExp
    {
        get
        {
            Dictionary<int, sm_hero_levelexp> hero_levelexp = GameConfigData.Ins.hero_levelexp;

            int n = 0;
            foreach (KeyValuePair<int, sm_hero_levelexp> kv in hero_levelexp)
            {
                if (kv.Key <= this.level)
                {
                    continue;
                }

                n += kv.Value.needExp;

                if (kv.Key > this.starLimitLv)
                {
                    break;
                }
            }

            return n;
        }
    }

    #endregion

    #region 新增 方法
    /// <summary>
    /// 英雄增加经验
    /// </summary>
    /// <param name="add"></param>
    /// <returns></returns>
    public int AddExp(int add)
    {
        var maxLevel = GlobalParameter.Instance.Hero_Upgrade_BasicMaxLevel;     // 最大等级
        if (this.level >= maxLevel)
        {
            return 0;                                                           // 已达顶级
        }
        var lvMo = GameConfigData.Ins.Gethero_levelexpMo(this.level + 1);
        this.xp += add;
        Debug.Assert(this.xp >= 0, "[" + this.uid + "] : HeroExp is negative!");
        while (this.xp >= lvMo.needExp)
        {
            if (this.level < maxLevel)
            {                                                                  // 如果未到达最大等级
                //var nextlv = this.level + 1;
                this.level += 1;
                if (this.level >= maxLevel)
                {
                    this.xp = lvMo.needExp;
                }
                else
                {
                    this.xp -= lvMo.needExp;
                }
                //this.maxXp = lvMo.needExp;
                lvMo = GameConfigData.Ins.Gethero_levelexpMo(this.level + 1);
            }
            else
            {                                                                   // 如果已到达最大等级则仅补齐缺失的经验即可
                this.xp = this.maxXp;                                           // 经验不能超过最大值
                break;
            }
        }
        return this.xp;
    }
    /// <summary>
    /// 克隆方法 
    /// </summary>
    /// <returns></returns>
    public GameHeroVo Clone()
    {
        return (GameHeroVo)this.MemberwiseClone();
    }

    /// <summary>
    /// 是否已经拥有(解锁)此英雄
    /// </summary>
    public bool IsOwned
    {
        get
        {
            return (!string.IsNullOrWhiteSpace(this.uid) && int.Parse(this.uid) > 0);  // 拥有实例id代表已经拥有此英雄
        }
    }

    #region undone: 装备、言灵
    /// <summary>
    /// 获取英雄装备的武器信息(待补完)
    /// </summary>
    /// <returns></returns>
    public HeroGameVo_Equip GetWeapon()
    {
        return this.equips["weapon"];
        //// todo: 待武器模块补完后, 修补这里. --wg 2019年12月4日13:50:40
        //return null;
    }
    /// <summary>
    /// 获取已经装备的言灵信息
    /// </summary>
    public void GetYanlingInfo()
    {
        // todo: 待言灵模块添加后, 修补这里. --王刚 2019年12月4日 
    }
    #endregion 

    #region 升级与进阶   
    /// <summary>
    /// 废弃
    /// </summary>
    public sm_heroextra_level mo_Grade_cur
    {
        get
        {
            return sm_heroextra_level.GetMoById(this.mo.heroId, this.grade);
        }
    }

    public string nextGrade
    {
        get
        {
            var cur = (EHeroQuality)Enum.Parse(typeof(EHeroQuality), this.grade);
            return (cur + 1).ToString();
        }
    }
    public sm_heroextra_level nextGradeMo
    {
        get
        {
            return sm_heroextra_level.GetMoById(this.mo.heroId, this.nextGrade);
        }
    }
    /// <summary>
    /// 下一等级
    /// </summary>
    public int nextLevel
    {
        get
        {
            var next = this.level + 1;
            if (next > sm_hero_levelexp.GetMaxLevel()) // 最大等级校验 -wg 2019年12月4日17:26:19
            {
                next = sm_hero_levelexp.GetMaxLevel();
            }
            return next;
        }
    }
    public sm_hero_levelexp mo_HeroLevelExp_cur { get { return sm_hero_levelexp.GetMoById(this.level); } }
    public sm_hero_levelexp mo_HeroLevelExp_next { get { return sm_hero_levelexp.GetMoById(this.nextLevel); } }
    /// <summary>
    /// 想要升阶还需再获得多少个碎片
    /// </summary>
    public int upGradeNeedMoreSegments
    {
        get
        {
            if (this.grade == "S")
            {
                return 0;                 // 已经达到顶级
            }

            var needNum = this.NextGradeRequireSegNumber - HasSegNub;
            return needNum > 0 ? needNum : 0;
        }
    }
    /// <summary>
    /// 拥有碎片数量
    /// </summary>
    public int HasSegNub { get { return UserProxy.Instance.player.collectItem.GetItemCount(this.mo_segment.typeId.ToString()); } }
    /// <summary>
    /// 进阶到下一阶要求的碎片数量
    /// </summary>
    public int NextGradeRequireSegNumber
    {
        get { return this.nextGradeMo.segNum; }
    }
    /// <summary>
    /// 对应的碎片mo
    /// </summary>
    public sm_item_base mo_segment
    {
        get
        {
            var seg = sm_item_segment.GetMoByHeroId(int.Parse(this.typeId));
            return sm_item_base.GetMoById(seg.typeId);
        }
    }
    /// <summary>
    /// 碎片图标
    /// </summary>
    public string SegmentIcon
    {
        get
        {
            return mo_segment.icon;
        }
    }
    #endregion

    #endregion


    #region 方法

    // todo: 下面的代码尚未整理 -wg  2019年12月4日

    /// <summary>
    /// 根据查询的技能类型，获取该类型技能对应的等级信息
    /// </summary>
    /// <param name="skillType">"normalSkill","manuSkill1","manuSkill2","passiveSkill", </param>
    /// <returns></returns>
    [Obsolete("2019年12月31日", true)]
    public int GetSkillLevel(string skillType)
    {
        int level = 1;
        if (skillDic.ContainsKey(skillType))
        {
            level = skillDic[skillType];
        }
        return level;
    }

    /// <summary>
    /// 获取该角色战斗力数值
    /// 生命值+物理攻击*4+魔法强度*4+护甲*5+魔抗*5
    /// </summary>
    /// <returns></returns>
    public int GetPower()
    {
        return (int)(getHpForBattle() * 1.0f
            + getNengLiangZhiJiForBattle() * 0
            + getWuLiGongJiForBattle() * 4
            + getFaShuQiangDuForBattle() * 4
            + getFangYuHuJiaForBattle() * 5
            + getMoFaKangXingForBattle() * 5
            );
    }

    /// <summary>
    /// 获得角色装备的 物品提供的属性加成
    /// </summary>
    /// <param name="attribute"></param>
    /// <returns></returns>
    protected float getEquipExtraProperty(EHeroProperties attribute)
    {
        float result = 0;

        if (this.equips.Count == 0)
        {
            return result;
        }
        Player player = UserProxy.Instance.player;
        foreach (string key in equips.Keys)
        {
            HeroGameVo_Equip vo = equips[key];
            if (player.collectEquip.equipments.ContainsKey(int.Parse(vo.equipItemUID)))
            {
                Dictionary<EHeroProperties, int> baseAttr = player.collectEquip.equipments[int.Parse(vo.equipItemUID)].baseAttr;
                if (baseAttr.ContainsKey(attribute))
                {
                    result += baseAttr[attribute];
                }
            }
        }
        return result;
        #region
        /*
        if (!IsMyOwnerHero)
        {
            foreach (string key in equips.Keys)
            {
                //todo: 这两处, 通过itemId去Ref里面查找实例,计算加成. 
                HeroGameVo_Equip vo = equips[key];
                if (EquipRef.equipments.ContainsKey(int.Parse(vo.equipItemUID)))
                {
                    ItemVo item = EquipRef.equipments[int.Parse(vo.equipItemUID)];
                    var wp = item.nMo.GetWeaponExt();
                    switch (attribute)
                    {
                        case EHeroProperties.WULIGONGJI:
                            result += wp.phyAtk;
                            break;
                        case EHeroProperties.FASHUQIANGDU:
                            result += wp.fashuqiangdu;
                            break;
                        case EHeroProperties.CRICITAL:
                            result += wp.crit;
                            break;
                    }

                }
            }
        }
        else
        {
            Player player = UserProxy.Instance.player;
            foreach (string key in equips.Keys)
            {
                HeroGameVo_Equip vo = equips[key];
                if (player.collectEquip.equipments.ContainsKey(int.Parse(vo.equipItemUID)))
                {
                    ItemVo item = player.collectEquip.equipments[int.Parse(vo.equipItemUID)];
                    var wp = item.nMo.GetWeaponExt();
                    switch (attribute)
                    {
                        case EHeroProperties.WULIGONGJI:
                            result += wp.phyAtk;
                            break;
                        case EHeroProperties.FASHUQIANGDU:
                            result += wp.fashuqiangdu;
                            break;
                        case EHeroProperties.CRICITAL:
                            result += wp.crit;
                            break;
                    }
                }
            }
        }
        return result;
        */
        #endregion
    }
    /// <summary>
    /// 获得角色装备的言灵提供的属性加成
    /// </summary>
    /// <param name="attribute"></param>
    /// <returns></returns>
    protected float getYanlingExtraProperty(EHeroProperties attribute)
    {
        float result = 0;
        if (this.hero_yanling.Count == 0)
        {
            return result;
        }

        foreach (KeyValuePair<int, UserYanlingVo> kv in this.hero_yanling)
        {
            if (kv.Value.typeId != null)
            {
                Dictionary<EHeroProperties, int> baseAttr = kv.Value.baseAttr;
                if (baseAttr.ContainsKey(attribute))
                {
                    int baseNum = baseAttr[attribute];
                    Dictionary<EHeroAddProperties, int> rAttr = kv.Value.randAttr;
                    Dictionary<EHeroAddProperties, int> gRandAttr = kv.Value.gemrRandAttr;
                    List<yanlingComposeDataVo> ylComposeAttr = kv.Value.yanlingComposeAttr;

                    int attr = (int)attribute;
                    int add = 0;
                    if (rAttr.ContainsKey((EHeroAddProperties)attr))
                    {
                        add += rAttr[(EHeroAddProperties)attr];
                    }
                    if (gRandAttr.ContainsKey((EHeroAddProperties)attr))
                    {
                        add += gRandAttr[(EHeroAddProperties)attr];
                    }

                    if (ylComposeAttr.Count != 0)
                    {
                        foreach (yanlingComposeDataVo vo in ylComposeAttr)
                        {
                            if (vo.isShow == false)
                            {
                                continue;
                            }

                            if (vo.attr == (EHeroAddProperties)attr)
                            {
                                add += vo.val;
                            }
                        }
                    }

                    result += 1.0f * add / 100 * baseNum + baseNum;
                }
            }
        }

        return result;


        #region
        /*
        if (IsMyOwnerHero)
        {
            foreach (var yl in this.yanling)
            {
                if (yl.Value != null && yl.Value.itemuid > 0)                           // 判断是否装备了言灵
                {
                    var mo = yl.Value.Mo().GetYanlingExt();
                    if (mo != null)
                    {
                        switch (attribute)
                        {
                            case EHeroProperties.HP:
                                result += mo.TrueHp;
                                break;
                            case EHeroProperties.WULIGONGJI:
                                result += mo.TruePhyAtk;
                                break;
                            case EHeroProperties.FASHUQIANGDU:
                                result += mo.TrueFashuqiangdu;
                                break;
                            case EHeroProperties.CRICITAL:
                                result += mo.TrueCrit;
                                break;
                            case EHeroProperties.FANGYUHUJIA:
                                result += mo.TruePhyDef;
                                break;
                            case EHeroProperties.MOFAKANGXING:
                                result += mo.TrueMofakangxing;
                                break;
                            default:
                                break;
                        }
                    }
                }
            }

        }
        else
        {
            // 非玩家数据,暂定为空
            foreach (var yl in this.yanling)
            {
                if (yl.Value.itemuid > 0)                           // 判断是否装备了言灵
                {
                    var itemId = yl.Value.typeId;
                    var mo = sm_item_base.GetMoById(itemId).GetYanlingExt();
                    if (mo != null)
                    {
                        switch (attribute)
                        {
                            case EHeroProperties.HP:
                                result += mo.TrueHp;
                                break;
                            case EHeroProperties.WULIGONGJI:
                                result += mo.TruePhyAtk;
                                break;
                            case EHeroProperties.FASHUQIANGDU:
                                result += mo.TrueFashuqiangdu;
                                break;
                            case EHeroProperties.CRICITAL:
                                result += mo.TrueCrit;
                                break;
                            case EHeroProperties.FANGYUHUJIA:
                                result += mo.TruePhyDef;
                                break;
                            case EHeroProperties.MOFAKANGXING:
                                result += mo.TrueMofakangxing;
                                break;
                            default:
                                break;
                        }
                    }
                }
            }
        }
        return result;
        */
        #endregion
    }

    /// <summary>
    /// 血量
    /// </summary>
    /// <returns></returns>
    protected float getHp()
    {
        return HeroProxy.Instance.getHeroProperty(typeId, EHeroProperties.HP, level, grade);
    }

    /// <summary>
    /// 言能
    /// </summary>
    /// <returns></returns>
    public float getNengLiangZhi()
    {
        return HeroProxy.Instance.getHeroProperty(typeId, EHeroProperties.NENGLIANGZHI, level, grade);
    }
    /// <summary>
    /// 言攻
    /// </summary>
    /// <returns></returns>
    protected float getFaShuQiangDu()
    {
        return HeroProxy.Instance.getHeroProperty(typeId, EHeroProperties.FASHUQIANGDU, level, grade);
    }
    /// <summary>
    /// 言抗
    /// </summary>
    /// <returns></returns>
    protected float getMoFaKangXing()
    {
        return HeroProxy.Instance.getHeroProperty(typeId, EHeroProperties.MOFAKANGXING, level, grade);
    }
    /// <summary>
    /// 物攻
    /// </summary>
    /// <returns></returns>
    protected float getWuLiGongJi()
    {
        return HeroProxy.Instance.getHeroProperty(typeId, EHeroProperties.WULIGONGJI, level, grade);
    }
    /// <summary>
    /// 物抗
    /// </summary>
    /// <returns></returns>
    protected float getFangYuHuJia()
    {
        return HeroProxy.Instance.getHeroProperty(typeId, EHeroProperties.FANGYUHUJIA, level, grade);
    }
    /// <summary>
    /// 暴击
    /// </summary>
    /// <returns></returns>
    protected float getCritical()
    {
        return HeroProxy.Instance.getHeroProperty(typeId, EHeroProperties.CRICITAL, level, grade);
    }
    [Obsolete("去掉攻速了-2019年12月4日")]
    protected float getGongJiSuDu()
    {
        return HeroProxy.Instance.getHeroProperty(typeId, EHeroProperties.GONGJISUDU, level, grade);
    }

    protected float getKangbaoji()
    {
        return HeroProxy.Instance.getHeroProperty(typeId, EHeroProperties.KANGBAOJI, level, grade);
    }

    protected float getYanli()
    {
        return HeroProxy.Instance.getHeroProperty(typeId, EHeroProperties.YANLI, level, grade);
    }

    #region   战斗战斗 为战斗提供的人物的属性数值 基础属性 * 升级加成 + 升星加成 + 升阶加成 + 装备加成 + 言灵加成 、、、

    /* 2019年12月4日 大概公式: 基础值*等级加成  + 武器加成  + 言灵加成 后面补完. */
    /// <summary>
    /// 当前的属性值 【2022-1-19】
    /// </summary>
    /// <returns></returns>
    public int getHpForBattle()
    {
        //基础值+ 升级给的加成+        
        return (int)(getHp()                                                   // 英雄数据
            + getEquipExtraProperty(EHeroProperties.HP)                        // 武器数据
            + getYanlingExtraProperty(EHeroProperties.HP)
            );                                                                 // 言灵数据
    }

    /// <summary>
    /// 角色突破升星时当前的属性---2022-7-13修改
    /// </summary>
    /// <returns></returns>
    public float getHpForBattle_PrimaryGrade()
    {
        return this.getHp();                                                                     // 言灵数据
    }

    /// <summary>
    /// 突破后的唤灵师的属性
    /// </summary>
    /// <returns></returns>
    public float getHpForBattle_NextGrade()
    {
        string gradeNew = "S";
        if (this.curStar < 5)
        {
            gradeNew = sm_heroextra_level_tupo.GetMoById(int.Parse(this.typeId), this.curStar + 1).quality;
        }

        return HeroProxy.Instance.getHeroProperty(typeId, EHeroProperties.HP, this.level, gradeNew);

        ////基础值+ 升级给的加成+        
        //return (int)(heroAr                                                   // 英雄数据
        //    + getEquipExtraProperty(EHeroProperties.HP)                        // 武器数据
        //    + getYanlingExtraProperty(EHeroProperties.HP)
        //    );                                                                 // 言灵数据
    }

    public int getNengLiangZhiJiForBattle()
    {
        return (int)(getNengLiangZhi()                                         // 英雄本身
            + getEquipExtraProperty(EHeroProperties.NENGLIANGZHI)              // + 武器加成
            + getYanlingExtraProperty(EHeroProperties.NENGLIANGZHI)            // + 言灵加成
            );
    }


    public float getNengliangzhi_PrimaryGrade()
    {
        return this.getNengLiangZhi();
    }

    /// <summary>
    /// 突破后的唤灵师的属性
    /// </summary>
    /// <returns></returns>
    public float getNengliangzhiForBattle_NextGrade()
    {
        string gradeNew = "S";
        if (this.curStar < 5)
        {
            gradeNew = sm_heroextra_level_tupo.GetMoById(int.Parse(this.typeId), this.curStar + 1).quality;
        }

        return HeroProxy.Instance.getHeroProperty(typeId, EHeroProperties.NENGLIANGZHI, this.level, gradeNew);
        //return (int)(heroAr                                                   // 英雄数据
        //    + getEquipExtraProperty(EHeroProperties.NENGLIANGZHI)                        // 武器数据
        //    + getYanlingExtraProperty(EHeroProperties.NENGLIANGZHI)
        //    );

    }


    /// <summary>
    /// 当前唤灵师属性
    /// </summary>
    /// <returns></returns>
    public int getWuLiGongJiForBattle()
    {
        return (int)(getWuLiGongJi()
            + getEquipExtraProperty(EHeroProperties.WULIGONGJI)
            + getYanlingExtraProperty(EHeroProperties.WULIGONGJI)
            );
    }

    public float getWuLiGongJiForBattle_PrimaryGrade()
    {
        return this.getWuLiGongJi();
    }

    /// <summary>
    /// 突破后的唤灵师的属性
    /// </summary>
    /// <returns></returns>
    public float getWuLiGongJiForBattle_NextGrade()
    {
        string gradeNew = "S";
        if (this.curStar < 5)
        {
            gradeNew = sm_heroextra_level_tupo.GetMoById(int.Parse(this.typeId), this.curStar + 1).quality;
        }

        return HeroProxy.Instance.getHeroProperty(typeId, EHeroProperties.WULIGONGJI, this.level, gradeNew);
        //return (int)(heroAr                                                   // 英雄数据
        //    + getEquipExtraProperty(EHeroProperties.WULIGONGJI)                        // 武器数据
        //    + getYanlingExtraProperty(EHeroProperties.WULIGONGJI)
        //    );
    }

    public int getFaShuQiangDuForBattle()
    {
        return (int)(getFaShuQiangDu()
             + getEquipExtraProperty(EHeroProperties.FASHUQIANGDU)
             + getYanlingExtraProperty(EHeroProperties.FASHUQIANGDU)
             );
    }

    public float getFaShuQiangDuForBattle_PrimaryGrade()
    {
        return this.getFaShuQiangDu();
    }

    public float getFaShuQiangDuForBattle_NextGrade()
    {
        string gradeNew = "S";
        if (this.curStar < 5)
        {
            gradeNew = sm_heroextra_level_tupo.GetMoById(int.Parse(this.typeId), this.curStar + 1).quality;
        }

        return HeroProxy.Instance.getHeroProperty(typeId, EHeroProperties.FASHUQIANGDU, level, gradeNew);

        //return (int)(heroAr
        //     + getEquipExtraProperty(EHeroProperties.FASHUQIANGDU)
        //     + getYanlingExtraProperty(EHeroProperties.FASHUQIANGDU)
        //     );
    }

    public int getMoFaKangXingForBattle()
    {
        return (int)(getMoFaKangXing()
             + getEquipExtraProperty(EHeroProperties.MOFAKANGXING)
             + getYanlingExtraProperty(EHeroProperties.MOFAKANGXING)
             );
    }

    public float getMoFaKangXingForBattle_PrimaryGrade()
    {
        return this.getMoFaKangXing();
    }

    public float getMoFaKangXingForBattle_NextGrade()
    {
        string gradeNew = "S";
        if (this.curStar < 5)
        {
            gradeNew = sm_heroextra_level_tupo.GetMoById(int.Parse(this.typeId), this.curStar + 1).quality;
        }

        return HeroProxy.Instance.getHeroProperty(typeId, EHeroProperties.MOFAKANGXING, level, gradeNew);
    }

    /// <summary>
    /// 当前唤灵师属性
    /// </summary>
    /// <returns></returns>
    public int getFangYuHuJiaForBattle()
    {
        return (int)(getFangYuHuJia()
            + getEquipExtraProperty(EHeroProperties.FANGYUHUJIA)
            + getYanlingExtraProperty(EHeroProperties.FANGYUHUJIA)
            );
    }

    public float getFangYuHuJiaForBattle_PrimaryGrade()
    {

        return this.getFangYuHuJia();
    }

    /// <summary>
    /// 突破后的唤灵师属性
    /// </summary>
    /// <returns></returns>
    public float getFangYuHuJiaForBattle_NextGrade()
    {
        string gradeNew = "S";
        if (this.curStar < 5)
        {
            gradeNew = sm_heroextra_level_tupo.GetMoById(int.Parse(this.typeId), this.curStar + 1).quality;
        }

        return HeroProxy.Instance.getHeroProperty(typeId, EHeroProperties.FANGYUHUJIA, level, gradeNew);

        //return (int)(heroAr
        //    + getEquipExtraProperty(EHeroProperties.FANGYUHUJIA)
        //    + getYanlingExtraProperty(EHeroProperties.FANGYUHUJIA)
        //    );
    }

    [Obsolete("取消攻速了")]
    public float getGongJiSuDuForBattle()
    {
        return (getGongJiSuDu()
            + getEquipExtraProperty(EHeroProperties.GONGJISUDU));
    }

    /// <summary>
    /// 暴击
    /// </summary>
    /// <returns></returns>
    public int getCriticalForBattle()
    {
        Debug.Log("基础暴击:" + getCritical());
        Debug.Log("武器暴击:" + getEquipExtraProperty(EHeroProperties.CRICITAL));
        Debug.Log("言灵暴击:" + getYanlingExtraProperty(EHeroProperties.CRICITAL));

        return (int)(getCritical()
            + getEquipExtraProperty(EHeroProperties.CRICITAL)
            + getYanlingExtraProperty(EHeroProperties.CRICITAL)
            );
    }

    public float getCriticalForBattle_PrimaryGrade()
    {
        return this.getCritical();
    }

    public float getCriticalForBattle_NextGrade()
    {
        string gradeNew = "S";
        if (this.curStar < 5)
        {
            gradeNew = sm_heroextra_level_tupo.GetMoById(int.Parse(this.typeId), this.curStar + 1).quality;
        }

        return HeroProxy.Instance.getHeroProperty(typeId, EHeroProperties.CRICITAL, level, gradeNew);

        //return (int)(heroAr
        //    + getEquipExtraProperty(EHeroProperties.CRICITAL)
        //    + getYanlingExtraProperty(EHeroProperties.CRICITAL)
        //    );
    }

    public int getKangbaojiForBattle()
    {
        return (int)(getKangbaoji()
            //+ getEquipExtraProperty(EHeroProperties.KANGBAOJI)//武器没有抗暴击
            + getYanlingExtraProperty(EHeroProperties.KANGBAOJI)
            );
    }

    public float getKangbaojiForBattle_PrimaryGrade()
    {
        return this.getKangbaoji();
    }

    public float getKangbaojiForBattle_NextGrade()
    {
        string gradeNew = "S";
        if (this.curStar < 5)
        {
            gradeNew = sm_heroextra_level_tupo.GetMoById(int.Parse(this.typeId), this.curStar + 1).quality;
        }

        return HeroProxy.Instance.getHeroProperty(typeId, EHeroProperties.KANGBAOJI, level, gradeNew);

        //return (int)(heroAr            
        //    + getYanlingExtraProperty(EHeroProperties.KANGBAOJI)
        //    );
    }

    public int getYanliForBattle()
    {
        return (int)(getYanli()
            + getEquipExtraProperty(EHeroProperties.YANLI)
            + getYanlingExtraProperty(EHeroProperties.YANLI)
            );
    }

    public float getYanliForBattle_PrimaryGrade()
    {
        return this.getYanli();
    }

    public float getYanliForBattle_NextGrade()
    {
        string gradeNew = "S";
        if (this.curStar < 5)
        {
            gradeNew = sm_heroextra_level_tupo.GetMoById(int.Parse(this.typeId), this.curStar + 1).quality;
        }

        return HeroProxy.Instance.getHeroProperty(typeId, EHeroProperties.YANLI, level, gradeNew);

        //return (int)(heroAr
        //    +getEquipExtraProperty(EHeroProperties.YANLI)
        //    + getYanlingExtraProperty(EHeroProperties.YANLI)
        //    );
    }


    /// <summary>
    /// 获取暴击率(战斗中使用)(2020.6.3)
    /// </summary>
    /// <returns></returns>
    public float getCriticalRatioInBattle()
    {
        return this.getCriticalForBattle() / (75 + level * 5);
    }
    #endregion

    /// <summary>
    /// 获取唤灵师下所有言灵的属性信息
    /// </summary>
    public Dictionary<EHeroProperties, int> GetYanLingBaseAttr
    {
        get
        {
            Dictionary<EHeroProperties, int> dic = new Dictionary<EHeroProperties, int>();
            if (this.yanling.Count <= 0)
            {
                return dic;
            }
            Dictionary<int, UserYanlingVo> items = UserProxy.Instance.player.collectYanling.items;
            int hp = 0;
            int crit = 0;
            int phyAtk = 0;
            int phyDef = 0;
            int atkSpeed = 0;
            int fashuqiangdu = 0;
            int mofakangxing = 0;

            foreach (KeyValuePair<int, HeroGameVo_Yanling> kv in this.yanling)
            {
                if (!items.ContainsKey(kv.Value.itemuid))
                {
                    continue;
                }

                Dictionary<EHeroProperties, int> baseAttr = items[kv.Value.itemuid].baseAttr;
                if (baseAttr.ContainsKey(EHeroProperties.HP))
                {
                    hp += baseAttr[EHeroProperties.HP];
                }

                if (baseAttr.ContainsKey(EHeroProperties.CRICITAL))
                {
                    crit += baseAttr[EHeroProperties.CRICITAL];
                }

                if (baseAttr.ContainsKey(EHeroProperties.WULIGONGJI))
                {
                    phyAtk += baseAttr[EHeroProperties.WULIGONGJI];
                }

                if (baseAttr.ContainsKey(EHeroProperties.FANGYUHUJIA))
                {
                    phyDef += baseAttr[EHeroProperties.FANGYUHUJIA];
                }

                if (baseAttr.ContainsKey(EHeroProperties.ATKSPEED))
                {
                    atkSpeed += baseAttr[EHeroProperties.ATKSPEED];
                }

                if (baseAttr.ContainsKey(EHeroProperties.FASHUQIANGDU))
                {
                    fashuqiangdu += baseAttr[EHeroProperties.FASHUQIANGDU];
                }

                if (baseAttr.ContainsKey(EHeroProperties.MOFAKANGXING))
                {
                    mofakangxing += baseAttr[EHeroProperties.MOFAKANGXING];
                }
            }
            if (hp != 0)
            {
                dic[EHeroProperties.HP] = hp;
            }
            if (crit != 0)
            {
                dic[EHeroProperties.CRICITAL] = crit;
            }

            if (phyAtk != 0)
            {
                dic[EHeroProperties.WULIGONGJI] = phyAtk;
            }

            if (phyDef != 0)
            {
                dic[EHeroProperties.FANGYUHUJIA] = phyDef;
            }

            if (atkSpeed != 0)
            {
                dic[EHeroProperties.ATKSPEED] = atkSpeed;
            }
            if (fashuqiangdu != 0)
            {
                dic[EHeroProperties.FASHUQIANGDU] = fashuqiangdu;
            }
            if (mofakangxing != 0)
            {
                dic[EHeroProperties.MOFAKANGXING] = mofakangxing;
            }
            return dic;
        }
    }

    /// <summary>
    /// 获取唤灵师下所有言灵的随机属性
    /// </summary>
    public Dictionary<EHeroAddProperties, int> GetYanLingRandAttr
    {
        get
        {
            Dictionary<EHeroAddProperties, int> dic = new Dictionary<EHeroAddProperties, int>();
            if (this.yanling.Count <= 0)
            {
                return dic;
            }
            Dictionary<int, UserYanlingVo> items = UserProxy.Instance.player.collectYanling.items;
            int hp = 0;
            int manaUpperlimit = 0;
            int phyDamage = 0;
            int magDamage = 0;
            int phyDefend = 0;
            int magDefend = 0;
            int phyDamagereduce = 0;
            int magDamagereduce = 0;
            int additional_monsterExp = 0;
            int additional_atkSpeed = 0;
            int additional_moveSpeed = 0;
            int additional_critProbability = 0;
            int additional_critDamage = 0;
            int skillCoolTs = 0;

            foreach (KeyValuePair<int, HeroGameVo_Yanling> kv in this.yanling)
            {
                if (!items.ContainsKey(kv.Value.itemuid))
                {
                    continue;
                }

                Dictionary<EHeroAddProperties, int> randAttr = items[kv.Value.itemuid].randAttr;
                if (randAttr.ContainsKey(EHeroAddProperties.additional_hpUpperlimit))
                {
                    hp += randAttr[EHeroAddProperties.additional_hpUpperlimit];
                }

                if (randAttr.ContainsKey(EHeroAddProperties.additional_manaUpperlimit))
                {
                    manaUpperlimit += randAttr[EHeroAddProperties.additional_manaUpperlimit];
                }

                if (randAttr.ContainsKey(EHeroAddProperties.additional_phyDamage))
                {
                    phyDamage += randAttr[EHeroAddProperties.additional_phyDamage];
                }

                if (randAttr.ContainsKey(EHeroAddProperties.additional_magDamage))
                {
                    magDamage += randAttr[EHeroAddProperties.additional_magDamage];
                }

                if (randAttr.ContainsKey(EHeroAddProperties.additional_phyDefend))
                {
                    phyDefend += randAttr[EHeroAddProperties.additional_phyDefend];
                }

                if (randAttr.ContainsKey(EHeroAddProperties.additional_magDefend))
                {
                    magDefend += randAttr[EHeroAddProperties.additional_magDefend];
                }

                if (randAttr.ContainsKey(EHeroAddProperties.additional_phyDamagereduce))
                {
                    phyDamagereduce += randAttr[EHeroAddProperties.additional_phyDamagereduce];
                }

                if (randAttr.ContainsKey(EHeroAddProperties.additional_magDamagereduce))
                {
                    magDamagereduce += randAttr[EHeroAddProperties.additional_magDamagereduce];
                }

                if (randAttr.ContainsKey(EHeroAddProperties.additional_monsterExp))
                {
                    additional_monsterExp += randAttr[EHeroAddProperties.additional_monsterExp];
                }

                if (randAttr.ContainsKey(EHeroAddProperties.additional_atkSpeed))
                {
                    additional_atkSpeed += randAttr[EHeroAddProperties.additional_atkSpeed];
                }

                if (randAttr.ContainsKey(EHeroAddProperties.additional_moveSpeed))
                {
                    additional_moveSpeed += randAttr[EHeroAddProperties.additional_moveSpeed];
                }

                if (randAttr.ContainsKey(EHeroAddProperties.additional_critProbability))
                {
                    additional_critProbability += randAttr[EHeroAddProperties.additional_critProbability];
                }

                if (randAttr.ContainsKey(EHeroAddProperties.additional_critDamage))
                {
                    additional_critDamage += randAttr[EHeroAddProperties.additional_critDamage];
                }

                if (randAttr.ContainsKey(EHeroAddProperties.skillCoolTs))
                {
                    additional_critDamage += randAttr[EHeroAddProperties.skillCoolTs];
                }


            }
            if (hp != 0)
            {
                dic[EHeroAddProperties.additional_hpUpperlimit] = hp;
            }
            if (manaUpperlimit != 0)
            {
                dic[EHeroAddProperties.additional_manaUpperlimit] = manaUpperlimit;
            }

            if (phyDamage != 0)
            {
                dic[EHeroAddProperties.additional_phyDamage] = phyDamage;
            }

            if (magDamage != 0)
            {
                dic[EHeroAddProperties.additional_magDamage] = magDamage;
            }

            if (phyDefend != 0)
            {
                dic[EHeroAddProperties.additional_phyDefend] = phyDefend;
            }
            if (magDefend != 0)
            {
                dic[EHeroAddProperties.additional_magDefend] = magDefend;
            }
            if (phyDamagereduce != 0)
            {
                dic[EHeroAddProperties.additional_phyDamagereduce] = phyDamagereduce;
            }

            if (magDamagereduce != 0)
            {
                dic[EHeroAddProperties.additional_magDamagereduce] = magDamagereduce;
            }

            if (additional_monsterExp != 0)
            {
                dic[EHeroAddProperties.additional_monsterExp] = additional_monsterExp;
            }

            if (additional_atkSpeed != 0)
            {
                dic[EHeroAddProperties.additional_atkSpeed] = additional_atkSpeed;
            }

            if (additional_moveSpeed != 0)
            {
                dic[EHeroAddProperties.additional_moveSpeed] = additional_moveSpeed;
            }

            if (additional_critProbability != 0)
            {
                dic[EHeroAddProperties.additional_critProbability] = additional_critProbability;
            }

            if (additional_critDamage != 0)
            {
                dic[EHeroAddProperties.additional_critDamage] = additional_critDamage;
            }

            if (skillCoolTs != 0)
            {
                dic[EHeroAddProperties.skillCoolTs] = skillCoolTs;
            }


            return dic;
        }
    }

    public void ReloadData(GameHeroVo from)
    {
        var tp = typeof(GameHeroVo);
        var pps = tp.GetProperties();
        foreach (var p in pps)
        {
            if (p.CanWrite)
            {
                p.SetValue(this, p.GetValue(from));
            }
        }
    }


    #endregion
}
/// <summary>
/// 英雄品阶枚举
/// </summary>
public enum EHeroQuality
{
    D = 1,
    C = 2,
    B = 3,
    A = 4,
    S = 5
}


/// <summary>
///  英雄属性
/// </summary>
public enum EHeroProperties
{
    /// <summary>
    /// 生命值
    /// </summary>
    HP,

    /// <summary>
    /// 能量值
    /// </summary>
    NENGLIANGZHI,
    /// <summary>
    /// 物理攻击
    /// </summary>
    WULIGONGJI,

    /// <summary>
    /// 防御护甲
    /// </summary>
    FANGYUHUJIA,

    /// <summary>
    /// 敏捷---废弃
    /// </summary>
    GONGJISUDU,

    /// <summary>
    /// 暴击
    /// </summary>
    CRICITAL,

    /// <summary>
    /// 法术强度
    /// </summary>
    FASHUQIANGDU,

    /// <summary>
    /// 魔法抗性
    /// </summary>       
    MOFAKANGXING,

    /// <summary>
    ///攻击速度--废弃
    /// </summary>
    ATKSPEED,

    /// <summary>
    /// 抗暴击
    /// </summary>
    KANGBAOJI,

    /// <summary>
    /// 言力
    /// </summary>
    YANLI,
}
/// <summary>
/// 随机属性
/// </summary>
public enum EHeroAddProperties
{
    /// <summary>
    /// 生命上限加成
    /// </summary>
    additional_hpUpperlimit,

    /// <summary>
    /// 言能上限加成
    /// </summary>
    additional_manaUpperlimit,
    /// <summary>
    /// 物攻伤害加成
    /// </summary>
    additional_phyDamage,

    /// <summary>
    /// 护甲加成
    /// </summary>
    additional_phyDefend,

    /// <summary>
    /// 敏捷
    /// </summary>
    additional_moveSpeed,

    /// <summary>
    /// 暴击伤害加成
    /// </summary>
    additional_critDamage,

    /// <summary>
    /// 言攻伤害加成
    /// </summary>
    additional_magDamage,

    /// <summary>
    /// 言抗加成
    /// </summary>
    additional_magDefend,

    /// <summary>
    /// 攻击速度加成
    /// </summary>
    additional_atkSpeed,

    /// <summary>
    /// 物伤减免加成
    /// </summary>
    additional_phyDamagereduce,

    /// <summary>
    /// 言伤减免加成
    /// </summary>       
    additional_magDamagereduce,

    /// <summary>
    ///怪物经验加成
    /// </summary>
    additional_monsterExp,

    /// <summary>
    /// 暴击几率加成
    /// </summary>
    additional_critProbability,

    /// <summary>
    /// 冷却时间
    /// </summary>
    skillCoolTs,
}

public class PropertiesComparison : Singleton<PropertiesComparison>
{
    public static Dictionary<EHeroAddProperties, string> Comparison = new Dictionary<EHeroAddProperties, string>
    {
        { EHeroAddProperties.additional_hpUpperlimit,"生命上限"},
        { EHeroAddProperties.additional_manaUpperlimit,"言能上限"},
        { EHeroAddProperties.additional_phyDamage,"物攻伤害"},
        { EHeroAddProperties.additional_magDamage,"言攻伤害"},
        { EHeroAddProperties.additional_phyDefend,"护甲加成"},
        { EHeroAddProperties.additional_magDefend,"言抗加成"},
        { EHeroAddProperties.additional_phyDamagereduce,"物伤减免"},
        { EHeroAddProperties.additional_magDamagereduce,"言伤减免"},
        { EHeroAddProperties.additional_monsterExp,"经验加成"},
        { EHeroAddProperties.additional_atkSpeed,"攻击速度"},
        { EHeroAddProperties.additional_moveSpeed,"移动速度"},
        { EHeroAddProperties.additional_critProbability,"暴击几率"},
        { EHeroAddProperties.additional_critDamage,"暴击伤害"},
        { EHeroAddProperties.skillCoolTs,"冷却时间"},
    };
}

/// <summary>
/// 英雄的职业类别
/// </summary>
public enum HeroZhiye
{
    战士 = 1,   //防
    法师 = 2,
    辅助 = 3,   //辅
    坦克 = 4,   //突
    刺客 = 5,   //攻
}

/// <summary>
/// 英雄的所属元素元素类型//0 空的//1 金 //2 冰 //3 火 //4 风 //5 雷 //6 毒 //7 黑暗 //8 亡灵 // 9 物理
/// </summary>
public enum HeroYuansu
{
    金系 = 1,
    冰系 = 2,
    火系 = 3,
    风系 = 4,
    雷系 = 5,
    毒系 = 6,
    黑暗系 = 7,
    亡灵系 = 8,
    物理系 = 9,
}


/// <summary>
/// 英雄自身的装备数据
/// </summary>
public class HeroGameVo_Equip
{
    /// <summary>
    /// 装备的类型
    /// </summary>
    public string equipType { get; set; }

    /// <summary>
    /// 装备的物品UID
    /// </summary>
    public string equipItemUID { get; set; }

    /// <summary>
    /// 物品类型
    /// </summary>
    public int typeId
    {
        get
        {
            var player = UserProxy.Instance.player;
            var uid = int.Parse(this.equipItemUID);
            if (player.collectEquip.equipments.ContainsKey(uid))
            {
                return int.Parse(player.collectEquip.equipments[uid].typeId);
            }
            return 0;
        }
    }

    /// <summary>
    /// 物品等级
    /// </summary>
    public int level { get; set; }

    /// <summary>
    /// 获取装备的Mo(基础数据), 武器扩展数据请继续.GetWeaponExt();
    /// </summary>
    /// <returns></returns>
    public sm_item_base EquipMo()
    {
        return sm_item_base.GetMoById(this.typeId);
    }

    /// <summary>
    /// 把int隐式转换为HeroGameVo_Yanling对象
    /// </summary>
    /// <param name="i"></param>
    public static implicit operator HeroGameVo_Equip(int i)
    {
        return i > 0 ? new HeroGameVo_Equip() { equipItemUID = i.ToString() } : null;
    }


    /// <summary>
    /// 隐式转换为int值
    /// </summary>
    /// <param name="o"></param>
    public static implicit operator int(HeroGameVo_Equip o)
    {
        return int.Parse(o.equipItemUID);
    }
}
/// <summary>
/// 英雄自身的言灵数据
/// </summary>
public class HeroGameVo_Yanling
{
    /// <summary>
    /// 言灵的实例唯一ID
    /// </summary>
    public int itemuid { get; set; }

    /// <summary>
    /// 当前能量值
    /// </summary>
    public int sp_now { get; set; }

    /// <summary>
    /// 当前CD
    /// </summary>
    public float cd_now { get; set; }

    /// <summary>
    /// 物品类型
    /// </summary>
    public int typeId;
    //{
    private int getTypeIdFromUID()
    {
        var player = UserProxy.Instance.player;
        var uid = this.itemuid;
        if (player.collectYanling.items.ContainsKey(uid))
        {
            return int.Parse(player.collectYanling.items[uid].typeId);
        }
        return 0;
    }
    //}


    /// <summary>
    /// 获取言灵的Mo(基础数据), 获取扩展数据请继续.GetYanlingExt();
    /// </summary>
    /// <returns></returns>
    public sm_item_base Mo()
    {
        return sm_item_base.GetMoById(this.typeId);
    }

    /// <summary>
    /// 把int隐式转换为HeroGameVo_Yanling对象
    /// </summary>
    /// <param name="i"></param>
    public static implicit operator HeroGameVo_Yanling(int i)
    {
        if (i > 0)
        {
            var p = UserProxy.Instance.player;
            var hvo = new HeroGameVo_Yanling() { itemuid = i };
            hvo.typeId = hvo.getTypeIdFromUID();
            return hvo;
        }
        return null;
    }
    /// <summary>
    /// 把int隐式转换为HeroGameVo_Yanling对象
    /// </summary>
    /// <param name="i"></param>
    public static implicit operator HeroGameVo_Yanling(long i)
    {
        if (i > 0)
        {
            var p = UserProxy.Instance.player;
            var hvo = new HeroGameVo_Yanling() { itemuid = (int)i };
            hvo.typeId = hvo.getTypeIdFromUID();
            return hvo;
        }
        return null;
    }
    /// <summary>
    /// 隐式转换为int值
    /// </summary>
    /// <param name="o"></param>
    public static implicit operator int(HeroGameVo_Yanling o)
    {
        return o.itemuid;
    }
}