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);
}