public static bool DoesSheetContainImages(CastleDBParser.RootNode rootNode, CastleDBParser.SheetNode sheetNode)
        {
            Debug.Log(sheetNode.Name);

            for (int i = 0; i < sheetNode.Columns.Count; i++)
            {
                CastleDBParser.ColumnNode column = sheetNode.Columns[i];
                string typeNum = GetTypeNumFromCastleDBTypeString(column.TypeStr);

                if (typeNum == "7")
                {
                    return(true);
                }
                else if (typeNum == "6")
                {
                    string refType  = GetTypeFromCastleDBColumn(column);
                    var    refSheet = rootNode.GetSheetWithName(refType);
                    Debug.Log(refType);
                    return(DoesSheetContainImages(rootNode, refSheet));
                }
                else if (typeNum == "8")
                {
                    var refSheet = rootNode.GetSheetWithName(column.Name);
                    Debug.Log(column.Name);
                    return(DoesSheetContainImages(rootNode, refSheet));
                }
            }

            return(false);
        }
        public static void GenerateTypes(CastleDBParser.RootNode root, CastleDBConfig configFile, string dbname)
        {
            // Create scripts
            List <string>  scripts     = new List <string>();
            CastleDBConfig config      = configFile;
            String         FieldIndent = "        ";

            InitTypePath(config);
            InitPath(configFile.GeneratedTypesLocation + $"/{dbname}/");
            foreach (CastleDBParser.SheetNode sheet in root.Sheets)
            {
                string scriptPath = $"Assets/{config.GeneratedTypesLocation}/{dbname}/{sheet.Name}.cs";
                scripts.Add(scriptPath);

                //generate fields
                string fieldText = "";
                for (int i = 0; i < sheet.Columns.Count; i++)
                {
                    fieldText += FieldIndent;
                    CastleDBParser.ColumnNode column = sheet.Columns[i];
                    string fieldType = CastleDBUtils.GetTypeFromCastleDBColumn(column);
                    if (fieldType != "Enum") //non-enum, normal field
                    {
                        if (CastleDBUtils.GetTypeNumFromCastleDBTypeString(column.TypeStr) == "8")
                        {
                            fieldText += ($"public List<{fieldType}> {column.Name}List = new List<{fieldType}>();");
                        }
                        else
                        {
                            fieldText += ($"public {fieldType} {column.Name};");
                        }
                    }
                    else //enum type
                    {
                        string[] enumValueNames = CastleDBUtils.GetEnumValuesFromTypeString(column.TypeStr);
                        string   enumEntries    = "";
                        if (CastleDBUtils.GetTypeNumFromCastleDBTypeString(column.TypeStr) == "10") //flag
                        {
                            fieldText += ($"public {column.Name}Flag {column.Name};");
                            for (int val = 0; val < enumValueNames.Length; val++)
                            {
                                enumEntries += (enumValueNames[val] + " = " + (int)Math.Pow(2, val));
                                if (val + 1 < enumValueNames.Length)
                                {
                                    enumEntries += ",";
                                }
                                ;
                            }
                            fieldText += ($"[FlagsAttribute] public enum {column.Name}Flag {{ {enumEntries} }}");
                        }
                        else
                        {
                            fieldText += ($"public {column.Name}Enum {column.Name};");
                            for (int val = 0; val < enumValueNames.Length; val++)
                            {
                                enumEntries += (enumValueNames[val] + " = " + val);
                                if (val + 1 < enumValueNames.Length)
                                {
                                    enumEntries += ",";
                                }
                                ;
                            }
                            fieldText += ($"public enum {column.Name}Enum {{  {enumEntries} }}");
                        }
                    }

                    fieldText += "\r\n";
                }

                #region ("Row Values Field")
                string possibleValuesText = "";
                if (!sheet.NestedType)
                {
                    possibleValuesText += $"public enum RowValues {{";

                    for (int i = 0; i < sheet.Rows.Count; i++)
                    {
                        string rowName = sheet.Rows[i][config.GUIDColumnName];
                        possibleValuesText += rowName;
                        if (i + 1 < sheet.Rows.Count)
                        {
                            possibleValuesText += " , ";
                        }
                    }
                    possibleValuesText += " }\r\n";
                }
                #endregion

                //generate the constructor that sets the fields based on the passed in value
                string constructorText   = "";
                string constructorIndent = "            ";
                if (!sheet.NestedType)
                {
                    constructorText += $"{constructorIndent}SimpleJSON.JSONNode node = root.GetSheetWithName(\"{sheet.Name}\").Rows[(int)line];\r\n";
                }
                for (int i = 0; i < sheet.Columns.Count; i++)
                {
                    constructorText += constructorIndent;
                    CastleDBParser.ColumnNode column = sheet.Columns[i];
                    string castText = CastleDBUtils.GetCastStringFromCastleDBTypeStr(column.TypeStr);
                    string enumCast = "";
                    string typeNum  = CastleDBUtils.GetTypeNumFromCastleDBTypeString(column.TypeStr);
                    if (typeNum == "8")
                    {
                        //list type
                        constructorText += $"foreach(var item in node[\"{column.Name}\"]) {{ {column.Name}List.Add(new {column.Name}(root, item));}}";
                    }
                    else if (typeNum == "6")
                    {
                        //working area:
                        //ref type
                        string refType = CastleDBUtils.GetTypeFromCastleDBColumn(column);
                        //look up the line based on the passed in row
                        constructorText += $"{column.Name} = new {refType}(root,{refType}.GetRowValue(node[\"{column.Name}\"]));";
                    }
                    else if (typeNum == "7") // Image
                    {
                        constructorText += $"{column.Name} = Resources.Load<Texture>(node[\"{column.Name}\"]) as Texture;";
                    }
                    else if (typeNum == "11") // Color
                    {
                        constructorText += $"{column.Name} = CastleDBUtils.GetColorFromString( node[\"{column.Name}\"]);";
                    }
                    else
                    {
                        if (typeNum == "10")
                        {
                            enumCast = $"({column.Name}Flag)";
                        }
                        else if (typeNum == "5")
                        {
                            enumCast = $"({column.Name}Enum)";
                        }
                        constructorText += $"{column.Name} = {enumCast}node[\"{column.Name}\"]{castText};";
                    }

                    constructorText += "\r\n";
                }



                string getMethodText = "";
                if (!sheet.NestedType)
                {
                    getMethodText += $@"
        public static {sheet.Name}.RowValues GetRowValue(string name)
        {{
            var values = (RowValues[])Enum.GetValues(typeof(RowValues));
            for (int i = 0; i < values.Length; i++)
            {{
                if(values[i].ToString() == name)
                {{
                    return values[i];
                }}
            }}
            return values[0];
        }}";
                }

                string ctor = "";
                if (!sheet.NestedType)
                {
                    ctor = $"public {sheet.Name} (CastleDBParser.RootNode root, RowValues line)";
                }
                else
                {
                    ctor = $"public {sheet.Name} (CastleDBParser.RootNode root, SimpleJSON.JSONNode node)";
                }
                // string usings = "using UnityEngine;\r\n using System;\r\n using System.Collections.Generic;\r\n using SimpleJSON;\r\n using CastleDBImporter;\r\n";
                string fullClassText = $@"
using UnityEngine;
using System;
using System.Collections.Generic;
using SimpleJSON;
using CastleDBImporter;
using {config.GeneratedTypesNamespace}.{dbname};

namespace {config.GeneratedTypesNamespace}.{dbname}
{{ 
    public class {sheet.Name}
    {{
{fieldText}
        {possibleValuesText} 
        {ctor} 
        {{
{constructorText}
        }}  
        {getMethodText}
    }}
}}";
                if (!config.SuppressBuildInfo)
                {
                    Debug.Log("Generating CDB Class: " + sheet.Name);
                }

                File.WriteAllText(scriptPath, fullClassText);
            }

            //build the CastleDB file
            string cdbscriptPath = $"Assets/{config.GeneratedTypesLocation}/{dbname}/{dbname}.cs";
            scripts.Add(cdbscriptPath);
            //fields
            string cdbfields          = "";
            string cdbconstructorBody = "";
            string classTexts         = "";
            foreach (CastleDBParser.SheetNode sheet in root.Sheets)
            {
                if (sheet.NestedType)
                {
                    continue;
                }                               //only write main types to CastleDB
                cdbfields          += $"        public {sheet.Name}Type {sheet.Name};\r\n";
                cdbconstructorBody += $"            {sheet.Name} = new {sheet.Name}Type();\r\n";

                //get a list of all the row names
                classTexts += $"        public class {sheet.Name}Type \r\n        {{\r\n";
                for (int i = 0; i < sheet.Rows.Count; i++)
                {
                    string rowName = sheet.Rows[i][config.GUIDColumnName];
                    classTexts += $"           public {sheet.Name} {rowName} {{ get {{ return Get({configFile.GeneratedTypesNamespace}.{dbname}.{sheet.Name}.RowValues.{rowName}); }} }} \r\n";
                }

                classTexts += $"           private {sheet.Name} Get({sheet.Name}.RowValues line) {{ return new {sheet.Name}(parsedDB.Root, line); }}\r\n";
                classTexts += $@"
           public {sheet.Name}[] GetAll() 
           {{
               var values = ({sheet.Name}.RowValues[])Enum.GetValues(typeof({sheet.Name}.RowValues));
               {sheet.Name}[] returnList = new {sheet.Name}[values.Length];
               for (int i = 0; i < values.Length; i++)
               {{
                   returnList[i] = Get(values[i]);
               }}
               return returnList;
           }}";
                classTexts += $"\r\n        }} //END OF {sheet.Name} \r\n\r\n";
            }

            string fullCastle = $@"
using UnityEngine;
using CastleDBImporter;
using System.Collections.Generic;
using System;
using {config.GeneratedTypesNamespace}.{dbname};

namespace {config.GeneratedTypesNamespace}.{dbname}
{{
    public class {dbname}
    {{
        static CastleDBParser parsedDB;
{cdbfields}
        
{classTexts}

        public {dbname}(TextAsset castleDBAsset)
        {{
            parsedDB = new CastleDBParser(castleDBAsset);
{cdbconstructorBody}
        }}
    }}
}}";
            if (!config.SuppressBuildInfo)
            {
                Debug.Log("Generating CastleDB class");

                if (CastleDBConfig.NamesHaveSpaces)
                {
                    Debug.Log("Your CastleDB file contains spaces in names! These spaces will be automatically converted to '_'.");
                }

                Debug.Log("To suppress log messages from import, check the CastleDBConfig flag 'Suppress Import Messages'");
            }

            File.WriteAllText(cdbscriptPath, fullCastle);
            AssetDatabase.Refresh();
        }
        public static void GenerateTypes(CastleDBParser.RootNode root, CastleDBConfig configFile)
        {
            // Create scripts
            List <string>  scripts = new List <string>();
            CastleDBConfig config  = configFile;

            InitTypePath(config);

            foreach (CastleDBParser.SheetNode sheet in root.Sheets)
            {
                Debug.Log("Doinog: " + sheet.Name);
                string scriptPath = $"Assets/{config.GeneratedTypesLocation}/{sheet.Name}.cs";
                scripts.Add(scriptPath);

                //generate fields
                string fieldText = "";
                for (int i = 0; i < sheet.Columns.Count; i++)
                {
                    CastleDBParser.ColumnNode column = sheet.Columns[i];
                    string fieldType = CastleDBUtils.GetTypeFromCastleDBColumn(column);
                    if (fieldType != "Enum") //non-enum, normal field
                    {
                        if (CastleDBUtils.GetTypeNumFromCastleDBTypeString(column.TypeStr) == "8")
                        {
                            fieldText += ($"public List<{fieldType}> {column.Name}List = new List<{fieldType}>();\n\t\t");
                        }
                        else
                        {
                            fieldText += ($"public {fieldType} {column.Name};\n\t\t");
                        }
                    }
                    else //enum type
                    {
                        string[] enumValueNames = CastleDBUtils.GetEnumValuesFromTypeString(column.TypeStr);
                        string   enumEntries    = "";
                        if (CastleDBUtils.GetTypeNumFromCastleDBTypeString(column.TypeStr) == "10") //flag
                        {
                            fieldText += ($"public {column.Name}Flag {column.Name};\n");
                            for (int val = 0; val < enumValueNames.Length; val++)
                            {
                                enumEntries += (enumValueNames[val] + " = " + (int)Math.Pow(2, val));
                                if (val + 1 < enumValueNames.Length)
                                {
                                    enumEntries += ",";
                                }
                                ;
                            }
                            fieldText += ($"[FlagsAttribute] public enum {column.Name}Flag {{ {enumEntries} }}");
                        }
                        else
                        {
                            fieldText += ($"public {column.Name}Enum {column.Name};\n");
                            for (int val = 0; val < enumValueNames.Length; val++)
                            {
                                enumEntries += (enumValueNames[val] + " = " + val);
                                if (val + 1 < enumValueNames.Length)
                                {
                                    enumEntries += ",";
                                }
                                ;
                            }
                            fieldText += ($"public enum {column.Name}Enum {{  {enumEntries} }}");
                        }
                    }
                }

                //generate the constructor that sets the fields based on the passed in value
                StringBuilder constructorText = new StringBuilder();


                for (int i = 0; i < sheet.Columns.Count; i++)
                {
                    CastleDBParser.ColumnNode column = sheet.Columns[i];
                    string castText = CastleDBUtils.GetCastStringFromCastleDBTypeStr(column.TypeStr);
                    string enumCast = "";
                    string typeNum  = CastleDBUtils.GetTypeNumFromCastleDBTypeString(column.TypeStr);
                    if (typeNum == "8")
                    {
                        //list type
                        if (CastleDBUtils.DoesSheetContainImages(root, root.GetSheetWithName(column.Name)))
                        {
                            constructorText.Append($"\t\t\tforeach(var item in node[\"{column.Name}\"]) {{ {column.Name}List.Add(new {column.Name}(root, item, DatabaseImages));}}\n");
                        }
                        else
                        {
                            constructorText.Append($"\t\t\tforeach(var item in node[\"{column.Name}\"]) {{ {column.Name}List.Add(new {column.Name}(root, item));}}\n");
                        }
                    }
                    else if (typeNum == "6")
                    {
                        //working area:
                        //ref type
                        string refType = CastleDBUtils.GetTypeFromCastleDBColumn(column);
                        //look up the line based on the passed in row
                        if (CastleDBUtils.DoesSheetContainImages(root, sheet))
                        {
                            constructorText.Append(
                                $"{column.Name} = new {config.GeneratedTypesNamespace}.{refType}(root, root.GetSheetWithName(\"{refType}\")." +
                                $"Rows.Find( pred => pred[\"{config.GUIDColumnName}\"] == node[\"{column.Name}\"]), DatabaseImages);\n"
                                );
                        }
                        else
                        {
                            constructorText.Append(
                                $"{column.Name} = new {config.GeneratedTypesNamespace}.{refType}(root, root.GetSheetWithName(\"{refType}\")." +
                                $"Rows.Find( pred => pred[\"{config.GUIDColumnName}\"] == node[\"{column.Name}\"]));\n"
                                );
                        }
                    }
                    else if (typeNum == "7") // Image type
                    {
                        constructorText.Append($"\t\t\t{column.Name} = DatabaseImages[node[\"{column.Name}\"]];\n");
                    }
                    else
                    {
                        if (typeNum == "10")
                        {
                            enumCast = $"({column.Name}Flag)";
                        }
                        else if (typeNum == "5")
                        {
                            enumCast = $"({column.Name}Enum)";
                        }
                        constructorText.Append($"\t\t\t{column.Name} = {enumCast}node[\"{column.Name}\"]{castText};\n");
                    }
                }

                string ctor = "";
                if (CastleDBUtils.DoesSheetContainImages(root, sheet))
                {
                    ctor = $"public {sheet.Name} (CastleDBParser.RootNode root, SimpleJSON.JSONNode node, Dictionary<string, Texture> DatabaseImages)";
                }
                else
                {
                    ctor = $"public {sheet.Name} (CastleDBParser.RootNode root, SimpleJSON.JSONNode node)";
                }
                string fullClassText = $@"
using UnityEngine;
using System;
using System.Collections.Generic;
using SimpleJSON;
using CastleDBImporter;
namespace {config.GeneratedTypesNamespace}
{{ 
    public class {sheet.Name}
    {{
        {fieldText}
        {ctor} 
        {{
            {constructorText}
        }} 
    }}
}}";
                Debug.Log("Generating CDB Class: " + sheet.Name);
                File.WriteAllText(scriptPath, fullClassText);
            }

            //build the CastleDB file
            string cdbscriptPath = $"Assets/{config.GeneratedTypesLocation}/CastleDB.cs";

            scripts.Add(cdbscriptPath);
            //fields
            string cdbfields          = "";
            string cdbconstructorBody = "";

            foreach (CastleDBParser.SheetNode sheet in root.Sheets)
            {
                if (sheet.NestedType)
                {
                    continue;
                }                                //only write main types to CastleDB
                cdbfields          += $"public Dictionary<string, {sheet.Name}> {sheet.Name};\n";
                cdbconstructorBody += $"{sheet.Name} = new Dictionary<string, {sheet.Name}>();\n";

                //get a list of all the row names
                cdbconstructorBody += $"\t\t\tforeach( var row in root.GetSheetWithName(\"{sheet.Name}\").Rows ) {{\n";

                if (CastleDBUtils.DoesSheetContainImages(root, sheet))
                {
                    cdbconstructorBody += $"\t\t\t\t{sheet.Name}[row[\"id\"]] = new {sheet.Name}(root, row, parsedDB.DatabaseImages);\n\t\t\t}}";
                }
                else
                {
                    cdbconstructorBody += $"\t\t\t\t{sheet.Name}[row[\"id\"]] = new {sheet.Name}(root, row);\n\t\t\t}}";
                }
            }

            string fullCastle = $@"
using UnityEngine;
using CastleDBImporter;
using System.Collections.Generic;
using System;

namespace {config.GeneratedTypesNamespace}
{{
    public class CastleDB
    {{
        static CastleDBParser parsedDB;
        {cdbfields}
        public CastleDB(TextAsset castleDBAsset, TextAsset castleDBImagesAsset = null)
        {{
            parsedDB = new CastleDBParser(castleDBAsset, castleDBImagesAsset);
            CastleDBParser.RootNode root = parsedDB.Root;
            { cdbconstructorBody }
        }}
    }}
}}";

            Debug.Log("Generating CastleDB class");
            File.WriteAllText(cdbscriptPath, fullCastle);
            AssetDatabase.Refresh();
        }
Exemple #4
0
        public static void GenerateTypes(CastleDBParser.RootNode root)
        {
            // Create scripts
            List <string> scripts = new List <string>();

            InitTypePath();

            foreach (CastleDBParser.SheetNode sheet in root.Sheets)
            {
                string scriptPath = $"Assets/{CastleDBParser.Config.GeneratedTypesLocation}/{sheet.Name}.cs";
                scripts.Add(scriptPath);

                //generate fields
                string fieldText = "";
                for (int i = 0; i < sheet.Columns.Count; i++)
                {
                    CastleDBParser.ColumnNode column = sheet.Columns[i];
                    string fieldType = CastleDBUtils.GetTypeFromCastleDBColumn(column);
                    if (fieldType != "Enum") //non-enum, normal field
                    {
                        if (CastleDBUtils.GetTypeNumFromCastleDBTypeString(column.TypeStr) == "8")
                        {
                            fieldText += ($"public List<{fieldType}> {column.Name}List = new List<{fieldType}>();\n");
                        }
                        else
                        {
                            fieldText += ($"public {fieldType} {column.Name};\n");
                        }
                    }
                    else //enum type
                    {
                        string[] enumValueNames = CastleDBUtils.GetEnumValuesFromTypeString(column.TypeStr);
                        string   enumEntries    = "";
                        if (CastleDBUtils.GetTypeNumFromCastleDBTypeString(column.TypeStr) == "10") //flag
                        {
                            fieldText += ($"public {column.Name}Flag {column.Name};\n");
                            for (int val = 0; val < enumValueNames.Length; val++)
                            {
                                enumEntries += (enumValueNames[val] + " = " + (int)Math.Pow(2, val));
                                if (val + 1 < enumValueNames.Length)
                                {
                                    enumEntries += ",";
                                }
                                ;
                            }
                            fieldText += ($"[FlagsAttribute] public enum {column.Name}Flag {{ {enumEntries} }}");
                        }
                        else
                        {
                            fieldText += ($"public {column.Name}Enum {column.Name};\n");
                            for (int val = 0; val < enumValueNames.Length; val++)
                            {
                                enumEntries += (enumValueNames[val] + " = " + val);
                                if (val + 1 < enumValueNames.Length)
                                {
                                    enumEntries += ",";
                                }
                                ;
                            }
                            fieldText += ($"public enum {column.Name}Enum {{  {enumEntries} }}");
                        }
                    }
                }

                //generate the constructor that sets the fields based on the passed in value
                string constructorText = "";
                if (!sheet.NestedType)
                {
                    constructorText += $"SimpleJSON.JSONNode node = root.GetSheetWithName(\"{sheet.Name}\").Rows[(int)line];\n";
                }
                for (int i = 0; i < sheet.Columns.Count; i++)
                {
                    CastleDBParser.ColumnNode column = sheet.Columns[i];
                    string castText = CastleDBUtils.GetCastStringFromCastleDBTypeStr(column.TypeStr);
                    string enumCast = "";
                    string typeNum  = CastleDBUtils.GetTypeNumFromCastleDBTypeString(column.TypeStr);
                    if (typeNum == "8")
                    {
                        //list type
                        constructorText += $"foreach(var item in node[\"{column.Name}\"]) {{ {column.Name}List.Add(new {column.Name}(root, item));}}\n";
                    }
                    else if (typeNum == "6")
                    {
                        //working area:
                        //ref type
                        string refType = CastleDBUtils.GetTypeFromCastleDBColumn(column);
                        //look up the line based on the passed in row
                        constructorText += $"{column.Name} = new {CastleDBParser.Config.GeneratedTypesNamespace}.{refType}(root,{CastleDBParser.Config.GeneratedTypesNamespace}.{refType}.GetRowValue(node[\"{column.Name}\"]));\n";
                    }
                    else
                    {
                        if (typeNum == "10")
                        {
                            enumCast = $"({column.Name}Flag)";
                        }
                        else if (typeNum == "5")
                        {
                            enumCast = $"({column.Name}Enum)";
                        }
                        constructorText += $"{column.Name} = {enumCast}node[\"{column.Name}\"]{castText};\n";
                    }
                }

                //need to construct an enum of possible types
                string possibleValuesText = "";
                if (!sheet.NestedType)
                {
                    possibleValuesText += $"public enum RowValues {{ \n";
                    foreach (var name in sheet.RowNames)
                    {
                        possibleValuesText += name;
                        if (sheet.RowNames.IndexOf(name) + 1 < sheet.RowNames.Count)
                        {
                            possibleValuesText += ", \n";
                        }
                    }
                    possibleValuesText += "\n }";
                }

                string getMethodText = "";
                if (!sheet.NestedType)
                {
                    getMethodText += $@"
public static {sheet.Name}.RowValues GetRowValue(string name)
{{
    var values = (RowValues[])Enum.GetValues(typeof(RowValues));
    for (int i = 0; i < values.Length; i++)
    {{
        if(values[i].ToString() == name)
        {{
            return values[i];
        }}
    }}
    return values[0];
}}";
                }

                string ctor = "";
                if (!sheet.NestedType)
                {
                    ctor = $"public {sheet.Name} (CastleDBParser.RootNode root, RowValues line)";
                }
                else
                {
                    ctor = $"public {sheet.Name} (CastleDBParser.RootNode root, SimpleJSON.JSONNode node)";
                }
                // string usings = "using UnityEngine;\n using System;\n using System.Collections.Generic;\n using SimpleJSON;\n using CastleDBImporter;\n";
                string fullClassText = $@"
using UnityEngine;
using System;
using System.Collections.Generic;
using SimpleJSON;
using CastleDBImporter;
namespace {CastleDBParser.Config.GeneratedTypesNamespace}
{{ 
    public class {sheet.Name}
    {{
        {fieldText}
        {possibleValuesText} 
        {ctor} 
        {{
            {constructorText}
        }}  
        {getMethodText}
    }}
}}";
                Debug.Log("Generating CDB Class: " + sheet.Name);
                File.WriteAllText(scriptPath, fullClassText);
            }

            //build the CastleDB file
            string cdbscriptPath = $"Assets/{CastleDBParser.Config.GeneratedTypesLocation}/CastleDB.cs";

            scripts.Add(cdbscriptPath);
            //fields
            string cdbfields          = "";
            string cdbconstructorBody = "";
            string classTexts         = "";

            foreach (CastleDBParser.SheetNode sheet in root.Sheets)
            {
                if (sheet.NestedType)
                {
                    continue;
                }                               //only write main types to CastleDB
                cdbfields          += $"public {sheet.Name}Type {sheet.Name};\n";
                cdbconstructorBody += $"{sheet.Name} = new {sheet.Name}Type();";

                //get a list of all the row names
                classTexts += $"public class {sheet.Name}Type \n {{";
                foreach (var name in sheet.RowNames)
                {
                    classTexts += $"public {sheet.Name} {name} {{ get {{ return Get({CastleDBParser.Config.GeneratedTypesNamespace}.{sheet.Name}.RowValues.{name}); }} }} \n";
                }

                classTexts += $"private {sheet.Name} Get({CastleDBParser.Config.GeneratedTypesNamespace}.{sheet.Name}.RowValues line) {{ return new {sheet.Name}(parsedDB.Root, line); }}\n";
                classTexts += $@"
                public {sheet.Name}[] GetAll() 
                {{
                    var values = ({CastleDBParser.Config.GeneratedTypesNamespace}.{sheet.Name}.RowValues[])Enum.GetValues(typeof({CastleDBParser.Config.GeneratedTypesNamespace}.{sheet.Name}.RowValues));
                    {sheet.Name}[] returnList = new {sheet.Name}[values.Length];
                    for (int i = 0; i < values.Length; i++)
                    {{
                        returnList[i] = Get(values[i]);
                    }}
                    return returnList;
                }}";
                classTexts += $"\n }} //END OF {sheet.Name} \n";
            }

            string fullCastle = $@"
using UnityEngine;
using CastleDBImporter;
using System.Collections.Generic;
using System;

namespace {CastleDBParser.Config.GeneratedTypesNamespace}
{{
    public class CastleDB
    {{
        static CastleDBParser parsedDB;
        {cdbfields}
        public CastleDB(TextAsset castleDBAsset)
        {{
            parsedDB = new CastleDBParser(castleDBAsset);
            {cdbconstructorBody}
        }}
        {classTexts}
    }}
}}";

            Debug.Log("Generating CastleDB class");
            File.WriteAllText(cdbscriptPath, fullCastle);
            AssetDatabase.Refresh();
        }