public static (Entity, List <string>) Main() { var fileTree = new List <KeyValuePair <int, object> >(); var values = new List <string>(); var crimes = new NativeList <EntityWrapper>(Allocator.Temp); var crimeNames = new List <string>(); var em = World.Active.EntityManager; FileUnpacker.ParseFile(Path.Combine(Application.streamingAssetsPath, "Common", "crime.txt"), fileTree, values, CrimeMagicOverride); using (var parentLocation = new NativeMultiHashMap <int, int>(1, Allocator.Temp)) { foreach (var crimeKvp in fileTree) { var crimeRanges = new List <DataRange>(); var crimeActions = new List <DataValue>(); parentLocation.Add(crimeKvp.Key, crimeRanges.Count); crimeRanges.Add(new DataRange(crimeKvp.Key, -1, -1)); FileUnpacker.ProcessQueue(crimeKvp, crimeActions, crimeRanges, parentLocation, values, (s, pair) => false); var currentCrime = crimes[crimeKvp.Key - (int)MagicUnifiedNumbers.Placeholder]; using (var tempRange = new NativeArray <DataRange>(crimeRanges.ToArray(), Allocator.TempJob)) { em.AddBuffer <DataRange>(currentCrime).AddRange(tempRange); } using (var tempValues = new NativeArray <DataValue>(crimeActions.ToArray(), Allocator.TempJob)) { em.AddBuffer <DataValue>(currentCrime).AddRange(tempValues); } } } var crimeCollector = FileUnpacker.GetCollector <CrimeCollector>(crimes); crimes.Dispose(); return(crimeCollector, crimeNames); int CrimeMagicOverride(int parent, string str) { if (parent != -1) { return((int)MagicUnifiedNumbers.ContinueMagicNumbers); } crimes.Add(em.CreateEntity(typeof(CrimeEntity))); crimeNames.Add(str); return((int)MagicUnifiedNumbers.Placeholder + crimeNames.Count - 1); } }
// Used by event modifiers and national values. public static (Entity, List <string>) Main <TEntity, TCollection>(IEnumerable <string> paths, Action <Entity, int> setEntityIndex) { var fileTree = new List <KeyValuePair <int, object> >(); var values = new List <string>(); var names = new List <string>(); var entities = new NativeList <EntityWrapper>(Allocator.Temp); var em = World.Active.EntityManager; foreach (var path in paths) { FileUnpacker.ParseFile(path, fileTree, values, NationalValueMagicOverride); } using (var parentLocation = new NativeMultiHashMap <int, int>(1, Allocator.Temp)) { foreach (var nodeKvP in fileTree) { var ranges = new List <DataRange>(); var actions = new List <DataValue>(); parentLocation.Add(nodeKvP.Key, ranges.Count); ranges.Add(new DataRange(nodeKvP.Key, -1, -1)); FileUnpacker.ProcessQueue(nodeKvP, actions, ranges, parentLocation, values, (s, pair) => false); if (ranges.Count > 2) // 1 is throwaway. 2 is BreakCore. There can not be a third. { throw new Exception("Invalid nested value in Event Modifiers or National Values!" + (LoadVariables)ranges[2].Type); } var currentValue = em.CreateEntity(typeof(TEntity)); setEntityIndex(currentValue, nodeKvP.Key - (int)MagicUnifiedNumbers.Placeholder); using (var tempValue = new NativeArray <DataValue>(actions.ToArray(), Allocator.Temp)) { em.AddBuffer <DataValue>(currentValue).AddRange(tempValue); } entities.Add(currentValue); } } var collector = FileUnpacker.GetCollector <TCollection>(entities); entities.Dispose(); return(collector, names); int NationalValueMagicOverride(int parent, string str) { if (parent != -1) { return((int)MagicUnifiedNumbers.ContinueMagicNumbers); } names.Add(str); return((int)MagicUnifiedNumbers.Placeholder + names.Count - 1); } }
public static Entity Main(Entity technologies, ref StringBox stringBox) { var inventions = new NativeList <EntityWrapper>(Allocator.Temp); var inventionNames = new List <string>(); var allIncompleteInventions = new List <List <IncompleteInventions> >(); var em = World.Active.EntityManager; using (var technologyList = em.GetBuffer <EntityWrapper>(technologies).ToNativeArray(Allocator.Temp)) using (var parentLocation = new NativeMultiHashMap <int, int>(1, Allocator.Temp)) { foreach (var inventPath in Directory.EnumerateFiles( Path.Combine(Application.streamingAssetsPath, "Inventions"), "*.txt")) { var fileTree = new List <KeyValuePair <int, object> >(); var values = new List <string>(); FileUnpacker.ParseFile(inventPath, fileTree, values, InventMagicOverride); foreach (var inventionKvP in fileTree) { var targetInvention = new InventionEntity { Index = inventionKvP.Key - (int)MagicUnifiedNumbers.Invention }; var inventionEntity = inventions[targetInvention.Index]; var inventValues = new List <DataValue>(); var inventRanges = new List <DataRange>(); var tempInventions = new List <IncompleteInventions>(); parentLocation.Add(inventionKvP.Key, inventRanges.Count); inventRanges.Add(new DataRange(inventionKvP.Key, -1, -1)); FileUnpacker.ProcessQueue(inventionKvP, inventValues, inventRanges, parentLocation, values, InventSwitchOverride); em.SetComponentData(inventionEntity, targetInvention); allIncompleteInventions.Add(tempInventions); using (var tempRange = new NativeArray <DataRange>(inventRanges.ToArray(), Allocator.Temp)) { em.AddBuffer <DataRange>(inventionEntity).AddRange(tempRange); } using (var tempValues = new NativeArray <DataValue>(inventValues.ToArray(), Allocator.Temp)) { em.AddBuffer <DataValue>(inventionEntity).AddRange(tempValues); } bool InventSwitchOverride(string targetStr, KeyValuePair <int, object> target) { switch ((MagicUnifiedNumbers)(target.Key / 10000 * 10000)) { case MagicUnifiedNumbers.Placeholder: var targetTech = technologyList[target.Key - (int)MagicUnifiedNumbers.Placeholder]; targetInvention.Technology = targetTech; em.GetBuffer <EntityWrapper>(targetTech).Add(inventionEntity); return(true); } if (target.Key != (int)LoadVariables.Invention) { return(false); } tempInventions.Add(new IncompleteInventions(targetStr, inventValues.Count)); inventValues.Add(new DataValue((int)LoadVariables.Invention, -1)); return(true); } } } } stringBox.InventionNames = inventionNames; var inventionCollector = FileUnpacker.GetCollector <InventionCollection>(inventions); inventions.Dispose(); CompleteInventions(inventionCollector, allIncompleteInventions); return(inventionCollector); int InventMagicOverride(int parent, string raw) { if (parent == (int)LoadVariables.Limit) { // God damn C# trash pointers. if (LookupDictionaries.Techs.TryGetValue(raw, out var techIndex)) { return((int)MagicUnifiedNumbers.Placeholder + techIndex); } } if (parent != -1) { return((int)MagicUnifiedNumbers.ContinueMagicNumbers); } inventions.Add(em.CreateEntity(typeof(InventionEntity))); inventionNames.Add(raw); return((int)MagicUnifiedNumbers.Invention + inventionNames.Count - 1); } }
public static (Entity, Entity, Entity, List <List <IncompleteInventions> >) Main(ref StringBox stringBox) { var folderNames = new List <string>(); var areaNames = new List <string>(); var schoolNames = new List <string>(); var technologyNames = new List <string>(); var techLookup = new Dictionary <string, int>(); var areaLookup = new Dictionary <string, int>(); var foldersLookup = new Dictionary <string, int>(); var schoolReadBeforeFolders = new Queue <string>(); var schoolQueueing = false; var folders = new NativeList <EntityWrapper>(Allocator.Temp); var schools = new NativeList <EntityWrapper>(Allocator.Temp); var areas = new NativeList <EntityWrapper>(Allocator.Temp); var technologies = new NativeList <EntityWrapper>(Allocator.Temp); var currentUpper = CurrentUpper.None; var lowerToggle = false; var em = World.Active.EntityManager; var currentFolder = new Entity(); var currentSchool = new Entity(); using (var tempAreas = new NativeList <EntityWrapper>(Allocator.Temp)) using (var tempSchoolValues = new NativeList <DataValue>(Allocator.Temp)) { foreach (var rawLine in File.ReadLines(Path.Combine(Application.streamingAssetsPath, "Common", "technology.txt"))) { if (LoadMethods.CommentDetector(rawLine, out var line)) { continue; } ParseCommonTechFile(line); } while (schoolReadBeforeFolders.Any()) { ParseCommonTechFile(schoolReadBeforeFolders.Dequeue()); } void ParseCommonTechFile(string line) { if (schoolQueueing) { // Buffer school section until exit. // Folder section contains critical info needed for schools parsing. if (line.Contains("{")) { if (!lowerToggle) { lowerToggle = true; } else { throw new Exception("Exceeded maximum nesting in Common/technology.txt."); } } if (line.Contains("}")) { if (lowerToggle) { lowerToggle = false; } else { schoolQueueing = false; } } schoolReadBeforeFolders.Enqueue(line); return; } var preEquals = Regex.Match(line, @"^.+?(?=\=)"); switch (currentUpper) { case CurrentUpper.None: switch (preEquals.Value.Trim()) { case "folders": currentUpper = CurrentUpper.Folder; break; case "schools": if (folders.Length < 1) { schoolQueueing = true; schoolReadBeforeFolders.Enqueue(line); return; } for (var i = 0; i < folders.Length; i++) { foldersLookup.Add(folderNames[i], i); } currentUpper = CurrentUpper.Schools; break; default: throw new NotImplementedException("Unknown tech type: " + line); } break; case CurrentUpper.Folder: if (!lowerToggle) { if (line.Contains("}")) { break; } lowerToggle = true; currentFolder = em.CreateEntity(typeof(FolderEntity)); em.SetComponentData(currentFolder, new FolderEntity { Index = folderNames.Count }); folderNames.Add(preEquals.Value.Trim()); break; } if (preEquals.Success) { throw new Exception("Invalid equals detected! " + line); } var newFolderEntry = line.Replace("}", "").Trim(); if (newFolderEntry == string.Empty) { break; } areaLookup.Add(newFolderEntry, areaNames.Count); var targetArea = em.CreateEntity(typeof(AreaEntity)); em.SetComponentData(targetArea, new AreaEntity { Index = areaNames.Count, Folder = currentFolder }); tempAreas.Add(targetArea); areas.Add(targetArea); areaNames.Add(newFolderEntry); break; case CurrentUpper.Schools: if (!lowerToggle) { if (line.Contains("}")) { break; } lowerToggle = true; currentSchool = em.CreateEntity(typeof(SchoolEntity)); em.SetComponentData(currentSchool, new SchoolEntity { Index = schoolNames.Count }); schoolNames.Add(preEquals.Value.Trim()); break; } var newSchoolEntry = preEquals.Value.Replace("}", "").Trim(); if (newSchoolEntry == string.Empty) { break; } int assignedNumber; if (!Enum.TryParse(newSchoolEntry.Replace("_", ""), true, out LoadVariables foundVar)) { if (!foldersLookup.TryGetValue( Regex.Match(newSchoolEntry, @"^.+?(?=_research_bonus)").Value, out var folderIndex)) { throw new Exception("Unknown folder _research_bonus: " + newSchoolEntry); } assignedNumber = folderIndex + (int)MagicUnifiedNumbers.ResearchBonus; } else { assignedNumber = (int)foundVar; } if (!float.TryParse(line.Substring(preEquals.Length + 1), out var schoolValue)) { throw new Exception("Unknown float value. " + line.Substring(preEquals.Length + 1)); } if (math.abs(schoolValue) < 0.01) { break; } tempSchoolValues.Add(new DataValue(assignedNumber, schoolValue)); break; } if (!line.Contains("}")) { return; } if (lowerToggle) { lowerToggle = false; if (currentUpper == CurrentUpper.Schools) { em.AddBuffer <DataValue>(currentSchool).AddRange(tempSchoolValues); tempSchoolValues.Clear(); schools.Add(currentSchool); } else { // Folders em.AddBuffer <EntityWrapper>(currentFolder).AddRange(tempAreas); tempAreas.Clear(); folders.Add(currentFolder); } } else { currentUpper = CurrentUpper.None; } } } // Actual tech parsing now stringBox.SchoolNames = schoolNames; stringBox.FolderNames = folderNames; stringBox.AreaNames = areaNames; var allTechInventions = new List <List <IncompleteInventions> >(); foreach (var techPath in Directory.GetFiles(Path.Combine(Application.streamingAssetsPath, "Technologies"), "*.txt")) { if (!foldersLookup.TryGetValue(Path.GetFileNameWithoutExtension(techPath), out _)) { throw new Exception("Unknown tech folder type! " + techPath); } var fileTree = new List <KeyValuePair <int, object> >(); var values = new List <string>(); FileUnpacker.ParseFile(techPath, fileTree, values, TechMagicOverride); using (var parentLocation = new NativeMultiHashMap <int, int>(10, Allocator.TempJob)) { foreach (var technology in fileTree) { var techRanges = new List <DataRange>(); var techActions = new List <DataValue>(); var passInventions = new List <IncompleteInventions>(); parentLocation.Add(technology.Key, techRanges.Count); techRanges.Add(new DataRange(technology.Key, -1, -1)); var currentTechnology = new TechnologyEntity { Index = technologyNames.Count, Year = -1 }; technologyNames.Add(values[technology.Key - (int)MagicUnifiedNumbers.Technology]); FileUnpacker.ProcessQueue(technology, techActions, techRanges, parentLocation, values, TechSwitchOverride); var targetTechnology = em.CreateEntity(typeof(TechnologyEntity)); em.SetComponentData(targetTechnology, currentTechnology); em.AddBuffer <EntityWrapper>(targetTechnology); // Inventions associated with technology. technologies.Add(targetTechnology); using (var tempRange = new NativeArray <DataRange>(techRanges.ToArray(), Allocator.Temp)) { em.AddBuffer <DataRange>(targetTechnology).AddRange(tempRange); } using (var tempValues = new NativeArray <DataValue>(techActions.ToArray(), Allocator.Temp)) { em.AddBuffer <DataValue>(targetTechnology).AddRange(tempValues); } allTechInventions.Add(passInventions); bool TechSwitchOverride(string targetStr, KeyValuePair <int, object> target) { switch ((LoadVariables)target.Key) { case LoadVariables.Area: if (!areaLookup.TryGetValue(targetStr, out var areaIndex)) { throw new Exception("Unknown area. " + targetStr); } currentTechnology.Area = areas[areaIndex]; return(true); case LoadVariables.Year: if (!int.TryParse(targetStr, out var year)) { throw new Exception("Unknown year. " + targetStr); } if (currentTechnology.Year == -1) { currentTechnology.Year = year; } else { techActions.Add(new DataValue(target.Key, year)); } return(true); case LoadVariables.Cost: if (!int.TryParse(targetStr, out var cost)) { throw new Exception("Unknown cost. " + targetStr); } currentTechnology.Cost = cost; return(true); case LoadVariables.Invention: // Inventions are completed after inventions are parsed passInventions.Add(new IncompleteInventions(targetStr, techActions.Count)); techActions.Add(new DataValue((int)LoadVariables.Invention, -1)); return(true); default: return(false); } } } } int TechMagicOverride(int parent, string str) { if (parent == -1) { values.Add(str); techLookup.Add(str, values.Count - 1); return((int)MagicUnifiedNumbers.Technology + values.Count - 1); } // Previous technology if (techLookup.TryGetValue(str, out var techIndex)) { return(techIndex + (int)MagicUnifiedNumbers.Technology); } return((int)MagicUnifiedNumbers.ContinueMagicNumbers); } } stringBox.TechNames = technologyNames; var techCollector = FileUnpacker.GetCollector <TechnologyCollection>(technologies); technologies.Dispose(); var schoolCollector = FileUnpacker.GetCollector <SchoolCollection>(schools); schools.Dispose(); var folderCollector = FileUnpacker.GetCollector <FolderCollection>(folders); folders.Dispose(); return(techCollector, schoolCollector, folderCollector, allTechInventions); }