테이틀 안티 메모리 5

2024-12-19 08:42:27 +09:00 · 2024-12-19 08:42:27 +09:00 · 04a8c930d9
parent 61094572ca
commit 04a8c930d9
7 changed files with 490 additions and 76 deletions
--- 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(); }
--- 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)
    {
--- 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)
    {
--- 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)
    {
--- 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()
--- 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(); }
 }
--- 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<float> list_rate = new List<float>();
 }