public static void WriteBlueprints(ARealmReversed realm)
{
HousingExteriorBlueprintSet blueprintSet = ReadExteriorBlueprintSet(realm);
string outpath = FFXIVHSPaths.GetHousingExteriorBlueprintSetJson();
if (File.Exists(outpath))
{
File.Delete(outpath);
}
string json = JsonConvert.SerializeObject(blueprintSet, Formatting.Indented);
File.WriteAllText(outpath, json);
}
private static void LoadExteriorBlueprints()
{
string jsonText = File.ReadAllText(FFXIVHSPaths.GetHousingExteriorBlueprintSetJson());
_blueprints = JsonConvert.DeserializeObject <HousingExteriorBlueprintSet>(jsonText);
}
/// <summary>
/// Returns a HousingExteriorBlueprintSet read from the small, medium, and large sgb paths in
/// HousingExteriorBlueprintSet.
/// </summary>
/// <param name="realm"></param>
/// <returns></returns>
private static HousingExteriorBlueprintSet ReadExteriorBlueprintSet(ARealmReversed realm)
{
HousingExteriorBlueprintSet thisSet = new HousingExteriorBlueprintSet();
thisSet.set = new HousingExteriorBlueprint[HousingExteriorBlueprintSet.SgbPaths.Length];
for (int i = 0; i < HousingExteriorBlueprintSet.SgbPaths.Length; i++)
{
string thisPath = HousingExteriorBlueprintSet.SgbPaths[i];
HousingExteriorBlueprint thisBlueprint = new HousingExteriorBlueprint {
size = (Size)i
};
//These are hardcoded, double check they're there
SaintCoinach.IO.File f;
if (!realm.Packs.TryGetFile(thisPath, out f))
{
throw new FileNotFoundException();
}
SgbFile sgb = new SgbFile(f);
foreach (SgbGroup group in sgb.Data.OfType <SgbGroup>())
{
foreach (SgbGimmickEntry gim in group.Entries.OfType <SgbGimmickEntry>())
{
string gimmickPath = gim.Gimmick.File.Path;
/*
* Group 1: s1h0 or opt
* Group 2: size, dor/wid variant, f for fence, or opt's 2chars
* Group 3: fixturetype or m for opt
* Group 4: a/b/c/d for fence, . for all others
*/
Regex pattern = new Regex(@"asset\/(.*)?_(.{1,2})_(.{1,3})([0-9]{4})([a-z]|\.)");
Match m = pattern.Match(gimmickPath);
if (!m.Success)
{
continue;
}
//Obtain fixture type
string fType = m.Groups[3].Value;
if (fType == "m")
{
fType = "o" + m.Groups[2].Value;
}
FixtureType fixtureType = (FixtureType)Enum.Parse(typeof(FixtureType), fType);
//Obtains the variant string, examples: s, m, l, co, ca, ci, a, b, c, d
string strVariant = m.Groups[5].Value == "." ? m.Groups[2].Value : m.Groups[5].Value;
int variant = 0;
//Attempt to parse group 2 into a Size to get variant
if (!Enum.TryParse(strVariant, out Size fixtureSize))
{
//If we can't parse variant to a size, we have to parse into a different fixture variant
if (fixtureType == FixtureType.dor)
{
variant = (int)Enum.Parse(typeof(DoorVariants), strVariant);
}
else if (fixtureType == FixtureType.wid)
{
variant = (int)Enum.Parse(typeof(WindowVariants), strVariant);
}
else if (fixtureType == FixtureType.fnc)
{
variant = (int)Enum.Parse(typeof(FenceVariants), strVariant);
}
}
else
{
//If rof/wal is not same size as blueprint, skip it
if (fixtureSize != thisBlueprint.size)
{
continue;
}
}
if (thisBlueprint.fixtureTransforms[fixtureType][variant] == null)
{
thisBlueprint.fixtureTransforms[fixtureType][variant] = new List <Transform>();
}
List <Transform> listForVariant = thisBlueprint.fixtureTransforms[fixtureType][variant];
Transform t = TransformFromVectors(gim.Header.Translation, gim.Header.Rotation,
gim.Header.Scale);
listForVariant.Add(t);
#region switch statement bad
// switch (m.Groups[3].Value)
// {
// case nameof(FixtureType.rof):
// if (m.Groups[2].Value == size.ToString())
// {
// //exampe but cool
// }
// break;
// case nameof(FixtureType.wal):
// //Do stuff
// break;
// case nameof(FixtureType.wid):
// //Do stuff
// break;
// case nameof(FixtureType.dor):
// //Do stuff
// break;
// case "m":
// switch ("o" + m.Groups[2].Value)
// {
// case nameof(FixtureType.orf):
// //Do stuff
// break;
// case nameof(FixtureType.owl):
// //Do stuff
// break;
// case nameof(FixtureType.osg):
// //Do stuff
// break;
// }
// break;
// case nameof(FixtureType.fnc):
// //Do stuff
// break;
// }
#endregion
}
}
/*
* The transforms relevant to the current blueprint come first,
* so figure out how many Transforms aren't for this size house
* by checking how many transforms are collectively in the blueprints
* below this size and variant, then remove that number of entries.
*/
if (i > 0)
{
int[][] numTransformsInSmallerBlueprints = new int[Enum.GetValues(typeof(FixtureType)).Length][];
//For every smaller blueprint
for (int smallerBlueprintIndex = 0; smallerBlueprintIndex < i; smallerBlueprintIndex++)
{
//For every fixture type
for (int fixtureTypeIndex = 0; fixtureTypeIndex < numTransformsInSmallerBlueprints.Length; fixtureTypeIndex++)
{
FixtureType fixtureType = (FixtureType)fixtureTypeIndex + 1;
int numberOfVariants = HousingExteriorFixture.GetVariants(fixtureType);
if (numTransformsInSmallerBlueprints[fixtureTypeIndex] == null)
{
numTransformsInSmallerBlueprints[fixtureTypeIndex] = new int[numberOfVariants];
}
for (int variantIndex = 0; variantIndex < numberOfVariants; variantIndex++)
{
int?toAddn = thisSet.set[smallerBlueprintIndex].fixtureTransforms[fixtureType][variantIndex]?.Count;
int toAdd = toAddn ?? 0;
numTransformsInSmallerBlueprints[fixtureTypeIndex][variantIndex] += toAdd;
}
}
}
//Whoops, don't do it for fences
for (int j = 0; j < numTransformsInSmallerBlueprints[(int)FixtureType.fnc - 1].Length; j++)
{
numTransformsInSmallerBlueprints[(int)FixtureType.fnc - 1][j] = 0;
}
//For every fixture type
for (int fixtureTypeIndex = 0; fixtureTypeIndex < numTransformsInSmallerBlueprints.Length; fixtureTypeIndex++)
{
FixtureType fixtureType = (FixtureType)fixtureTypeIndex + 1;
int numberOfVariants = HousingExteriorFixture.GetVariants(fixtureType);
for (int variantIndex = 0; variantIndex < numberOfVariants; variantIndex++)
{
List <Transform> variantTransformsList = thisBlueprint.fixtureTransforms[fixtureType][variantIndex];
if (thisBlueprint.fixtureTransforms[fixtureType][variantIndex] == null)
{
continue;
}
if (variantTransformsList == null)
{
continue;
}
int numTransforms = variantTransformsList.Count;
int difference = numTransforms - numTransformsInSmallerBlueprints[fixtureTypeIndex][variantIndex];
if (difference > 0)
{
List <Transform> newTransforms = new List <Transform>();
for (int tCount = 0; tCount < difference; tCount++)
{
newTransforms.Add(variantTransformsList[tCount]);
}
thisBlueprint.fixtureTransforms[fixtureType][variantIndex] = newTransforms;
}
}
}
}
thisSet.set[i] = thisBlueprint;
}
return(thisSet);
}
