public static bool ConfirmFeature(FeatureBuilder feature, string methodName) { const ConsoleColor ColorPrompt = Log.ColorPrompt; const ConsoleColor ColorSelection = Log.ColorPrintInfo; string name = feature.FeatureName; string type = feature.FeatureType; void LogSelection(string prompt, string selection) { Log.Write(prompt, ColorPrompt); Log.WriteLine(selection, ColorSelection); } Log.WriteLine(); LogSelection("FEATURE NAME: ", name); LogSelection("FEATURE TYPE: ", type); LogSelection("CLASS NAME: ", feature.ClassName); LogSelection("TEMPLATE NAME: ", feature.TemplateName); LogSelection("METHOD NAME: ", $"{methodName}()"); Log.WriteLine(); Log.Write("Type ", ColorPrompt); Log.Write("Y", ColorSelection); Log.Write("/", ColorPrompt); Log.Write("y", ColorSelection); Log.WriteLine(" to confirm.", ColorPrompt); string line = Log.ReadStringFromConsole(); Log.WriteLine(); bool ret = line.Equals("y", StringComparison.InvariantCultureIgnoreCase); return(ret); }
/// <summary> /// Attaches a new feature to a given the Unity object of a given Object Pool /// by adding an entry for the given feature's prefab to the metadata /// of the Object Pool. /// </summary> /// <param name="feature">The feature to add.</param> /// <param name="guidPrefab">The GUID of the new feature's prefab.</param> /// <param name="fileId">The file ID of the new feature's prefab.</param> private static void AppendPoolListPrefabData(FeatureBuilder feature, string guidPrefab, string fileId) { string poolPrefabPath = feature.PathObjectPool.Prefab; string featureName = feature.FeatureName; Debug.Assert(File.Exists(poolPrefabPath)); string prefabToAdd = $" {featureName}Prefab: {{fileID: {fileId}, guid: {guidPrefab},\r\n type: 3}}\r\n"; File.AppendAllText(poolPrefabPath, prefabToAdd); }
/// <summary> /// Inserts a given GUID into the metadata file of a given feature's /// code template file, then writes the results to its proper destination. /// </summary> /// <param name="feature">The feature to add.</param> /// <param name="guidCs">The GUID to insert.</param> private static void WriteCsMetaContents(FeatureBuilder feature, string guidCs) { string templatePath = feature.PathTemplate.CsMeta; string csMetaDestination = feature.PathDestination.CsMeta; Debug.Assert(File.Exists(templatePath)); Debug.Assert(!File.Exists(csMetaDestination)); string contents = File.ReadAllText(templatePath); contents = contents.Replace(TagGuidCS, guidCs); File.WriteAllText(csMetaDestination, contents); }
/// <summary> /// Inserts a given GUID and file ID into the prefab file of a given feature, /// then writes the results to its proper destination. /// </summary> /// <param name="feature">The feature to add.</param> /// <param name="guidCs">The GUID to insert.</param> /// <param name="fileId">The file ID to insert.</param> private static void WritePrefabContents(FeatureBuilder feature, string guidCs, string fileId) { string templatePath = feature.PathTemplate.Prefab; string prefabDestination = feature.PathDestination.Prefab; Debug.Assert(File.Exists(templatePath)); Debug.Assert(!File.Exists(prefabDestination)); StringBuilder sb = StringBuilderFromFile(templatePath); sb.Replace(TagFileId, fileId); sb.Replace(TagGuidCS, guidCs); string contents = sb.ToString(); File.WriteAllText(prefabDestination, contents); }
/// <summary> /// Generates a new GUID and File ID for a given feature. /// Then, it uses this information to copy a metadata file, a prefab file, /// and a prefab metadata file based on the feature's information. /// </summary> public static void CopyPrefabData(FeatureBuilder feature) { FileInfo csFileInfo = new FileInfo(feature.PathTemplate.Cs); #region Assert Debug.Assert(csFileInfo.Exists); Debug.Assert(csFileInfo.Extension == ".cs"); Debug.Assert(Directory.Exists(feature.DirDestination)); #endregion Assert string guidCs = NewGuid(); string guidPrefab = NewGuid(); string fileId = NewFileId(); WriteCsMetaContents(feature, guidCs); WritePrefabContents(feature, guidCs, fileId); WritePrefabMetaContents(feature, guidPrefab); AppendPoolListPrefabData(feature, guidPrefab, fileId); }
/// <summary> /// Reads a feature's template file, /// replaces the template name inside file with the feature's name, /// and writes the feature file to its destination. /// </summary> public static void CopyNewFeatureCsFile(FeatureBuilder feature) { string templateFilePath = feature.PathTemplate.Cs; string destinationDirectory = feature.DirDestination; string destinationPath = feature.PathDestination.Cs; string featureName = feature.FeatureName; string templateName = feature.TemplateName; #region Assert FileInfo fileInfo = new FileInfo(templateFilePath); Debug.Assert(fileInfo.Exists); Debug.Assert(fileInfo.Extension == ".cs"); Debug.Assert(Directory.Exists(destinationDirectory)); Debug.Assert(!File.Exists(destinationPath)); #endregion Assert string fileContents = feature.ReadTemplateCsFileContents(); fileContents = fileContents.Replace(templateName, featureName); File.WriteAllText(destinationPath, fileContents); AddCsFileToProjectCompile(feature); }
/// <summary> /// Adds a given feature's source code file path /// to the project's compilation files list. /// </summary> public static void AddCsFileToProjectCompile(FeatureBuilder feature) { string filePath = feature.PathDestination.Cs; string filePathTrimmed = filePath.Replace(UnityPaths.DirProject, ""); string pathCsProj = UnityPaths.PathCsproj; #region Assert Debug.Assert(File.Exists(filePath)); Debug.Assert(File.Exists(pathCsProj)); Debug.Assert(filePathTrimmed.StartsWith("Assets\\")); Debug.Assert(filePathTrimmed.EndsWith(".cs")); #endregion Assert string[] lines = File.ReadAllLines(pathCsProj); int endTagLine = FindCsprojCompilationItemGroupLine(lines); const string CompileTagStart = " <Compile Include=\""; const string CompileTagEnd = "\" />"; string compileTag = $"{CompileTagStart}{filePathTrimmed}{CompileTagEnd}"; InsertLineToFile(pathCsProj, lines, compileTag, endTagLine, true); }
/// <summary> /// Adds a variable for a feature's prefab inside the appropriate Object Pool file. /// </summary> /// <param name="feature">The feature to add.</param> public static void AppendPrefabVariableToPoolListCs(FeatureBuilder feature) { string filePath = feature.PathObjectPool.Cs; Debug.Assert(File.Exists(filePath)); string endTag = feature.TagPrefab; string featureName = feature.FeatureName; string className = feature.ClassName; string[] lines = File.ReadAllLines(filePath); int endTagLine = FindEndTagLine(endTag, lines, filePath); #region Assert // Assert coding style - one line of blank space // between last prefab and end tag. string _blankLine = lines[endTagLine + 1]; string _lastPrefabLine = lines[endTagLine]; Debug.Assert(String.IsNullOrWhiteSpace(_blankLine)); Debug.Assert(!String.IsNullOrWhiteSpace(_lastPrefabLine)); #endregion Assert const string SerializeTag = " [SerializeField]"; const string Private = " private"; string variableName = $"{featureName}Prefab"; string variableLine = $"{Private} {className} {variableName} = null;"; string[] linesToAdd = new string[] { SerializeTag, variableLine }; int insertLineNumber = endTagLine - 1; InsertLinesToFile(filePath, lines, linesToAdd, insertLineNumber, true); }
public static void LogProgress(string descriptor, FeatureBuilder feature) { Log.WriteLine($"Adding {descriptor} {feature.ClassName}...", Log.ColorMetaInfo); }
public static void LogProgress(FeatureBuilder feature) { Log.WriteLine($"Adding {feature.ClassName}...", Log.ColorMetaInfo); }
public static void AddFeatureWithPrefab(FeatureBuilder feature) { FileUtil.CopyNewFeatureCsFile(feature); PrefabUtil.CopyPrefabData(feature); FileUtil.AppendPrefabVariableToPoolListCs(feature); }