using IVDataFormat;
using System.Collections.Generic;
using System.Numerics;

public class BuffMgr
{
    #region Instance
    static BuffMgr s_instance;
    public static BuffMgr Instance
    {
        get
        {
            if(s_instance == null)
            {
                s_instance = new BuffMgr();
            }

            return s_instance;
        }
    }

    public static void ResetAll()
    {
        s_instance = null;
    }
    #endregion Instance

    #region Values Total
    //전투력
    private BigInteger battlePower;

    // 공격력.
    private BigInteger totalAtk;
    BIValue atkCalculator = new BIValue(0);
    // 체력.
    private BigInteger totalHp;
    BIValue hpCalculator = new BIValue(0);
    // 공격력.
    private BigInteger totalAtkAd;

    //획득재화 상승률 골드
    private float CharStageGold;
    FValue goldRateCalculator = new FValue(0);
    //획득재화 상승률 경험치
    private float CharStageExp;
    FValue expRateCalculator = new FValue(0);
    //획득재화 상승률 상자
    private float CharStageChest;
    //획득재화 상승률 펫상자
    private float CharStagePetBox;
    //던전 보상 획득 보너스
    private float CharDgGoldBonus;
    private float CharDgReinStoneBonus;
    private float CharDgPetBonus;
    private float CharDgAwakenStoneBonus;

    // 이동속도.
    private float totalMov;
    // 공격속도.
    private float totalSpd;
    // 관통력
    //private float totalPierce;

    // 치명타 데미지.
    private float totalCrtDam;
    // 치명타 확률.
    private int totalCrtRate;

    //스킬 피해량
    private float totalSkillDmg;
    FValue skillDmgCalculator = new FValue(0);
    //스킬 쿨타임
    private float totalSkillCool;
    //초당 생명력 회복량
    private float totalHpHealSec;

    // 적 공격력 감소.
    private float totalEnemyAtk;
    // 적 체력 감소.
    private float totalEnemyHp;
    #endregion Values Total

    #region Values Enhance & Lv Point
    private long enhanceAtkBase;
    private long enhanceHpBase;

    private long enhanceMov;
    private long enhanceSpd;
    private long enhancePierce;

    private long enhanceCrtDam;
    private long enhanceCrtRate;

    private long lvPointAtkBase;
    private long lvPointHpBase;

    private long lvPointCrtDam;

    private long lvPointMov;
    private long lvPointSpd;
    private long lvPointPierce;

    private long lvPointStageGold;
    private long lvPointStageExp;
    private long lvPointStageChest;
    private long lvPointStagePetBox;
    #endregion Values Enhance & Lv Point

    #region Values Awaken
    private long awakenAtkBase;
    private long awakenHpBase;

    private long awakenAtkBuff;
    private long awakenAtkBuffDg;
    private long awakenHpBuff;

    private long awakenStageGold;
    private long awakenStageExp;
    private long awakenStageChest;
    private long awakenStagePetBox;

    private long awakenMov;
    private long awakenSpd;
    private long awakenPierce;

    private long awakenCrtDam;

    private long awakenSkillDmg;
    private long awakenSkillCool;
    private long awakenHealSec;
    #endregion Values Awaken

    #region Values Gear
    // 장비 총합 레벨 효과.
    private Dictionary<int, int> dicGearLv = new Dictionary<int, int>(7)
    {
        [cGoods.TBagWeapon] = 0,
        [cGoods.TBagArmorCape] = 0,
        [cGoods.TBagArmorHat] = 0,
        [cGoods.TBagArmorShoes] = 0,
        [cGoods.TBagAcceEar] = 0,
        [cGoods.TBagAcceNeck] = 0,
        [cGoods.TBagAcceRing] = 0,
    };

    // 무기 장착 효과. 공격력.
    private long gearWeaponAtkBase;
    private long gearWeaponAtkBaseLast;

    // 망토 장착 효과. 체력.
    private long gearCapeHpBase;
    private long gearCapeHpBaseLast;
    //모자 장착 효과. 체력.
    private long gearHatHpBase;
    private long gearHatHpBaseLast;
    // 신발 장착 효과. 공격력.
    private long gearShoesAtkBase;
    private long gearShoesAtkBaseLast;

    // 귀걸이 장착 효과. 공격력, 체력.
    private long gearEarAtkBase;
    private long gearEarAtkBaseLast;
    private long geaEarHpBase;
    private long gearEarHpBaseLast;
    // 목걸이 장착 효과. 공격력, 체력.
    private long gearNeckAtkBase;
    private long gearNeckAtkBaseLast;
    private long gearNeckHpBase;
    private long gearNeckHpBaseLast;
    // 반지 장착 효과. 공격력, 체력.
    private long gearRingAtkBase;
    private long gearRingAtkBaseLast;
    private long geaRingHpBase;
    private long gearRingHpBaseLast;

    // 추가 효과. 장비 종류 7 * 추가 효과 슬롯 3
    private eEffectType[] gearExtraTypes = new eEffectType[21];
    private long[] gearExtraValues = new long[21];
    private Dictionary<eEffectType, long> gearExtraEfcs;
    #endregion Values Gear

    #region Values Treasure
    private long TreasureAtkBase;
    private long TreasureHpBase;

    private long TreasureStageGold;
    private long TreasureStageExp;
    private long TreasureStageChest;
    private long TreasureStagePetBox;

    private long TreasureMov;
    private long TreasureSpd;
    private long TreasurePierce;

    private long TreasureCrtDam;

    private long TreasureSkillDmg;
    private long TreasureSkillCool;
    private long TreasureHealSec;


    private long TreasureRareAtkBase;
    private long TreasureRareHpBase;

    private long TreasureRareAtkBuff;
    private long TreasureRareHpBuff;

    private long TreasureRareStageGold;
    private long TreasureRareStageExp;
    private long TreasureRareStageChest;
    private long TreasureRareStagePetBox;

    private long TreasureRareMov;
    private long TreasureRareSpd;
    private long TreasureRarePierce;

    private long TreasureRareCrtDam;

    private long TreasureRareSkillDmg;
    private long TreasureRareSkillCool;
    private long TreasureRareHealSec;
    #endregion Values Treasure

    #region Values Skill
    private int totalSkillLvDamage;
    private Dictionary<eEffectType, long> dicPassiveValues = new Dictionary<eEffectType, long>(15)
    {
        [eEffectType.AtkBase] = 0L,
        [eEffectType.HpBase] = 0L,

        [eEffectType.Mov] = 0L,
        [eEffectType.Spd] = 0L,
        [eEffectType.Pierce] = 0L,
        [eEffectType.CrtDam] = 0L,

        [eEffectType.GoldDropRate] = 0L,
        [eEffectType.ExpDropRate] = 0L,
        [eEffectType.ChestDropRate] = 0L,
        [eEffectType.PetBoxDropRate] = 0L,

        [eEffectType.SkillDamage] = 0L,
        [eEffectType.SkillCool] = 0L,
        [eEffectType.HealPerSec] = 0L,

        [eEffectType.EnemyAtk] = 0L,
        [eEffectType.EnemyHp] = 0L
    };
    #endregion Values Skill

    #region Values Pet
    // 펫 총합 레벨 효과.
    private int petLv;

    // 펫 장착 효과. 공격력, 방어력, 체력, 관통.
    private long[] petAtkBases = new long[3];
    private long petAtkBaseLast;
    private long[] petHpBases = new long[3];
    private long petHpBaseLast;
    private long[] petPierces = new long[3];
    private long petPierceLast;

    // 추가 효과. 펫 프리셋 슬롯 3 * (펫 추가 효과 슬롯 3 + 펫 옵션 보유 효과 슬롯 1)
    private eEffectType[] petExtraTypes = new eEffectType[12];
    private long[] petExtraValues = new long[12];
    private Dictionary<eEffectType, long> petExtraEfcs;
    #endregion Values Pet

    #region Values Costume
    // 항목 순서가 팝업에서 표시하는 순서.
    private Dictionary<eEffectType, long> dicCosValues = new Dictionary<eEffectType, long>(18)
    {
        [eEffectType.AtkBase] = 0L,
        [eEffectType.HpBase] = 0L,

        [eEffectType.Mov] = 0L,
        [eEffectType.Spd] = 0L,
        [eEffectType.CrtDam] = 0L,

        [eEffectType.GoldDropRate] = 0L,
        [eEffectType.ExpDropRate] = 0L,
        [eEffectType.ChestDropRate] = 0L,
        [eEffectType.PetBoxDropRate] = 0L,
        [eEffectType.DeepCaveDgBonus] = 0L,
        [eEffectType.AtlantisDgBonus] = 0L,
        [eEffectType.ProtectTheMerchantDgBonus] = 0L,
        [eEffectType.DevelopTheJungleDgBonus] = 0L,

        [eEffectType.SkillDamage] = 0L,
        [eEffectType.SkillCool] = 0L,
        [eEffectType.HealPerSec] = 0L,

        [eEffectType.EnemyAtk] = 0L,
        [eEffectType.EnemyHp] = 0L
    };
    #endregion Values Costume

    #region Values Title
    private Dictionary<eEffectType, long> dicTitleValues = new Dictionary<eEffectType, long>(18)
    {
        [eEffectType.AtkBase] = 0L,
        [eEffectType.HpBase] = 0L,

        [eEffectType.Mov] = 0L,
        [eEffectType.Spd] = 0L,
        [eEffectType.Pierce] = 0L,
        [eEffectType.CrtDam] = 0L,

        [eEffectType.GoldDropRate] = 0L,
        [eEffectType.ExpDropRate] = 0L,
        [eEffectType.ChestDropRate] = 0L,
        [eEffectType.PetBoxDropRate] = 0L,
        [eEffectType.DeepCaveDgBonus] = 0L,
        [eEffectType.AtlantisDgBonus] = 0L,
        [eEffectType.ProtectTheMerchantDgBonus] = 0L,
        [eEffectType.DevelopTheJungleDgBonus] = 0L,

        [eEffectType.SkillDamage] = 0L,
        [eEffectType.SkillCool] = 0L,
        [eEffectType.HealPerSec] = 0L,

        [eEffectType.EnemyAtk] = 0L,
        [eEffectType.EnemyHp] = 0L
    };
    #endregion

    #region Values Pvp
    private long PvpAtkAble;
    private long PvpHpAble;
    private long PvpAtkWill;
    private long PvpHpWill;
    #endregion Values Pvp

    #region Values ADBuff
    private long adBuffAttack;
    private long adBuffStageGold;
    private long adBuffStageExp;
    #endregion

    #region Values HotTime
    private long hotTimeGold;
    private long hotTimeExp;
    private long hotTimeChest;
    #endregion

    #region Values Guardian
    private long guardianAtkBase;
    private long guardianHpBase;

    private long guardianAtkBuff;
    private long guardianAtkBuffDg;
    private long guardianHpBuff;

    private long guardianStageGold;
    private long guardianStageExp;
    private long guardianStageChest;
    private long guardianStagePetBox;

    private long guardianMov;
    private long guardianSpd;
    private long guardianPierce;

    private long guardianCrtDam;

    private long guardianSkillDmg;
    private long guardianSkillCool;
    private long guardianHealSec;


    private long guardianAwakenAtkBase;
    private long guardianAwakenHpBase;

    private long guardianAwakenAtkBuff;
    private long guardianAwakenAtkBuffDg;
    private long guardianAwakenHpBuff;

    private long guardianAwakenStageGold;
    private long guardianAwakenStageExp;
    private long guardianAwakenStageChest;
    private long guardianAwakenStagePetBox;

    private long guardianAwakenMov;
    private long guardianAwakenSpd;
    private long guardianAwakenPierce;

    private long guardianAwakenCrtDam;

    private long guardianAwakenSkillDmg;
    private long guardianAwakenSkillCool;
    private long guardianAwakenHealSec;
    #endregion

    #region Value Relic
    private long RelicAtkBase;
    private long RelicHpBase;

    private long RelicAtkBuff;
    private long RelicAtkBuffDg;
    private long RelicHpBuff;

    private long RelicStageGold;
    private long RelicStageExp;
    private long RelicStageChest;
    private long RelicStagePetBox;

    private long RelicMov;
    private long RelicSpd;
    private long RelicPierce;

    private long RelicCrtDam;

    private long RelicSkillDmg;
    private long RelicSkillCool;
    private long RelicHealSec;

    private long RelicDgGoldBase;

    private long RelicAwakenAtkBase;
    private long RelicAwakenHpBase;

    private long RelicAwakenAtkBuff;
    private long RelicAwakenAtkBuffDg;
    private long RelicAwakenHpBuff;

    private long RelicAwakenStageGold;
    private long RelicAwakenStageExp;
    private long RelicAwakenStageChest;
    private long RelicAwakenStagePetBox;

    private long RelicAwakenMov;
    private long RelicAwakenSpd;
    private long RelicAwakenPierce;

    private long RelicAwakenCrtDam;

    private long RelicAwakenSkillDmg;
    private long RelicAwakenSkillCool;
    private long RelicAwakenHealSec;
    #endregion

    #region Base
    public void InitExtra()
    {
        if (gearExtraEfcs == null)
        {
            Dictionary<eEffectType, int>[] datas = DataHandler.GetExtraAbilityIds();
            gearExtraEfcs = new Dictionary<eEffectType, long>(datas[0].Count);
            petExtraEfcs = new Dictionary<eEffectType, long>(datas[0].Count);
            
            foreach (var item in datas[0])
            {
                gearExtraEfcs.Add(item.Key, 0L);
                petExtraEfcs.Add(item.Key, 0L);
            }

            // 펫 옵션 보유 효과.
            if (!petExtraEfcs.ContainsKey(eEffectType.GoldDropRate))
                petExtraEfcs.Add(eEffectType.GoldDropRate, 0L);
            if (!petExtraEfcs.ContainsKey(eEffectType.ExpDropRate))
                petExtraEfcs.Add(eEffectType.ExpDropRate, 0L);
            if (!petExtraEfcs.ContainsKey(eEffectType.ChestDropRate))
                petExtraEfcs.Add(eEffectType.ChestDropRate, 0L);
            if (!petExtraEfcs.ContainsKey(eEffectType.PetBoxDropRate))
                petExtraEfcs.Add(eEffectType.PetBoxDropRate, 0L);
            if (!petExtraEfcs.ContainsKey(eEffectType.AtkBuff))
                petExtraEfcs.Add(eEffectType.AtkBuff, 0L);
            if (!petExtraEfcs.ContainsKey(eEffectType.HpBuff))
                petExtraEfcs.Add(eEffectType.HpBuff, 0L);
            if (!petExtraEfcs.ContainsKey(eEffectType.EnemyAtk))
                petExtraEfcs.Add(eEffectType.EnemyAtk, 0L);
            if (!petExtraEfcs.ContainsKey(eEffectType.EnemyHp))
                petExtraEfcs.Add(eEffectType.EnemyHp, 0L);
        }
    }

    public static BuffMgr CopyBuffMgr(BuffMgr befmgr)
    {
        BuffMgr aftmgr = new BuffMgr();
        aftmgr.InitExtra();

        #region Enhance & Lv Point
        aftmgr.enhanceAtkBase = befmgr.enhanceAtkBase;
        aftmgr.enhanceHpBase = befmgr.enhanceHpBase;

        aftmgr.enhanceMov = befmgr.enhanceMov;
        aftmgr.enhanceSpd = befmgr.enhanceSpd;
        aftmgr.enhancePierce = befmgr.enhancePierce;

        aftmgr.enhanceCrtDam = befmgr.enhanceCrtDam;
        aftmgr.enhanceCrtRate = befmgr.enhanceCrtRate;

        aftmgr.lvPointAtkBase = befmgr.lvPointAtkBase;
        aftmgr.lvPointHpBase = befmgr.lvPointHpBase;

        aftmgr.lvPointCrtDam = befmgr.lvPointCrtDam;

        aftmgr.lvPointMov = befmgr.lvPointMov;
        aftmgr.lvPointSpd = befmgr.lvPointSpd;
        aftmgr.lvPointPierce = befmgr.lvPointPierce;

        aftmgr.lvPointStageGold = befmgr.lvPointStageGold;
        aftmgr.lvPointStageExp = befmgr.lvPointStageExp;
        aftmgr.lvPointStageChest = befmgr.lvPointStageChest;
        aftmgr.lvPointStagePetBox = befmgr.lvPointStagePetBox;
        #endregion Enhance & Lv Point

        #region Awaken
        aftmgr.awakenAtkBase = befmgr.awakenAtkBase;
        aftmgr.awakenHpBase = befmgr.awakenHpBase;

        aftmgr.awakenAtkBuff = befmgr.awakenAtkBuff;
        aftmgr.awakenAtkBuffDg = befmgr.awakenAtkBuffDg;
        aftmgr.awakenHpBuff = befmgr.awakenHpBuff;

        aftmgr.awakenStageGold = befmgr.awakenStageGold;
        aftmgr.awakenStageExp = befmgr.awakenStageExp;
        aftmgr.awakenStageChest = befmgr.awakenStageChest;
        aftmgr.awakenStagePetBox = befmgr.awakenStagePetBox;

        aftmgr.awakenMov = befmgr.awakenMov;
        aftmgr.awakenSpd = befmgr.awakenSpd;
        aftmgr.awakenPierce = befmgr.awakenPierce;

        aftmgr.awakenCrtDam = befmgr.awakenCrtDam;

        aftmgr.awakenSkillDmg = befmgr.awakenSkillDmg;
        aftmgr.awakenSkillCool = befmgr.awakenSkillCool;
        aftmgr.awakenHealSec = befmgr.awakenHealSec;
        #endregion Awaken

        #region Gear
        aftmgr.dicGearLv = new Dictionary<int, int>(befmgr.dicGearLv.Count);
        foreach (var item in befmgr.dicGearLv)
        {
            aftmgr.dicGearLv.Add(item.Key, item.Value);
        }

        aftmgr.gearWeaponAtkBase = befmgr.gearWeaponAtkBase;
        aftmgr.gearWeaponAtkBaseLast = befmgr.gearWeaponAtkBaseLast;

        aftmgr.gearCapeHpBase = befmgr.gearCapeHpBase;
        aftmgr.gearCapeHpBaseLast = befmgr.gearCapeHpBaseLast;

        aftmgr.gearHatHpBase = befmgr.gearHatHpBase;
        aftmgr.gearHatHpBaseLast = befmgr.gearHatHpBaseLast;

        aftmgr.gearShoesAtkBase = befmgr.gearShoesAtkBase;
        aftmgr.gearShoesAtkBaseLast = befmgr.gearShoesAtkBaseLast;

        aftmgr.gearEarAtkBase = befmgr.gearEarAtkBase;
        aftmgr.gearEarAtkBaseLast = befmgr.gearEarAtkBaseLast;
        aftmgr.geaEarHpBase = befmgr.geaEarHpBase;
        aftmgr.gearEarHpBaseLast = befmgr.gearEarHpBaseLast;

        aftmgr.gearNeckAtkBase = befmgr.gearNeckAtkBase;
        aftmgr.gearNeckAtkBaseLast = befmgr.gearNeckAtkBaseLast;
        aftmgr.gearNeckHpBase = befmgr.gearNeckHpBase;
        aftmgr.gearNeckHpBaseLast = befmgr.gearNeckHpBaseLast;

        aftmgr.gearRingAtkBase = befmgr.gearRingAtkBase;
        aftmgr.gearRingAtkBaseLast = befmgr.gearRingAtkBaseLast;
        aftmgr.geaRingHpBase = befmgr.geaRingHpBase;
        aftmgr.gearRingHpBaseLast = befmgr.gearRingHpBaseLast;


        int igearextralen = befmgr.gearExtraTypes.Length;
        aftmgr.gearExtraTypes = new eEffectType[igearextralen];
        aftmgr.gearExtraValues = new long[igearextralen];
        for (int i = 0; i < igearextralen; i++)
        {
            aftmgr.gearExtraTypes[i] = befmgr.gearExtraTypes[i];
            aftmgr.gearExtraValues[i] = befmgr.gearExtraValues[i];
        }

        aftmgr.gearExtraEfcs = new Dictionary<eEffectType, long>(befmgr.gearExtraEfcs.Count);
        foreach (var item in befmgr.gearExtraEfcs)
        {
            aftmgr.gearExtraEfcs.Add(item.Key, item.Value);
        }
        #endregion Gear

        #region Treasure
        aftmgr.TreasureAtkBase = befmgr.TreasureAtkBase;
        aftmgr.TreasureHpBase = befmgr.TreasureHpBase;

        aftmgr.TreasureStageGold = befmgr.TreasureStageGold;
        aftmgr.TreasureStageExp = befmgr.TreasureStageExp;
        aftmgr.TreasureStageChest = befmgr.TreasureStageChest;
        aftmgr.TreasureStagePetBox = befmgr.TreasureStagePetBox;

        aftmgr.TreasureMov = befmgr.TreasureMov;
        aftmgr.TreasureSpd = befmgr.TreasureSpd;
        aftmgr.TreasurePierce = befmgr.TreasurePierce;

        aftmgr.TreasureCrtDam = befmgr.TreasureCrtDam;

        aftmgr.TreasureSkillDmg = befmgr.TreasureSkillDmg;
        aftmgr.TreasureSkillCool = befmgr.TreasureSkillCool;
        aftmgr.TreasureHealSec = befmgr.TreasureHealSec;


        aftmgr.TreasureRareAtkBase = befmgr.TreasureRareAtkBase;
        aftmgr.TreasureRareHpBase = befmgr.TreasureRareHpBase;

        aftmgr.TreasureRareAtkBuff = befmgr.TreasureRareAtkBuff;
        aftmgr.TreasureRareHpBuff = befmgr.TreasureRareHpBuff;

        aftmgr.TreasureRareStageGold = befmgr.TreasureRareStageGold;
        aftmgr.TreasureRareStageExp = befmgr.TreasureRareStageExp;
        aftmgr.TreasureRareStageChest = befmgr.TreasureRareStageChest;
        aftmgr.TreasureRareStagePetBox = befmgr.TreasureRareStagePetBox;

        aftmgr.TreasureRareMov = befmgr.TreasureRareMov;
        aftmgr.TreasureRareSpd = befmgr.TreasureRareSpd;
        aftmgr.TreasureRarePierce = befmgr.TreasureRarePierce;

        aftmgr.TreasureRareCrtDam = befmgr.TreasureRareCrtDam;

        aftmgr.TreasureRareSkillDmg = befmgr.TreasureRareSkillDmg;
        aftmgr.TreasureRareSkillCool = befmgr.TreasureRareSkillCool;
        aftmgr.TreasureRareHealSec = befmgr.TreasureRareHealSec;
        #endregion Treasure

        #region Skill
        aftmgr.totalSkillLvDamage = befmgr.totalSkillLvDamage;
        aftmgr.dicPassiveValues = new Dictionary<eEffectType, long>(befmgr.dicPassiveValues.Count);
        foreach (var item in befmgr.dicPassiveValues)
        {
            aftmgr.dicPassiveValues.Add(item.Key, item.Value);
        }
        #endregion Skill

        #region Pet
        aftmgr.petLv = befmgr.petLv;

        aftmgr.petAtkBaseLast = befmgr.petAtkBaseLast;
        aftmgr.petHpBaseLast = befmgr.petHpBaseLast;
        aftmgr.petPierceLast = befmgr.petPierceLast;

        int ipetpresetlen = befmgr.petAtkBases.Length;
        aftmgr.petAtkBases = new long[ipetpresetlen];
        aftmgr.petHpBases = new long[ipetpresetlen];
        aftmgr.petPierces = new long[ipetpresetlen];
        for (int i = 0; i < ipetpresetlen; i++)
        {
            aftmgr.petAtkBases[i] = befmgr.petAtkBases[i];
            aftmgr.petHpBases[i] = befmgr.petHpBases[i];
            aftmgr.petPierces[i] = befmgr.petPierces[i];
        }

        int ipetextralen = befmgr.petExtraTypes.Length;
        aftmgr.petExtraTypes = new eEffectType[ipetextralen];
        aftmgr.petExtraValues = new long[ipetextralen];
        for (int i = 0; i < ipetextralen; i++)
        {
            aftmgr.petExtraTypes[i] = befmgr.petExtraTypes[i];
            aftmgr.petExtraValues[i] = befmgr.petExtraValues[i];
        }

        aftmgr.petExtraEfcs = new Dictionary<eEffectType, long>(befmgr.petExtraEfcs.Count);
        foreach (var item in befmgr.petExtraEfcs)
        {
            aftmgr.petExtraEfcs.Add(item.Key, item.Value);
        }
        #endregion Pet

        #region Costume
        aftmgr.dicCosValues = new Dictionary<eEffectType, long>(befmgr.dicCosValues.Count);
        foreach (var item in befmgr.dicCosValues)
        {
            aftmgr.dicCosValues.Add(item.Key, item.Value);
        }
        #endregion Costume

        #region Title
        aftmgr.dicTitleValues = new Dictionary<eEffectType, long>(befmgr.dicTitleValues.Count);
        foreach (var item in befmgr.dicTitleValues)
        {
            aftmgr.dicTitleValues.Add(item.Key, item.Value);
        }
        #endregion Title

        #region Pvp
        aftmgr.PvpAtkAble = befmgr.PvpAtkAble;
        aftmgr.PvpHpAble = befmgr.PvpHpAble;
        aftmgr.PvpAtkWill = befmgr.PvpAtkWill;
        aftmgr.PvpHpWill = befmgr.PvpHpWill;
        #endregion Pvp

        #region ADBuff
        aftmgr.adBuffAttack = befmgr.adBuffAttack;
        aftmgr.adBuffStageGold = befmgr.adBuffStageGold;
        aftmgr.adBuffStageExp = befmgr.adBuffStageExp;
        #endregion ADBuff

        #region HotTime
        aftmgr.hotTimeGold = befmgr.hotTimeGold;
        aftmgr.hotTimeExp = befmgr.hotTimeExp;
        aftmgr.hotTimeChest = befmgr.hotTimeChest;
        #endregion HotTime

        aftmgr.CalcAllStat();
        aftmgr.CalcBattlePower();
        return aftmgr;
    }
    #endregion Base

    #region Enhance
    public void ChangeCharStat(eEffectType type, long ivalue, bool brecalc)
    {
        switch (type)
        {
            case eEffectType.AtkBase:
                enhanceAtkBase = ivalue;
                break;
            case eEffectType.HpBase:
                enhanceHpBase = ivalue;
                break;
            case eEffectType.CrtDam:
                enhanceCrtDam = ivalue;
                break;
            case eEffectType.CrtRate:
                ivalue = dConst.RateMax + ivalue;
                if (ivalue <= enhanceCrtRate)
                    return;
                enhanceCrtRate = ivalue;
                break;
            case eEffectType.Pierce:
                enhancePierce = ivalue;
                break;
            case eEffectType.SkillDamage:
                break;
            case eEffectType.SkillCool:
                break;
            case eEffectType.HealPerSec:
                break;
            default:
                return;
        }

        if (brecalc)
            CalcCharStat(type);
    }

    public void ChangeCharLvPoint(eEffectType type, long ivalue, bool brecalc)
    {
        switch (type)
        {
            case eEffectType.AtkBase:
                lvPointAtkBase = ivalue;
                break;

            case eEffectType.HpBase:
                lvPointHpBase = ivalue;
                break;

            case eEffectType.CrtDam:
                lvPointCrtDam = ivalue;
                break;

            case eEffectType.Mov:
                lvPointMov = ivalue;
                break;

            case eEffectType.Spd:
                lvPointSpd = ivalue;
                break;

            case eEffectType.Pierce:
                //CharLvPointPierce = ivalue;
                break;

            case eEffectType.GoldDropRate:
                lvPointStageGold = ivalue;
                break;

            case eEffectType.ExpDropRate:
                lvPointStageExp = ivalue;
                break;

            case eEffectType.ChestDropRate:
                lvPointStageChest = ivalue;
                break;

            case eEffectType.PetBoxDropRate:
                lvPointStagePetBox = ivalue;
                break;

            default:
                return;
        }
        if (brecalc)
            CalcCharStat(type);
    }

    public void AwakenReset()
    {
        awakenAtkBase = 0L;
        awakenHpBase = 0L;
        awakenAtkBuff = 0L;
        awakenHpBuff = 0L;
        awakenCrtDam = 0L;
        awakenMov = 0L;
        awakenSpd = 0L;
        awakenPierce = 0L;
        awakenSkillDmg = 0L;
        awakenSkillCool = 0L;
        awakenHealSec = 0L;
        awakenStageGold = 0L;
        awakenStageExp = 0L;
        awakenStageChest = 0L;
        awakenStagePetBox = 0L;
    }

    public void ChangeAwakenStat(eEffectType type, long ivalue, bool brecalc)
    {
        switch (type)
        {
            case eEffectType.AtkBase:
                awakenAtkBase += ivalue;
                break;

            case eEffectType.HpBase:
                awakenHpBase += ivalue;
                break;

            case eEffectType.AtkBuff:
                awakenAtkBuff += ivalue;
                break;

            case eEffectType.HpBuff:
                awakenHpBuff += ivalue;
                break;

            case eEffectType.CrtDam:
                awakenCrtDam += ivalue;
                break;

            case eEffectType.Mov:
                awakenMov += ivalue;
                break;

            case eEffectType.Spd:
                awakenSpd += ivalue;
                break;

            case eEffectType.Pierce:
                awakenPierce += ivalue;
                break;

            case eEffectType.SkillDamage:
                awakenSkillDmg += ivalue;
                break;

            case eEffectType.SkillCool:
                awakenSkillCool += ivalue;
                break;

            case eEffectType.HealPerSec:
                awakenHealSec += ivalue;
                break;

            case eEffectType.GoldDropRate:
                awakenStageGold += ivalue;
                break;

            case eEffectType.ExpDropRate:
                awakenStageExp += ivalue;
                break;

            case eEffectType.ChestDropRate:
                awakenStageChest += ivalue;
                break;

            case eEffectType.PetBoxDropRate:
                awakenStagePetBox += ivalue;
                break;

            default:
                return;
        }
        if (brecalc)
            CalcCharStat(type);
    }

    public void ChangeAwakenDungeonStat(int id)
    {
        awakenAtkBuffDg = DataHandler.SysAwakenRewards[id].awakenInc;
        CalcCharStat(eEffectType.AtkBuff);
    }
    #endregion Enhance

    #region Gear & Treasure
    // 장비 총합 레벨 효과 적용.
    public void SetGearLv(int itype, int ivalue, bool brecalc)
    {
        dicGearLv[itype] = ivalue;
        if (brecalc)
            CalcGearEquip(itype);
    }

    // 장비 장착 효과 적용.
    public void SetGearEquip(int itype, eEffectType type, long ivalue, bool brecalc)
    {
        switch (itype)
        {
            case cGoods.TBagWeapon:
                gearWeaponAtkBase = ivalue;
                gearWeaponAtkBaseLast = ivalue * (dConst.RateMax + dicGearLv[itype]) / dConst.RateMax;
                break;

            case cGoods.TBagArmorCape:
                gearCapeHpBase = ivalue;
                gearCapeHpBaseLast = ivalue * (dConst.RateMax + dicGearLv[itype]) / dConst.RateMax;
                break;

            case cGoods.TBagArmorHat:
                gearHatHpBase = ivalue;
                gearHatHpBaseLast = ivalue * (dConst.RateMax + dicGearLv[itype]) / dConst.RateMax;
                break;

            case cGoods.TBagArmorShoes:
                gearShoesAtkBase = ivalue;
                gearShoesAtkBaseLast = ivalue * (dConst.RateMax + dicGearLv[itype]) / dConst.RateMax;
                break;

            case cGoods.TBagAcceEar:
                switch (type)
                {
                    case eEffectType.AtkBase:
                        gearEarAtkBase = ivalue;
                        gearEarAtkBaseLast = ivalue * (dConst.RateMax + dicGearLv[itype]) / dConst.RateMax;
                        break;
                    case eEffectType.HpBase:
                        geaEarHpBase = ivalue;
                        gearEarHpBaseLast = ivalue * (dConst.RateMax + dicGearLv[itype]) / dConst.RateMax;
                        break;
                    default:
                        return;
                }
                break;

            case cGoods.TBagAcceNeck:
                switch (type)
                {
                    case eEffectType.AtkBase:
                        gearNeckAtkBase = ivalue;
                        gearNeckAtkBaseLast = ivalue * (dConst.RateMax + dicGearLv[itype]) / dConst.RateMax;
                        break;
                    case eEffectType.HpBase:
                        gearNeckHpBase = ivalue;
                        gearNeckHpBaseLast = ivalue * (dConst.RateMax + dicGearLv[itype]) / dConst.RateMax;
                        break;
                    default:
                        return;
                }
                break;

            case cGoods.TBagAcceRing:
                switch (type)
                {
                    case eEffectType.AtkBase:
                        gearRingAtkBase = ivalue;
                        gearRingAtkBaseLast = ivalue * (dConst.RateMax + dicGearLv[itype]) / dConst.RateMax;
                        break;
                    case eEffectType.HpBase:
                        geaRingHpBase = ivalue;
                        gearRingHpBaseLast = ivalue * (dConst.RateMax + dicGearLv[itype]) / dConst.RateMax;
                        break;
                    default:
                        return;
                }
                break;

            default:
                return;
        }
        if (brecalc)
            CalcCharStat(type);
    }

    // 장비 장착 효과 재계산.
    private void CalcGearEquip(int itype)
    {
        switch (itype)
        {
            case cGoods.TBagWeapon:
                gearWeaponAtkBaseLast = gearWeaponAtkBase * (dConst.RateMax + dicGearLv[itype]) / dConst.RateMax;
                CalcCharStat(eEffectType.AtkBase);
                break;

            case cGoods.TBagArmorCape:
                gearCapeHpBaseLast = gearCapeHpBase * (dConst.RateMax + dicGearLv[itype]) / dConst.RateMax;
                CalcCharStat(eEffectType.HpBase);
                break;

            case cGoods.TBagArmorHat:
                gearHatHpBaseLast = gearHatHpBase * (dConst.RateMax + dicGearLv[itype]) / dConst.RateMax;
                CalcCharStat(eEffectType.Pierce);
                break;

            case cGoods.TBagArmorShoes:
                gearShoesAtkBaseLast = gearShoesAtkBase * (dConst.RateMax + dicGearLv[itype]) / dConst.RateMax;
                //@
                CalcCharStat(eEffectType.AtkBase);
                break;

            case cGoods.TBagAcceEar:
                gearEarAtkBaseLast = gearEarAtkBase * (dConst.RateMax + dicGearLv[itype]) / dConst.RateMax;
                gearEarHpBaseLast = geaEarHpBase * (dConst.RateMax + dicGearLv[itype]) / dConst.RateMax;
                CalcCharStat(eEffectType.AtkBase);
                CalcCharStat(eEffectType.HpBase);
                break;

            case cGoods.TBagAcceNeck:
                gearNeckAtkBaseLast = gearNeckAtkBase * (dConst.RateMax + dicGearLv[itype]) / dConst.RateMax;
                gearNeckHpBaseLast = gearNeckHpBase * (dConst.RateMax + dicGearLv[itype]) / dConst.RateMax;
                CalcCharStat(eEffectType.AtkBase);
                CalcCharStat(eEffectType.HpBase);
                break;

            case cGoods.TBagAcceRing:
                gearRingAtkBaseLast = gearRingAtkBase * (dConst.RateMax + dicGearLv[itype]) / dConst.RateMax;
                gearRingHpBaseLast = geaRingHpBase * (dConst.RateMax + dicGearLv[itype]) / dConst.RateMax;
                CalcCharStat(eEffectType.AtkBase);
                CalcCharStat(eEffectType.HpBase);
                break;

            default:
                return;
        }
    }

    // 장비 추가 효과 적용.
    public void SetGearExtra(int itype, int islot, eEffectType type, long ivalue, bool brecalc)
    {
        int index = -1;
        switch (itype)
        {
            case cGoods.TBagWeapon:
                index = islot;
                break;

            case cGoods.TBagArmorCape:
                index = 3 + islot;
                break;

            case cGoods.TBagArmorHat:
                index = 6 + islot;
                break;

            case cGoods.TBagArmorShoes:
                index = 9 + islot;
                break;

            case cGoods.TBagAcceEar:
                index = 12 + islot;
                break;

            case cGoods.TBagAcceNeck:
                index = 15 + islot;
                break;

            case cGoods.TBagAcceRing:
                index = 18 + islot;
                break;

            default:
                return;
        }

        if (index < 0 || index >= gearExtraValues.Length)
            return;

        // 기존 효과가 있는 슬롯이라면 기존 효과 감산.
        if (gearExtraTypes[index] != eEffectType.None)
            gearExtraEfcs[gearExtraTypes[index]] -= gearExtraValues[index];

        // 슬롯 효과 변경.
        gearExtraTypes[index] = type;
        gearExtraValues[index] = ivalue;

        // 새 효과가 있다면 새 효과 가산.
        if (gearExtraTypes[index] != eEffectType.None)
            gearExtraEfcs[gearExtraTypes[index]] += gearExtraValues[index];

        if (brecalc)
            CalcAllStat();
    }

    // 장비 추가 효과 불러오기.
    private long GetGearExtra(eEffectType type)
    {
#if UNITY_EDITOR
        if (gearExtraEfcs == null)
            return 0L;
#endif
        if (gearExtraEfcs.ContainsKey(type))
            return gearExtraEfcs[type];
        return 0L;
    }

    // 일반 보물 효과 적용.
    public void SetGearTreasure(eEffectType type, long ivalue, bool brecalc)
    {
        switch (type)
        {
            case eEffectType.AtkBase:
                TreasureAtkBase = ivalue;
                break;

            case eEffectType.HpBase:
                TreasureHpBase = ivalue;
                break;

            case eEffectType.CrtDam:
                TreasureCrtDam = ivalue;
                break;

            case eEffectType.Mov:
                TreasureMov = ivalue;
                break;

            case eEffectType.Spd:
                TreasureSpd = ivalue;
                break;

            case eEffectType.Pierce:
                TreasurePierce = ivalue;
                break;

            case eEffectType.SkillDamage:
                TreasureSkillDmg = ivalue;
                break;

            case eEffectType.SkillCool:
                TreasureSkillCool = ivalue;
                break;

            case eEffectType.HealPerSec:
                TreasureHealSec = ivalue;
                break;

            case eEffectType.GoldDropRate:
                TreasureStageGold = ivalue;
                break;

            case eEffectType.ExpDropRate:
                TreasureStageExp = ivalue;
                break;

            case eEffectType.ChestDropRate:
                TreasureStageChest = ivalue;
                break;

            case eEffectType.PetBoxDropRate:
                TreasureStagePetBox = ivalue;
                break;

            default:
                return;
        }
        if (brecalc)
            CalcCharStat(type);
    }

    // 희귀 보물 효과 적용.
    public void SetGearTreasureRare(eEffectType type, long ivalue, bool brecalc)
    {
        switch (type)
        {
            case eEffectType.AtkBase:
                TreasureRareAtkBase = ivalue;
                break;

            case eEffectType.HpBase:
                TreasureRareHpBase = ivalue;
                break;

            case eEffectType.AtkBuff:
                TreasureRareAtkBuff = ivalue;
                break;

            case eEffectType.HpBuff:
                TreasureRareHpBuff = ivalue;
                break;

            case eEffectType.CrtDam:
                TreasureRareCrtDam = ivalue;
                break;

            case eEffectType.Mov:
                TreasureRareMov = ivalue;
                break;

            case eEffectType.Spd:
                TreasureRareSpd = ivalue;
                break;

            case eEffectType.Pierce:
                TreasureRarePierce = ivalue;
                break;

            case eEffectType.SkillDamage:
                TreasureRareSkillDmg = ivalue;
                break;

            case eEffectType.SkillCool:
                TreasureRareSkillCool = ivalue;
                break;

            case eEffectType.HealPerSec:
                TreasureRareHealSec = ivalue;
                break;

            case eEffectType.GoldDropRate:
                TreasureRareStageGold = ivalue;
                break;

            case eEffectType.ExpDropRate:
                TreasureRareStageExp = ivalue;
                break;

            case eEffectType.ChestDropRate:
                TreasureRareStageChest = ivalue;
                break;

            case eEffectType.PetBoxDropRate:
                TreasureRareStagePetBox = ivalue;
                break;

            default:
                return;
        }
        if (brecalc)
            CalcCharStat(type);
    }
    #endregion Gear & Treasure

    #region Skill
    // 스킬 총합 레벨 효과 적용.
    public void SetSkillLv(int ivalue)
    {
        totalSkillLvDamage = ivalue;
        CalcCharStat(eEffectType.SkillDamage);
    }

    public void ChangePassiveStat(eEffectType type, long ivalue, bool brecalc)
    {
        if (dicPassiveValues.ContainsKey(type))
        {
            dicPassiveValues[type] = ivalue;
            if (brecalc)
                CalcCharStat(type);
        }
    }
    #endregion Skill

    #region Pet
    // 펫 총합 레벨 효과 적용.
    public void SetPetLv(int ivalue, bool brecalc)
    {
        petLv = ivalue;
        if (brecalc)
            CalcPetEquip();
    }

    // 펫 장착 효과 적용.
    public void SetPetEquip(int slotindex, eEffectType type1, long ivalue1, eEffectType type2, long ivalue2, eEffectType type3, long ivalue3, bool brecalc)
    {
        petAtkBases[slotindex] = 0L;
        petHpBases[slotindex] = 0L;
        petPierces[slotindex] = 0L;

        switch (type1)
        {
            case eEffectType.AtkBase:
                petAtkBases[slotindex] = ivalue1;
                break;
            case eEffectType.HpBase:
                petHpBases[slotindex] = ivalue1;
                break;
            case eEffectType.Pierce:
                petPierces[slotindex] = ivalue1;
                break;
        }

        switch (type2)
        {
            case eEffectType.AtkBase:
                petAtkBases[slotindex] = ivalue2;
                break;
            case eEffectType.HpBase:
                petHpBases[slotindex] = ivalue2;
                break;
            case eEffectType.Pierce:
                petPierces[slotindex] = ivalue2;
                break;
        }

        switch (type3)
        {
            case eEffectType.AtkBase:
                petAtkBases[slotindex] = ivalue3;
                break;
            case eEffectType.HpBase:
                petHpBases[slotindex] = ivalue3;
                break;
            case eEffectType.Pierce:
                petPierces[slotindex] = ivalue3;
                break;
        }

        if (brecalc)
            CalcPetEquip();
    }

    // 펫 장착 효과 재계산.
    private void CalcPetEquip()
    {
        petAtkBaseLast = (petAtkBases[0] + petAtkBases[1] + petAtkBases[2]) * (dConst.RateMax + petLv) / dConst.RateMax;
        petHpBaseLast = (petHpBases[0] + petHpBases[1] + petHpBases[2]) * (dConst.RateMax + petLv) / dConst.RateMax;
        petPierceLast = (petPierces[0] + petPierces[1] + petPierces[2]) * (dConst.RateMax + petLv) / dConst.RateMax;
        CalcCharStat(eEffectType.AtkBase);
        CalcCharStat(eEffectType.HpBase);
        CalcCharStat(eEffectType.Pierce);
    }

    /// <summary>
    /// 펫 추가 & 옵션 효과 적용.
    /// </summary>
    /// <param name="slotindex">펫이 장착된 슬롯. 0~2.</param>
    /// <param name="islot">추가 효과 슬롯. 0~2: 추가 효과, 3: 옵션 보유 효과.</param>
    /// <param name="ivalue">효과 값.</param>
    /// <param name="brecalc">모든 스테이터스 재계산.</param>
    /// <returns></returns>
    public void SetPetExtra(int slotindex, int islot, eEffectType type, long ivalue, bool brecalc)
    {
        int index = slotindex * 4 + islot;
        if (index < 0 || index >= petExtraValues.Length)
        {
            if (brecalc)
                CalcAllStat();
            return;
        }

        // 기존 효과가 있는 슬롯이라면 기존 효과 감산.
        if (petExtraTypes[index] != eEffectType.None)
            petExtraEfcs[petExtraTypes[index]] -= petExtraValues[index];

        // 슬롯 효과 변경.
        petExtraTypes[index] = type;
        petExtraValues[index] = ivalue;

        // 새 효과가 있다면 새 효과 가산.
        if (type != eEffectType.None)
            petExtraEfcs[type] += ivalue;

        if (brecalc)
            CalcAllStat();
    }

    // 펫 추가 효과 불러오기.
    private long GetPetExtra(eEffectType type)
    {
#if UNITY_EDITOR
        if (petExtraEfcs == null)
            return 0L;
#endif
        if (petExtraEfcs.ContainsKey(type))
            return petExtraEfcs[type];
        return 0L;
    }
    #endregion Pet

    #region Costume
    public void AddCostumeEfc(eEffectType type, long ivalue, bool brecalc)
    {
        if (dicCosValues.ContainsKey(type))
        {
            dicCosValues[type] += ivalue;
            if (brecalc)
                CalcCharStat(type);
        }
    }

    public Dictionary<eEffectType, long> GetCostumeEfcs()
    {
        return dicCosValues;
    }
    #endregion Costume

    #region Title
    public void AddTitleEfc(eEffectType type, long ivalue, bool brecalc)
    {
        if (dicTitleValues.ContainsKey(type))
        {
            dicTitleValues[type] += ivalue;
            if (brecalc)
                CalcCharStat(type);
        }
    }

    public Dictionary<eEffectType, long> GetTitleEfcs()
    {
        return dicTitleValues;
    }

    #endregion

    #region Pvp
    // 결투장 티어 효과 적용.
    public void SetPvpTier(long iatkable, long ihpable, long iatkwill, long ihpwill)
    {
        PvpAtkAble = iatkable;
        PvpHpAble = ihpable;
        PvpAtkWill = iatkwill;
        PvpHpWill = ihpwill;
        CalcCharStat(eEffectType.AtkAble);
        CalcCharStat(eEffectType.HpAble);
    }
    #endregion Pvp

    #region AdBuff
    public void OnAdBuff(eEffectType type, long ivalue, bool brecalc)
    {
        switch (type)
        {
            case eEffectType.AtkBuff:
                adBuffAttack = ivalue;
                break;

            case eEffectType.GoldDropRate:
                adBuffStageGold = ivalue;
                break;

            case eEffectType.ExpDropRate:
                adBuffStageExp = ivalue;
                break;

            default:
                return;
        }
        if (brecalc)
            CalcCharStat(type);
    }

    public void OffAdBuff(eEffectType type, bool brecalc)
    {
        switch (type)
        {
            case eEffectType.AtkBuff:
                adBuffAttack = 0L;
                break;

            case eEffectType.GoldDropRate:
                adBuffStageGold = 0L;
                break;

            case eEffectType.ExpDropRate:
                adBuffStageExp = 0L;
                break;

            default:
                return;
        }
        if (brecalc)
            CalcCharStat(type);
    }
    #endregion

    #region HotTime
    public void OnHotTime()
    {
        hotTimeGold = DataHandler.GetEvents()[(int)eEventMoveType.Hottime].scale1;
        hotTimeExp = DataHandler.GetEvents()[(int)eEventMoveType.Hottime].scale2;
        hotTimeChest = DataHandler.GetEvents()[(int)eEventMoveType.Hottime].scale3;
        CalcCharStat(eEffectType.GoldDropRate);
        CalcCharStat(eEffectType.ExpDropRate);
        CalcCharStat(eEffectType.ChestDropRate);
    }

    public void OffHotTime()
    {
        hotTimeGold = 0;
        hotTimeExp = 0;
        hotTimeChest = 0;
        CalcCharStat(eEffectType.GoldDropRate);
        CalcCharStat(eEffectType.ExpDropRate);
        CalcCharStat(eEffectType.ChestDropRate);
    }
    #endregion

    #region Guardian
    public void GuardianGrowReset()
    {
        guardianAtkBase = 0L;
        guardianHpBase = 0L;
        guardianAtkBuff = 0L;
        guardianHpBuff = 0L;
        guardianCrtDam = 0L;
        guardianMov = 0L;
        guardianSpd = 0L;
        guardianPierce = 0L;
        guardianSkillDmg = 0L;
        guardianSkillCool = 0L;
        guardianHealSec = 0L;
        guardianStageGold = 0L;
        guardianStageExp = 0L;
        guardianStageChest = 0L;
        guardianStagePetBox = 0L;
    }

    public void GuardianAwakenReset()
    {
        guardianAwakenAtkBase = 0L;
        guardianAwakenHpBase = 0L;
        guardianAwakenAtkBuff = 0L;
        guardianAwakenHpBuff = 0L;
        guardianAwakenCrtDam = 0L;
        guardianAwakenMov = 0L;
        guardianAwakenSpd = 0L;
        guardianAwakenPierce = 0L;
        guardianAwakenSkillDmg = 0L;
        guardianAwakenSkillCool = 0L;
        guardianAwakenHealSec = 0L;
        guardianAwakenStageGold = 0L;
        guardianAwakenStageExp = 0L;
        guardianAwakenStageChest = 0L;
        guardianAwakenStagePetBox = 0L;
    }

    public void ChangeGuardianGrowStat(eEffectType type, long ivalue, bool brecalc)
    {
        switch (type)
        {
            case eEffectType.AtkBase:
                guardianAtkBase += ivalue;
                break;

            case eEffectType.HpBase:
                guardianHpBase += ivalue;
                break;

            case eEffectType.AtkBuff:
                guardianAtkBuff += ivalue;
                break;

            case eEffectType.HpBuff:
                guardianHpBuff += ivalue;
                break;

            case eEffectType.CrtDam:
                guardianCrtDam += ivalue;
                break;

            case eEffectType.Mov:
                guardianMov += ivalue;
                break;

            case eEffectType.Spd:
                guardianSpd += ivalue;
                break;

            case eEffectType.Pierce:
                guardianPierce += ivalue;
                break;

            case eEffectType.SkillDamage:
                guardianSkillDmg += ivalue;
                break;

            case eEffectType.SkillCool:
                guardianSkillCool += ivalue;
                break;

            case eEffectType.HealPerSec:
                guardianHealSec += ivalue;
                break;

            case eEffectType.GoldDropRate:
                guardianStageGold += ivalue;
                break;

            case eEffectType.ExpDropRate:
                guardianStageExp += ivalue;
                break;

            case eEffectType.ChestDropRate:
                guardianStageChest += ivalue;
                break;

            case eEffectType.PetBoxDropRate:
                guardianStagePetBox += ivalue;
                break;

            default:
                return;
        }
        if (brecalc)
            CalcCharStat(type);
    }

    public void ChangeGuardianAwakenStat(eEffectType type, long ivalue, bool brecalc)
    {
        switch (type)
        {
            case eEffectType.AtkBase:
                guardianAwakenAtkBase += ivalue;
                break;

            case eEffectType.HpBase:
                guardianAwakenHpBase += ivalue;
                break;

            case eEffectType.AtkBuff:
                guardianAwakenAtkBuff += ivalue;
                break;

            case eEffectType.HpBuff:
                guardianAwakenHpBuff += ivalue;
                break;

            case eEffectType.CrtDam:
                guardianAwakenCrtDam += ivalue;
                break;

            case eEffectType.Mov:
                guardianAwakenMov += ivalue;
                break;

            case eEffectType.Spd:
                guardianAwakenSpd += ivalue;
                break;

            case eEffectType.Pierce:
                guardianAwakenPierce += ivalue;
                break;

            case eEffectType.SkillDamage:
                guardianAwakenSkillDmg += ivalue;
                break;

            case eEffectType.SkillCool:
                guardianAwakenSkillCool += ivalue;
                break;

            case eEffectType.HealPerSec:
                guardianAwakenHealSec += ivalue;
                break;

            case eEffectType.GoldDropRate:
                guardianAwakenStageGold += ivalue;
                break;

            case eEffectType.ExpDropRate:
                guardianAwakenStageExp += ivalue;
                break;

            case eEffectType.ChestDropRate:
                guardianAwakenStageChest += ivalue;
                break;

            case eEffectType.PetBoxDropRate:
                guardianAwakenStagePetBox += ivalue;
                break;

            default:
                return;
        }
        if (brecalc)
            CalcCharStat(type);
    }

    public void SetGuardianStat(eEffectType ability, long count)
    {
        ChangeGuardianGrowStat(ability, count, false);
    }

    public void SetGuardianAwakenStat()
    {
        GuardianAwakenReset();

        for (int i = 1; i <= DataHandler.GetPlayGuardians().Count; i++)
        {
            for (int j = 0; j < DataHandler.GetPlayGuardian(i).extras.Length; j++)
            {
                if (DataHandler.GetPlayGuardian(i).extras[j] >= 0)
                {
                    BuffMgr.Instance.ChangeGuardianAwakenStat(DataHandler.GetExtraAbility(DataHandler.GetPlayGuardian(i).extras[j]).abilityType, DataHandler.GetExtraAbility(DataHandler.GetPlayGuardian(i).extras[j]).abilityValue, false);
                }
            }
        }
    }
    #endregion

    #region Relic
    public void RelicStatReset()
    {
        RelicAtkBase = 0L;
        RelicHpBase = 0L;
        RelicAtkBuff = 0L;
        RelicHpBuff = 0L;
        RelicCrtDam = 0L;
        RelicMov = 0L;
        RelicSpd = 0L;
        RelicPierce = 0L;
        RelicSkillDmg = 0L;
        RelicSkillCool = 0L;
        RelicHealSec = 0L;
        RelicStageGold = 0L;
        RelicStageExp = 0L;
        RelicStageChest = 0L;
        RelicStagePetBox = 0L;
    }

    public void ChangeRelicStat(eEffectType type, long ivalue, bool brecalc)
    {
        switch (type)
        {
            case eEffectType.AtkBase:
                RelicAtkBase += ivalue;
                break;

            case eEffectType.HpBase:
                RelicHpBase += ivalue;
                break;

            case eEffectType.AtkBuff:
                RelicAtkBuff += ivalue;
                break;

            case eEffectType.HpBuff:
                RelicHpBuff += ivalue;
                break;

            case eEffectType.CrtDam:
                RelicCrtDam += ivalue;
                break;

            case eEffectType.Mov:
                RelicMov += ivalue;
                break;

            case eEffectType.Spd:
                RelicSpd += ivalue;
                break;

            case eEffectType.Pierce:
                RelicPierce += ivalue;
                break;

            case eEffectType.SkillDamage:
                RelicSkillDmg += ivalue;
                break;

            case eEffectType.SkillCool:
                RelicSkillCool += ivalue;
                break;

            case eEffectType.HealPerSec:
                RelicHealSec += ivalue;
                break;

            case eEffectType.GoldDropRate:
                RelicStageGold += ivalue;
                break;

            case eEffectType.ExpDropRate:
                RelicStageExp += ivalue;
                break;

            case eEffectType.ChestDropRate:
                RelicStageChest += ivalue;
                break;

            case eEffectType.PetBoxDropRate:
                RelicStagePetBox += ivalue;
                break;

            case eEffectType.DeepCaveDgBonus:
            {
                RelicDgGoldBase += ivalue;
                break;
            }

            default:
                return;
        }
        if (brecalc)
            CalcCharStat(type);
    }
    #endregion

    #region Calc.
    // 캐릭터 전체 스탯 재계산.
    public void CalcAllStat()
    {
        CalcCharStat(eEffectType.AtkBase);
        CalcCharStat(eEffectType.HpBase);
        CalcCharStat(eEffectType.CrtDam);
        CalcCharStat(eEffectType.CrtRate);
        CalcCharStat(eEffectType.Mov);
        CalcCharStat(eEffectType.Spd);
        CalcCharStat(eEffectType.Pierce);
        CalcCharStat(eEffectType.GoldDropRate);
        CalcCharStat(eEffectType.ExpDropRate);
        CalcCharStat(eEffectType.ChestDropRate);
        CalcCharStat(eEffectType.PetBoxDropRate);
        CalcCharStat(eEffectType.DeepCaveDgBonus);
        CalcCharStat(eEffectType.AtlantisDgBonus);
        CalcCharStat(eEffectType.ProtectTheMerchantDgBonus);
        CalcCharStat(eEffectType.DevelopTheJungleDgBonus);
        CalcCharStat(eEffectType.SkillDamage);
    }

    // 캐릭터 특정 스탯 재계산.
    public void CalcCharStat(eEffectType type)
    {
        switch (type)
        {
            case eEffectType.AtkBase:
            case eEffectType.AtkAble:
            case eEffectType.AtkWill:
            case eEffectType.AtkBuff:
                BigInteger biatk = enhanceAtkBase + lvPointAtkBase; // 기본 스탯
                biatk = CalcBaseLong(biatk, SumContentStatLong(gearWeaponAtkBaseLast, gearShoesAtkBaseLast)); // 장비
                biatk = CalcBaseLong(biatk, SumContentStatLong(gearRingAtkBaseLast, gearEarAtkBaseLast, gearNeckAtkBaseLast)); // 장신구
                biatk = CalcBaseLong(biatk, TreasureAtkBase, TreasureRareAtkBase, petAtkBaseLast);// 보물,펫
                biatk = CalcBaseInt(biatk, SumContentStatLong(GetGearExtra(eEffectType.AtkBase), GetPetExtra(eEffectType.AtkBase), awakenAtkBase, guardianAwakenAtkBase, guardianAtkBase)); //추가스탯 합적용
                biatk = CalcBaseInt(biatk, RelicAtkBase);
                biatk = CalcBaseInt(biatk, dicCosValues[eEffectType.AtkBase], dicTitleValues[eEffectType.AtkBase], dicPassiveValues[eEffectType.AtkBase]);// 코스튬, 칭호, 패시브
                biatk = CalcBaseInt(biatk, awakenAtkBuffDg, PvpAtkAble, PvpAtkWill);

                atkCalculator.ClearModifiers();
                atkCalculator.DefaultValue = biatk;

                if(adBuffAttack > 0)
                {
                    float adBuffPercent = (adBuffAttack / dConst.RateMaxFloat) * 100;
                    atkCalculator.AddModifiers(new ValueModifier(ValueModifier.Type.AppendablePercent, adBuffPercent));
                }

                foreach (var buff in GamePlayBuffMgr.Instance.BuffGroup.GetBuffs(eEffectType.AtkBuff))
                {
                    atkCalculator.AddModifiers(buff.Value);
                }

                totalAtk = atkCalculator.ModifiedValue;
                totalAtkAd = atkCalculator.ModifiedValue;
                break;
            case eEffectType.HpBase:
            case eEffectType.HpAble:
            case eEffectType.HpWill:
            case eEffectType.HpBuff:
                BigInteger baseHp = enhanceHpBase + lvPointHpBase;
                baseHp = CalcBaseLong(baseHp, SumContentStatLong(gearCapeHpBaseLast, gearHatHpBaseLast));
                baseHp = CalcBaseLong(baseHp, SumContentStatLong(gearEarHpBaseLast, gearNeckHpBaseLast, gearRingHpBaseLast));
                baseHp = CalcBaseLong(baseHp, TreasureHpBase, TreasureRareHpBase, petHpBaseLast);
                baseHp = CalcBaseInt(baseHp, SumContentStatLong(GetPetExtra(eEffectType.HpBase), GetGearExtra(eEffectType.HpBase), awakenHpBase, guardianAwakenHpBase, guardianHpBase));
                baseHp = CalcBaseInt(baseHp, RelicHpBase);
                baseHp = CalcBaseInt(baseHp, dicCosValues[eEffectType.HpBase], dicTitleValues[eEffectType.HpBase], dicPassiveValues[eEffectType.HpBase]);
                baseHp = CalcBaseInt(baseHp, PvpHpAble, PvpHpWill);

                hpCalculator.ClearModifiers();
                hpCalculator.DefaultValue = baseHp;

                foreach (var buff in GamePlayBuffMgr.Instance.BuffGroup.GetBuffs(eEffectType.HpBuff))
                {
                    hpCalculator.AddModifiers(buff.Value);
                }

                totalHp = hpCalculator.ModifiedValue;
                break;
            case eEffectType.Mov:
                totalMov = dConst.RateMax + enhanceMov + lvPointMov + awakenMov + dicPassiveValues[type] +
                    GetGearExtra(type) + TreasureMov + TreasureRareMov + GetPetExtra(type) + dicCosValues[type] + dicTitleValues[type] + guardianAwakenMov + guardianMov + 
                    RelicMov;
                break;
            case eEffectType.Spd:
                totalSpd = dConst.RateMax + enhanceSpd + lvPointSpd + awakenSpd + dicPassiveValues[type] +
                    GetGearExtra(type) + TreasureSpd + TreasureRareSpd + GetPetExtra(type) + dicCosValues[type] + dicTitleValues[type] + guardianAwakenSpd + guardianSpd + 
                    RelicSpd;
                break;
            case eEffectType.CrtDam:
                totalCrtDam = enhanceCrtDam + lvPointCrtDam + awakenCrtDam + dicPassiveValues[type] +
                    GetGearExtra(type) + TreasureCrtDam + TreasureRareCrtDam + GetPetExtra(type) + dicCosValues[type] + dicTitleValues[type] + guardianAwakenCrtDam + guardianCrtDam + 
                    RelicCrtDam;
                break;
            case eEffectType.CrtRate:
                totalCrtRate = (int)enhanceCrtRate;
                break;
            case eEffectType.SkillDamage:
                totalSkillDmg = dConst.RateMax + awakenSkillDmg + dicPassiveValues[type] + TreasureSkillDmg + TreasureRareSkillDmg + dicCosValues[type] + dicTitleValues[type] + guardianAwakenSkillDmg + guardianSkillDmg + RelicSkillDmg;
#if false
                totalSkillDmg = totalSkillDmg * (1f + totalSkillLvDamage / dConst.RateMaxFloat);
#else
                skillDmgCalculator.ClearModifiers();
                skillDmgCalculator.DefaultValue = totalSkillDmg;

                if(totalSkillLvDamage > 0)
                {
                    float percent = (totalSkillLvDamage / dConst.RateMaxFloat) * 100;
                    skillDmgCalculator.AddModifiers(new ValueModifier(ValueModifier.Type.AppendablePercent, percent));
                }

                foreach (var buff in GamePlayBuffMgr.Instance.BuffGroup.GetBuffs(eEffectType.SkillDamage))
                {
                    skillDmgCalculator.AddModifiers(buff.Value);
                }

                totalSkillDmg = skillDmgCalculator.ModifiedValue;
#endif
                break;
            case eEffectType.SkillCool:
                totalSkillCool = awakenSkillCool + dicPassiveValues[type] + TreasureSkillCool + TreasureRareSkillCool + dicCosValues[type] + dicTitleValues[type] + guardianAwakenSkillCool + guardianSkillCool + RelicSkillCool;
                break;
            case eEffectType.HealPerSec:
                totalHpHealSec = awakenHealSec + dicPassiveValues[type] + TreasureHealSec + TreasureRareHealSec + dicCosValues[type] + dicTitleValues[type] + guardianAwakenHealSec + guardianHealSec + RelicHealSec;
                break;
            case eEffectType.GoldDropRate:
                float goldBase = dConst.RateMax + lvPointStageGold + awakenStageGold + dicPassiveValues[type] +
                    GetGearExtra(type) + TreasureStageGold + TreasureRareStageGold + GetPetExtra(type) + dicCosValues[type] + dicTitleValues[type] + adBuffStageGold + guardianAwakenStageGold + guardianStageGold + 
                    RelicStageGold;

                goldRateCalculator.ClearModifiers();
                goldRateCalculator.DefaultValue = goldBase;

                if (hotTimeGold > 0)
                {
                    float hotTimeGoldPercent = (hotTimeGold / dConst.RateMaxFloat) * 100;
                    goldRateCalculator.AddModifiers(new ValueModifier(ValueModifier.Type.AppendablePercent, hotTimeGoldPercent));
                }
        
                foreach (var buff in GamePlayBuffMgr.Instance.BuffGroup.GetBuffs(eEffectType.GoldDropRate))
                {
                    goldRateCalculator.AddModifiers(buff.Value);
                }       

                CharStageGold = goldRateCalculator.ModifiedValue;
                break;
            case eEffectType.ExpDropRate:
                float expBase = dConst.RateMax + lvPointStageExp + awakenStageExp + dicPassiveValues[type] +
                    GetGearExtra(type) + TreasureStageExp + TreasureRareStageExp + GetPetExtra(type) + dicCosValues[type] + dicTitleValues[type] + adBuffStageExp + guardianAwakenStageExp + guardianStageExp + 
                    RelicStageExp;

                expRateCalculator.ClearModifiers();
                expRateCalculator.DefaultValue = expBase;

                if (hotTimeExp > 0)
                {
                    float hotTimeExpPercent = (hotTimeExp / dConst.RateMaxFloat) * 100;
                    expRateCalculator.AddModifiers(new ValueModifier(ValueModifier.Type.AppendablePercent, hotTimeExpPercent));
                }

                foreach (var buff in GamePlayBuffMgr.Instance.BuffGroup.GetBuffs(eEffectType.ExpDropRate))
                {
                    expRateCalculator.AddModifiers(buff.Value);
                }

                CharStageExp = expRateCalculator.ModifiedValue;
                break;
            case eEffectType.ChestDropRate:
                float chestBase = lvPointStageChest + awakenStageChest + dicPassiveValues[type] +
                    GetGearExtra(type) + TreasureStageChest + TreasureRareStageChest + GetPetExtra(type) + dicCosValues[type] + dicTitleValues[type] + guardianAwakenStageChest + guardianStageChest + 
                    RelicStageChest;
                float ichestBuff = hotTimeChest;

                CharStageChest = chestBase + ichestBuff;
                break;
            case eEffectType.PetBoxDropRate:
                CharStagePetBox = lvPointStagePetBox + awakenStagePetBox + dicPassiveValues[type] +
                    GetGearExtra(type) + TreasureStagePetBox + TreasureRareStagePetBox + GetPetExtra(type) + dicCosValues[type] + dicTitleValues[type] + guardianAwakenStagePetBox + guardianStagePetBox + 
                    RelicStagePetBox;
                break;
            case eEffectType.DeepCaveDgBonus:
                CharDgGoldBonus = dConst.RateMax + dicCosValues[type] + dicTitleValues[type] + RelicDgGoldBase;
                break;
            case eEffectType.AtlantisDgBonus:
                CharDgReinStoneBonus = dConst.RateMax + dicCosValues[type] + dicTitleValues[type];
                break;
            case eEffectType.ProtectTheMerchantDgBonus:
                CharDgPetBonus = dConst.RateMax + dicCosValues[type] + dicTitleValues[type];
                break;
            case eEffectType.DevelopTheJungleDgBonus:
                CharDgAwakenStoneBonus = dConst.RateMax + dicCosValues[type] + dicTitleValues[type];
                break;
            case eEffectType.EnemyAtk:
                totalEnemyAtk = dicPassiveValues[type] + dicCosValues[type] + dicTitleValues[type];
                break;

            case eEffectType.EnemyHp:
                totalEnemyHp = dicPassiveValues[type] + dicCosValues[type] + dicTitleValues[type];
                break;
        }
    }

    // 전투력 재계산.
    public void CalcBattlePower()
    {
        battlePower = (totalAtk * 5) + (totalHp * 1);
    }

    private long SumContentStatLong(long lvalue1, long lvalue2 = 0, long lvalue3 = 0, long lvalue4 = 0, long lvalue5 = 0)
    {
        return lvalue1 + lvalue2 + lvalue3 + lvalue4 + lvalue5;
    }

    private BigInteger CalcBaseLong(BigInteger Base, long lvalue1, long lvalue2=0, long lvalue3=0, long lvalue4=0, long lvalue5=0)
    {
        if(lvalue1 != 0)
        {
            Base *= dConst.RateDivideLong + lvalue1;
            Base /= dConst.RateDivideLong;
        }
        if (lvalue2 != 0)
        {
            Base *= dConst.RateDivideLong + lvalue2;
            Base /= dConst.RateDivideLong;
        }
        if (lvalue3 != 0)
        {
            Base *= dConst.RateDivideLong + lvalue3;
            Base /= dConst.RateDivideLong;
        }
        if (lvalue4 != 0)
        {
            Base *= dConst.RateDivideLong + lvalue4;
            Base /= dConst.RateDivideLong;
        }
        if (lvalue5 != 0)
        {
            Base *= dConst.RateDivideLong + lvalue5;
            Base /= dConst.RateDivideLong;
        }
        return Base;
    }

    private BigInteger CalcBaseInt(BigInteger Base, long ivalue1, long ivalue2 = 0, long ivalue3 = 0, long ivalue4 = 0, long ivalue5 = 0)
    {
        if (ivalue1 != 0)
        {
            Base *= dConst.RateMax + ivalue1;
            Base /= dConst.RateMax;
        }
        if (ivalue2 != 0)
        {
            Base *= dConst.RateMax + ivalue2;
            Base /= dConst.RateMax;
        }
        if (ivalue3 != 0)
        {
            Base *= dConst.RateMax + ivalue3;
            Base /= dConst.RateMax;
        }
        if (ivalue4 != 0)
        {
            Base *= dConst.RateMax + ivalue4;
            Base /= dConst.RateMax;
        }
        if (ivalue5 != 0)
        {
            Base *= dConst.RateMax + ivalue5;
            Base /= dConst.RateMax;
        }
        return Base;
    }
    #endregion Calc.

    #region Get Value
    public BigInteger GetBattlePower()
    {
        return battlePower;
    }

    public BigInteger GetCharAtk()
    {
        return totalAtkAd;
    }

    public BigInteger GetCharAtkExcAd()
    {
        return totalAtk;
    }

    public BigInteger GetCharAtkDg()
    {
        return totalAtk * (awakenAtkBuffDg / dConst.RateMaxBi);
    }

    public float getHpPer()
    {
        BigInteger bibase = CalcBaseLong(1L, gearCapeHpBaseLast, gearHatHpBaseLast, gearEarHpBaseLast, gearNeckHpBaseLast, gearRingHpBaseLast);
        bibase = CalcBaseLong(bibase, TreasureRareHpBase, petHpBaseLast, GetPetExtra(eEffectType.HpBase), GetGearExtra(eEffectType.HpBase));

        return (float)bibase;
    }

    public BigInteger GetCharHp()
    {
        return totalHp;
    }

    public float GetCharCrtDam()
    {
        return totalCrtDam;
    }

    public int GetCharCrtRate()
    {
        return totalCrtRate;
    }

    public float GetCharMov()
    {
        return totalMov;
    }

    public float GetCharSpd()
    {
        return totalSpd;
    }

    public float GetGoldDropRate()
    {
        return CharStageGold;
    }

    public float GetExpDropRate()
    {
        return CharStageExp;
    }

    public float GetChestDropRate()
    {
        return CharStageChest;
    }

    public float GetPetBoxDropRate()
    {
        return CharStagePetBox;
    }

    public float GetSkillDamage()
    {
        return totalSkillDmg;
    }

    public float GetSkillCooldownReduce()
    {
        return totalSkillCool;
    }

    public float GetHpHealPerSec()
    {
        return totalHpHealSec;
    }

    public float GetDeepCaveDgBonus()
    {
        return CharDgGoldBonus;
    }

    public float GetAtlantisDgBonus()
    {
        return CharDgReinStoneBonus;
    }

    public float GetProptectTheMerchantBonus()
    {
        return CharDgPetBonus;
    }

    public float GetDevelopTheJungleBonus()
    {
        return CharDgAwakenStoneBonus;
    }

    public float GetEnemyAtkDec()
    {
        return totalEnemyAtk;
    }

    public float GetEnemyHpDec()
    {
        return totalEnemyHp;
    }
    #endregion Get Value
}