public static (List <(int, int)>, List <string>) Main(bool cache, NativeHashMap <int, int> idIndex)
{
var provinces = new List <(int, int)>();
var continentNames = new List <string>();
var continentEntities = new List <ContinentEntity>();
if (cache)
{
(provinces, continentEntities, continentNames) = JsonUtility.FromJson <ContinentOutput>(
LoadMethods.Unzip(File.ReadAllBytes(Path.Combine(Application.streamingAssetsPath, "JsonData", "continent.txt"))));
LoadMethods.GenerateCacheEntities <ContinentEntity, ContinentCollection>(continentEntities, continentNames);
return(provinces, continentNames);
}
var em = World.DefaultGameObjectInjectionWorld.EntityManager;
var continents = new NativeList <EntityWrapper>(Allocator.Temp);
var outerToggle = false;
var provToggle = false;
var currentCont = new ContinentEntity();
foreach (var rawLine in File.ReadLines(Path.Combine(Application.streamingAssetsPath, "map", "continent.txt")))
{
if (LoadMethods.CommentDetector(rawLine, out var line))
{
continue;
}
var equalSplit = Regex.Match(line, @"^.*?(?=\=)");
if (line.Contains("{"))
{
var newLine = line.Substring(equalSplit.Length + 1).Replace("{", "").Trim();
if (!outerToggle)
{
outerToggle = true;
var name = equalSplit.Value.Trim();
currentCont = new ContinentEntity {
Name = name
}; // {Index = continentNames.Count};
continentNames.Add(name);
if (newLine == string.Empty)
{
continue;
}
equalSplit = Regex.Match(newLine, @"^.*?(?=\=)");
}
if (!equalSplit.Value.Contains("provinces"))
{
throw new Exception("Unknown nested value: " + equalSplit);
}
provToggle = true;
if (newLine == string.Empty)
{
continue;
}
line = newLine;
}
if (provToggle)
{
var numbers = Regex.Match(line, @"[\d\s]+");
if (numbers.Success)
{
var individualProv = numbers.Value.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);
foreach (var provId in individualProv)
{
if (!int.TryParse(provId, out var num))
{
continue;
}
provinces.Add((idIndex[num], continents.Length));
}
}
}
else
{
var newLine = line.Substring(equalSplit.Length + 1).Replace("}", "").Trim();
switch (equalSplit.Value.Trim())
{
case "assimilation_rate":
if (!float.TryParse(newLine, out var assimilationRate))
{
throw new Exception("Unknown assimilation rate: " + newLine);
}
currentCont.AssimilationRate = assimilationRate;
break;
case "farm_rgo_size":
if (!float.TryParse(newLine, out var farmSize))
{
throw new Exception("Unknown farm RGO size: " + newLine);
}
currentCont.FarmRgoSize = farmSize;
break;
case "mine_rgo_size":
if (!float.TryParse(newLine, out var mineSize))
{
throw new Exception("Unknown mine RGO size: " + newLine);
}
currentCont.MineRgoSize = mineSize;
break;
}
}
if (!line.Contains("}"))
{
continue;
}
if (provToggle)
{
provToggle = false;
}
else
{
outerToggle = false;
var target = em.CreateEntity(typeof(ContinentEntity));
em.SetComponentData(target, currentCont);
continents.Add(target);
continentEntities.Add(currentCont);
}
}
FileUnpacker.GetCollector <ContinentCollection>();
continents.Dispose();
//File.WriteAllText(Path.Combine(Application.streamingAssetsPath, "JsonData", "continent.txt"),
//JsonUtility.ToJson(new ContinentOutput(continentNames, provinces, continentEntities), true));
File.WriteAllBytes(Path.Combine(Application.streamingAssetsPath, "JsonData", "continent.txt"),
LoadMethods.Zip(JsonUtility.ToJson(new ContinentOutput(continentNames, provinces, continentEntities))));
return(provinces, continentNames);
}
public static (List <string>, List <string>) Main(bool cache)
{
var cultures = new List <CultureEntity>();
var cultureNames = new List <string>();
var cultureGroupNames = new List <string>();
if (cache)
{
(cultureNames, cultureGroupNames, cultures) = JsonUtility.FromJson <CulturesOutput>(
LoadMethods.Unzip(File.ReadAllBytes(Path.Combine(Application.streamingAssetsPath, "JsonData", "cultures.txt"))));
LoadMethods.GenerateCacheEntities <CultureEntity, CultureCollection>(cultures, cultureNames, cultureGroupNames);
return(cultureNames, cultureGroupNames);
}
var em = World.DefaultGameObjectInjectionWorld.EntityManager;
bool groupToggle = false,
cultureToggle = false,
ignoreToggle = false;
var currentCulture = new CultureEntity();
foreach (var line in File.ReadLines(Path.Combine(Application.streamingAssetsPath, "common",
"cultures.txt")))
{
if (LoadMethods.CommentDetector(line, out var commentSplit))
{
continue;
}
if (ignoreToggle)
{
if (commentSplit.Contains("}"))
{
ignoreToggle = false;
}
// Assuming no values defined after end brackets
continue;
}
var equalsSplit = Regex.Match(commentSplit, @"^.+?(?=\=)");
var preEquals = equalsSplit.Success ? equalsSplit.Value.Trim() : "";
if (commentSplit.Contains("{"))
{
if (!groupToggle)
{
groupToggle = true;
cultureGroupNames.Add(preEquals);
continue;
}
if (!commentSplit.Contains("_names") && !commentSplit.Contains("color"))
{
cultureToggle = true;
var name = preEquals.Trim();
cultureNames.Add(name);
currentCulture = new CultureEntity {
Group = cultureGroupNames.Last(), Name = name
};
}
}
switch (preEquals)
{
case "union":
currentCulture.Union =
LookupDictionaries.CountryTags[commentSplit.Substring(equalsSplit.Length + 1).Trim()];
continue;
case "first_names":
case "last_names":
// TODO: Implement names generation, someday.
if (!commentSplit.Contains("}"))
{
ignoreToggle = true;
}
continue;
case "color":
currentCulture.Color =
LoadMethods.ParseColor32(commentSplit.Substring(equalsSplit.Length + 1));
continue;
case "leader":
case "unit":
continue;
case "radicalism":
if (!float.TryParse(commentSplit.Substring(equalsSplit.Length + 1), out var radical))
{
throw new Exception("Unknown radicalism: " +
commentSplit.Substring(equalsSplit.Length + 1));
}
currentCulture.Radicalism = radical;
continue;
case "primary":
currentCulture.Primary =
LookupDictionaries.CountryTags[commentSplit.Substring(equalsSplit.Length + 1).Trim()];
continue;
}
if (!commentSplit.Contains("}"))
{
continue;
}
if (cultureToggle)
{
cultureToggle = false;
var targetCulture = em.CreateEntity(typeof(CultureEntity));
em.SetComponentData(targetCulture, currentCulture);
cultures.Add(currentCulture);
continue;
}
groupToggle = false;
}
File.WriteAllBytes(Path.Combine(Application.streamingAssetsPath, "JsonData", "cultures.txt"),
LoadMethods.Zip(JsonUtility.ToJson(
new CulturesOutput(cultureNames, cultureGroupNames, cultures))));
FileUnpacker.GetCollector <CultureCollection>();
return(cultureNames, cultureGroupNames);
}
private static TerrainOutput ParseParadoxFile()
{
var fileTree = new List <(int Key, object Value)>();
var terrainNames = new List <string>();
var terrains = new List <TerrainEntity>();
var terrainCache = new List <List <FirstLevelCore> >();
var paletteLookups = new List <(Color Palette, int Index)>();
// Generating file tree representation.
FileUnpacker.ParseFile(Path.Combine(Application.streamingAssetsPath, "map", "terrain.txt"),
fileTree, TerrainMagicOverride);
for (var index = 0; index < fileTree.Count; index++)
{
var currentTerrain = terrains[index];
var(breakCores, _) = FileUnpacker.AssignFirstLevelDistributeWorkload(ref currentTerrain, fileTree[index],
TerrainOverride);
terrainCache.Add(breakCores);
bool TerrainOverride((int Key, object Value) target)
{
switch ((LoadVariables)target.Key)
{
case LoadVariables.Palette:
if (!ColorUtility.TryParseHtmlString("#" + (string)target.Value, out var paletteColor))
{
throw new Exception("Unknown hex color. " + (string)target.Value);
}
paletteLookups.Add((paletteColor, index));
return(true);
default:
return(false);
}
}
}
int TerrainMagicOverride(int parent, string str)
{
if (parent != -1)
{
return((int)MagicUnifiedNumbers.ContinueMagicNumbers);
}
terrainNames.Add(str);
terrains.Add(new TerrainEntity {
Name = str
});
return((int)MagicUnifiedNumbers.Terrain + terrainNames.Count - 1);
}
var output = new TerrainOutput(terrainNames, terrains, terrainCache, paletteLookups);
//File.WriteAllText(Path.Combine(Application.streamingAssetsPath, "JsonData", "terrain.txt"),
//JsonUtility.ToJson(output, true));
File.WriteAllBytes(Path.Combine(Application.streamingAssetsPath, "JsonData", "terrain.txt"),
LoadMethods.Zip(JsonUtility.ToJson(output)));
return(output);
}
public static (List <string>, List <string>) Main(bool cache)
{
var groupNames = new List <string>();
var religionNames = new List <string>();
var religionEntities = new List <ReligionEntity>();
if (cache)
{
(religionNames, groupNames, religionEntities) = JsonUtility.FromJson <ReligionsOutput>(
LoadMethods.Unzip(File.ReadAllBytes(Path.Combine(Application.streamingAssetsPath, "JsonData", "religion.txt"))));
LoadMethods.GenerateCacheEntities <ReligionEntity, ReligionCollection>(religionEntities, religionNames, groupNames);
return(religionNames, groupNames);
}
var em = World.DefaultGameObjectInjectionWorld.EntityManager;
bool groupToggle = false, religionToggle = false, colorToggle = false;
var currentReligion = new ReligionEntity();
foreach (var line in File.ReadLines(Path.Combine(Application.streamingAssetsPath, "Common",
"religion.txt")))
{
if (LoadMethods.CommentDetector(line, out var commentSplit))
{
continue;
}
var equalsSplit = commentSplit.Split(new[] { "=" }, StringSplitOptions.RemoveEmptyEntries);
if (commentSplit.Contains("{"))
{
if (!groupToggle)
{
groupToggle = true;
groupNames.Add(equalsSplit[0].Trim());
continue;
}
if (!religionToggle)
{
religionToggle = true;
currentReligion = new ReligionEntity {
Group = groupNames.Last()
};
religionNames.Add(equalsSplit[0].Trim());
continue;
}
if (!colorToggle)
{
colorToggle = true;
}
}
switch (equalsSplit[0].Trim())
{
case "color":
// Why religion colors are in float, I have absolutely no idea.
currentReligion.Color = LoadMethods.ParseColor32(equalsSplit[1]);
break;
}
if (!commentSplit.Contains("}"))
{
continue;
}
if (colorToggle)
{
colorToggle = false;
continue;
}
if (religionToggle)
{
religionToggle = false;
var targetEntity = em.CreateEntity(typeof(ReligionEntity));
em.SetComponentData(targetEntity, currentReligion);
religionEntities.Add(currentReligion);
continue;
}
groupToggle = false;
}
FileUnpacker.GetCollector <ReligionCollection>();
File.WriteAllBytes(Path.Combine(Application.streamingAssetsPath, "JsonData", "religion.txt"),
LoadMethods.Zip(JsonUtility.ToJson(new ReligionsOutput(groupNames, religionNames, religionEntities))));
/*
* var test = em.GetBuffer<EntityWrapper>(religionCollectorEntity);
* foreach (var religion in test.AsNativeArray())
* {
* var religionEntity = em.GetComponentData<ReligionEntity>(religion.Entity);
* Debug.Log(religionNames[religionEntity.Index]
+ " of group " + groupNames[em.GetComponentData<ReligionGroupEntity>(religionEntity.Group).Index]);
+ }
*/
return(religionNames, groupNames);
}
