From 04a8c930d97a3f384ec6e42dd36291b9d3de7d9a Mon Sep 17 00:00:00 2001 From: Ino Date: Thu, 19 Dec 2024 08:42:27 +0900 Subject: [PATCH] =?UTF-8?q?=ED=85=8C=EC=9D=B4=ED=8B=80=20=EC=95=88?= =?UTF-8?q?=ED=8B=B0=20=EB=A9=94=EB=AA=A8=EB=A6=AC=205?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Assets/Script/Table/PC/table_abilityconfig.cs | 106 ++++++++++++-- Assets/Script/Table/PC/table_awakenconfig.cs | 45 +++++- Assets/Script/Table/PC/table_awakenupgrade.cs | 51 ++++++- Assets/Script/Table/PC/table_breakinglimit.cs | 75 ++++++++-- Assets/Script/Table/PC/table_classconfig.cs | 129 +++++++++++++++--- .../Table/PC/table_classopencondition.cs | 63 +++++++-- .../Table/PC/table_limitslotmagicrate.cs | 97 +++++++++++-- 7 files changed, 490 insertions(+), 76 deletions(-) diff --git a/Assets/Script/Table/PC/table_abilityconfig.cs b/Assets/Script/Table/PC/table_abilityconfig.cs index 21b0d9cfe..734053907 100644 --- a/Assets/Script/Table/PC/table_abilityconfig.cs +++ b/Assets/Script/Table/PC/table_abilityconfig.cs @@ -1,24 +1,100 @@ -using Newtonsoft.Json; using System; using System.Collections.Generic; -using UnityEngine; +using CodeStage.AntiCheat.ObscuredTypes; +using Newtonsoft.Json; [Serializable] public class AbilityConfigTableData : TableDataBase { - public int n_AbilityID; // 특성을 각각 구분하기 위한 고유 ID - public eBattleType e_BattleType; // 특성 UI 카테고리 분류를 위한 Enum 값 - public int n_AbilityStep; // 특성 강화 단계를 의미하며, 단계가 증가할수록 우측으로 점진적으로 배열된다. - public int n_AbilityOrder; // 특성이 배치 될 상/중/하 분류 위치 - public int n_RequireAbility1; // 특성 강화에 요구되는 선행 스킬의 ID1 - public int n_RequireAbility2; // 특성 강화에 요구되는 선행 스킬의 ID2 - public int n_NextAbility; - public eBattleType e_AbilityTarget; // 특성 효과가 적용 될 직업군을 분류하기 위한 값 (※예를 들어 같은 공격력 증가라도, 활 캐릭터에게만 적용 되는 공격력 증가 효과를 만들기 위한 목적) - public eStat e_OptionType; // 특성 효과를 구성하기 위한 옵션 타입 값 - public float f_DefaultValue; // 1레벨 기준 특성 효과의 기본 값 - public float f_LevelPerValue; // 레벨 당 특성 효과 증가량을 산출하기 위한 증가량 - public float f_BalanceConstant; // 레벨 당 특성 효과 증가량을 산출하기 위한 밸런스 상수 K 값 - public int n_MaxUpgradeLevel; // 특성을 강화할 수 있는 최대 제한 레벨 + // 특성을 각각 구분하기 위한 고유 ID + ObscuredInt _AbilityID; + public int n_AbilityID + { + get { return _AbilityID; } + set { _AbilityID = value; _AbilityID.RandomizeCryptoKey(); } + } + + // 특성 UI 카테고리 분류를 위한 Enum 값 + public eBattleType e_BattleType { get; set; } + + // 특성 강화 단계를 의미하며, 단계가 증가할수록 우측으로 점진적으로 배열된다. + ObscuredInt _AbilityStep; + public int n_AbilityStep + { + get { return _AbilityStep; } + set { _AbilityStep = value; _AbilityStep.RandomizeCryptoKey(); } + } + + // 특성이 배치 될 상/중/하 분류 위치 + ObscuredInt _AbilityOrder; + public int n_AbilityOrder + { + get { return _AbilityOrder; } + set { _AbilityOrder = value; _AbilityOrder.RandomizeCryptoKey(); } + } + + // 특성 강화에 요구되는 선행 스킬의 ID1 + ObscuredInt _RequireAbility1; + public int n_RequireAbility1 + { + get { return _RequireAbility1; } + set { _RequireAbility1 = value; _RequireAbility1.RandomizeCryptoKey(); } + } + + // 특성 강화에 요구되는 선행 스킬의 ID2 + ObscuredInt _RequireAbility2; + public int n_RequireAbility2 + { + get { return _RequireAbility2; } + set { _RequireAbility2 = value; _RequireAbility2.RandomizeCryptoKey(); } + } + + // 다음 단계의 특성 ID + ObscuredInt _NextAbility; + public int n_NextAbility + { + get { return _NextAbility; } + set { _NextAbility = value; _NextAbility.RandomizeCryptoKey(); } + } + + // 특성 효과가 적용될 직업군을 분류하기 위한 Enum 값 + public eBattleType e_AbilityTarget { get; set; } + + // 특성 효과를 구성하기 위한 옵션 타입 값 + public eStat e_OptionType { get; set; } + + // 1레벨 기준 특성 효과의 기본 값 + ObscuredFloat _DefaultValue; + public float f_DefaultValue + { + get { return _DefaultValue; } + set { _DefaultValue = value; _DefaultValue.RandomizeCryptoKey(); } + } + + // 레벨 당 특성 효과 증가량을 산출하기 위한 증가량 + ObscuredFloat _LevelPerValue; + public float f_LevelPerValue + { + get { return _LevelPerValue; } + set { _LevelPerValue = value; _LevelPerValue.RandomizeCryptoKey(); } + } + + // 레벨 당 특성 효과 증가량을 산출하기 위한 밸런스 상수 K 값 + ObscuredFloat _BalanceConstant; + public float f_BalanceConstant + { + get { return _BalanceConstant; } + set { _BalanceConstant = value; _BalanceConstant.RandomizeCryptoKey(); } + } + + // 특성을 강화할 수 있는 최대 제한 레벨 + ObscuredInt _MaxUpgradeLevel; + public int n_MaxUpgradeLevel + { + get { return _MaxUpgradeLevel; } + set { _MaxUpgradeLevel = value; _MaxUpgradeLevel.RandomizeCryptoKey(); } + } + public float Get_Value(int lv) { return Get_Value(lv, f_BalanceConstant, f_DefaultValue, f_LevelPerValue); } public override string Get_Name() { return table_itemlist.Ins.Get_Data(n_AbilityID).Get_Name(); } diff --git a/Assets/Script/Table/PC/table_awakenconfig.cs b/Assets/Script/Table/PC/table_awakenconfig.cs index 92d29755e..ecffee27e 100644 --- a/Assets/Script/Table/PC/table_awakenconfig.cs +++ b/Assets/Script/Table/PC/table_awakenconfig.cs @@ -1,3 +1,4 @@ +using CodeStage.AntiCheat.ObscuredTypes; using Newtonsoft.Json; using System; using System.Collections.Generic; @@ -10,12 +11,44 @@ public enum eAwakenUpgradeOptionType [Serializable] public class AwakenConfigTableData : TableDataBase { - public eStat e_UpgradeStatType; // 강화할 스텟 타입 - public int n_UpgradeOrder; // 강화 순서 (로테이션) - public eAwakenUpgradeOptionType e_UpgradeOptionType; // 업그레이드로 증가할 능력치 Enum 값 - public int n_DefaultUpgradeValue; // 1레벨의 능력치 기본 값 - public float f_LevelPerUpgradeValue; // 레벨당 능력치 증가량 - public float f_BalanceConstant; // 밸런스 상수 K값 + // 강화할 스텟 타입 + public eStat e_UpgradeStatType { get; set; } + + // 강화 순서 (로테이션) + ObscuredInt _UpgradeOrder; + public int n_UpgradeOrder + { + get { return _UpgradeOrder; } + set { _UpgradeOrder = value; _UpgradeOrder.RandomizeCryptoKey(); } + } + + // 업그레이드로 증가할 능력치 Enum 값 + public eAwakenUpgradeOptionType e_UpgradeOptionType { get; set; } + + // 1레벨의 능력치 기본 값 + ObscuredInt _DefaultUpgradeValue; + public int n_DefaultUpgradeValue + { + get { return _DefaultUpgradeValue; } + set { _DefaultUpgradeValue = value; _DefaultUpgradeValue.RandomizeCryptoKey(); } + } + + // 레벨당 능력치 증가량 + ObscuredFloat _LevelPerUpgradeValue; + public float f_LevelPerUpgradeValue + { + get { return _LevelPerUpgradeValue; } + set { _LevelPerUpgradeValue = value; _LevelPerUpgradeValue.RandomizeCryptoKey(); } + } + + // 밸런스 상수 K값 + ObscuredFloat _BalanceConstant; + public float f_BalanceConstant + { + get { return _BalanceConstant; } + set { _BalanceConstant = value; _BalanceConstant.RandomizeCryptoKey(); } + } + public float Get_Value(int lv) { diff --git a/Assets/Script/Table/PC/table_awakenupgrade.cs b/Assets/Script/Table/PC/table_awakenupgrade.cs index 5bac47b69..6d6793e6b 100644 --- a/Assets/Script/Table/PC/table_awakenupgrade.cs +++ b/Assets/Script/Table/PC/table_awakenupgrade.cs @@ -1,3 +1,4 @@ +using CodeStage.AntiCheat.ObscuredTypes; using Newtonsoft.Json; using System; using System.Collections.Generic; @@ -5,12 +6,50 @@ using System.Collections.Generic; [Serializable] public class AwakenUpgradeTableData : TableDataBase { - public int n_AwakenStep; // 각성 단계 - public int n_MaxUpgradeLevel; // 다음 단계 승급에 필요한 강화 횟수 - public int n_AwakenGoodsCost; // 각성에 필요한 재화 수량 - public int n_DefaultUpgradeCostValue; // 1레벨의 능력치 기본 값 - public float f_CountPerUpgradeCostValue; // 강화 횟수 당 능력치 증가량 - public float f_BalanceConstant; // 밸런스 상수 K값 + // ObscuredInt 적용 + ObscuredInt _AwakenStep; + public int n_AwakenStep + { + get { return _AwakenStep; } + set { _AwakenStep = value; _AwakenStep.RandomizeCryptoKey(); } + } // 각성 단계 + + ObscuredInt _MaxUpgradeLevel; + public int n_MaxUpgradeLevel + { + get { return _MaxUpgradeLevel; } + set { _MaxUpgradeLevel = value; _MaxUpgradeLevel.RandomizeCryptoKey(); } + } // 다음 단계 승급에 필요한 강화 횟수 + + ObscuredInt _AwakenGoodsCost; + public int n_AwakenGoodsCost + { + get { return _AwakenGoodsCost; } + set { _AwakenGoodsCost = value; _AwakenGoodsCost.RandomizeCryptoKey(); } + } // 각성에 필요한 재화 수량 + + ObscuredInt _DefaultUpgradeCostValue; + public int n_DefaultUpgradeCostValue + { + get { return _DefaultUpgradeCostValue; } + set { _DefaultUpgradeCostValue = value; _DefaultUpgradeCostValue.RandomizeCryptoKey(); } + } // 1레벨의 능력치 기본 값 + + // ObscuredFloat 적용 + ObscuredFloat _CountPerUpgradeCostValue; + public float f_CountPerUpgradeCostValue + { + get { return _CountPerUpgradeCostValue; } + set { _CountPerUpgradeCostValue = value; _CountPerUpgradeCostValue.RandomizeCryptoKey(); } + } // 강화 횟수 당 능력치 증가량 + + ObscuredFloat _BalanceConstant; + public float f_BalanceConstant + { + get { return _BalanceConstant; } + set { _BalanceConstant = value; _BalanceConstant.RandomizeCryptoKey(); } + } // 밸런스 상수 K값 + public float Get_Price(int lv) { diff --git a/Assets/Script/Table/PC/table_breakinglimit.cs b/Assets/Script/Table/PC/table_breakinglimit.cs index c3adb155d..5d295adf1 100644 --- a/Assets/Script/Table/PC/table_breakinglimit.cs +++ b/Assets/Script/Table/PC/table_breakinglimit.cs @@ -1,3 +1,4 @@ +using CodeStage.AntiCheat.ObscuredTypes; using Newtonsoft.Json; using System; using System.Collections.Generic; @@ -5,15 +6,71 @@ using System.Collections.Generic; [Serializable] public class BreakingLimitTableData : TableDataBase { - public int n_LimitLv; // 초월(한계 돌파) 달성 레벨 - public int n_RequireTotalStat; // 초월에 필요한 스텟 총 요구량 - public int n_RequireLevel; // 초월에 필요한 레벨 요구량 - public int n_MaxAbilityPoint; // 최대 특성 보유량 - public int n_Equip_Upgrade_Limit; // 장비 강화 최대 레벨 - public float f_Monster_DMG_Multiplier; // 일반 몬스터 피해 증가량 - public float f_Boss_DMG_Multiplier; // 보스 피해량 증가량 - public float f_ALL_STAT_Multiplier; // 모든 스텟 증가량 - public int n_limitSlotMagic; // 최대 마법부여 슬롯 (슬롯 개방 레벨은 n_LimitLv을 참조) + // ObscuredInt 적용 + ObscuredInt _LimitLv; + public int n_LimitLv + { + get { return _LimitLv; } + set { _LimitLv = value; _LimitLv.RandomizeCryptoKey(); } + } // 초월(한계 돌파) 달성 레벨 + + ObscuredInt _RequireTotalStat; + public int n_RequireTotalStat + { + get { return _RequireTotalStat; } + set { _RequireTotalStat = value; _RequireTotalStat.RandomizeCryptoKey(); } + } // 초월에 필요한 스탯 총 요구량 + + ObscuredInt _RequireLevel; + public int n_RequireLevel + { + get { return _RequireLevel; } + set { _RequireLevel = value; _RequireLevel.RandomizeCryptoKey(); } + } // 초월에 필요한 레벨 요구량 + + ObscuredInt _MaxAbilityPoint; + public int n_MaxAbilityPoint + { + get { return _MaxAbilityPoint; } + set { _MaxAbilityPoint = value; _MaxAbilityPoint.RandomizeCryptoKey(); } + } // 최대 특성 보유량 + + ObscuredInt _Equip_Upgrade_Limit; + public int n_Equip_Upgrade_Limit + { + get { return _Equip_Upgrade_Limit; } + set { _Equip_Upgrade_Limit = value; _Equip_Upgrade_Limit.RandomizeCryptoKey(); } + } // 장비 강화 최대 레벨 + + ObscuredInt _limitSlotMagic; + public int n_limitSlotMagic + { + get { return _limitSlotMagic; } + set { _limitSlotMagic = value; _limitSlotMagic.RandomizeCryptoKey(); } + } // 최대 마법부여 슬롯 (슬롯 개방 레벨은 n_LimitLv을 참조) + + // ObscuredFloat 적용 + ObscuredFloat _Monster_DMG_Multiplier; + public float f_Monster_DMG_Multiplier + { + get { return _Monster_DMG_Multiplier; } + set { _Monster_DMG_Multiplier = value; _Monster_DMG_Multiplier.RandomizeCryptoKey(); } + } // 일반 몬스터 피해 증가량 + + ObscuredFloat _Boss_DMG_Multiplier; + public float f_Boss_DMG_Multiplier + { + get { return _Boss_DMG_Multiplier; } + set { _Boss_DMG_Multiplier = value; _Boss_DMG_Multiplier.RandomizeCryptoKey(); } + } // 보스 피해량 증가량 + + ObscuredFloat _ALL_STAT_Multiplier; + public float f_ALL_STAT_Multiplier + { + get { return _ALL_STAT_Multiplier; } + set { _ALL_STAT_Multiplier = value; _ALL_STAT_Multiplier.RandomizeCryptoKey(); } + } // 모든 스탯 증가량 + public float Get_StatValue(eStat stat) { diff --git a/Assets/Script/Table/PC/table_classconfig.cs b/Assets/Script/Table/PC/table_classconfig.cs index 3fa18da7f..2ddf64ffd 100644 --- a/Assets/Script/Table/PC/table_classconfig.cs +++ b/Assets/Script/Table/PC/table_classconfig.cs @@ -1,3 +1,4 @@ +using CodeStage.AntiCheat.ObscuredTypes; using Newtonsoft.Json; using System; using System.Collections.Generic; @@ -10,25 +11,115 @@ public enum eBattleType [Serializable] public class ClassConfigTableData : TableDataBase { - public int n_ClassID; // 영웅의 직업을 분류하기 위한 고유 ID - public int n_Tier; // - public string s_AnimationController; - public string s_JobIcon; - public string s_WeaponLHPrefab, s_WeaponRHPrefab; - public eBattleType e_BattleType; - public float f_Scale; - public float f_AttackRange; - public eMainStatType e_MainStatType; // 플레이어의 주스텟 타입을 구분하기 위한 분류 값 - public int n_DefaultStr; // 기본 보유 힘 수치 - public int n_DefaultDex; // 기본 보유 민첩 수치 - public int n_DefaultInt; // 기본 보유 지능 수치 - public int n_DefaultLuk; // 기본 보유 행운 수치 - public int n_DefaultHP; // 기본 보유 HP 수치 - public int n_DefaultMP; // 기본 보유 MP 수치 - public int n_ExtraSkill; // 고유 패시브 스킬ID - public int n_AcquiredSkill1; // 개방 될 때 얻게 될 스킬의 ID1 - public int n_AcquiredSkill2; // 개방 될 때 얻게 될 스킬의 ID2 - public int n_AcquiredSkill3; // 개방 될 때 얻게 될 스킬의 ID3 + // ObscuredInt 적용 + ObscuredInt _ClassID; + public int n_ClassID + { + get { return _ClassID; } + set { _ClassID = value; _ClassID.RandomizeCryptoKey(); } + } // 영웅의 직업을 분류하기 위한 고유 ID + + ObscuredInt _Tier; + public int n_Tier + { + get { return _Tier; } + set { _Tier = value; _Tier.RandomizeCryptoKey(); } + } // Tier + + public string s_AnimationController { get; set; } + public string s_JobIcon { get; set; } + public string s_WeaponLHPrefab { get; set; } + public string s_WeaponRHPrefab { get; set; } + public eBattleType e_BattleType { get; set; } + + // ObscuredFloat 적용 + ObscuredFloat _Scale; + public float f_Scale + { + get { return _Scale; } + set { _Scale = value; _Scale.RandomizeCryptoKey(); } + } // 영웅의 크기 + + ObscuredFloat _AttackRange; + public float f_AttackRange + { + get { return _AttackRange; } + set { _AttackRange = value; _AttackRange.RandomizeCryptoKey(); } + } // 공격 범위 + + public eMainStatType e_MainStatType { get; set; } // 주스텟 타입 + + // ObscuredInt 적용 + ObscuredInt _DefaultStr; + public int n_DefaultStr + { + get { return _DefaultStr; } + set { _DefaultStr = value; _DefaultStr.RandomizeCryptoKey(); } + } // 기본 보유 힘 수치 + + ObscuredInt _DefaultDex; + public int n_DefaultDex + { + get { return _DefaultDex; } + set { _DefaultDex = value; _DefaultDex.RandomizeCryptoKey(); } + } // 기본 보유 민첩 수치 + + ObscuredInt _DefaultInt; + public int n_DefaultInt + { + get { return _DefaultInt; } + set { _DefaultInt = value; _DefaultInt.RandomizeCryptoKey(); } + } // 기본 보유 지능 수치 + + ObscuredInt _DefaultLuk; + public int n_DefaultLuk + { + get { return _DefaultLuk; } + set { _DefaultLuk = value; _DefaultLuk.RandomizeCryptoKey(); } + } // 기본 보유 행운 수치 + + ObscuredInt _DefaultHP; + public int n_DefaultHP + { + get { return _DefaultHP; } + set { _DefaultHP = value; _DefaultHP.RandomizeCryptoKey(); } + } // 기본 보유 HP 수치 + + ObscuredInt _DefaultMP; + public int n_DefaultMP + { + get { return _DefaultMP; } + set { _DefaultMP = value; _DefaultMP.RandomizeCryptoKey(); } + } // 기본 보유 MP 수치 + + ObscuredInt _ExtraSkill; + public int n_ExtraSkill + { + get { return _ExtraSkill; } + set { _ExtraSkill = value; _ExtraSkill.RandomizeCryptoKey(); } + } // 고유 패시브 스킬 ID + + ObscuredInt _AcquiredSkill1; + public int n_AcquiredSkill1 + { + get { return _AcquiredSkill1; } + set { _AcquiredSkill1 = value; _AcquiredSkill1.RandomizeCryptoKey(); } + } // 개방 시 얻게 될 스킬 ID1 + + ObscuredInt _AcquiredSkill2; + public int n_AcquiredSkill2 + { + get { return _AcquiredSkill2; } + set { _AcquiredSkill2 = value; _AcquiredSkill2.RandomizeCryptoKey(); } + } // 개방 시 얻게 될 스킬 ID2 + + ObscuredInt _AcquiredSkill3; + public int n_AcquiredSkill3 + { + get { return _AcquiredSkill3; } + set { _AcquiredSkill3 = value; _AcquiredSkill3.RandomizeCryptoKey(); } + } // 개방 시 얻게 될 스킬 ID3 + public string Get_JobName() { return table_localtext.Ins.Get_Text(n_ClassID); } public eMainStatType Get_MainStat() diff --git a/Assets/Script/Table/PC/table_classopencondition.cs b/Assets/Script/Table/PC/table_classopencondition.cs index 2e844f6e1..3bfeb5a23 100644 --- a/Assets/Script/Table/PC/table_classopencondition.cs +++ b/Assets/Script/Table/PC/table_classopencondition.cs @@ -1,3 +1,4 @@ +using CodeStage.AntiCheat.ObscuredTypes; using Newtonsoft.Json; using System; using System.Collections.Generic; @@ -5,15 +6,59 @@ using System.Collections.Generic; [Serializable] public class ClassOpenConditionTableData : TableDataBase { - public int n_ClassID; // 클래스 ID - public int n_linkedClass1; // 연관된 클래스 1 - public int n_linkedClass2; // 연관된 클래스 2 - public int n_RequireAbility; // 필요 능력치 - public eStat e_RequireAwakenType1; // 첫 번째 각성 필요 유형 - public int n_RequireAwakenStep1; // 첫 번째 각성 단계 - public eStat e_RequireAwakenType2; // 두 번째 각성 필요 유형 - public int n_RequireAwakenStep2; // 두 번째 각성 단계 - public int n_NeedGoodsCount; // 필요 아이템 수량 + ObscuredInt _ClassID; + public int n_ClassID + { + get { return _ClassID; } + set { _ClassID = value; _ClassID.RandomizeCryptoKey(); } + } // 클래스 ID + + ObscuredInt _LinkedClass1; + public int n_linkedClass1 + { + get { return _LinkedClass1; } + set { _LinkedClass1 = value; _LinkedClass1.RandomizeCryptoKey(); } + } // 연관된 클래스 1 + + ObscuredInt _LinkedClass2; + public int n_linkedClass2 + { + get { return _LinkedClass2; } + set { _LinkedClass2 = value; _LinkedClass2.RandomizeCryptoKey(); } + } // 연관된 클래스 2 + + ObscuredInt _RequireAbility; + public int n_RequireAbility + { + get { return _RequireAbility; } + set { _RequireAbility = value; _RequireAbility.RandomizeCryptoKey(); } + } // 필요 능력치 + + public eStat e_RequireAwakenType1 { get; set; } // 첫 번째 각성 필요 유형 + + ObscuredInt _RequireAwakenStep1; + public int n_RequireAwakenStep1 + { + get { return _RequireAwakenStep1; } + set { _RequireAwakenStep1 = value; _RequireAwakenStep1.RandomizeCryptoKey(); } + } // 첫 번째 각성 단계 + + public eStat e_RequireAwakenType2 { get; set; } // 두 번째 각성 필요 유형 + + ObscuredInt _RequireAwakenStep2; + public int n_RequireAwakenStep2 + { + get { return _RequireAwakenStep2; } + set { _RequireAwakenStep2 = value; _RequireAwakenStep2.RandomizeCryptoKey(); } + } // 두 번째 각성 단계 + + ObscuredInt _NeedGoodsCount; + public int n_NeedGoodsCount + { + get { return _NeedGoodsCount; } + set { _NeedGoodsCount = value; _NeedGoodsCount.RandomizeCryptoKey(); } + } // 필요 아이템 수량 + public override string Get_Name() { return table_itemlist.Ins.Get_Data(n_ClassID).Get_Name(); } } diff --git a/Assets/Script/Table/PC/table_limitslotmagicrate.cs b/Assets/Script/Table/PC/table_limitslotmagicrate.cs index e627bce35..542f2f943 100644 --- a/Assets/Script/Table/PC/table_limitslotmagicrate.cs +++ b/Assets/Script/Table/PC/table_limitslotmagicrate.cs @@ -1,3 +1,4 @@ +using CodeStage.AntiCheat.ObscuredTypes; using Newtonsoft.Json; using System; using System.Collections.Generic; @@ -7,19 +8,91 @@ using UnityEngine; [Serializable] public class LimitSlotMagicRateTableData : TableDataBase { - public int n_NeedLimitLv; // 필요한 초월 레벨 - public int n_DropIndex; // - public int n_GachaGradeRate1; // Grade1 아이템의 드랍 확률 (일반) - public int n_GachaGradeRate2; // Grade2 아이템의 드랍 확률 (고급) - public int n_GachaGradeRate3; // Grade3 아이템의 드랍 확률 (희귀) - public int n_GachaGradeRate4; // Grade4 아이템의 드랍 확률 (영웅) - public int n_GachaGradeRate5; // Grade5 아이템의 드랍 확률 (전설) - public int n_GachaGradeRate6; // Grade6 아이템의 드랍 확률 (고대) - public int n_GachaGradeRate7; // Grade7 아이템의 드랍 확률 (신화) - public int n_GachaGradeRate8; // Grade8 아이템의 드랍 확률 (불멸) - public int n_GachaGradeRate9; // Grade9 아이템의 드랍 확률 (유일) + ObscuredInt _NeedLimitLv; + public int n_NeedLimitLv + { + get { return _NeedLimitLv; } + set { _NeedLimitLv = value; _NeedLimitLv.RandomizeCryptoKey(); } + } // 필요한 초월 레벨 + + ObscuredInt _DropIndex; + public int n_DropIndex + { + get { return _DropIndex; } + set { _DropIndex = value; _DropIndex.RandomizeCryptoKey(); } + } // Drop Index + + ObscuredInt _GachaGradeRate1; + public int n_GachaGradeRate1 + { + get { return _GachaGradeRate1; } + set { _GachaGradeRate1 = value; _GachaGradeRate1.RandomizeCryptoKey(); } + } // Grade1 아이템의 드랍 확률 (일반) + + ObscuredInt _GachaGradeRate2; + public int n_GachaGradeRate2 + { + get { return _GachaGradeRate2; } + set { _GachaGradeRate2 = value; _GachaGradeRate2.RandomizeCryptoKey(); } + } // Grade2 아이템의 드랍 확률 (고급) + + ObscuredInt _GachaGradeRate3; + public int n_GachaGradeRate3 + { + get { return _GachaGradeRate3; } + set { _GachaGradeRate3 = value; _GachaGradeRate3.RandomizeCryptoKey(); } + } // Grade3 아이템의 드랍 확률 (희귀) + + ObscuredInt _GachaGradeRate4; + public int n_GachaGradeRate4 + { + get { return _GachaGradeRate4; } + set { _GachaGradeRate4 = value; _GachaGradeRate4.RandomizeCryptoKey(); } + } // Grade4 아이템의 드랍 확률 (영웅) + + ObscuredInt _GachaGradeRate5; + public int n_GachaGradeRate5 + { + get { return _GachaGradeRate5; } + set { _GachaGradeRate5 = value; _GachaGradeRate5.RandomizeCryptoKey(); } + } // Grade5 아이템의 드랍 확률 (전설) + + ObscuredInt _GachaGradeRate6; + public int n_GachaGradeRate6 + { + get { return _GachaGradeRate6; } + set { _GachaGradeRate6 = value; _GachaGradeRate6.RandomizeCryptoKey(); } + } // Grade6 아이템의 드랍 확률 (고대) + + ObscuredInt _GachaGradeRate7; + public int n_GachaGradeRate7 + { + get { return _GachaGradeRate7; } + set { _GachaGradeRate7 = value; _GachaGradeRate7.RandomizeCryptoKey(); } + } // Grade7 아이템의 드랍 확률 (신화) + + ObscuredInt _GachaGradeRate8; + public int n_GachaGradeRate8 + { + get { return _GachaGradeRate8; } + set { _GachaGradeRate8 = value; _GachaGradeRate8.RandomizeCryptoKey(); } + } // Grade8 아이템의 드랍 확률 (불멸) + + ObscuredInt _GachaGradeRate9; + public int n_GachaGradeRate9 + { + get { return _GachaGradeRate9; } + set { _GachaGradeRate9 = value; _GachaGradeRate9.RandomizeCryptoKey(); } + } // Grade9 아이템의 드랍 확률 (유일) + + ObscuredInt _MaxGrade; + public int MaxGrade + { + get { return _MaxGrade; } + set { _MaxGrade = value; _MaxGrade.RandomizeCryptoKey(); } + } // Max Grade + - public int MaxGrade; public List list_rate = new List(); }