public static void OpenFileInME3(IMEPackage pcc, bool canHotLoad = false, bool shouldPad = true)
{
var tempMapName = GameController.TempMapName;
string tempDir = ME3Directory.CookedPCPath;
string tempFilePath = Path.Combine(tempDir, $"{tempMapName}.pcc");
pcc.Save(tempFilePath);
if (shouldPad)
{
if (!InteropHelper.TryPadFile(tempFilePath))
{
//if file was too big to pad, hotloading is impossible
canHotLoad = false;
}
}
if (GameController.TryGetME3Process(out Process me3Process) && canHotLoad)
{
IntPtr handle = me3Process.MainWindowHandle;
GameController.ExecuteConsoleCommands(handle, MEGame.ME3, $"at {tempMapName}");
return;
}
me3Process?.Kill();
int resX = 1000;
int resY = 800;
int posX = (int)(SystemParameters.PrimaryScreenWidth - (resX + 100));
int posY = (int)(SystemParameters.PrimaryScreenHeight - resX) / 2;
AutoTOCWPF.GenerateAllTOCs();
Process.Start(ME3Directory.ExecutablePath, $"{tempMapName} -nostartupmovies -Windowed ResX={resX} ResY={resY} WindowPosX={posX} WindowPosY={posY}");
}
public bool ImportFromPSA(string path)
{
PSAFile psa = new PSAFile();
psa.ImportPSA(path);
PSAFile.PSAData d = psa.data;
DebugOutput.PrintLn("Checking data...");
if (d.Bones.Count != SetData.TrackBoneNames.Count)
{
MessageBox.Show("Cant import: different count of bones");
return(false);
}
for (int i = 0; i < SetData.TrackBoneNames.Count; i++)
{
if (d.Bones[i].name != SetData.TrackBoneNames[i])
{
MessageBox.Show("Cant import: couldnt match all bones");
return(false);
}
}
if (d.Infos.Count != Sequences.Count)
{
MessageBox.Show("Cant import: different count of sequences");
return(false);
}
for (int i = 0; i < Sequences.Count; i++)
{
AnimSequence ans = new AnimSequence(pcc.GetUExport(Sequences[i]));
if (d.Infos[i].name != ans.SequenceName)
{
MessageBox.Show("Cant import: couldnt match all sequences");
return(false);
}
}
int pos = 0;
List <Vector4> rot = new List <Vector4>();
for (int i = 0; i < Sequences.Count; i++)
{
DebugOutput.PrintLn($"Importing into AnimSequence #{Sequences[i]} ...");
AnimSequence ans = new AnimSequence(pcc.GetUExport(Sequences[i]));
PSAFile.PSAAnimInfo inf = d.Infos[i];
var loc = new List <Vector3>();
for (int j = 0; j < inf.TotalBones; j++)
{
PSAFile.PSAAnimKeys key = d.Keys[pos + j];
loc.Add(key.location.ToVector3());
rot.Add(key.rotation.ToVector4());
}
ans.ImportKeys(loc.ToArray(), rot.ToArray(), inf.NumRawFrames);
ans.SaveChanges();
pos += inf.KeyQuotum;
}
pcc.Save();
return(true);
}
public static void SetUpAnimStreamFile(string animSourceFilePath, int animSequenceUIndex, string saveAsName)
{
string animViewerAnimStreamFilePath = Path.Combine(App.ExecFolder, "ME3AnimViewer_StreamAnim.pcc");
using IMEPackage pcc = MEPackageHandler.OpenMEPackage(animViewerAnimStreamFilePath);
if (animSourceFilePath != null)
{
try
{
const int InterpDataUIndex = 8;
const int InterpTrackAnimControlUIndex = 10;
const int KIS_DYN_AnimsetUIndex = 6;
#if DEBUG
Debug.WriteLine($"AnimViewer Loading: {animSourceFilePath} #{animSequenceUIndex}");
#endif
using IMEPackage animSourceFile = MEPackageHandler.OpenMEPackage(animSourceFilePath);
ExportEntry sourceAnimSeq = animSourceFile.GetUExport(animSequenceUIndex);
IEntry parent = EntryImporter.GetOrAddCrossImportOrPackage(sourceAnimSeq.ParentFullPath, animSourceFile, pcc);
EntryImporter.ImportAndRelinkEntries(EntryImporter.PortingOption.CloneAllDependencies, sourceAnimSeq, pcc, parent, true, out IEntry ent);
ExportEntry importedAnimSeq = (ExportEntry)ent;
NameReference seqName = importedAnimSeq.GetProperty <NameProperty>("SequenceName").Value;
float seqLength = importedAnimSeq.GetProperty <FloatProperty>("SequenceLength");
IEntry bioAnimSet = pcc.GetEntry(importedAnimSeq.GetProperty <ObjectProperty>("m_pBioAnimSetData").Value);
string setName = importedAnimSeq.ObjectName.Name.RemoveRight(seqName.Name.Length + 1);
ExportEntry animInterpData = pcc.GetUExport(InterpDataUIndex);
animInterpData.WriteProperty(new FloatProperty(seqLength, "InterpLength"));
ExportEntry animTrack = pcc.GetUExport(InterpTrackAnimControlUIndex);
var animSeqKeys = animTrack.GetProperty <ArrayProperty <StructProperty> >("AnimSeqs");
animSeqKeys[0].Properties.AddOrReplaceProp(new NameProperty(seqName, "AnimSeqName"));
animTrack.WriteProperty(animSeqKeys);
ExportEntry dynamicAnimSet = pcc.GetUExport(KIS_DYN_AnimsetUIndex);
dynamicAnimSet.WriteProperty(new ObjectProperty(bioAnimSet.UIndex, "m_pBioAnimSetData"));
dynamicAnimSet.WriteProperty(new NameProperty(setName, "m_nmOrigSetName"));
dynamicAnimSet.WriteProperty(new ArrayProperty <ObjectProperty>("Sequences")
{
new ObjectProperty(importedAnimSeq.UIndex)
});
}
catch (Exception e)
{
MessageBox.Show($"Error Loading {animSourceFilePath} #{animSequenceUIndex}");
}
}
string tempFilePath = Path.Combine(ME3Directory.CookedPCPath, $"{saveAsName}.pcc");
pcc.Save(tempFilePath);
InteropHelper.TryPadFile(tempFilePath, 10_485_760);
}
public static void InstallDLC_MOD_Interop()
{
if (Directory.Exists(ModInstallPath))
{
FileSystemHelper.DeleteFilesAndFoldersRecursively(ModInstallPath);
}
Dictionary <string, string> fileMap = MELoadedFiles.GetFilesLoadedInGame(MEGame.ME3, true);
string sourcePath = Path.Combine(App.ExecFolder, modName);
FileSystem.CopyDirectory(sourcePath, ModInstallPath);
PadCamPathFile();
InteropHelper.InstallInteropASI();
string consoleExtASIWritePath = Path.Combine(ME3Directory.ExecutableFolder, "asi", consoleExtASIName);
if (File.Exists(consoleExtASIWritePath))
{
File.Delete(consoleExtASIWritePath);
}
File.Copy(Path.Combine(App.ExecFolder, consoleExtASIName), consoleExtASIWritePath);
const string bioPGlobalFileName = "BioP_Global.pcc";
const string bioPGlobalNCFileName = "BioP_Global_NC.pcc";
var sourceFiles = new List <(string filePath, string md5)>
{
AugmentAndInstall(bioPGlobalFileName),
AugmentAndInstall(bioPGlobalNCFileName)
};
File.WriteAllText(InstallInfoPath, JsonConvert.SerializeObject(new InstallInfo
{
InstallTime = DateTime.Now,
Version = CURRENT_VERSION,
SourceFiles = sourceFiles
}));
AutoTOCWPF.GenerateAllTOCs();
(string, string) AugmentAndInstall(string fileName)
{
string existingFile = fileMap[fileName];
using (IMEPackage pcc = MEPackageHandler.OpenMEPackage(existingFile))
{
AugmentMapToLoadLiveEditor(pcc);
pcc.Save(Path.Combine(ModInstallPath, "CookedPCConsole", fileName));
}
return(existingFile, InteropHelper.CalculateMD5(existingFile));
}
}
/// <summary>
/// Ports a power into a package
/// </summary>
/// <param name="targetPackage"></param>
/// <param name="powerInfo"></param>
/// <param name="additionalPowers">A list of additioanl powers that are referenced when this powerinfo is an import only power (prevent re-opening package)</param>
/// <returns></returns>
public static IEntry PortPowerIntoPackage(IMEPackage targetPackage, PowerInfo powerInfo, out IMEPackage sourcePackage)
{
if (powerInfo.IsCorrectedPackage)
{
var sourceData = MERUtilities.GetEmbeddedStaticFilesBinaryFile("correctedloadouts.powers." + powerInfo.PackageFileName);
sourcePackage = MEPackageHandler.OpenMEPackageFromStream(new MemoryStream(sourceData));
}
else
{
sourcePackage = NonSharedPackageCache.Cache.GetCachedPackage(powerInfo.PackageFileName);
}
if (sourcePackage != null)
{
var sourceExport = sourcePackage.GetUExport(powerInfo.SourceUIndex);
if (!sourceExport.InheritsFrom("SFXPower") || sourceExport.IsDefaultObject)
{
throw new Exception("Wrong setup!");
}
if (sourceExport.Parent != null && sourceExport.Parent.ClassName != "Package")
{
throw new Exception("Cannot port power - parent object is not Package!");
}
var newParent = EntryExporter.PortParents(sourceExport, targetPackage);
IEntry newEntry;
if (powerInfo.ImportOnly)
{
//Debug.WriteLine($"ImportOnly in file {targetPackage.FilePath}");
if (powerInfo.RequiresStartupPackage)
{
ThreadSafeDLCStartupPackage.AddStartupPackage(Path.GetFileNameWithoutExtension(powerInfo.PackageFileName));
if (powerInfo.IsCorrectedPackage)
{
// File must be added to MERFS DLC
var outP = Path.Combine(MERFileSystem.DLCModCookedPath, powerInfo.PackageFileName);
if (!File.Exists(outP))
{
sourcePackage.Save(outP, true);
}
}
}
newEntry = PackageTools.CreateImportForClass(sourceExport, targetPackage, newParent);
// Port in extra imports so the calling class can reference them as necessary.
foreach (var addlPow in powerInfo.AdditionalRequiredPowers)
{
var addlSourceExp = sourcePackage.FindExport(addlPow);
PackageTools.CreateImportForClass(addlSourceExp, targetPackage, EntryExporter.PortParents(addlSourceExp, targetPackage));
}
}
else
{
#if DEBUG
// DEBUG ONLY-----------------------------------
//var defaults = sourceExport.GetDefaults();
//defaults.RemoveProperty("VFX");
//var vfx = defaults.GetProperty<ObjectProperty>("VFX").ResolveToEntry(sourcePackage) as ExportEntry;
//vxx.RemoveProperty("PlayerCrust");
//vfx.FileRef.GetUExport(1544).RemoveProperty("oPrefab");
////vfx = defaults.FileRef.GetUExport(6211); // Prefab
////vfx.RemoveProperty("WorldImpactVisualEffect");
//MERPackageCache cached = new MERPackageCache();
//EntryExporter.ExportExportToPackage(vfx, targetPackage, out newEntry, cached);
//PackageTools.AddReferencesToWorld(targetPackage, new [] {newEntry as ExportEntry});
//return null;
// END DEBUG ONLY--------------------------------
#endif
List <EntryStringPair> relinkResults = null;
if ((powerInfo.IsCorrectedPackage || (PackageTools.IsPersistentPackage(powerInfo.PackageFileName) && MERFileSystem.GetPackageFile(powerInfo.PackageFileName.ToLocalizedFilename()) == null)))
{
// Faster this way, without having to check imports
Dictionary <IEntry, IEntry> crossPCCObjectMap = new Dictionary <IEntry, IEntry>(); // Not sure what this is used for these days. SHould probably just be part of the method
relinkResults = EntryImporter.ImportAndRelinkEntries(EntryImporter.PortingOption.CloneAllDependencies, sourceExport, targetPackage,
newParent, true, out newEntry, crossPCCObjectMap);
}
else
{
// MEMORY SAFE (resolve imports to exports)
MERPackageCache cache = new MERPackageCache();
relinkResults = EntryExporter.ExportExportToPackage(sourceExport, targetPackage, out newEntry, cache);
}
if (relinkResults.Any())
{
Debugger.Break();
}
}
return(newEntry);
}
return(null); // No package was found
}
/// <summary>
/// Copy ME2 Static art and collision into an ME3 file.
/// By Kinkojiro
/// </summary>
/// <param name="Game">Target Game</param>
/// <param name="BioPSource">Source BioP</param>
/// <param name="tgtOutputfolder">OutputFolder</param>
/// <param name="BioArtsToCopy">List of level source file locations</param>
/// <param name="ActorsToMove">Dicitionary: key Actors, value filename, entry uid</param>
/// <param name="AssetsToMove">Dictionary key: AssetInstancedPath, value filename, isimport, entry uid</param>
/// <param name="fromreload">is reloaded json</param>
public static async Task <List <string> > ConvertLevelToGame(MEGame Game, IMEPackage BioPSource, string tgtOutputfolder, string tgttfc, Action <string> callbackAction, LevelConversionData conversionData = null, bool fromreload = false, bool createtestlevel = false)
{
//VARIABLES / VALIDATION
var actorclassesToMove = new List <string>()
{
"BlockingVolume", "SpotLight", "SpotLightToggleable", "PointLight", "PointLightToggleable", "SkyLight", "HeightFog", "LenseFlareSource", "StaticMeshActor", "BioTriggerStream", "BioBlockingVolume"
};
var actorclassesToSubstitute = new Dictionary <string, string>()
{
{ "BioBlockingVolume", "Engine.BlockingVolume" }
};
var archetypesToSubstitute = new Dictionary <string, string>()
{
{ "Default__BioBlockingVolume", "Default__BlockingVolume" }
};
var fails = new List <string>();
string busytext = null;
if ((BioPSource.Game == MEGame.ME2 && ME2Directory.DefaultGamePath == null) || (BioPSource.Game == MEGame.ME1 && ME1Directory.DefaultGamePath == null) || (BioPSource.Game == MEGame.ME3 && ME3Directory.DefaultGamePath == null) || BioPSource.Game == MEGame.UDK)
{
fails.Add("Source Game Directory not found");
return(fails);
}
//Get filelist from BioP, Save a copy in outputdirectory, Collate Actors and asset information
if (!fromreload)
{
busytext = "Collating level files...";
callbackAction?.Invoke(busytext);
conversionData = new LevelConversionData(Game, BioPSource.Game, null, null, null, new ConcurrentDictionary <string, string>(), new ConcurrentDictionary <string, (string, int)>(), new ConcurrentDictionary <string, (string, int, List <string>)>());
var supportedExtensions = new List <string> {
".pcc", ".u", ".upk", ".sfm"
};
if (Path.GetFileName(BioPSource.FilePath).ToLowerInvariant().StartsWith("biop_") && BioPSource.Exports.FirstOrDefault(x => x.ClassName == "BioWorldInfo") is ExportEntry BioWorld)
{
string biopname = Path.GetFileNameWithoutExtension(BioPSource.FilePath);
conversionData.GameLevelName = biopname.Substring(5, biopname.Length - 5);
var lsks = BioWorld.GetProperty <ArrayProperty <ObjectProperty> >("StreamingLevels").ToList();
if (lsks.IsEmpty())
{
fails.Add("No files found in level.");
return(fails);
}
foreach (var l in lsks)
{
var lskexp = BioPSource.GetUExport(l.Value);
var filename = lskexp.GetProperty <NameProperty>("PackageName");
if ((filename?.Value.ToString().ToLowerInvariant().StartsWith("bioa") ?? false) || (filename?.Value.ToString().ToLowerInvariant().StartsWith("biod") ?? false))
{
var filePath = Directory.GetFiles(ME2Directory.DefaultGamePath, $"{filename.Value.Instanced}.pcc", SearchOption.AllDirectories).FirstOrDefault();
conversionData.FilesToCopy.TryAdd(filename.Value.Instanced, filePath);
}
}
conversionData.BioPSource = $"{biopname}_{BioPSource.Game}";
BioPSource.Save(Path.Combine(tgtOutputfolder, $"{conversionData.BioPSource}.pcc"));
BioPSource.Dispose();
}
else
{
fails.Add("Requires an BioP to work with.");
return(fails);
}
busytext = "Collating actors and assets...";
callbackAction?.Invoke(busytext);
Parallel.ForEach(conversionData.FilesToCopy, (pccref) =>
{
using IMEPackage pcc = MEPackageHandler.OpenMEPackage(pccref.Value);
var sourcelevel = pcc.Exports.FirstOrDefault(l => l.ClassName == "Level");
if (ObjectBinary.From(sourcelevel) is Level levelbin)
{
foreach (var act in levelbin.Actors)
{
if (act < 1)
{
continue;
}
var actor = pcc.GetUExport(act);
if (actorclassesToMove.Contains(actor.ClassName))
{
conversionData.ActorsToMove.TryAdd($"{pccref.Key}.{actor.InstancedFullPath}", (pccref.Key, act));
HashSet <int> actorrefs = pcc.GetReferencedEntries(true, true, actor);
foreach (var r in actorrefs)
{
var objref = pcc.GetEntry(r);
if (objref != null)
{
if (objref.InstancedFullPath.Contains("PersistentLevel")) //remove components of actors
{
continue;
}
string instancedPath = objref.InstancedFullPath;
if (objref.idxLink == 0)
{
instancedPath = $"{pccref.Key}.{instancedPath}";
}
var added = conversionData.AssetsToMove.TryAdd(instancedPath, (pccref.Key, r, new List <string>()
{
pccref.Key
}));
if (!added)
{
conversionData.AssetsToMove[instancedPath].Item3.FindOrAdd(pccref.Key);
if (r > 0 && conversionData.AssetsToMove[instancedPath].Item2 < 0) //Replace imports with exports if possible
{
var currentlist = conversionData.AssetsToMove[instancedPath].Item3;
conversionData.AssetsToMove[instancedPath] = (pccref.Key, r, currentlist);
}
}
public static string GenerateUDKFileForLevel(string udkPath, IMEPackage pcc)
{
#region AssetPackage
string meshPackageName = $"{Path.GetFileNameWithoutExtension(pcc.FilePath)}Meshes";
string meshFile = Path.Combine(udkPath, @"UDKGame\Content\Shared\", $"{meshPackageName}.upk");
MEPackageHandler.CreateAndSavePackage(meshFile, MEGame.UDK);
using IMEPackage meshPackage = MEPackageHandler.OpenUDKPackage(meshFile);
meshPackage.getEntryOrAddImport("Core.Package");
IEntry defMat = meshPackage.getEntryOrAddImport("EngineMaterials.DefaultMaterial", "Material", "Engine");
var allMats = new HashSet <int>();
var relinkMap = new Dictionary <IEntry, IEntry>();
#region StaticMeshes
List <ExportEntry> staticMeshes = pcc.Exports.Where(exp => exp.ClassName == "StaticMesh").ToList();
foreach (ExportEntry mesh in staticMeshes)
{
var mats = new Queue <int>();
StaticMesh stm = ObjectBinary.From <StaticMesh>(mesh);
foreach (StaticMeshRenderData lodModel in stm.LODModels)
{
foreach (StaticMeshElement meshElement in lodModel.Elements)
{
mats.Enqueue(meshElement.Material);
allMats.Add(meshElement.Material);
meshElement.Material = 0;
}
}
if (pcc.GetEntry(stm.BodySetup) is ExportEntry rbBodySetup)
{
rbBodySetup.RemoveProperty("PhysMaterial");
}
mesh.WriteBinary(stm);
IEntry newParent = EntryImporter.GetOrAddCrossImportOrPackage(mesh.ParentFullPath, pcc, meshPackage);
EntryImporter.ImportAndRelinkEntries(EntryImporter.PortingOption.CloneTreeAsChild, mesh, meshPackage, newParent, false, out IEntry ent, relinkMap);
ExportEntry portedMesh = (ExportEntry)ent;
stm = ObjectBinary.From <StaticMesh>(portedMesh);
foreach (StaticMeshRenderData lodModel in stm.LODModels)
{
foreach (StaticMeshElement meshElement in lodModel.Elements)
{
meshElement.Material = mats.Dequeue();
}
}
portedMesh.WriteBinary(stm);
}
#endregion
#region Materials
using (IMEPackage udkResources = MEPackageHandler.OpenMEPackageFromStream(Utilities.GetCustomAppResourceStream(MEGame.UDK)))
{
ExportEntry normDiffMat = udkResources.Exports.First(exp => exp.ObjectName == "NormDiffMat");
foreach (int matUIndex in allMats)
{
if (pcc.GetEntry(matUIndex) is ExportEntry matExp)
{
List <IEntry> textures = new MaterialInstanceConstant(matExp).Textures;
ExportEntry diff = null;
ExportEntry norm = null;
foreach (IEntry texEntry in textures)
{
if (texEntry is ExportEntry texport)
{
if (texport.ObjectName.Name.ToLower().Contains("diff"))
{
diff = texport;
}
else if (texport.ObjectName.Name.ToLower().Contains("norm"))
{
norm = texport;
}
}
}
if (diff == null)
{
relinkMap[matExp] = defMat;
continue;
}
else
{
EntryImporter.ImportAndRelinkEntries(EntryImporter.PortingOption.AddSingularAsChild, diff, meshPackage, null, false, out IEntry ent);
diff = (ExportEntry)ent;
diff.RemoveProperty("TextureFileCacheName");
diff.RemoveProperty("TFCFileGuid");
diff.RemoveProperty("LODGroup");
}
if (norm != null)
{
EntryImporter.ImportAndRelinkEntries(EntryImporter.PortingOption.AddSingularAsChild, norm, meshPackage, null, false, out IEntry ent);
norm = (ExportEntry)ent;
norm.RemoveProperty("TextureFileCacheName");
norm.RemoveProperty("TFCFileGuid");
norm.RemoveProperty("LODGroup");
}
EntryImporter.ImportAndRelinkEntries(EntryImporter.PortingOption.CloneTreeAsChild, normDiffMat, meshPackage, null, true, out IEntry matEnt);
ExportEntry newMat = (ExportEntry)matEnt;
newMat.ObjectName = matExp.ObjectName;
Material matBin = ObjectBinary.From <Material>(newMat);
matBin.SM3MaterialResource.UniformExpressionTextures = new UIndex[] { norm?.UIndex ?? 0, diff.UIndex };
newMat.WriteBinary(matBin);
relinkMap[matExp] = newMat;
if (newMat.GetProperty <ArrayProperty <ObjectProperty> >("Expressions") is {} expressionsProp&& expressionsProp.Count >= 2)
{
ExportEntry diffExpression = meshPackage.GetUExport(expressionsProp[0].Value);
ExportEntry normExpression = meshPackage.GetUExport(expressionsProp[1].Value);
diffExpression.WriteProperty(new ObjectProperty(diff.UIndex, "Texture"));
normExpression.WriteProperty(new ObjectProperty(norm?.UIndex ?? 0, "Texture"));
}
}
else if (pcc.GetEntry(matUIndex) is ImportEntry matImp)
{
relinkMap[matImp] = defMat;
}
}
var relinkMapping = new OrderedMultiValueDictionary <IEntry, IEntry>(relinkMap);
foreach (ExportEntry stmExport in staticMeshes)
{
if (relinkMap.TryGetValue(stmExport, out IEntry destEnt) && destEnt is ExportEntry destExp)
{
Relinker.Relink(stmExport, destExp, relinkMapping);
}
}
}
#endregion
meshPackage.Save();
#endregion
var staticMeshActors = new List <ExportEntry>();
var lightActors = new List <ExportEntry>();
string tempPackagePath = Path.Combine(App.ExecFolder, $"{Path.GetFileNameWithoutExtension(pcc.FilePath)}.udk");
File.Copy(Path.Combine(App.ExecFolder, "empty.udk"), tempPackagePath, true);
using IMEPackage udkPackage = MEPackageHandler.OpenUDKPackage(tempPackagePath);
{
var topLevelMeshPackages = new List <IEntry>();
foreach (ExportEntry exportEntry in staticMeshes)
{
IEntry imp = udkPackage.getEntryOrAddImport($"{exportEntry.FullPath}", "StaticMesh", "Engine", exportEntry.ObjectName.Number);
while (imp.Parent != null)
{
imp = imp.Parent;
}
if (!topLevelMeshPackages.Contains(imp))
{
topLevelMeshPackages.Add(imp);
}
}
ExportEntry levelExport = udkPackage.Exports.First(exp => exp.ClassName == "Level");
List <int> actorsInLevel = ObjectBinary.From <Level>(pcc.Exports.First(exp => exp.ClassName == "Level")).Actors.Select(u => u.value).ToList();
var componentToMatrixMap = new Dictionary <int, Matrix>();
foreach (int uIndex in actorsInLevel)
{
if (pcc.GetEntry(uIndex) is ExportEntry stcExp)
{
if (stcExp.ClassName == "StaticMeshCollectionActor")
{
StaticMeshCollectionActor stmc = ObjectBinary.From <StaticMeshCollectionActor>(stcExp);
var components = stcExp.GetProperty <ArrayProperty <ObjectProperty> >("StaticMeshComponents");
for (int i = 0; i < components.Count; i++)
{
componentToMatrixMap[components[i].Value] = stmc.LocalToWorldTransforms[i];
}
}
else if (stcExp.ClassName == "StaticLightCollectionActor")
{
StaticLightCollectionActor stlc = ObjectBinary.From <StaticLightCollectionActor>(stcExp);
var components = stcExp.GetProperty <ArrayProperty <ObjectProperty> >("LightComponents");
for (int i = 0; i < components.Count; i++)
{
componentToMatrixMap[components[i].Value] = stlc.LocalToWorldTransforms[i];
}
}
}
}
#region StaticMeshActors
{
var emptySMCBin = new StaticMeshComponent();
IEntry staticMeshActorClass = udkPackage.getEntryOrAddImport("Engine.StaticMeshActor");
udkPackage.getEntryOrAddImport("Engine.Default__StaticMeshActor", "StaticMeshActor", "Engine");
IEntry staticMeshComponentArchetype = udkPackage.getEntryOrAddImport("Engine.Default__StaticMeshActor.StaticMeshComponent0",
"StaticMeshComponent", "Engine");
int smaIndex = 2;
int smcIndex = 2;
foreach (ExportEntry smc in pcc.Exports.Where(exp => exp.ClassName == "StaticMeshComponent"))
{
if (smc.Parent is ExportEntry parent && actorsInLevel.Contains(parent.UIndex) && parent.IsA("StaticMeshActorBase"))
{
StructProperty locationProp;
StructProperty rotationProp;
StructProperty scaleProp = null;
smc.CondenseArchetypes();
if (!(smc.GetProperty <ObjectProperty>("StaticMesh") is { } meshProp) || !pcc.IsUExport(meshProp.Value))
{
continue;
}
smc.WriteBinary(emptySMCBin);
smc.RemoveProperty("bBioIsReceivingDecals");
smc.RemoveProperty("bBioForcePrecomputedShadows");
//smc.RemoveProperty("bUsePreComputedShadows");
smc.RemoveProperty("bAcceptsLights");
smc.RemoveProperty("IrrelevantLights");
smc.RemoveProperty("Materials"); //should make use of this?
smc.ObjectName = new NameReference("StaticMeshComponent", smcIndex++);
if (parent.ClassName == "StaticMeshCollectionActor")
{
if (!componentToMatrixMap.TryGetValue(smc.UIndex, out Matrix m))
{
continue;
}
(Vector3 posVec, Vector3 scaleVec, Rotator rotator) = m.UnrealDecompose();
locationProp = CommonStructs.Vector3Prop(posVec, "Location");
rotationProp = CommonStructs.RotatorProp(rotator, "Rotation");
scaleProp = CommonStructs.Vector3Prop(scaleVec, "DrawScale3D");
//smc.WriteProperty(CommonStructs.Matrix(m, "CachedParentToWorld"));
}
else
{
locationProp = parent.GetProperty <StructProperty>("Location");
rotationProp = parent.GetProperty <StructProperty>("Rotation");
scaleProp = parent.GetProperty <StructProperty>("DrawScale3D");
if (parent.GetProperty <FloatProperty>("DrawScale")?.Value is float scale)
{
Vector3 scaleVec = Vector3.One;
if (scaleProp != null)
{
scaleVec = CommonStructs.GetVector3(scaleProp);
}
scaleProp = CommonStructs.Vector3Prop(scaleVec * scale, "DrawScale3D");
}
}
ExportEntry sma = new ExportEntry(udkPackage, EntryImporter.CreateStack(MEGame.UDK, staticMeshActorClass.UIndex))
{
ObjectName = new NameReference("StaticMeshActor", smaIndex++),
Class = staticMeshActorClass,
Parent = levelExport
};
sma.ObjectFlags |= UnrealFlags.EObjectFlags.HasStack;
udkPackage.AddExport(sma);
EntryImporter.ImportAndRelinkEntries(EntryImporter.PortingOption.AddSingularAsChild, smc, udkPackage,
sma, true, out IEntry result);
var props = new PropertyCollection
{
new ObjectProperty(result.UIndex, "StaticMeshComponent"),
new NameProperty(new NameReference(Path.GetFileNameWithoutExtension(smc.FileRef.FilePath), smc.UIndex),
"Tag"),
new ObjectProperty(result.UIndex, "CollisionComponent")
};
if (locationProp != null)
{
props.Add(locationProp);
}
if (rotationProp != null)
{
props.Add(rotationProp);
}
if (scaleProp != null)
{
props.Add(scaleProp);
}
sma.WriteProperties(props);
staticMeshActors.Add(sma);
}
}
IEntry topMeshPackageImport = udkPackage.getEntryOrAddImport(meshPackageName, "Package");
foreach (IEntry mp in topLevelMeshPackages)
{
mp.Parent = topMeshPackageImport;
}
}
#endregion
#region LightActors
{
IEntry pointLightClass = udkPackage.getEntryOrAddImport("Engine.PointLight");
IEntry spotLightClass = udkPackage.getEntryOrAddImport("Engine.SpotLight");
IEntry directionalLightClass = udkPackage.getEntryOrAddImport("Engine.DirectionalLight");
int plaIndex = 1;
int plcIndex = 1;
int slaIndex = 1;
int slcIndex = 1;
int dlaIndex = 1;
int dlcIndex = 1;
foreach (ExportEntry lightComponent in pcc.Exports)
{
if (!(lightComponent.Parent is ExportEntry parent && actorsInLevel.Contains(parent.UIndex)))
{
continue;
}
StructProperty locationProp;
StructProperty rotationProp;
StructProperty scaleProp;
switch (lightComponent.ClassName)
{
case "PointLightComponent":
lightComponent.CondenseArchetypes();
lightComponent.ObjectName = new NameReference("PointLightComponent", plcIndex++);
if (parent.ClassName == "StaticLightCollectionActor")
{
if (!componentToMatrixMap.TryGetValue(lightComponent.UIndex, out Matrix m))
{
continue;
}
(Vector3 posVec, Vector3 scaleVec, Rotator rotator) = m.UnrealDecompose();
locationProp = CommonStructs.Vector3Prop(posVec, "Location");
rotationProp = CommonStructs.RotatorProp(rotator, "Rotation");
scaleProp = CommonStructs.Vector3Prop(scaleVec, "DrawScale3D");
}
else
{
locationProp = parent.GetProperty <StructProperty>("Location");
rotationProp = parent.GetProperty <StructProperty>("Rotation");
scaleProp = parent.GetProperty <StructProperty>("DrawScale3D");
if (parent.GetProperty <FloatProperty>("DrawScale")?.Value is float scale)
{
Vector3 scaleVec = Vector3.One;
if (scaleProp != null)
{
scaleVec = CommonStructs.GetVector3(scaleProp);
}
scaleProp = CommonStructs.Vector3Prop(scaleVec * scale, "DrawScale3D");
}
}
ExportEntry pla = new ExportEntry(udkPackage, EntryImporter.CreateStack(MEGame.UDK, pointLightClass.UIndex))
{
ObjectName = new NameReference("PointLight", plaIndex++),
Class = pointLightClass,
Parent = levelExport
};
pla.ObjectFlags |= UnrealFlags.EObjectFlags.HasStack;
udkPackage.AddExport(pla);
EntryImporter.ImportAndRelinkEntries(EntryImporter.PortingOption.AddSingularAsChild, lightComponent, udkPackage, pla, true,
out IEntry portedPLC);
var plsProps = new PropertyCollection
{
new ObjectProperty(portedPLC.UIndex, "LightComponent"),
new NameProperty("PointLight", "Tag"),
};
if (locationProp != null)
{
plsProps.Add(locationProp);
}
if (rotationProp != null)
{
plsProps.Add(rotationProp);
}
if (scaleProp != null)
{
plsProps.Add(scaleProp);
}
pla.WriteProperties(plsProps);
lightActors.Add(pla);
break;
case "SpotLightComponent":
lightComponent.CondenseArchetypes();
lightComponent.ObjectName = new NameReference("SpotLightComponent", slcIndex++);
if (parent.ClassName == "StaticLightCollectionActor")
{
if (!componentToMatrixMap.TryGetValue(lightComponent.UIndex, out Matrix m))
{
continue;
}
(Vector3 posVec, Vector3 scaleVec, Rotator rotator) = m.UnrealDecompose();
locationProp = CommonStructs.Vector3Prop(posVec, "Location");
rotationProp = CommonStructs.RotatorProp(rotator, "Rotation");
scaleProp = CommonStructs.Vector3Prop(scaleVec, "DrawScale3D");
}
else
{
locationProp = parent.GetProperty <StructProperty>("Location");
rotationProp = parent.GetProperty <StructProperty>("Rotation");
scaleProp = parent.GetProperty <StructProperty>("DrawScale3D");
if (parent.GetProperty <FloatProperty>("DrawScale")?.Value is float scale)
{
Vector3 scaleVec = Vector3.One;
if (scaleProp != null)
{
scaleVec = CommonStructs.GetVector3(scaleProp);
}
scaleProp = CommonStructs.Vector3Prop(scaleVec * scale, "DrawScale3D");
}
}
ExportEntry sla = new ExportEntry(udkPackage, EntryImporter.CreateStack(MEGame.UDK, spotLightClass.UIndex))
{
ObjectName = new NameReference("SpotLight", slaIndex++),
Class = spotLightClass,
Parent = levelExport
};
sla.ObjectFlags |= UnrealFlags.EObjectFlags.HasStack;
udkPackage.AddExport(sla);
EntryImporter.ImportAndRelinkEntries(EntryImporter.PortingOption.AddSingularAsChild, lightComponent, udkPackage, sla, true,
out IEntry portedSLC);
var slaProps = new PropertyCollection
{
new ObjectProperty(portedSLC.UIndex, "LightComponent"),
new NameProperty("SpotLight", "Tag"),
};
if (locationProp != null)
{
slaProps.Add(locationProp);
}
if (rotationProp != null)
{
slaProps.Add(rotationProp);
}
if (scaleProp != null)
{
slaProps.Add(scaleProp);
}
sla.WriteProperties(slaProps);
lightActors.Add(sla);
break;
case "DirectionalLightComponent":
lightComponent.CondenseArchetypes();
lightComponent.ObjectName = new NameReference("DirectionalLightComponent", dlcIndex++);
if (parent.ClassName == "StaticLightCollectionActor")
{
if (!componentToMatrixMap.TryGetValue(lightComponent.UIndex, out Matrix m))
{
continue;
}
(Vector3 posVec, Vector3 scaleVec, Rotator rotator) = m.UnrealDecompose();
locationProp = CommonStructs.Vector3Prop(posVec, "Location");
rotationProp = CommonStructs.RotatorProp(rotator, "Rotation");
scaleProp = CommonStructs.Vector3Prop(scaleVec, "DrawScale3D");
}
else
{
locationProp = parent.GetProperty <StructProperty>("Location");
rotationProp = parent.GetProperty <StructProperty>("Rotation");
scaleProp = parent.GetProperty <StructProperty>("DrawScale3D");
if (parent.GetProperty <FloatProperty>("DrawScale")?.Value is float scale)
{
Vector3 scaleVec = Vector3.One;
if (scaleProp != null)
{
scaleVec = CommonStructs.GetVector3(scaleProp);
}
scaleProp = CommonStructs.Vector3Prop(scaleVec * scale, "DrawScale3D");
}
}
ExportEntry dla = new ExportEntry(udkPackage, EntryImporter.CreateStack(MEGame.UDK, directionalLightClass.UIndex))
{
ObjectName = new NameReference("DirectionalLight", dlaIndex++),
Class = directionalLightClass,
Parent = levelExport
};
dla.ObjectFlags |= UnrealFlags.EObjectFlags.HasStack;
udkPackage.AddExport(dla);
EntryImporter.ImportAndRelinkEntries(EntryImporter.PortingOption.AddSingularAsChild, lightComponent, udkPackage, dla, true,
out IEntry portedDLC);
var dlaProps = new PropertyCollection
{
new ObjectProperty(portedDLC.UIndex, "LightComponent"),
new NameProperty("DirectionalLight", "Tag"),
};
if (locationProp != null)
{
dlaProps.Add(locationProp);
}
if (rotationProp != null)
{
dlaProps.Add(rotationProp);
}
if (scaleProp != null)
{
dlaProps.Add(scaleProp);
}
dla.WriteProperties(dlaProps);
lightActors.Add(dla);
break;
}
}
}
UDKifyLights(udkPackage);
#endregion
Level level = ObjectBinary.From <Level>(levelExport);
level.Actors = levelExport.GetChildren().Where(ent => ent.IsA("Actor")).Select(ent => new UIndex(ent.UIndex)).ToList();
levelExport.WriteBinary(level);
udkPackage.Save();
}
string resultFilePath = Path.Combine(udkPath, @"UDKGame\Content\Maps\", $"{Path.GetFileNameWithoutExtension(pcc.FilePath)}.udk");
using (IMEPackage udkPackage2 = MEPackageHandler.OpenUDKPackage(Path.Combine(App.ExecFolder, "empty.udk")))
{
ExportEntry levelExport = udkPackage2.Exports.First(exp => exp.ClassName == "Level");
Level levelBin = ObjectBinary.From <Level>(levelExport);
foreach (ExportEntry actor in staticMeshActors)
{
EntryImporter.ImportAndRelinkEntries(EntryImporter.PortingOption.CloneTreeAsChild, actor, udkPackage2, levelExport, true, out IEntry result);
levelBin.Actors.Add(result.UIndex);
}
foreach (ExportEntry actor in lightActors)
{
EntryImporter.ImportAndRelinkEntries(EntryImporter.PortingOption.CloneTreeAsChild, actor, udkPackage2, levelExport, true, out IEntry result);
levelBin.Actors.Add(result.UIndex);
}
levelExport.WriteBinary(levelBin);
udkPackage2.Save(resultFilePath);
}
File.Delete(tempPackagePath);
return(resultFilePath);
}
public static void RunGame2EmailMerge(GameTarget target)
{
M3MergeDLC.RemoveMergeDLC(target);
var loadedFiles = MELoadedFiles.GetFilesLoadedInGame(target.Game, gameRootOverride: target.TargetPath);
// File to base modifications on
using IMEPackage pcc = MEPackageHandler.OpenMEPackage(loadedFiles[@"BioD_Nor103_Messages.pcc"]);
// Path to Message templates file - different files for ME2/LE2
string ResourcesFilePath = $@"MassEffectModManagerCore.modmanager.emailmerge.{target.Game}.103Message_Template_{target.Game}";
using IMEPackage resources = MEPackageHandler.OpenMEPackageFromStream(Utilities.GetResourceStream(ResourcesFilePath));
// Startup file to place conditionals and transitions into
using IMEPackage startup = MEPackageHandler.OpenMEPackageFromStream(Utilities.GetResourceStream(
$@"MassEffectModManagerCore.modmanager.mergedlc.{target.Game}.Startup_{M3MergeDLC.MERGE_DLC_FOLDERNAME}.pcc"));
var emailInfos = new List <ME2EmailMergeFile>();
var jsonSupercedances = M3Directories.GetFileSupercedances(target, new[] { @".json" });
if (jsonSupercedances.TryGetValue(EMAIL_MERGE_MANIFEST_FILE, out var jsonList))
{
jsonList.Reverse();
foreach (var dlc in jsonList)
{
var jsonFile = Path.Combine(M3Directories.GetDLCPath(target), dlc, target.Game.CookedDirName(),
EMAIL_MERGE_MANIFEST_FILE);
emailInfos.Add(JsonConvert.DeserializeObject <ME2EmailMergeFile>(File.ReadAllText(jsonFile)));
}
}
// Sanity checks
if (!emailInfos.Any() || !emailInfos.SelectMany(e => e.Emails).Any())
{
return;
}
if (emailInfos.Any(e => e.Game != target.Game))
{
throw new Exception("ME2 email merge manifest targets incorrect game");
}
// Startup File
// Could replace this with full instanced path in M3 implementation
ExportEntry stateEventMapExport = startup.Exports
.First(e => e.ClassName == "BioStateEventMap" && e.ObjectName == "StateTransitionMap");
BioStateEventMap StateEventMap = stateEventMapExport.GetBinaryData <BioStateEventMap>();
ExportEntry ConditionalClass =
startup.FindExport($@"PlotManager{M3MergeDLC.MERGE_DLC_FOLDERNAME}.BioAutoConditionals");
#region Sequence Exports
// Send message - All email conditionals are checked and emails transitions are triggered
ExportEntry SendMessageContainer = pcc.FindExport(@"TheWorld.PersistentLevel.Main_Sequence.Send_Messages");
ExportEntry LastSendMessage = KismetHelper.GetSequenceObjects(SendMessageContainer).OfType <ExportEntry>()
.FirstOrDefault(e =>
{
var outbound = KismetHelper.GetOutboundLinksOfNode(e);
return(outbound.Count == 1 && outbound[0].Count == 0);
});
ExportEntry TemplateSendMessage = resources.FindExport(@"TheWorld.PersistentLevel.Main_Sequence.Send_MessageTemplate");
ExportEntry TemplateSendMessageBoolCheck = resources.FindExport(@"TheWorld.PersistentLevel.Main_Sequence.Send_MessageTemplate_BoolCheck");
// Mark Read - email ints are set to read
// This is the only section that does not gracefully handle different DLC installations - DLC_CER is required atm
ExportEntry MarkReadContainer = pcc.FindExport(@"TheWorld.PersistentLevel.Main_Sequence.Mark_Read");
ExportEntry LastMarkRead = pcc.FindExport(@"TheWorld.PersistentLevel.Main_Sequence.Mark_Read.DLC_CER");
ExportEntry MarkReadOutLink = KismetHelper.GetOutboundLinksOfNode(LastMarkRead)[0][0].LinkedOp as ExportEntry;
KismetHelper.RemoveOutputLinks(LastMarkRead);
ExportEntry TemplateMarkRead = resources.FindExport(@"TheWorld.PersistentLevel.Main_Sequence.Mark_ReadTemplate");
ExportEntry TemplateMarkReadTransition = resources.FindExport(@"TheWorld.PersistentLevel.Main_Sequence.Mark_Read_Transition");
// Display Messages - Str refs are passed through to GUI
ExportEntry DisplayMessageContainer =
pcc.FindExport(@"TheWorld.PersistentLevel.Main_Sequence.Display_Messages");
ExportEntry DisplayMessageOutLink =
pcc.FindExport(@"TheWorld.PersistentLevel.Main_Sequence.Display_Messages.SeqCond_CompareBool_0");
ExportEntry LastDisplayMessage = SeqTools.FindOutboundConnectionsToNode(DisplayMessageOutLink, KismetHelper.GetSequenceObjects(DisplayMessageContainer).OfType <ExportEntry>())[0];
KismetHelper.RemoveOutputLinks(LastDisplayMessage);
var DisplayMessageVariableLinks = LastDisplayMessage.GetProperty <ArrayProperty <StructProperty> >("VariableLinks");
ExportEntry TemplateDisplayMessage =
resources.FindExport(@"TheWorld.PersistentLevel.Main_Sequence.Display_MessageTemplate");
// Archive Messages - Message ints are set to 3
ExportEntry ArchiveContainer = pcc.FindExport(@"TheWorld.PersistentLevel.Main_Sequence.Archive_Message");
ExportEntry ArchiveSwitch = pcc.FindExport(@"TheWorld.PersistentLevel.Main_Sequence.Archive_Message.SeqAct_Switch_0");
ExportEntry ArchiveOutLink =
pcc.FindExport(
@"TheWorld.PersistentLevel.Main_Sequence.Archive_Message.BioSeqAct_PMCheckConditional_1");
ExportEntry ExampleSetInt = KismetHelper.GetOutboundLinksOfNode(ArchiveSwitch)[0][0].LinkedOp as ExportEntry;
ExportEntry ExamplePlotInt = SeqTools.GetVariableLinksOfNode(ExampleSetInt)[0].LinkedNodes[0] as ExportEntry;
#endregion
int messageID = KismetHelper.GetOutboundLinksOfNode(ArchiveSwitch).Count + 1;
int currentSwCount = ArchiveSwitch.GetProperty <IntProperty>("LinkCount").Value;
foreach (var emailMod in emailInfos)
{
string modName = "DLC_MOD_" + emailMod.ModName;
foreach (var email in emailMod.Emails)
{
string emailName = modName + "_" + email.EmailName;
// Create send transition
int transitionId = WriteTransition(StateEventMap, email.StatusPlotInt);
int conditionalId = WriteConditional(email.TriggerConditional);
#region SendMessage
//////////////
// SendMessage
//////////////
// Create seq object
var SMTemp = emailMod.InMemoryBool.HasValue ? TemplateSendMessageBoolCheck : TemplateSendMessage;
EntryImporter.ImportAndRelinkEntries(EntryImporter.PortingOption.CloneTreeAsChild,
SMTemp, pcc, SendMessageContainer, true, new RelinkerOptionsPackage(), out var outSendEntry);
var newSend = outSendEntry as ExportEntry;
// Set name, comment, add to sequence
newSend.ObjectName = new NameReference(emailName);
KismetHelper.AddObjectToSequence(newSend, SendMessageContainer);
KismetHelper.SetComment(newSend, emailName);
if (target.Game == MEGame.ME2)
{
newSend.WriteProperty(new StrProperty(emailName, "ObjName"));
}
// Set Trigger Conditional
var pmCheckConditionalSM = newSend.GetChildren()
.FirstOrDefault(e => e.ClassName == "BioSeqAct_PMCheckConditional" && e is ExportEntry);
if (pmCheckConditionalSM is ExportEntry conditional)
{
conditional.WriteProperty(new IntProperty(conditionalId, "m_nIndex"));
KismetHelper.SetComment(conditional, "Time for " + email.EmailName + "?");
}
// Set Send Transition
var pmExecuteTransitionSM = newSend.GetChildren()
.FirstOrDefault(e => e.ClassName == "BioSeqAct_PMExecuteTransition" && e is ExportEntry);
if (pmExecuteTransitionSM is ExportEntry transition)
{
transition.WriteProperty(new IntProperty(transitionId, "m_nIndex"));
KismetHelper.SetComment(transition, "Send " + email.EmailName + " message.");
}
// Set Send Transition
if (emailMod.InMemoryBool.HasValue)
{
var pmCheckStateSM = newSend.GetChildren()
.FirstOrDefault(e => e.ClassName == "BioSeqAct_PMCheckState" && e is ExportEntry);
if (pmCheckStateSM is ExportEntry checkState)
{
checkState.WriteProperty(new IntProperty(emailMod.InMemoryBool.Value, "m_nIndex"));
KismetHelper.SetComment(checkState, "Is " + emailMod.ModName + " installed?");
}
}
// Hook up output links
KismetHelper.CreateOutputLink(LastSendMessage, "Out", newSend);
LastSendMessage = newSend;
#endregion
#region MarkRead
///////////
// MarkRead
///////////
// Create seq object
var MRTemp = email.ReadTransition.HasValue ? TemplateMarkReadTransition : TemplateMarkRead;
EntryImporter.ImportAndRelinkEntries(EntryImporter.PortingOption.CloneTreeAsChild,
MRTemp, pcc, MarkReadContainer, true, new RelinkerOptionsPackage(), out var outMarkReadEntry);
var newMarkRead = outMarkReadEntry as ExportEntry;
// Set name, comment, add to sequence
newMarkRead.ObjectName = new NameReference(emailName);
KismetHelper.AddObjectToSequence(newMarkRead, MarkReadContainer);
KismetHelper.SetComment(newMarkRead, emailName);
if (target.Game == MEGame.ME2)
{
newMarkRead.WriteProperty(new StrProperty(emailName, "ObjName"));
}
// Set Plot Int
var storyManagerIntMR = newMarkRead.GetChildren()
.FirstOrDefault(e => e.ClassName == "BioSeqVar_StoryManagerInt" && e is ExportEntry);
if (storyManagerIntMR is ExportEntry plotIntMR)
{
plotIntMR.WriteProperty(new IntProperty(email.StatusPlotInt, "m_nIndex"));
KismetHelper.SetComment(plotIntMR, email.EmailName);
}
if (email.ReadTransition.HasValue)
{
var pmExecuteTransitionMR = newMarkRead.GetChildren()
.FirstOrDefault(e => e.ClassName == "BioSeqAct_PMExecuteTransition" && e is ExportEntry);
if (pmExecuteTransitionMR is ExportEntry transitionMR)
{
transitionMR.WriteProperty(new IntProperty(email.ReadTransition.Value, "m_nIndex"));
KismetHelper.SetComment(transitionMR, "Trigger " + email.EmailName + " read transition");
}
}
// Hook up output links
KismetHelper.CreateOutputLink(LastMarkRead, "Out", newMarkRead);
LastMarkRead = newMarkRead;
#endregion
#region DisplayEmail
////////////////
// Display Email
////////////////
// Create seq object
EntryImporter.ImportAndRelinkEntries(EntryImporter.PortingOption.CloneTreeAsChild,
TemplateDisplayMessage, pcc, DisplayMessageContainer, true, new RelinkerOptionsPackage(), out var outDisplayMessage);
var newDisplayMessage = outDisplayMessage as ExportEntry;
// Set name, comment, variable links, add to sequence
newDisplayMessage.ObjectName = new NameReference(emailName);
KismetHelper.AddObjectToSequence(newDisplayMessage, DisplayMessageContainer);
newDisplayMessage.WriteProperty(DisplayMessageVariableLinks);
KismetHelper.SetComment(newDisplayMessage, emailName);
if (target.Game == MEGame.ME2)
{
newDisplayMessage.WriteProperty(new StrProperty(emailName, "ObjName"));
}
var displayChildren = newDisplayMessage.GetChildren();
// Set Plot Int
var storyManagerIntDE = displayChildren.FirstOrDefault(e =>
e.ClassName == "BioSeqVar_StoryManagerInt" && e is ExportEntry);
if (storyManagerIntDE is ExportEntry plotIntDE)
{
plotIntDE.WriteProperty(new IntProperty(email.StatusPlotInt, "m_nIndex"));
}
// Set Email ID
var emailIdDE = displayChildren.FirstOrDefault(e =>
e.ClassName == "SeqVar_Int" && e is ExportEntry);
if (emailIdDE is ExportEntry EmailIDDE)
{
EmailIDDE.WriteProperty(new IntProperty(messageID, "IntValue"));
}
// Set Title StrRef
var titleStrRef = displayChildren.FirstOrDefault(e =>
e.ClassName == "BioSeqVar_StrRef" && e is ExportEntry ee && ee.GetProperty <NameProperty>("VarName").Value == "Title StrRef");
if (titleStrRef is ExportEntry Title)
{
Title.WriteProperty(new StringRefProperty(email.TitleStrRef, "m_srValue"));
}
// Set Description StrRef
var descStrRef = displayChildren.FirstOrDefault(e =>
e.ClassName == "BioSeqVar_StrRef" && e is ExportEntry ee && ee.GetProperty <NameProperty>("VarName").Value == "Desc StrRef");
if (descStrRef is ExportEntry Desc)
{
Desc.WriteProperty(new StringRefProperty(email.DescStrRef, "m_srValue"));
}
// Hook up output links
KismetHelper.CreateOutputLink(LastDisplayMessage, "Out", newDisplayMessage);
LastDisplayMessage = newDisplayMessage;
#endregion
#region ArchiveEmail
////////////////
// Archive Email
////////////////
var NewSetInt = EntryCloner.CloneEntry(ExampleSetInt);
KismetHelper.AddObjectToSequence(NewSetInt, ArchiveContainer);
KismetHelper.CreateOutputLink(NewSetInt, "Out", ArchiveOutLink);
KismetHelper.CreateNewOutputLink(ArchiveSwitch, "Link " + (messageID - 1), NewSetInt);
var NewPlotInt = EntryCloner.CloneEntry(ExamplePlotInt);
KismetHelper.AddObjectToSequence(NewPlotInt, ArchiveContainer);
NewPlotInt.WriteProperty(new IntProperty(email.StatusPlotInt, "m_nIndex"));
NewPlotInt.WriteProperty(new StrProperty(emailName, "m_sRefName"));
var linkedVars = SeqTools.GetVariableLinksOfNode(NewSetInt);
linkedVars[0].LinkedNodes = new List <IEntry>()
{
NewPlotInt
};
SeqTools.WriteVariableLinksToNode(NewSetInt, linkedVars);
messageID++;
currentSwCount++;
#endregion
}
}
KismetHelper.CreateOutputLink(LastMarkRead, "Out", MarkReadOutLink);
KismetHelper.CreateOutputLink(LastDisplayMessage, "Out", DisplayMessageOutLink);
ArchiveSwitch.WriteProperty(new IntProperty(currentSwCount, "LinkCount"));
stateEventMapExport.WriteBinary(StateEventMap);
// Save Messages file into DLC
var cookedDir = Path.Combine(M3Directories.GetDLCPath(target), M3MergeDLC.MERGE_DLC_FOLDERNAME, target.Game.CookedDirName());
var outMessages = Path.Combine(cookedDir, @"BioD_Nor103_Messages.pcc");
pcc.Save(outMessages);
// Save Startup file into DLC
var startupF = Path.Combine(cookedDir, $@"Startup_{M3MergeDLC.MERGE_DLC_FOLDERNAME}.pcc");
startup.Save(startupF);
}