opening editor as open source

.gitignore

@@ -80,7 +80,6 @@ crashlytics-build.properties
 /.idea/.idea.DCGO
 
 #Open Source Locked
-/Assets/Editor
 /Assets/AddOn/@ Xxuebi
 /Assets/AddOn/Energy Shield Shader
 /Assets/AddOn/NucleusDNAEffect
@@ -93,7 +92,6 @@ crashlytics-build.properties
 /Assets/Sound
 /Assets/CardBaseEntity/CardEntity_JSONLoader.asset
 
-/Assets/Editor.meta
 /Assets/AddOn/@ Xxuebi.meta
 /Assets/AddOn/Energy Shield Shader.meta
 /Assets/AddOn/NucleusDNAEffect.meta

Assets/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 42e4264df5b24bc46857604fe355a1f5
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/AttachCardData.cs

@@ -0,0 +1,77 @@
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+using System.Linq;
+using System;
+public class AttachCardData : MonoBehaviour
+{
+    [MenuItem("Window/Attach/AttachCardData")]
+    static void Attach_CardData()
+    {
+        List<CEntity_Base> List = GetAsset.LoadAll<CEntity_Base>("Assets/CardBaseEntity/");
+
+        List<string> UnimplementedCardSpriteNames = new List<string>() { "P-147", "BT17-085_P3", "BT15-082_P2", "BT15-084_P2", "BT14-085_P2", "BT13-100_P2", "BT11-086_P2", "BT10-042_P5" };
+        /*
+         BT17_085 Rika Nonaka
+         BT15_082 Sora Takenouchi
+         BT15_084 Kari Kamiya
+         BT14_085 Mimi Tachikawa
+         BT13_100 Yoshino Fujieda
+         BT11_086 Mervamon
+         BT10_042
+         */
+        List<string> DebugCardSpriteNames = new List<string>() { };
+
+        foreach (GameObject obj in Selection.gameObjects)
+        {
+            if (obj.GetComponent<ContinuousController>() != null)
+            {
+                ContinuousController CCtrl = obj.GetComponent<ContinuousController>();
+
+                CCtrl.CardList = new CEntity_Base[] { };
+                CCtrl.SortedCardList = new CEntity_Base[] { };
+
+                List<CEntity_Base> cEntity_Bases = new List<CEntity_Base>();
+
+                foreach (CEntity_Base cEntity_Base in List)
+                {
+                    if (UnimplementedCardSpriteNames.Contains(cEntity_Base.CardSpriteName))
+                    {
+                        Debug.Log(cEntity_Base.CardID);
+                        continue;
+                    }
+
+                    
+
+                    if (String.IsNullOrEmpty(cEntity_Base.CardSpriteName))
+                    {
+                        continue;
+                    }
+
+                    if (DebugCardSpriteNames.Contains(cEntity_Base.CardSpriteName))
+                    {
+                        Debug.Log(cEntity_Base.CardID);
+                    }
+
+                    cEntity_Bases.Add(cEntity_Base);
+                }
+
+                EditorGUI.BeginChangeCheck();
+
+                CCtrl.CardList = DeckData.SortedCardPoolList(cEntity_Bases).ToArray();
+                cEntity_Bases.Sort((a, b) => a.CardIndex - b.CardIndex);
+                CCtrl.SortedCardList = cEntity_Bases.ToArray();
+
+                if (EditorGUI.EndChangeCheck())
+                {
+                    var scene = SceneManager.GetActiveScene();
+                    EditorSceneManager.MarkSceneDirty(scene);
+                }
+
+                return;
+            }
+        }
+    }
+}

Assets/Editor/AttachCardData.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 474a6403af004284d91d644da6e8dfb9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/AttachCardPoolPrefab.cs

@@ -0,0 +1,51 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+using UnityEngine.Events;
+using System;
+using System.Reflection;
+using UnityEngine.UI;
+using UnityEngine.EventSystems;
+using Photon;
+using Photon.Pun;
+using System.Linq;
+
+public class AttachCardPoolPrefab : MonoBehaviour
+{
+	[MenuItem("Window/Attach/AttachCardPoolPrefab")]
+	static void Attach_CardPoolPrefab()
+	{
+		EditDeck editDeck = null;
+		List<CardPrefab_CreateDeck> cardPrefab_CreateDecks_all = new List<CardPrefab_CreateDeck>();
+
+		foreach (GameObject obj in Selection.gameObjects)
+		{
+			if(obj.GetComponent<EditDeck>() != null)
+			{
+				editDeck = obj.GetComponent<EditDeck>();
+			}
+
+			ScrollRect scrollRect = obj.GetComponent<ScrollRect>();
+			if (scrollRect != null)
+			{
+				for(int i=0;i< scrollRect.content.childCount;i++)
+				{
+					CardPrefab_CreateDeck cardPrefab_CreateDeck = scrollRect.content.GetChild(i).GetComponent<CardPrefab_CreateDeck>();
+					if (cardPrefab_CreateDeck != null)
+					{
+						cardPrefab_CreateDecks_all.Add(cardPrefab_CreateDeck);
+					}
+				}
+			}
+		}
+
+		if(editDeck != null)
+		{
+			if(cardPrefab_CreateDecks_all.Count > 0)
+			{
+				editDeck.cardPoolPrefabs_all = cardPrefab_CreateDecks_all;
+			}
+		}
+	}
+}

Assets/Editor/AttachCardPoolPrefab.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fb894db4c96c9484587c2d9b42ce15ef
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/AttachShuffledNumberIDs.cs

@@ -0,0 +1,52 @@
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+public class AttachShuffledNumberIDs : MonoBehaviour
+{
+	[MenuItem("Window/Attach/AttachShuffledNumberIDs")]
+	static void Attach_ShuffledNumberIDs()
+	{
+		UnityEngine.Random.InitState(1145141919);
+
+		foreach (GameObject obj in Selection.gameObjects)
+		{
+			if (obj.GetComponent<ShuffleDeckCode>() != null)
+			{
+				ShuffleDeckCode shuffleDeckCode = obj.GetComponent<ShuffleDeckCode>();
+
+				shuffleDeckCode.ShuffledNumberIDs = new int[ConvertBinaryNumber.numbers.Length];
+
+				for(int i=0;i< shuffleDeckCode.ShuffledNumberIDs.Length;i++)
+				{
+					shuffleDeckCode.ShuffledNumberIDs[i] = i;
+				}
+
+				Shuffle(shuffleDeckCode.ShuffledNumberIDs);
+
+				EditorGUI.BeginChangeCheck();
+
+				if (EditorGUI.EndChangeCheck())
+				{
+					var scene = SceneManager.GetActiveScene();
+					EditorSceneManager.MarkSceneDirty(scene);
+				}
+
+				return;
+			}
+		}
+	}
+
+	static void Shuffle(int[] numbers)
+	{
+		for (int i = 0; i < numbers.Length; i++)
+		{
+			int temp = numbers[i]; // 現在の要素を預けておく
+			int randomIndex = UnityEngine.Random.Range(0, numbers.Length); // 入れ替える先をランダムに選ぶ
+			numbers[i] = numbers[randomIndex]; // 現在の要素に上書き
+			numbers[randomIndex] = temp; // 入れ替え元に預けておいた要素を与える
+		}
+	}
+}

Assets/Editor/AttachShuffledNumberIDs.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3b73120343888ad42b2b6334d79448c2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/AutoTextureConvert.cs

@@ -0,0 +1,20 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+public class AutoTextureConvert : AssetPostprocessor
+{
+    void OnPreprocessTexture()
+    {
+        TextureImporter textureImporter = assetImporter as TextureImporter;
+
+        if(textureImporter.textureType == TextureImporterType.Cursor)
+        {
+            return;
+        }
+
+        textureImporter.textureType = TextureImporterType.Sprite;
+        textureImporter.maxTextureSize = 512;
+    }
+}

Assets/Editor/AutoTextureConvert.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 88ee619b20bc66e42add776e1afd9efe
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/ConvertDigiEggCardKind.cs

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+public class ConvertDigiEggCardKind : MonoBehaviour
+{
+    [MenuItem("Window/Attach/ConvertDigiEggCardKind")]
+    static void Convert_DigiEggCardKind()
+    {
+        List<CEntity_Base> List = GetAsset.LoadAll<CEntity_Base>("Assets/CardBaseEntity/");
+
+        foreach (CEntity_Base cEntity_Base in List)
+        {
+            if (cEntity_Base.cardKind == CardKind.Digimon)
+            {
+                if (cEntity_Base.Level == 2)
+                {
+                    cEntity_Base.cardKind = CardKind.DigiEgg;
+                    EditorUtility.SetDirty(cEntity_Base);
+                    AssetDatabase.SaveAssetIfDirty(cEntity_Base);
+                }
+            }
+        }
+    }
+}

Assets/Editor/ConvertDigiEggCardKind.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 35212dedd86d7164785c6bd9a07d99e2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/CsvLoader_CardEntity.cs

@@ -0,0 +1,428 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Text;
+using Unity.EditorCoroutines.Editor;
+using UnityEditor;
+using UnityEngine;
+using System.Linq;
+using System;
+
+[CustomEditor(typeof(LoadCSV_CardEntity))]
+public class CsvLoader_CardEntity : Editor
+{
+    public override void OnInspectorGUI()
+    {
+        var LoadCSV = target as LoadCSV_CardEntity;
+        DrawDefaultInspector();
+
+        if (GUILayout.Button("Create Scriptable Objects"))
+        {
+            EditorCoroutineUtility.StartCoroutine(SetCsvDataToScriptableObject(LoadCSV), this);
+        }
+    }
+
+    IEnumerator SetCsvDataToScriptableObject(LoadCSV_CardEntity loadCSV)
+    {
+        List<TextAsset> CardListTexts = GetAsset.LoadAll<TextAsset>("Assets/TextAsset");
+
+        int value = 0;
+
+        // Check if CSV file is null
+        if (loadCSV.csvFile == null)
+        {
+            Debug.LogWarning("CSV File is null: " + loadCSV.name);
+            yield break;
+        }
+
+        Debug.Log("CSV File Found: " + loadCSV.name);
+
+        // CSV‚ Text
+        string csvText = loadCSV.csvFile.text;
+
+        //Split by new line
+        string[] afterParse = csvText.Split('\n');
+
+        //Skip the first line, parse by ","
+        for (int i = 1; i < afterParse.Length; i++)
+        {
+            string[] parseByComma = afterParse[i].Split(',');
+
+            // �skip if first column is empty
+            if (string.IsNullOrEmpty(parseByComma[0]))
+            {
+                continue;
+            }
+
+            int column = 0;
+
+            string cardImageName = parseByComma[column].CleanTrimString().Replace(".jpg", "").Replace(".png", "").Trim();
+            column++;
+
+            yield return EditorCoroutineUtility.StartCoroutine(CreateCardData(cardImageName), this);
+
+            IEnumerator CreateCardData(string CardImageName)
+            {
+                
+                // CardEntity‚ instance created
+                CEntity_Base cardEntity = CreateInstance<CEntity_Base>();
+
+                cardEntity.CardSpriteName = CardImageName;
+
+                //Set card effect class name
+                cardEntity.CardEffectClassName = parseByComma[column];
+                column++;
+
+                //Set card index number
+                if (int.TryParse(parseByComma[column], out value))
+                {
+                    cardEntity.CardIndex = value;
+                }
+                column++;
+
+                //Parse max count (most csv this is empty)
+                if (!string.IsNullOrEmpty(parseByComma[column]))
+                {
+                    if (int.TryParse(parseByComma[column], out value))
+                    {
+                        cardEntity.MaxCountInDeck = value;
+                    }
+                }
+                column++;
+
+                //Get Card Image Name
+                string[] parseByUnderBar = CEntity_Base.GetParseByUnderBar(CardImageName);
+
+                cardEntity.CardID = $"{parseByUnderBar[0]}";
+
+                string customCardID = "";
+
+                if (parseByComma.Length >= column + 1)
+                {
+                    if (!string.IsNullOrEmpty(parseByComma[column]))
+                    {
+                        if (parseByComma[column].Contains("-"))
+                        {
+                            customCardID = parseByComma[column];
+                        }
+                    }
+                }
+                column++;
+
+                //Get Japanese and English card ID
+                List<string> CardListIDs_JPN = DataBase.CardListIDs(CEntity_Base.GetParseByHyphen(CardImageName)[0], false);
+                List<string> CardListIDs_ENG = DataBase.CardListIDs(CEntity_Base.GetParseByHyphen(CardImageName)[0], true);
+
+                List<TextAsset> CardListTexts_JPN = new List<TextAsset>();
+
+                foreach (TextAsset textAsset in CardListTexts)
+                {
+                    if (CardListIDs_JPN.Contains(textAsset.name))
+                    {
+                        CardListTexts_JPN.Add(textAsset);
+                    }
+                }
+
+                List<TextAsset> CardListTexts_ENG = new List<TextAsset>();
+
+                foreach (TextAsset textAsset in CardListTexts)
+                {
+                    if (CardListIDs_ENG.Contains(textAsset.name))
+                    {
+                        CardListTexts_ENG.Add(textAsset);
+                    }
+                }
+
+                List<string[]> CardDatas_JPN = OfficialCardListUtility.GetCardDatas(CardListTexts_JPN);
+                List<string[]> CardDatas_ENG = OfficialCardListUtility.GetCardDatas(CardListTexts_ENG);
+
+                List<int> evoCosts_level = new List<int>();
+                List<int> evoCosts_memory = new List<int>();
+
+                OfficialCardListUtility.AttachCardData(cardEntity, CardDatas_JPN, CardDatas_ENG, ref evoCosts_level, ref evoCosts_memory);
+
+                if (cardEntity.cardKind == CardKind.Digimon)
+                {
+                    if (evoCosts_level.Count >= 1)
+                    {
+                        List<CardColor> evoCosts_color = new List<CardColor>();
+
+                        //wiki‚grab text from site
+                        yield return new EditorWaitForSeconds(0.5f);
+                        WebClient wc = new WebClient();
+                        wc.Encoding = Encoding.UTF8;
+                        string resultText = wc.DownloadString($"https://wikimon.net/{cardEntity.CardID}_(DCG)");
+                        string[] parseByEnter = resultText.Split('\n');
+
+                        //�i‰»ƒRƒXƒg‚Ì�F
+                        for (int j = 0; j < parseByEnter.Length; j++)
+                        {
+                            string text = parseByEnter[j];
+
+                            if (!string.IsNullOrEmpty(text))
+                            {
+                                text = text.Replace("\n", "").Replace("\t", "").Replace(" ", "").Trim();
+
+                                if (text.Contains(">fromLv."))
+                                {
+                                    if (text.Contains("linear-gradient"))
+                                    {
+                                        evoCosts_color.Add(CardColor.Red);
+                                        evoCosts_color.Add(CardColor.Blue);
+                                        evoCosts_color.Add(CardColor.Yellow);
+                                        evoCosts_color.Add(CardColor.Green);
+                                        evoCosts_color.Add(CardColor.Black);
+                                        evoCosts_color.Add(CardColor.Purple);
+                                        evoCosts_color.Add(CardColor.White);
+                                    }
+
+                                    else
+                                    {
+                                        int startIndex = text.IndexOf('#');
+                                        int length = 7;
+
+                                        text = text.Substring(startIndex, length);
+
+                                        switch (text)
+                                        {
+                                            case "#cb2e32":
+                                                evoCosts_color.Add(CardColor.Red);
+                                                break;
+
+                                            case "#0099dc":
+                                                evoCosts_color.Add(CardColor.Blue);
+                                                break;
+
+                                            case "#f0ac09":
+                                                evoCosts_color.Add(CardColor.Yellow);
+                                                break;
+
+                                            case "#009f6d":
+                                                evoCosts_color.Add(CardColor.Green);
+                                                break;
+
+                                            case "#4e4e4e":
+                                                evoCosts_color.Add(CardColor.Black);
+                                                break;
+
+                                            case "#7e67aa":
+                                                evoCosts_color.Add(CardColor.Purple);
+                                                break;
+
+                                            case "#ceddef":
+                                                evoCosts_color.Add(CardColor.White);
+                                                break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+
+                        if (evoCosts_color.Count < evoCosts_level.Count)
+                        {
+                            if (cardEntity.cardColors.Count >= 1)
+                            {
+                                evoCosts_color.Add(cardEntity.cardColors[0]);
+                            }
+                        }
+
+                        for (int j = 0; j < evoCosts_color.Count; j++)
+                        {
+                            EvoCost evoCost = new EvoCost();
+                            evoCost.CardColor = evoCosts_color[j];
+
+                            int level = evoCosts_level[evoCosts_level.Count - 1];
+
+                            if (j < evoCosts_level.Count)
+                            {
+                                level = evoCosts_level[j];
+                            }
+
+                            evoCost.Level = level;
+
+                            int memoryCost = evoCosts_memory[evoCosts_memory.Count - 1];
+
+                            if (j < evoCosts_memory.Count)
+                            {
+                                memoryCost = evoCosts_memory[j];
+                            }
+
+                            evoCost.MemoryCost = memoryCost;
+
+                            cardEntity.EvoCosts.Add(evoCost);
+                        }
+                    }
+
+                    #region BT9-059(ƒoƒNƒ‚ƒ“)
+                    if (cardEntity.CardID == "BT9-059")
+                    {
+                        if (cardEntity.EvoCosts.Count((evoCost) => evoCost.CardColor == CardColor.Black && evoCost.MemoryCost == 0 && evoCost.Level == 2) == 0)
+                        {
+                            EvoCost evoCost = new EvoCost();
+                            evoCost.CardColor = CardColor.Black;
+                            evoCost.MemoryCost = 0;
+                            evoCost.Level = 2;
+
+                            cardEntity.EvoCosts.Add(evoCost);
+                        }
+                    }
+                    #endregion
+
+                    #region BT9-041(ƒ‰ƒCƒYƒOƒŒƒCƒ‚ƒ“X�R‘Ì)
+                    if (cardEntity.CardID == "BT9-041")
+                    {
+                        if (cardEntity.EvoCosts.Count((evoCost) => evoCost.CardColor == CardColor.Red && evoCost.MemoryCost == 4 && evoCost.Level == 4) == 0)
+                        {
+                            EvoCost evoCost = new EvoCost();
+                            evoCost.CardColor = CardColor.Red;
+                            evoCost.MemoryCost = 4;
+                            evoCost.Level = 4;
+
+                            cardEntity.EvoCosts.Add(evoCost);
+                        }
+                    }
+                    #endregion
+
+                    #region BT14-018(ƒSƒbƒhƒhƒ‰ƒ‚ƒ“)
+                    if (cardEntity.CardID == "BT14-018")
+                    {
+                        if (cardEntity.EvoCosts.Count((evoCost) => evoCost.CardColor == CardColor.Yellow && evoCost.MemoryCost == 4 && evoCost.Level == 5) == 0)
+                        {
+                            EvoCost evoCost = new EvoCost();
+                            evoCost.CardColor = CardColor.Yellow;
+                            evoCost.MemoryCost = 4;
+                            evoCost.Level = 5;
+
+                            cardEntity.EvoCosts.Add(evoCost);
+                        }
+                    }
+                    #endregion
+
+                    #region ST12-09(ƒ{ƒ‹ƒP�[ƒ‚ƒ“)
+                    if (cardEntity.CardID == "ST12-09")
+                    {
+                        if (cardEntity.EvoCosts.Count((evoCost) => evoCost.CardColor == CardColor.Black && evoCost.MemoryCost == 4 && evoCost.Level == 4) == 0)
+                        {
+                            EvoCost evoCost = new EvoCost();
+                            evoCost.CardColor = CardColor.Black;
+                            evoCost.MemoryCost = 4;
+                            evoCost.Level = 4;
+
+                            cardEntity.EvoCosts.Add(evoCost);
+                        }
+                    }
+                    #endregion
+
+                    cardEntity.EvoCosts = cardEntity.EvoCosts.Distinct().ToList();
+                }
+
+                #region ƒtƒ@ƒCƒ‹–¼‚Æ•Û‘¶�æ
+                //ƒtƒ@ƒCƒ‹–¼
+                string fileName = $"{cardEntity.CardName_ENG}-{CardImageName}.asset";
+                fileName = fileName.Replace("?", "�H").Replace(":", "�F");
+                cardEntity.name = fileName.Replace(".asset", "");
+                //•Û‘¶�æ
+                string folderName_SetID = $"{cardEntity.SetID}";
+                string folderName_CardColor = $"{DataBase.CardColorNameDictionary[cardEntity.cardColors[0]]}";
+                folderName_CardColor = char.ToUpper(folderName_CardColor[0]) + folderName_CardColor.Substring(1);
+                string folderName_CardKind = $"{DataBase.CardKindENNameDictionary[cardEntity.cardKind]}";
+
+                string folderPath = $"Assets/CardBaseEntity/{folderName_SetID}/{folderName_CardColor}/{folderName_CardKind}";
+
+                string filePath = $"{folderPath}/{fileName}".Trim().Replace("\t", "").Replace("\n", "").Replace("\r", "").Replace(" ", "");
+
+                //ƒtƒHƒ‹ƒ_‚ª–³‚¯‚ê‚Î�ì�¬
+                if (!Directory.Exists(folderPath))
+                {
+                    Directory.CreateDirectory(folderPath);
+                }
+                #endregion
+
+                if (!string.IsNullOrEmpty(customCardID))
+                {
+                    cardEntity.CardID = customCardID;
+                }
+
+                // ƒAƒZƒbƒg‚Æ‚µ‚Ä•Û‘¶
+                var asset = (CEntity_Base)AssetDatabase.LoadAssetAtPath(filePath, typeof(CEntity_Base));
+
+                if (asset == null)
+                {
+                    // Attempt to create Asset
+                    AssetDatabase.CreateAsset(cardEntity, filePath);
+                }
+                else
+                {
+                    // •Û‘¶�æ‚̃pƒX‚Ƀtƒ@ƒCƒ‹‚ª‚ ‚ê‚Î�ã�‘‚«
+                    EditorUtility.CopySerialized(cardEntity, asset);
+                    AssetDatabase.SaveAssets();
+                }
+
+                AssetDatabase.Refresh();
+
+                Debug.Log($"{i}/{afterParse.Length - 1}:{cardImageName}‚Scriptable Object Created");
+            }
+        }
+
+        Debug.Log("Card Data Created for: " + loadCSV.name);
+    }
+
+    string GetCardDataURL(string CardImageName)
+    {
+        string URL = "";
+
+        string[] parseByUnderBar = CEntity_Base.GetParseByUnderBar(CardImageName);
+
+        URL = $"https://www.unionarena-tcg.com/jp/cardlist/detail_iframe.php?card_no={parseByUnderBar[3]}/{parseByUnderBar[0]}-{parseByUnderBar[1]}-{parseByUnderBar[2]}";
+
+        return URL;
+    }
+}
+
+/// <summary>
+/// string extension methods
+/// </summary>
+public static partial class StringExtensions
+{
+
+    /// <summary>
+    /// Žw’肵‚½•¶Žš—ñ‚ª‚¢‚­‚‚ ‚é‚©
+    /// </summary>
+    public static int CountOf(this string self, params string[] strArray)
+    {
+        int count = 0;
+
+        foreach (string str in strArray)
+        {
+            int index = self.IndexOf(str, 0);
+            while (index != -1)
+            {
+                count++;
+                index = self.IndexOf(str, index + str.Length);
+            }
+        }
+
+        return count;
+    }
+
+    /// <summary>
+    /// Removes all instances of the specified string from the current string.
+    /// </summary>
+    public static string CleanTrimString(this string self)
+    {
+        string cleanString = self;
+
+        if (!string.IsNullOrEmpty(self))
+        {
+            foreach (string str in new string[] { " ", "\n", "\r", "\t" })
+            {
+                cleanString = cleanString.Replace(str, "");
+            }
+        }
+
+        return cleanString.Trim();
+    }
+
+}
+

Assets/Editor/CsvLoader_CardEntity.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3f4076d3a69738548bc27f03aecdaf3b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/FindEntitiesFromCardIndex.cs

@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+
+namespace DCGO.Tools.Repair
+{
+    public class FindEntitiesFromCardIndex : MonoBehaviour
+    {
+        [MenuItem("Window/DCGO/Repair/Find Entity Card Index")]
+        static void FixEntityCardIndex()
+        {
+            int startingIndex = 10336;
+            string path = "Assets/CardBaseEntity/";
+
+            List<CEntity_Base> List = GetAsset.LoadAll<CEntity_Base>(path)
+                .Where(x => x.CardIndex >= startingIndex)
+                .OrderBy(x => x.CardIndex).ToList();
+
+            foreach (CEntity_Base card in List)
+            {
+                Debug.Log($"{card.CardName_ENG}: {card.CardIndex} - {startingIndex}");
+            }
+
+            Debug.Log("Found all card index in CardBaseEntity");
+            return;
+        }
+    }
+}

Assets/Editor/FindEntitiesFromCardIndex.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 36081db6ebca7fb42a07af943d5f1102
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Fixing Scripts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0eecb10b23bf22140b086092069658c6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Fixing Scripts/AdjustSetSpecificCardIndex.cs

@@ -0,0 +1,40 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+
+namespace DCGO.Tools.Repair
+{
+    public class AdjustSetSpecificCardIndex : MonoBehaviour
+    {
+        [MenuItem("Window/DCGO/Repair/Fix Entity Card Index")]
+        static void FixEntityCardIndex()
+        {
+            int startingIndex = 10352;
+            int adjustment = 0;
+            string path = "Assets/CardBaseEntity/";
+
+            if (Selection.assetGUIDs.Length != 0)
+                path = AssetDatabase.GUIDToAssetPath(Selection.assetGUIDs[0]);
+
+            Debug.Log($"ASSET PATH: {path}");
+
+            List<CEntity_Base> List = GetAsset.LoadAll<CEntity_Base>(path)
+                .OrderBy(x => x.name.Substring(x.name.LastIndexOf("-")+1, 2)).ToList()
+                .Filter(x => x.CardIndex >= startingIndex);
+
+            foreach (CEntity_Base card in List)
+            {
+                Debug.Log($"{card.name}: {card.CardIndex} - {startingIndex}");
+            
+                card.CardIndex = startingIndex - adjustment;
+                EditorUtility.SetDirty(card);
+                startingIndex++;
+            }
+
+
+            Debug.Log("Fixed all card index in CardBaseEntity");
+            return;
+        }
+    }
+}

Assets/Editor/Fixing Scripts/AdjustSetSpecificCardIndex.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b79313248be043f43b1a14fc491b302e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Fixing Scripts/ChangeAssetsToEnglish.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor.SceneManagement;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+using DCGO.CardEntities;
+
+namespace DCGO.Tools.Repair{
+    public class ChangeAssetsToEnglish : MonoBehaviour
+    {
+        [MenuItem("Window/DCGO/Repair/Change Entity Names To English")]
+        static void FixEntityNames()
+        {
+            List<CEntity_Base> List = GetAsset.LoadAll<CEntity_Base>("Assets/CardBaseEntity/");
+
+            foreach (CEntity_Base card in List)
+            {
+                string assetName = card.name;
+                string correctName = $"{FixCharactersInName($"{card.CardName_ENG.Replace(" ", "")}-{card.CardSpriteName}")}";
+
+                if (assetName.Equals(correctName))
+                    continue;
+
+                Debug.Log(assetName + " - " + correctName);
+                AssetDatabase.RenameAsset(AssetDatabase.GetAssetPath(card), correctName);
+                EditorUtility.SetDirty(card);
+            }
+                
+
+            Debug.Log("All names changed in CardBaseEntity");
+            return;
+
+            //Parse ScriptableObject Name
+            string FixCharactersInName(string str)
+            {
+                string name = str;
+
+                name = name
+                    .Replace(" ", "_")
+                    .Replace(":", "")
+                    .Replace("?", "")
+                    .Replace("!", "")
+                    .Replace("<", "")
+                    .Replace(">", "");
+
+                return name;
+            }
+        }        
+    }
+}
+

Assets/Editor/Fixing Scripts/ChangeAssetsToEnglish.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f9318dc00f79e0c4c8f7f23fd8192473
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Fixing Scripts/CleanUpClassName.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace DCGO.Tools.Repair{
+    public class CleanUpClassName : MonoBehaviour
+    {
+        [MenuItem("Window/DCGO/Repair/Fix Entity Class Names")]
+        static void FixEntityClassNames()
+        {
+            List<CEntity_Base> List = GetAsset.LoadAll<CEntity_Base>("Assets/CardBaseEntity/");
+
+            foreach (CEntity_Base card in List)
+            {
+                card.CardEffectClassName = FixCharactersInClassName(card.CardEffectClassName);
+                EditorUtility.SetDirty(card);
+            }
+                
+
+            Debug.Log("Fixed all class names in CardBaseEntity");
+            return;
+
+            //Parse ScriptableObject Class Name
+            string FixCharactersInClassName(string str)
+            {
+                string name = str;
+
+                name = FixCharactersInName(name);
+
+                name = name
+                    .Replace("-", "_")
+                    .Replace(".", "")
+                    .Replace("'", "")
+                    .Replace("&", "And")
+                    .Replace("(", "")
+                    .Replace(")", "");
+
+                return name;
+            }
+
+            //Parse ScriptableObject Name
+            string FixCharactersInName(string str)
+            {
+                string name = str;
+
+                name = name
+                    .Replace(" ", "_")
+                    .Replace(":", "")
+                    .Replace("?", "")
+                    .Replace("!", "")
+                    .Replace("<", "")
+                    .Replace(">", "");
+
+                return name;
+            }
+        }
+
+        [MenuItem("Window/DCGO/Repair/Convert Entity Class Names")]
+        static void ConvertEntityClassNames()
+        {
+            string path = "Assets/CardBaseEntity/";
+
+            if (Selection.assetGUIDs.Length != 0)
+                path = AssetDatabase.GUIDToAssetPath(Selection.assetGUIDs[0]);
+
+            List<CEntity_Base> List = GetAsset.LoadAll<CEntity_Base>(path);
+
+            string cardList = "";
+            int count = 0;
+
+            foreach (CEntity_Base card in List)
+            {
+                string cardID = card.CardID.Replace("-", "_");
+
+                if(!String.IsNullOrEmpty(card.CardEffectClassName))
+                    card.CardEffectClassName = card.CardEffectClassName.Substring(card.CardEffectClassName.IndexOf("_") + 1);
+                EditorUtility.SetDirty(card);
+                Debug.Log($"{card.CardSpriteName.Replace("-", "_")} - {cardID} - {card.CardEffectClassName}");
+                AssetDatabase.RenameAsset(AssetDatabase.GetAssetPath(card), card.CardSpriteName.Replace("-", "_"));
+                count++;
+                EditorUtility.SetDirty(card);
+            }
+
+            Debug.Log("Cards using another class:\n" + cardList);
+            Debug.Log($"Fixed all class names in CardBaseEntity: {count}");
+            return;
+        }
+    }
+}
+

Assets/Editor/Fixing Scripts/CleanUpClassName.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5a47d53c3e3059143a9e75c648f09280
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Fixing Scripts/FindInconsistentCardType.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor.SceneManagement;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+using DCGO.CardEntities;
+using Unity.EditorCoroutines.Editor;
+using System.Collections;
+using UnityEngine.Networking;
+using WebSocketSharp;
+using static UnityEngine.ParticleSystem;
+
+namespace DCGO.Tools.Repair{
+
+
+    public class FindInconsistentCardType : MonoBehaviour
+    {
+        InconsistentName _stringValue;
+        List<TrackedData> _entities;
+
+
+        [MenuItem("Window/DCGO/Repair/Find Inconsistent Card Types")]
+        static void FindInconsistentCardTypes()
+        {
+            List<CEntity_Base> Entities = GetAsset.LoadAll<CEntity_Base>("Assets/CardBaseEntity/");
+
+            foreach (CEntity_Base card in Entities)
+            {
+                if(card.Level == 2)
+                {
+                    if(card.cardKind != CardKind.DigiEgg)
+                        Debug.Log($"Mismatched Type (Egg): {card.CardSprite} - {card.cardColors[0]}");
+                }
+                else if (card.Level > 2)
+                {
+                    if (card.cardKind != CardKind.Digimon)
+                        Debug.Log($"Mismatched Type (Digimon): {card.CardSprite} - {card.cardColors[0]}");
+                }
+            }
+
+            Debug.Log($"FIND INCONSISTANCY COMPLETE");
+        }
+    }
+}
+

Assets/Editor/Fixing Scripts/FindInconsistentCardType.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5eca2c40d97888546b8be6fe080443d7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Fixing Scripts/FindInconsistentNaming.cs

@@ -0,0 +1,169 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor.SceneManagement;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+using DCGO.CardEntities;
+using Unity.EditorCoroutines.Editor;
+using System.Collections;
+using UnityEngine.Networking;
+using WebSocketSharp;
+using static UnityEngine.ParticleSystem;
+
+namespace DCGO.Tools.Repair{
+
+    [CreateAssetMenu(fileName = "CardEntity_Inconsistency", menuName = "Create Inconsistency Entity")]
+    public class InconsistentName : ScriptableObject
+    {
+        public enum DataType
+        {
+            name,
+            text,
+            attribute,
+            type
+        }
+
+        public DataType dataType;
+        public string stringToFind;
+        public string stringToCompare;
+    }
+
+    public class TrackedData
+    {
+        public CEntity_Base entity;
+        public string name;
+        public List<string> tags = new List<string>();
+    }
+
+    [CustomEditor(typeof(InconsistentName))]
+    public class FindInconsistentNaming : Editor
+    {
+        InconsistentName _stringValue;
+        List<TrackedData> _entities;
+
+        public override void OnInspectorGUI()
+        {
+            _stringValue = target as InconsistentName;
+            DrawDefaultInspector();
+
+            if (GUILayout.Button("Find Inconsistencies"))
+                EditorCoroutineUtility.StartCoroutine(FindInconsistency(_stringValue), this);
+
+            if (_entities == null)
+                return;
+
+            GUILayout.Space(30);
+
+            GUILayout.Label($"Inconsistencies Found: {_entities.Count}");
+
+            GUILayout.Space(10);
+
+            if (GUILayout.Button("Fix Inconsistencies"))
+                UpdateInconsistencies(_stringValue);
+
+            
+            GUILayout.BeginVertical();
+
+            foreach (TrackedData data in _entities)
+            {
+                if (GUILayout.Button($"Card ID: {data.entity.CardID}"))
+                    Selection.SetActiveObjectWithContext(data.entity, null);
+            }
+
+            GUILayout.EndVertical();
+        }
+
+        IEnumerator FindInconsistency(InconsistentName value)
+        {
+            List<CEntity_Base> List = GetAsset.LoadAll<CEntity_Base>("Assets/CardBaseEntity/");
+            _entities = new List<TrackedData>();
+
+            foreach (CEntity_Base card in List)
+            {
+                TrackedData data = new TrackedData();
+
+                switch (value.dataType)
+                {
+                    case InconsistentName.DataType.name:
+                        if (!card.CardName_ENG.Contains(value.stringToFind))
+                            continue;
+
+                        data.entity = card;
+                        data.name = card.CardName_ENG.Replace(value.stringToFind,value.stringToCompare);
+                        _entities.Add(data);
+                        break;
+                    case InconsistentName.DataType.text:
+
+                        break;
+                    case InconsistentName.DataType.attribute:
+                        List<string> attributes = card.Attribute_ENG.Clone().ToList();
+
+                        for (int i = 0; i < attributes.Count; i++)
+                        {
+                            if (!attributes[i].Contains(value.stringToFind))
+                                continue;
+
+                            if (attributes[i].Equals(value.stringToCompare))
+                                continue;
+
+                            attributes[i] = value.stringToCompare;
+                            data.entity = card;
+                            data.tags = attributes;
+
+                            _entities.Add(data);
+                        }
+                        break;
+                    case InconsistentName.DataType.type:
+                        List<string> types = card.Type_ENG.Clone().ToList();
+
+                        for (int i = 0; i < types.Count; i++)
+                        {
+                            if (!types[i].Contains(value.stringToFind))
+                                continue;
+
+                            if (types[i].Equals(value.stringToCompare))
+                                continue;
+
+                            types[i] = value.stringToCompare;
+                            data.entity = card;
+                            data.tags = types;
+
+                            _entities.Add(data);
+                        }
+                        break;
+                }
+                
+            }
+
+            Debug.Log($"Inconsistency Complete: Found {_entities.Count}");
+            yield return null;
+        }
+        void UpdateInconsistencies(InconsistentName value)
+        {
+            
+            foreach (TrackedData data in _entities)
+            {
+                switch (value.dataType)
+                {
+                    case InconsistentName.DataType.name:
+                        data.entity.CardName_ENG = data.name;
+                        break;
+                    case InconsistentName.DataType.text:
+
+                        break;
+                    case InconsistentName.DataType.attribute:
+                        data.entity.Attribute_ENG = data.tags;
+                        break;
+                    case InconsistentName.DataType.type:
+                        data.entity.Type_ENG = data.tags;
+                        break;
+                }
+
+                EditorUtility.SetDirty(data.entity);
+            }
+        }
+    }
+}
+

Assets/Editor/Fixing Scripts/FindInconsistentNaming.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 70d19f60ba851394a891ce1e5706cf68
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Fixing Scripts/FindMissingAAs.cs

@@ -0,0 +1,185 @@
+using DCGO.CardEntities;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Security.Policy;
+using Unity.EditorCoroutines.Editor;
+using UnityEditor;
+using UnityEditor.PackageManager;
+using UnityEngine;
+using UnityEngine.Networking;
+
+namespace DCGO.Tools
+{
+    public class FindMissingAAs : MonoBehaviour
+    {
+        static FindMissingAAs instance;
+        string baseURL = "https://raw.githubusercontent.com/TakaOtaku/Digimon-Cards/main/src/assets/";
+        public List<CardData> _cardData;
+
+        string debugText = "";
+        int matchedCount = 0;
+
+        [MenuItem("Window/DCGO/Find Missing AAs")]
+        static void ErrataImages()
+        {
+            instance = new FindMissingAAs();
+            EditorCoroutineUtility.StartCoroutine(instance.FindAAs(), instance);
+        }
+
+        IEnumerator FindAAs()
+        {
+            yield return EditorCoroutineUtility.StartCoroutine(instance.GetJsonData(), instance);
+
+            List<CardData> aaCards = _cardData.Filter(x => x.AAs.Count > 0);
+
+            foreach (CardData card in aaCards)
+            {
+                foreach(AlternateArt AA in card.AAs)
+                {
+                    string ID = AA.id.Replace("-Errata", "");
+
+                    if (FindFile(ID, card))
+                    {
+                        debugText += $"{ID}\n";
+                        matchedCount++;
+                    }
+                }
+            }
+
+            Debug.Log(debugText);
+            Debug.Log($"COMPLETED: {matchedCount}");
+        }
+
+        bool FindFile(string ID, CardData data)
+        {
+            string fileName = $"{FixCharactersInClassName($"{ID}")}.asset";
+
+            string folderName_SetID = $"{GetParseByHyphen(data.id)[0]}";
+            string folderName_CardColor = $"{DataBase.CardColorNameDictionary[GetCardColors(data.color)[0]]}";
+            folderName_CardColor = char.ToUpper(folderName_CardColor[0]) + folderName_CardColor.Substring(1);
+
+            string folderName_CardKind = $"{DataBase.CardKindENNameDictionary[DictionaryUtility.GetCardKind(data.cardType.Replace("-", ""), DataBase.CardKindENNameDictionary)]}";
+            string folderPath = $"Assets/CardBaseEntity/{folderName_SetID}/{folderName_CardColor}/{folderName_CardKind}";
+
+            if (Directory.Exists(folderPath))
+            {
+                string filePath = $"{folderPath}/{fileName}".Trim().Replace("\t", "").Replace("\n", "").Replace("\r", "").Replace(" ", "");
+
+                CEntity_Base card = GetAsset.Load<CEntity_Base>(filePath);
+
+                if (card == null)
+                {
+                    return GetImage(ID);
+                }
+            }
+
+            return false;
+        }
+        bool GetImage(string ID)
+        {
+            string imgURL = $"{baseURL}images/cards/{ID}.webp";
+
+            Debug.Log(imgURL);
+            try
+            {
+                WebClient wc = new WebClient();
+                string HTMLSource = wc.DownloadString(imgURL);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Debug.LogWarning(ex.Message);
+                return false;
+            }
+        }
+
+        IEnumerator GetJsonData()
+        {
+            string url = baseURL + "cardlists/DigimonCards.json";
+            UnityWebRequest jsonWebRequest = UnityWebRequest.Get(url);
+
+            yield return jsonWebRequest.SendWebRequest();
+
+            if (jsonWebRequest.result != UnityWebRequest.Result.Success)
+            {
+                Debug.Log(jsonWebRequest.error);
+            }
+            else
+            {
+
+                RootObject root = JsonUtility.FromJson<RootObject>("{\"cards\":" + jsonWebRequest.downloadHandler.text + "}");
+                _cardData = root.cards;
+            }
+
+            yield return null;
+        }
+
+        //Parse ScriptableObject Name
+        string FixCharactersInName(string str)
+        {
+            string name = str;
+
+            name = name
+                .Replace(" ", "_")
+                .Replace(":", "")
+                .Replace("?", "")
+                .Replace("!", "")
+                .Replace("<", "")
+                .Replace(">", "");
+
+            return name;
+        }
+
+        //Parse ScriptableObject Class Name
+        public string FixCharactersInClassName(string str)
+        {
+            string name = str;
+
+            name = FixCharactersInName(name);
+
+            name = name
+                .Replace("-", "_")
+                .Replace(".", "")
+                .Replace("'", "")
+                .Replace("&", "And")
+                .Replace("(", "")
+                .Replace(")", "");
+
+            return name;
+        }
+
+        public static string[] GetParseByHyphen(string CardImageName)
+        {
+            string[] parseByHyphen = new string[] { CardImageName };
+
+            if (CardImageName.Contains('-'))
+            {
+                parseByHyphen = CardImageName.Split('-');
+            }
+
+            return parseByHyphen;
+        }
+
+        //Parse card colors to list
+        List<CardColor> GetCardColors(string colors)
+        {
+            List<CardColor> cardColors = new List<CardColor>();
+
+            foreach (string cardColorName in colors.Split("/"))
+            {
+                foreach (string cardColorNameValues in DataBase.CardColorNameDictionary.Values)
+                {
+                    if (cardColorName.ToLower().Trim() == cardColorNameValues)
+                    {
+                        cardColors.Add(DictionaryUtility.GetCardColor(cardColorName.ToLower().Trim(), DataBase.CardColorNameDictionary));
+                    }
+                }
+            }
+
+            return cardColors;
+        }
+    }
+}

Assets/Editor/Fixing Scripts/FindMissingAAs.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 654712c927e33024eb1b17462bb811b0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Fixing Scripts/FixDigiEggCost.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace DCGO.Tools.Repair{
+    public class FixDigiEggCost : MonoBehaviour
+    {
+        [MenuItem("Window/DCGO/Repair/Fix Digi-Egg Play Cost")]
+        static void FixDigiEggPlayCost()
+        {
+            List<CEntity_Base> List = GetAsset.LoadAll<CEntity_Base>("Assets/CardBaseEntity/");
+            List = List.Filter(x => x.cardKind == CardKind.DigiEgg).Filter(x => x.PlayCost == 0);
+
+            foreach (CEntity_Base card in List)
+            {
+                card.PlayCost = -1;
+                EditorUtility.SetDirty(card);
+            }
+
+            Debug.Log("Fixed all Digi-Egg play cost in CardBaseEntity");
+            return;
+        }
+    }
+}
+

Assets/Editor/Fixing Scripts/FixDigiEggCost.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 54ac91e9626d2d34f842e2ff505e844c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Fixing Scripts/FixErrataImages.cs

@@ -0,0 +1,308 @@
+using DCGO.CardEntities;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using Unity.EditorCoroutines.Editor;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Networking;
+
+namespace DCGO.Tools.Repair
+{
+    public class FixErrataImages : MonoBehaviour
+    {
+        static FixErrataImages instance;
+        string baseURL = "https://raw.githubusercontent.com/TakaOtaku/Digimon-Cards/main/src/";
+        public List<CardData> _cardData;
+
+        string debugText = "";
+        int matchedCount = 0;
+
+        #region Fix Errata Images
+        [MenuItem("Window/DCGO/Repair/Fix Errata Images")]
+        static void ErrataImages()
+        {
+            instance = new FixErrataImages();
+            EditorCoroutineUtility.StartCoroutine(instance.FixImages(), instance);
+        }
+
+        IEnumerator FixImages()
+        {
+            yield return EditorCoroutineUtility.StartCoroutine(instance.GetJsonData(), instance);
+
+            List<CEntity_Base> Entities = GetAsset.LoadAll<CEntity_Base>("Assets/CardBaseEntity/");
+
+            foreach (CEntity_Base card in Entities)
+            {
+                CardData data = _cardData.Where(x => x.id == card.CardID).First();
+
+                if (card.CardSpriteName.Contains("-Errata"))
+                {
+                    Debug.Log($"Already is an Errata: {card.CardID}");
+                    continue;
+                }
+
+                string errataName = FindMatchingErrata(card.CardSpriteName, data);
+
+                if (card.CardSpriteName != errataName)
+                {
+                    card.CardSpriteName = errataName;
+                    EditorUtility.SetDirty(card);
+                }
+            }
+
+            Debug.Log(debugText);
+            Debug.Log($"COMPLETED: {matchedCount}");
+        }
+
+        string FindMatchingErrata(string imageName, CardData data)
+        {
+            string name = imageName;
+
+            foreach (AlternateArt AA in data.AAs)
+            {
+                if (AA.id.Replace("-Errata", "") != imageName)
+                    continue;
+
+                name = AA.id;
+            }
+
+            if (name != imageName)
+            {
+                debugText += $"{imageName}\n";
+                matchedCount++;
+            }
+
+            return name;
+        }
+
+        #endregion
+
+        #region Fix Sample Images
+        [MenuItem("Window/DCGO/Repair/Fix Sample Images")]
+        static void SampleImages()
+        {
+            instance = new FixErrataImages();
+            instance.FixSampleImages();
+        }
+
+        void FixSampleImages()
+        {
+            string path = "Assets/CardBaseEntity/";
+
+            if (Selection.assetGUIDs.Length != 0)
+                path = AssetDatabase.GUIDToAssetPath(Selection.assetGUIDs[0]);
+
+            Debug.Log($"ASSET PATH: {path}");
+
+            List<CEntity_Base> Entities = GetAsset.LoadAll<CEntity_Base>(path);
+
+            foreach (CEntity_Base card in Entities)
+            {
+                string errataName = FindMatchingSample(card.CardSpriteName);
+
+                if (card.CardSpriteName != errataName)
+                {
+                    card.CardSpriteName = errataName;
+                    EditorUtility.SetDirty(card);
+                }
+            }
+
+            Debug.Log($"COMPLETED");
+        }
+
+        string FindMatchingSample(string imageName)
+        {
+            string name = imageName;
+
+            if (!name.Contains("_P"))
+                name += "-Sample";
+
+            return name;
+        }
+
+        #endregion
+
+        #region Remove Sample Images
+        [MenuItem("Window/DCGO/Repair/Remove Sample Images")]
+        static void RemoveSample()
+        {
+            instance = new FixErrataImages();
+            instance.RemoveSampleImages();
+        }
+
+        void RemoveSampleImages()
+        {
+            string path = "Assets/CardBaseEntity/";
+
+            if (Selection.assetGUIDs.Length != 0)
+                path = AssetDatabase.GUIDToAssetPath(Selection.assetGUIDs[0]);
+
+            Debug.Log($"ASSET PATH: {path}");
+
+            List<CEntity_Base> Entities = GetAsset.LoadAll<CEntity_Base>(path);
+
+            foreach (CEntity_Base card in Entities)
+            {
+                string errataName = RemoveMatchingSample(card.CardSpriteName);
+
+                if (card.CardSpriteName != errataName)
+                {
+                    card.CardSpriteName = errataName;
+                    EditorUtility.SetDirty(card);
+                }
+            }
+
+            Debug.Log($"COMPLETED");
+        }
+
+        string RemoveMatchingSample(string imageName)
+        {
+            string name = imageName;
+
+            if (name.Contains("-Sample"))
+                name = name.Remove(name.IndexOf("-Sample"));
+
+            return name;
+        }
+
+        #endregion
+
+
+
+        IEnumerator GetJsonData()
+        {
+            string url = baseURL + "assets/cardlists/DigimonCards.json";
+            UnityWebRequest jsonWebRequest = UnityWebRequest.Get(url);
+
+            yield return jsonWebRequest.SendWebRequest();
+
+            if (jsonWebRequest.result != UnityWebRequest.Result.Success)
+            {
+                Debug.Log(jsonWebRequest.error);
+            }
+            else
+            {
+
+                RootObject root = JsonUtility.FromJson<RootObject>("{\"cards\":" + jsonWebRequest.downloadHandler.text + "}");
+                _cardData = root.cards;
+            }
+
+            yield return null;
+        }
+
+        void SetSpriteName(string ID, CardData data)
+        {
+            string fileName = $"{FixCharactersInClassName($"{ID}")}.asset";
+
+            string folderName_SetID = $"{GetParseByHyphen(data.id)[0]}";
+
+            string folderName_CardColor = $"{DataBase.CardColorNameDictionary[GetCardColors(data.color)[0]]}";
+            folderName_CardColor = char.ToUpper(folderName_CardColor[0]) + folderName_CardColor.Substring(1);
+
+            string folderName_CardKind = $"{DataBase.CardKindENNameDictionary[DictionaryUtility.GetCardKind(data.cardType.Replace("-", ""), DataBase.CardKindENNameDictionary)]}";
+            string folderPath = $"Assets/CardBaseEntity/{folderName_SetID}/{folderName_CardColor}/{folderName_CardKind}";
+            string filePath = $"{folderPath}/{fileName}".Trim().Replace("\t", "").Replace("\n", "").Replace("\r", "").Replace(" ", "");
+
+            CEntity_Base card = GetAsset.Load<CEntity_Base>(filePath);
+
+            if (card == null)
+            {
+                Debug.Log($"NO ASSET FOUND: {fileName}");
+                return;
+            }
+            string errataName = GetImageURL(data.cardImage, data.cardNumber, data.AAs);
+
+            if (!errataName.Equals(card.CardSpriteName))
+            {
+                debugText += $"{fileName}: {errataName}\n";
+                matchedCount++;
+                //card.CardSpriteName = errataName;
+                //EditorUtility.SetDirty(card);
+            }
+        }
+
+        string GetImageURL(string url, string ID, List<AlternateArt> AA)
+        {
+            string[] urlSplit = url.Split(".");
+            string startURL = urlSplit[0].Substring(0, urlSplit[0].LastIndexOf("/"));
+
+            if (!ID.Contains("Errata") && !ID.Contains("_") && AA.Count > 0)
+            {
+                AlternateArt errata = AA.Where(x => x.id.StartsWith(ID) && x.id.Contains("Errata")).FirstOrDefault();
+
+                if(ID.Contains("BT16-077"))
+
+                if (errata != null)
+                    ID = errata.id;
+            }
+
+            return $"{ID}";
+        }
+
+        //Parse ScriptableObject Name
+        string FixCharactersInName(string str)
+        {
+            string name = str;
+
+            name = name
+                .Replace(" ", "_")
+                .Replace(":", "")
+                .Replace("?", "")
+                .Replace("!", "")
+                .Replace("<", "")
+                .Replace(">", "");
+
+            return name;
+        }
+
+        //Parse ScriptableObject Class Name
+        public string FixCharactersInClassName(string str)
+        {
+            string name = str;
+
+            name = FixCharactersInName(name);
+
+            name = name
+                .Replace("-", "_")
+                .Replace(".", "")
+                .Replace("'", "")
+                .Replace("&", "And")
+                .Replace("(", "")
+                .Replace(")", "");
+
+            return name;
+        }
+
+        public static string[] GetParseByHyphen(string CardImageName)
+        {
+            string[] parseByHyphen = new string[] { CardImageName };
+
+            if (CardImageName.Contains('-'))
+            {
+                parseByHyphen = CardImageName.Split('-');
+            }
+
+            return parseByHyphen;
+        }
+
+        //Parse card colors to list
+        List<CardColor> GetCardColors(string colors)
+        {
+            List<CardColor> cardColors = new List<CardColor>();
+
+            foreach (string cardColorName in colors.Split("/"))
+            {
+                foreach (string cardColorNameValues in DataBase.CardColorNameDictionary.Values)
+                {
+                    if (cardColorName.ToLower().Trim() == cardColorNameValues)
+                    {
+                        cardColors.Add(DictionaryUtility.GetCardColor(cardColorName.ToLower().Trim(), DataBase.CardColorNameDictionary));
+                    }
+                }
+            }
+
+            return cardColors;
+        }
+    }
+}

Assets/Editor/Fixing Scripts/FixErrataImages.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 02133ac4ff1439c4ebf30746eb6b8150
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Fixing Scripts/GetHighestCardIndex.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor.SceneManagement;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+using DCGO.CardEntities;
+
+namespace DCGO.Tools 
+{
+    public class GetHighestCardIndex : MonoBehaviour
+    {
+        [MenuItem("Window/DCGO/Get Index/Get Highest Card Index")]
+        static void GetIndex()
+        {
+            List<CEntity_Base> Entities = GetAsset.LoadAll<CEntity_Base>("Assets/CardBaseEntity/");
+            int cardIndex = 0;
+            string name = "";
+
+            foreach (CEntity_Base card in Entities)
+            {
+                if (card.CardID.Contains("P-"))
+                    continue;
+
+                if (cardIndex == card.CardIndex)
+                    Debug.LogWarning($"DUPLICATE INDEX FOUND: {card.CardSpriteName} - {cardIndex}");
+
+                if (card.CardIndex > cardIndex)
+                {
+                    cardIndex = card.CardIndex;
+                    name = card.CardSpriteName;
+                }
+            }
+
+            Debug.Log($"Highest Card Index: {cardIndex} - {name}");
+        }
+    }
+
+    public class GetHighestPromoCardIndex : MonoBehaviour
+    {
+        [MenuItem("Window/DCGO/Get Index/Get Highest Promo Index")]
+        static void GetIndex()
+        {
+            List<CEntity_Base> Entities = GetAsset.LoadAll<CEntity_Base>("Assets/CardBaseEntity/");
+            int cardIndex = 0;
+            string name = "";
+
+            foreach (CEntity_Base card in Entities)
+            {
+                if (!card.CardID.Contains("P-"))
+                    continue;
+
+                if (cardIndex == card.CardIndex)
+                    Debug.LogWarning($"DUPLICATE INDEX FOUND: {card.CardSpriteName} - {cardIndex}");
+
+                if (card.CardIndex > cardIndex)
+                {
+                    cardIndex = card.CardIndex;
+                    name = card.CardSpriteName;
+                }
+            }
+
+            Debug.Log($"Highest Card Index: {cardIndex} - {name}");
+        }
+    }
+}

Assets/Editor/Fixing Scripts/GetHighestCardIndex.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 48db2dcae0172ca46bfc1ab85553b6cf
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Fixing Scripts/GetListOfInvalidClassNames.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor.SceneManagement;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+using DCGO.CardEntities;
+
+namespace DCGO.Tools.Repair 
+{
+    public class GetListOfInvalidClassNames : MonoBehaviour
+    {
+        [MenuItem("Window/DCGO/Repair/Get List of Invalid Class Names")]
+        static void FixEntityClassNames()
+        {
+            List<CEntity_Base> Entities = GetAsset.LoadAll<CEntity_Base>("Assets/CardBaseEntity/");
+            List<string> InvalidClassNames = new List<string>();
+
+            foreach (CEntity_Base card in Entities)
+            {
+                if (CanAttachEffectComponent(card.SetID, card.CardEffectClassName))
+                    continue;
+
+                if (card.EffectDiscription_ENG.Equals("")
+                    && card.InheritedEffectDiscription_ENG.Equals("")
+                    && card.SecurityEffectDiscription_ENG.Equals(""))
+                    continue;
+
+                if (card.EffectDiscription_ENG.Equals("-") 
+                    && card.InheritedEffectDiscription_ENG.Equals("-")
+                    && card.SecurityEffectDiscription_ENG.Equals("-"))
+                    continue;
+
+                if(InvalidClassNames.Contains(card.CardEffectClassName))
+                    continue;
+
+                InvalidClassNames.Add(card.CardEffectClassName);
+                Debug.LogError($"Invalid Class Name: {card.name} - {card.CardEffectClassName}");
+            }
+
+            Debug.Log($"Total Invalid Class Names: {InvalidClassNames.Count}");
+
+            bool CanAttachEffectComponent(string ID, string ClassName)
+            {
+                if (string.IsNullOrEmpty(ClassName))
+                    return false;
+
+                if (Type.GetType(ClassName + ",Assembly-CSharp") == null)
+                {
+                    if (!ClassName.Contains("token"))
+                    {
+                        if (Type.GetType($"DCGO.CardEffects.{ID}.{ClassName},Assembly-CSharp") == null)
+                            return false;
+                    }
+                    else
+                    {
+                        if (Type.GetType($"DCGO.CardEffects.Tokens.{ClassName},Assembly-CSharp") == null)
+                            return false;
+                    }
+                }
+                
+                return true;
+            }
+        }
+    }
+}

Assets/Editor/Fixing Scripts/GetListOfInvalidClassNames.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8e72e82afeed9cf47b793f2e5f64919b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Fixing Scripts/GetLowestCardIndex.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor.SceneManagement;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+using DCGO.CardEntities;
+using static UnityEditor.ShaderGraph.Internal.KeywordDependentCollection;
+
+namespace DCGO.Tools
+{
+    public class GetLowestCardIndex : MonoBehaviour
+    {
+        [MenuItem("Window/DCGO/Get Index/Get Lowest Card Index")]
+        static void GetIndex()
+        {
+
+            string path = "";
+            int minValue = 0;
+
+            if (Selection.assetGUIDs.Length != 0)
+                path = AssetDatabase.GUIDToAssetPath(Selection.assetGUIDs[0]);
+
+            if (path != "")
+            {
+                List<CEntity_Base> List = GetAsset.LoadAll<CEntity_Base>(path)
+                .OrderBy(x => x.CardIndex).ToList();
+
+                minValue = List[0].CardIndex;
+            }
+
+            List<CEntity_Base> Entities = GetAsset.LoadAll<CEntity_Base>("Assets/CardBaseEntity/")
+            .Filter(entity => !entity.CardID.Contains("P-"))
+            .Filter(entity => entity.CardIndex >= minValue);
+            int cardIndex = 0;
+            string name = "";
+
+            foreach (CEntity_Base card in Entities)
+            {
+                if (card.CardID.Contains("P-"))
+                    continue;
+
+                if (cardIndex == card.CardIndex)
+                    Debug.LogWarning($"DUPLICATE INDEX FOUND: {card.CardSpriteName} - {cardIndex}");
+
+                if (card.CardIndex < cardIndex || cardIndex == 0)
+                {
+                    cardIndex = card.CardIndex;
+                    name = card.CardSpriteName;
+                }
+            }
+
+            Debug.Log($"Lowest Card Index: {cardIndex} - {name}");
+        }
+    }
+
+    public class GetLowestPromoCardIndex : MonoBehaviour
+    {
+        [MenuItem("Window/DCGO/Get Index/Get Lowest Promo Index")]
+        static void GetIndex()
+        {
+            string path = "";
+            int minValue = 0;
+
+            if (Selection.assetGUIDs.Length != 0)
+                path = AssetDatabase.GUIDToAssetPath(Selection.assetGUIDs[0]);
+
+            if(path != "")
+            {
+                CEntity_Base entity = GetAsset.Load<CEntity_Base>(path);
+
+                minValue = entity.CardIndex;
+            }
+            
+
+            List<CEntity_Base> Entities = GetAsset.LoadAll<CEntity_Base>("Assets/CardBaseEntity/")
+            .Filter(entity => entity.CardID.Contains("P-"))
+            .Filter(entity => entity.CardIndex > minValue);
+
+            int cardIndex = 0;
+            string name = "";
+
+            Debug.Log($"CARD COUNT: {Entities.Count}");
+            foreach (CEntity_Base card in Entities)
+            {
+                if (cardIndex == card.CardIndex)
+                    Debug.LogWarning($"DUPLICATE INDEX FOUND: {card.CardSpriteName} - {cardIndex}");
+
+                if ((card.CardIndex < cardIndex || cardIndex == 0))
+                {
+                    cardIndex = card.CardIndex;
+                    name = card.CardSpriteName;
+                }
+            }
+
+            Debug.Log($"Lowest Card Index: {cardIndex} - {name}");
+        }
+    }
+}

Assets/Editor/Fixing Scripts/GetLowestCardIndex.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5ba00a03ae900094d9b18e9b248f90e6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Fixing Scripts/MatchClassNames.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.VersionControl;
+using UnityEngine;
+using UnityEngine.Analytics;
+using WebSocketSharp;
+
+namespace DCGO.Tools.Repair
+{
+    public class MatchClassNames : MonoBehaviour
+    {
+        [MenuItem("Window/DCGO/Repair/MatchClassNames")]
+        static void FixEntityCardIndex()
+        {
+            Dictionary<string,string> classNameDictionary = new Dictionary<string,string>();
+            string path = "Assets/CardBaseEntity/";
+
+            if (Selection.assetGUIDs.Length != 0)
+                path = AssetDatabase.GUIDToAssetPath(Selection.assetGUIDs[0]);
+
+            List<CEntity_Base> List = GetAsset.LoadAll<CEntity_Base>(path).ToList();
+            List<CEntity_Base> normalArts = List.Filter(x => !x.name.Contains("_P"));
+            List<CEntity_Base> alternateArts = List.Filter(x => x.name.Contains("_P"));
+
+            string assetName = "";
+            int mismatchCount = 0;
+
+            //Locate All mismatched classNames
+            foreach (CEntity_Base card in normalArts)
+            {
+                assetName = card.CardEffectClassName;
+
+                List<CEntity_Base> matchingCards = alternateArts.Filter(x => x.CardID == card.CardID);
+
+                foreach(CEntity_Base matchingCard in matchingCards)
+                {
+                    if(matchingCard.CardEffectClassName != assetName)
+                    {
+                        Debug.Log($"Mismatch Found: {matchingCard.name}");
+                        mismatchCount++;
+                        matchingCard.CardEffectClassName = assetName;
+                        EditorUtility.SetDirty(matchingCard);
+                    }
+                }
+            }
+
+            Debug.Log($"DONE: mismatches found: {mismatchCount}");
+            return;
+        }
+    }
+}

Assets/Editor/Fixing Scripts/MatchClassNames.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3525c4ed3729f9d4aa2dd7309b26f468
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Fixing Scripts/ScriptableObjects.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5ac2702bf8706dd4aaf175b7a9adc52d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Fixing Scripts/ScriptableObjects/CardEntity_Inconsistency.asset

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca4f8e6076bfa5c76a02676756e8f364c24e7190b13b2029f5bdb021030b52ff
+size 500

Assets/Editor/Fixing Scripts/ScriptableObjects/CardEntity_Inconsistency.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 69fb98d52f9303a4da65124f2a5f4189
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/GetAsset.cs

@@ -0,0 +1,70 @@
+using UnityEditor;
+using UnityEngine;
+
+using System.IO;
+using System.Collections.Generic;
+using static UnityEditor.ShaderGraph.Internal.KeywordDependentCollection;
+using UnityEngine.Windows;
+
+/// <summary>
+/// Resources Objects other than directories can be accessed. In fact, you can also access objects in the Resources directory.
+/// </summary>
+public static class GetAsset
+{
+
+    //=================================================================================
+    //Single load
+    //=================================================================================
+
+    /// <summary>
+    /// Set the file path (including the extension from Assets) and type, and load the Object. Returns Null if not present
+    /// </summary>
+    public static T Load<T>(string path) where T : Object
+    {
+        return AssetDatabase.LoadAssetAtPath<T>(path);
+    }
+
+    /// <summary>
+    /// Set the file path (from Assets, including the extension) and load the Object. Returns Null if not present
+    /// </summary>
+    public static Object Load(string path)
+    {
+        return Load<Object>(path);
+    }
+
+    //=================================================================================
+    //multiple loads
+    //=================================================================================
+
+    /// <summary>
+    /// Set the directory path(from Assets) and type, and load the Object.Returns an empty List if it does not exist
+    /// </summary>
+    public static List<T> LoadAll<T>(string directoryPath) where T : Object
+    {
+        List<T> assetList = new List<T>();
+
+        //Get all files in the specified directory (including child directories)
+        string[] filePathArray = System.IO.Directory.GetFiles(directoryPath, "*", SearchOption.AllDirectories);
+
+        //Add only assets from the acquired files to the list
+        foreach (string filePath in filePathArray)
+        {
+            T asset = Load<T>(filePath);
+            if (asset != null)
+            {
+                assetList.Add(asset);
+            }
+        }
+
+        return assetList;
+    }
+
+    /// <summary>
+    /// Set the directory path (from Assets) and read the Object. Returns an empty List if it does not exist
+    /// </summary>
+    public static List<Object> LoadAll(string directoryPath)
+    {
+        return LoadAll<Object>(directoryPath);
+    }
+
+}

Assets/Editor/GetAsset.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a6298f8ecad10c14da3fb3c9164f1f33
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/JSONLoader_CardEntity.cs

@@ -0,0 +1,555 @@
+using System;
+using System.IO;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using Unity.EditorCoroutines.Editor;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Networking;
+using System.Drawing.Text;
+using System.Net;
+using System.Data;
+
+namespace DCGO.CardEntities
+{
+    [CustomEditor(typeof(LoadJSON_CardEntity))]
+    public class JSONLoader_CardEntity : Editor
+    {
+        LoadJSON_CardEntity _loadJSON;
+        //string baseURL = "https://raw.githubusercontent.com/TakaOtaku/Digimon-Cards/main/src/";
+        string baseURL = "https://raw.githubusercontent.com/TakaOtaku/Digimon-Card-App/main/src/";
+
+        public List<CardData> _cardData;
+
+        string cardIDString = "";
+        bool onlyAA = false;
+        bool updateExisting = false;
+        bool debugMode = false;
+        bool withoutImages = false;
+
+        public override void OnInspectorGUI()
+        {
+            _loadJSON = target as LoadJSON_CardEntity;
+            DrawDefaultInspector();
+
+            if (GUILayout.Button("Get JSON Object"))
+                EditorCoroutineUtility.StartCoroutine(GetJsonData(_loadJSON), this);
+
+            if (_cardData != null)
+            {
+                updateExisting = GUILayout.Toggle(updateExisting, "Update Existing Assets");
+                onlyAA = GUILayout.Toggle(onlyAA, "AA Only");
+                debugMode = GUILayout.Toggle(debugMode, "Run in Debug Mode");
+                withoutImages = GUILayout.Toggle(withoutImages, "Create Assets Without Images");
+
+                GUILayout.Label("Card ID: ");
+                cardIDString = GUILayout.TextField(cardIDString, 500).ToUpper();
+
+                if (cardIDString != "")
+                {
+                    if (GUILayout.Button("Create Scriptable Object"))
+                    {
+                        List<string> list = cardIDString.Split(",").ToList();
+                        List<CardData> cards = new List<CardData>();
+
+                        foreach (string str in list)
+                            cards.AddRange(_cardData.Where(x => x.cardNumber.Contains(str)).ToList());
+
+                        SetDataToScriptableObject(cards);
+
+                        if(!debugMode)
+                            _loadJSON.prevCardIndex = _loadJSON.setCardIndex-1;
+                    }
+                }
+            }
+        }
+
+        IEnumerator GetJsonData(LoadJSON_CardEntity loadJSON)
+        {
+            string url = baseURL + "assets/cardlists/DigimonCards.json";
+            UnityWebRequest jsonWebRequest = UnityWebRequest.Get(url);
+
+            yield return jsonWebRequest.SendWebRequest();
+
+            if (jsonWebRequest.result != UnityWebRequest.Result.Success)
+            {
+                Debug.Log(jsonWebRequest.error);
+            }
+            else
+            {
+               
+                RootObject root = JsonUtility.FromJson<RootObject>("{\"cards\":" + jsonWebRequest.downloadHandler.text + "}");
+                _cardData = root.cards;
+            }
+
+            yield return null;
+        }
+
+        void SetDataToScriptableObject(List<CardData> data)
+        {
+            foreach (CardData card in data)
+            {
+                if(!onlyAA)
+                    CreateScriptableObject(card, card.cardNumber);
+                
+                CreateAA(card);
+            }
+        }
+
+        string GetImageURL(string url, string ID, List<AlternateArt> AA)
+        {
+            string[] urlSplit = url.Split(".");
+            string startURL = urlSplit[0].Substring(0, urlSplit[0].LastIndexOf("/"));
+
+            if (debugMode)
+                Debug.Log($"{ID} - {AA.Count}");
+
+            if (!ID.Contains("Errata") && !ID.Contains("_") && AA.Count > 0)
+            {
+                AlternateArt errata = AA.Where(x => x.id.StartsWith(ID) && x.id.Contains("Errata")).FirstOrDefault();
+
+                if (errata != null)
+                    ID = errata.id;
+            }
+
+            return $"{ID}";
+        }
+
+
+        void CreateScriptableObject(CardData card, string imageID)
+        {
+            Debug.Log($"creating: {card.name.english} - {card.cardType}");
+            // CardEntity‚ instance created
+            CEntity_Base cardEntity = CreateInstance<CEntity_Base>();
+
+            cardEntity.cardColors = GetCardColors(card.color);
+
+            cardEntity.PlayCost = intParse(card.playCost);
+            cardEntity.EvoCosts = GetEvoCosts(card.digivolveCondition,cardEntity.cardColors);
+
+            cardEntity.Level = levelParse(card.cardLv);
+            cardEntity.CardName_ENG = card.name.english;
+
+            cardEntity.Form_ENG = GetCardInfo(card.form);
+            cardEntity.Attribute_ENG = GetCardInfo(card.attribute);
+            cardEntity.Type_ENG = GetCardInfo(card.type, card.rule);
+
+            cardEntity.CardSpriteName = GetImageURL(card.cardImage, imageID, card.AAs);
+
+            cardEntity.cardKind = DictionaryUtility.GetCardKind(card.cardType.Replace("-",""), DataBase.CardKindENNameDictionary);
+
+            cardEntity.EffectDiscription_ENG = GetEffectDescription(card);
+            cardEntity.InheritedEffectDiscription_ENG = card.digivolveEffect;
+            cardEntity.SecurityEffectDiscription_ENG = card.securityEffect;
+
+            cardEntity.CardEffectClassName = FixCharactersInClassName($"{card.cardNumber}");
+
+            cardEntity.DP = intParse(card.dp);
+            cardEntity.rarity = card.rarity.Equals("-") ? Rarity.None : (Rarity)Enum.Parse(typeof(Rarity), card.rarity);
+            cardEntity.OverflowMemory = GetOverflowMemory(card.aceEffect);
+            cardEntity.CardID = card.id;
+            cardEntity.MaxCountInDeck = GetMaxCount(card.restrictions.japanese, card.rule);
+
+            cardEntity.LinkDP = dpParse(card.linkDP);
+            cardEntity.LinkEffect = card.linkEffect;
+            cardEntity.LinkRequirement = card.linkRequirement;
+
+            cardEntity.name = cardEntity.CardSpriteName.Replace("-Errata","").Replace("-","_");
+
+            if (cardEntity.cardKind == CardKind.DigiEgg && cardEntity.PlayCost == 0)
+                cardEntity.PlayCost = -1;
+
+            if (!debugMode)
+            {
+                if(withoutImages || GetImage(cardEntity.CardSpriteName))
+                {
+                    Debug.Log($"created: {cardEntity.name}: {cardEntity.CardSpriteName}, {cardEntity.CardEffectClassName}");
+                    SaveScriptableObject(cardEntity);
+                }
+            }
+            else
+                Debug.Log($"DATA {cardEntity.name}: {cardEntity.CardSpriteName}, {cardEntity.CardEffectClassName}, {GetCardIndex(cardEntity)}");
+        }
+
+        void CreateAA(CardData data)
+        {
+            foreach (AlternateArt AA in data.AAs)
+            {
+                if (!AA.id.Contains("_"))
+                    continue;
+
+                CreateScriptableObject(data, AA.id);
+            }
+        }
+
+        #region Save Scriptable Object
+        void SaveScriptableObject(CEntity_Base entity)
+        {
+            string fileName = $"{entity.name}.asset";
+
+            string folderName_SetID = $"{entity.SetID}";
+            string folderName_CardColor = entity.cardColors.Count > 0 ? $"{DataBase.CardColorNameDictionary[entity.cardColors[0]]}" : "Unknown";
+            folderName_CardColor = char.ToUpper(folderName_CardColor[0]) + folderName_CardColor.Substring(1);
+
+            string folderName_CardKind = $"{DataBase.CardKindENNameDictionary[entity.cardKind]}";
+            string folderPath = $"Assets/CardBaseEntity/{folderName_SetID}/{folderName_CardColor}/{folderName_CardKind}";
+            string filePath = $"{folderPath}/{fileName}".Trim().Replace("\t", "").Replace("\n", "").Replace("\r", "").Replace(" ", "");
+
+            if (!Directory.Exists(folderPath))
+                Directory.CreateDirectory(folderPath);
+
+            if(File.Exists(filePath))
+            {
+                if (updateExisting)
+                {
+                    CEntity_Base asset = (CEntity_Base)AssetDatabase.LoadAssetAtPath(filePath, typeof(CEntity_Base));
+
+                    entity.CardIndex = asset.CardIndex;
+
+                    EditorUtility.CopySerialized(entity, asset);
+                    AssetDatabase.SaveAssets();
+                    Debug.Log($"{entity.name}: Scriptable Object Updated");
+                }
+            }
+            else
+            {
+                entity.CardIndex = GetCardIndex(entity);
+                AssetDatabase.CreateAsset(entity, filePath);
+                Debug.Log($"{entity.name}: Scriptable Object Created");
+            }
+
+            AssetDatabase.Refresh();
+        }
+        #endregion
+
+        #region Parsing Methods
+
+        //Get Card Index
+        int GetCardIndex(CEntity_Base entity)
+        {
+            int index = _loadJSON.setCardIndex;
+
+            /*f (entity.SetID.Equals("P"))
+            {
+                index = _loadJSON.promoCardIndex;
+                _loadJSON.promoCardIndex++;
+            }
+            else*/
+            _loadJSON.setCardIndex++;
+
+            while (CheckIndexIsUsed())
+            {
+                _loadJSON.setCardIndex++;
+            }
+
+            if (!debugMode)
+                EditorUtility.SetDirty(_loadJSON);
+
+            return index;
+        }
+
+        bool CheckIndexIsUsed()
+        {
+            return GetAsset.LoadAll<CEntity_Base>("Assets/CardBaseEntity/")
+                .Any(x => x.CardIndex == _loadJSON.setCardIndex);
+        }
+
+        //Parse ScriptableObject Name
+        string FixCharactersInName(string str)
+        {
+            string name = str;
+
+            name = name
+                .Replace(" ", "_")
+                .Replace(":","")
+                .Replace("?","")
+                .Replace("!","")
+                .Replace("<", "")
+                .Replace(">", "");
+
+            return name;
+        }
+
+        //Parse ScriptableObject Class Name
+        public string FixCharactersInClassName(string str)
+        {
+            string name = str;
+
+            name = FixCharactersInName(name);
+
+            name = name
+                .Replace("-", "_")
+                .Replace(".", "")
+                .Replace("'", "")
+                .Replace("&", "And")
+                .Replace("(", "")
+                .Replace(")", "");
+
+            return name;
+        }
+
+        //Parse effect description
+        string GetEffectDescription(CardData card)
+        {
+            string effect = "-";
+            List<string> effects = new List<string>();
+
+            if (card.specialDigivolve != "-")
+                effects.Add($"{card.specialDigivolve}");
+
+            if(card.effect != "-")
+                effects.Add($"{card.effect}");
+
+            if(card.digiXros != "-")
+                effects.Add($"{card.digiXros}");
+
+            if (effects.Count > 0)
+            {
+                effect = "";
+
+                string lastEffect = effects.Last();
+                foreach (string e in effects)
+                {
+                    effect += $"{e}";
+
+                    if (!e.Equals(lastEffect))
+                        effect += "\n\n";
+                }
+                
+            }
+
+            return effect;
+        }
+        //Parse card info split by "/" to list
+        List<string> GetCardInfo(string str, string rule = "")
+        {
+            List<string> strings = new List<string>();
+
+            foreach (string data in str.Split("/"))
+            {
+                strings.Add(data.Replace("\n","").Replace("\r", "").Replace("(App Name)", "").Trim());
+            }
+
+            if (!String.IsNullOrEmpty(rule))
+                strings.AddRange(GetRuleTrait(rule));
+
+            string debugTxt = "";
+            foreach (string data in strings)
+                debugTxt += data + "\n";
+
+            return strings;
+        }
+
+        //Parse RULE text
+        List<string> GetRuleTrait(string str)
+        {
+            List<string> strings = new List<string>();
+
+            if (!str.Contains("[Rule] Trait:"))
+                return new List<string>();
+
+            string traitRule = str.Split("[Rule] Trait:")[1];
+            int startIndex = traitRule.IndexOf("[");
+            traitRule = traitRule.Substring(startIndex, traitRule.LastIndexOf("]") - startIndex)
+                .Replace("[","")
+                .Replace("]", "");
+       
+            foreach (string data in traitRule.Split("/"))
+                strings.Add(data.Trim().Replace("\n", "").Replace("\r", ""));
+
+            return strings;
+        }
+
+        //[Rule] You can include up to 50 copies of cards with this card's card number in your deck.
+        int GetRuleMaxCount(string str)
+        {
+            int totalCount = 4;
+
+            if (!str.Contains("[Rule] You can include up to"))
+                return totalCount;
+
+            string splitString = str.Split("[Rule] You can include up to")[1];
+            string valueString = splitString.Replace("copies of cards with this card's card number in your deck.", "");
+            int value = int.Parse(valueString.Trim());
+
+            return value;
+        }
+
+        //Parse digivolve conditions to list
+        List<EvoCost> GetEvoCosts(List<DigivolveCondition> digivolveConditions, List<CardColor> cardColors)
+        {
+            List<EvoCost> evoCosts = new List<EvoCost>();
+
+            foreach (DigivolveCondition digivolveCondition in digivolveConditions)
+            {
+                if (digivolveCondition.color.ToLower() == "all")
+                {
+                    if (int.TryParse(digivolveCondition.level, out _))
+                    {
+                        foreach (CardColor color in DataBase.cardColors)
+                        {
+                            if (color == CardColor.White || color == CardColor.None)
+                                continue;
+
+                            EvoCost evoCost = new EvoCost();
+
+                            evoCost.CardColor = color;
+
+                            evoCost.Level = int.Parse(digivolveCondition.level);
+                            evoCost.MemoryCost = int.Parse(digivolveCondition.cost);
+
+                            evoCosts.Add(evoCost);
+                        }
+                    }
+                }
+                else
+                {
+                    EvoCost evoCost = new EvoCost();
+
+                    if (digivolveCondition.color.ToLower() == "")
+                        evoCost.CardColor = cardColors[0];
+                    else
+                        evoCost.CardColor = DictionaryUtility.GetCardColor(digivolveCondition.color.ToLower(), DataBase.CardColorNameDictionary);
+
+                    evoCost.MemoryCost = int.Parse(digivolveCondition.cost);
+
+                    if (digivolveCondition.level != "Tamer")
+                    {
+                        evoCost.Level = int.Parse(digivolveCondition.level);
+                        evoCosts.Add(evoCost);
+                    }
+                }
+            }
+
+            return evoCosts;
+        }
+
+        //Parse card colors to list
+        List<CardColor> GetCardColors(string colors)
+        {
+            List<CardColor> cardColors = new List<CardColor>();
+
+            foreach (string cardColorName in colors.Split("/"))
+            {
+                foreach (string cardColorNameValues in DataBase.CardColorNameDictionary.Values)
+                {
+                    if (cardColorName.ToLower().Trim() == cardColorNameValues)
+                    {
+                        cardColors.Add(DictionaryUtility.GetCardColor(cardColorName.ToLower().Trim(), DataBase.CardColorNameDictionary));
+                    }
+                }
+            }
+
+            return cardColors;
+        }
+
+        //Parse overflow memory
+        int GetOverflowMemory(string aceEffect)
+        {
+            int value = 0;
+
+            if(aceEffect != "-")
+            {
+                int startIndex = aceEffect.IndexOf("\uff1c") + 1;
+                int endIndex = aceEffect.IndexOf("\uff1e") - startIndex;
+                string overflowMemory = aceEffect.Substring(startIndex, endIndex);
+
+                if (int.TryParse(overflowMemory, out value))
+                    return Math.Abs(value);
+            }
+
+            return value;
+        }
+
+        //Parse Max count in deck
+        int GetMaxCount(string restriction, string rule)
+        {
+            int value = 4;
+
+            if (!String.IsNullOrEmpty(rule))
+                value = GetRuleMaxCount(rule);
+
+            if (restriction == "Banned")
+                value = 0;
+
+            if(restriction.StartsWith("Restricted"))
+                value = int.Parse(restriction.Substring(restriction.Length-1));
+
+            return value;
+        }
+
+        //Parse Link Cost
+        int GetLinkCost(string requirement)
+        {
+            int value = 0;
+
+            if (requirement.Equals("-"))
+                return value;
+
+            string costString = requirement.Split("Cost")[1].Trim();
+
+            if (int.TryParse(costString, out value))
+                return value;
+
+            return value;
+        }
+
+        int intParse(string str)
+        {
+            int value = 0;
+
+            if (int.TryParse(str, out value))
+                return value;
+
+            return value;
+        }
+
+        int dpParse(string str)
+        {
+            int value = 0;
+
+            if (str.Equals("-"))
+                return value;
+
+            if (int.TryParse(str.Substring(1, str.Length - 4), out value))
+                return value;
+
+            if (str.StartsWith("-"))
+                value *= -1;
+
+            return value;
+        }
+
+        int levelParse(string str)
+        {
+            int value = 0;
+
+            if (str.Contains("Lv") && int.TryParse(str.Substring(3, 1), out value))
+                return value;
+
+            return value;
+        }
+        #endregion
+
+        #region Attempt to load Image
+        bool GetImage(string ID)
+        {
+            string imgURL = $"{baseURL}assets/images/cards/{ID}.webp";
+
+            Debug.Log(imgURL);
+            try
+            {
+                WebClient wc = new WebClient();
+                string HTMLSource = wc.DownloadString(imgURL);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Debug.LogWarning(ex.Message);
+                return false;
+            }
+        }
+        #endregion
+    }
+}

Assets/Editor/JSONLoader_CardEntity.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3df56444aa4cb8c458614eaa845f7245
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ce495ac44d53f0547a7ee9c98df33f39
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT19.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 99a6fc2e76b5c464c932cb3b102c9ff6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT19/Blue.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4e837457a3405df4c9014cb22abe81e2
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT19/Blue/Tamer.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f0f8f44665847d149ae65996e917d17d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT19/Blue/Tamer/BT19_081_P0.asset

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4d2c5fa3aebb9e5bf360f156d015ad83ae6a684b02b17a291a6bff6c10553520
+size 1445

Assets/Editor/Missing AAs/BT19/Blue/Tamer/BT19_081_P0.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 966e744eebaaad849a63975c7f62533e
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT19/Red.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: dc8d002785e83b54cafccc38b8b5c87a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT19/Red/Tamer.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 40bdb6923647dd24eb20f79c2941fd24
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT19/Red/Tamer/BT19_079_P0.asset

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:007d9041a27cd15f7488c2bba545df9ed463446c717f951fea4968300c7ecd9c
+size 1351

Assets/Editor/Missing AAs/BT19/Red/Tamer/BT19_079_P0.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0dd4898cf899c7740b0121461be7e1d7
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 55c76b89e4f88ad4b8db16d4cc02cd8e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Black.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4959c0672dabbed4ba7cabd8e52e87ea
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Black/Digimon.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 46abbd1ecc8e8b545acac9a189bde474
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Black/Digimon/BT20_048_P0.asset

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d7398d551c2954fba6473de5aad49939c7074d9b773b0be2c071bd391973d663
+size 1452

Assets/Editor/Missing AAs/BT20/Black/Digimon/BT20_048_P0.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 718b56900ab2bc94fb945dccf0a932cb
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Black/Digimon/BT20_052_P0.asset

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:26b84800183855310cc60979e49f8dded7ce6b25e71b076897c2c80f0fa6741a
+size 1561

Assets/Editor/Missing AAs/BT20/Black/Digimon/BT20_052_P0.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5a1b5b17ee32289498c39e791366d556
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Black/Digimon/BT20_053_P1.asset

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4bd550b714ca221546a61dfdd6bbeff840a9194afcd489baed5e994021621321
+size 1637

Assets/Editor/Missing AAs/BT20/Black/Digimon/BT20_053_P1.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f6abc206dbd83424f9ac64829cca4576
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Black/Digimon/BT20_057_P0.asset

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:862f46dda1149fd748cb5e69b292039a831df6c2b945bca79c78c5050f316140
+size 1530

Assets/Editor/Missing AAs/BT20/Black/Digimon/BT20_057_P0.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 31c91dfc0b2957a41aa92783bbd38def
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Black/Digimon/BT20_058_P0.asset

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c4611f537d1dca693adda5479790d5e0918bc050c7a421544260a915c458fc3f
+size 1433

Assets/Editor/Missing AAs/BT20/Black/Digimon/BT20_058_P0.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d0654dce2558a4a4e8f56595cefe5125
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Black/Digimon/BT20_059_P0.asset

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:df1d7efc2c199b328afb02d93d2ba77c83d86c4cedb2dc3130ab9be6bf1f9764
+size 1746

Assets/Editor/Missing AAs/BT20/Black/Digimon/BT20_059_P0.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b88c09d23f02ab4419b8e977e5020225
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Black/Tamer.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c63b31e7669a86444b7b4999f9911bb5
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Black/Tamer/BT20_086_P0.asset

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:80f3664c2cf366ee8eb255fcf37096a35becf5206e848a8904da722bdb7272ea
+size 1376

Assets/Editor/Missing AAs/BT20/Black/Tamer/BT20_086_P0.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: dd464128d0d13bb44b0ae7fc4b1e21f9
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Black/Tamer/BT20_087_P0.asset

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d0a438ae8e677afaba96a79bdf4e0f0046dd0b928a5edb6cd3e1a3290d1406a2
+size 1395

Assets/Editor/Missing AAs/BT20/Black/Tamer/BT20_087_P0.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1f7a1e904b8cdfa4dbd507fdaa26bc4d
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Blue.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ebf053b7cd221df449babe4bb1d269ed
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Blue/Digimon.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 892322fd2dd766f42b303ae5bc51ccc6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Blue/Digimon/BT20_025_P0.asset

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0a240bcd84d1c9805dc9efce4677a9ec5f8375f363dd8340b176ff06a8bf896f
+size 1368

Assets/Editor/Missing AAs/BT20/Blue/Digimon/BT20_025_P0.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d49751c6b2156914abdb081080defb4f
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Blue/Digimon/BT20_026_P0.asset

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:037a93a41d340d5ce3fa9881e8f060b88f53b29659ad30de431e863300baaa06
+size 1452

Assets/Editor/Missing AAs/BT20/Blue/Digimon/BT20_026_P0.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5774ba37f42009549bdcdfc9a0f3f638
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Green.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 000332faa9e841e428d15e95cca656b1
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Green/Digimon.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8dffb3704ef7e254baa7de8fc6efb6b8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Green/Digimon/BT20_042_P0.asset

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c6b433f46c9517c0aebfa81db46af90bb2518659098cb355f4837ed75ac3479d
+size 1539

Assets/Editor/Missing AAs/BT20/Green/Digimon/BT20_042_P0.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9b3b7b296a6c0fc41bb3d9a3e047d036
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Green/Digimon/BT20_043_P0.asset

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5ba6e00710086bae029d112116d7de159f2e4771ba021fa1dd645cee06c5c0e
+size 1732

Assets/Editor/Missing AAs/BT20/Green/Digimon/BT20_043_P0.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c600ef5a0b535d044a48e3a17b721d03
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Green/Tamer.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: fba269762477cb64a9adec7379bb93cd
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Green/Tamer/BT20_085_P0.asset

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8f282bcd50c557937679688286894087b30bda766b5c5accb121b9fa60a25b9f
+size 1559

Assets/Editor/Missing AAs/BT20/Green/Tamer/BT20_085_P0.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b2bcda8ace052084fb84a79f36a121f5
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Purple.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: eedb0cb7129dc4542aaad0eda4882e39
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Purple/Digimon.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9576fbf576e364f4d899f12feef14cad
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Purple/Digimon/BT20_063_P0.asset

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:664e1364bca67a3d5b293363b500eaa2467d5fd5eeba3ee6f5f6d61f62405401
+size 1281

Assets/Editor/Missing AAs/BT20/Purple/Digimon/BT20_063_P0.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f089ef32433c551478e9a04d51271898
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Purple/Digimon/BT20_064_P0.asset

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e77c9a81df4434196a5632e6dbc72e3ece22d306a4fd6cb0560a63cd0a892d03
+size 1428

Assets/Editor/Missing AAs/BT20/Purple/Digimon/BT20_064_P0.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: dd156453dd901574783bf6c86f82bc55
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Editor/Missing AAs/BT20/Purple/Digimon/BT20_068_P1.asset

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:825097d6a0cc80cfe00d4ad554e5d0376fc50899b834f8556cff60586d0ccaa7
+size 1213