You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2199 lines
67 KiB
2199 lines
67 KiB
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.Pierce] = 0L,
|
|
[eEffectType.CrtDam] = 0L,
|
|
|
|
[eEffectType.GoldDropRate] = 0L,
|
|
[eEffectType.ExpDropRate] = 0L,
|
|
[eEffectType.ChestDropRate] = 0L,
|
|
[eEffectType.PetBoxDropRate] = 0L,
|
|
[eEffectType.DgGoldBonus] = 0L,
|
|
[eEffectType.DgReinStoneBonus] = 0L,
|
|
[eEffectType.DgPetBonus] = 0L,
|
|
[eEffectType.DgAwakneStoneBonus] = 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.DgGoldBonus] = 0L,
|
|
[eEffectType.DgReinStoneBonus] = 0L,
|
|
[eEffectType.DgPetBonus] = 0L,
|
|
[eEffectType.DgAwakneStoneBonus] = 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.DgGoldBonus:
|
|
{
|
|
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.DgGoldBonus);
|
|
CalcCharStat(eEffectType.DgReinStoneBonus);
|
|
CalcCharStat(eEffectType.DgPetBonus);
|
|
CalcCharStat(eEffectType.DgAwakneStoneBonus);
|
|
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.DgGoldBonus:
|
|
CharDgGoldBonus = dConst.RateMax + dicCosValues[type] + dicTitleValues[type] + RelicDgGoldBase;
|
|
break;
|
|
case eEffectType.DgReinStoneBonus:
|
|
CharDgReinStoneBonus = dConst.RateMax + dicCosValues[type] + dicTitleValues[type];
|
|
break;
|
|
case eEffectType.DgPetBonus:
|
|
CharDgPetBonus = dConst.RateMax + dicCosValues[type] + dicTitleValues[type];
|
|
break;
|
|
case eEffectType.DgAwakneStoneBonus:
|
|
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 GetDgGoldBonus()
|
|
{
|
|
return CharDgGoldBonus;
|
|
}
|
|
public float GetDgReinStoneBonus()
|
|
{
|
|
return CharDgReinStoneBonus;
|
|
}
|
|
public float GetDgPetBonus()
|
|
{
|
|
return CharDgPetBonus;
|
|
}
|
|
public float GetDgAwakenStoneBonus()
|
|
{
|
|
return CharDgAwakenStoneBonus;
|
|
}
|
|
|
|
public float GetEnemyAtkDec()
|
|
{
|
|
return totalEnemyAtk;
|
|
}
|
|
|
|
public float GetEnemyHpDec()
|
|
{
|
|
return totalEnemyHp;
|
|
}
|
|
#endregion Get Value
|
|
}
|