public static IEntry PortWeaponIntoPackage(IMEPackage targetPackage, GunInfo gunInfo)
{
IMEPackage sourcePackage;
if (gunInfo.IsCorrectedPackage)
{
var sourceData = MERUtilities.GetEmbeddedStaticFilesBinaryFile("correctedloadouts.weapons." + gunInfo.PackageFileName);
sourcePackage = MEPackageHandler.OpenMEPackageFromStream(new MemoryStream(sourceData));
if (gunInfo.ImportOnly)
{
// We need to install this file
var outfname = Path.Combine(MERFileSystem.DLCModCookedPath, gunInfo.PackageFileName);
if (!File.Exists(outfname))
{
sourcePackage.Save(outfname, true);
ThreadSafeDLCStartupPackage.AddStartupPackage(Path.GetFileNameWithoutExtension(gunInfo.PackageFileName));
}
}
}
else
{
sourcePackage = NonSharedPackageCache.Cache.GetCachedPackage(gunInfo.PackageFileName);
}
if (sourcePackage != null)
{
var sourceExport = sourcePackage.GetUExport(gunInfo.SourceUIndex);
if (!sourceExport.InheritsFrom("SFXWeapon") || sourceExport.IsDefaultObject)
{
throw new Exception("Wrong setup!");
}
if (sourceExport.Parent != null && sourceExport.Parent.ClassName != "Package")
{
throw new Exception("Cannot port weapon - parent object is not Package!");
}
// 1. Setup the link that will be used.
//var newParent = EntryExporter.PortParents(sourceExport, targetPackage);
var newParent = EntryExporter.PortParents(sourceExport, targetPackage, gunInfo.ImportOnly);
void errorOccuredCB(string s)
{
Debugger.Break();
}
IEntry newEntry = null;
if (gunInfo.ImportOnly)
{
Debug.WriteLine($"Gun ImportOnly in file {targetPackage.FilePath}");
if (gunInfo.RequiresStartupPackage)
{
ThreadSafeDLCStartupPackage.AddStartupPackage(Path.GetFileNameWithoutExtension(gunInfo.PackageFileName));
}
newEntry = PackageTools.CreateImportForClass(sourceExport, targetPackage, newParent);
}
else
{
List <EntryStringPair> relinkResults = null;
if (gunInfo.IsCorrectedPackage || (PackageTools.IsPersistentPackage(gunInfo.PackageFileName) && MERFileSystem.GetPackageFile(gunInfo.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);
}
else
{
Debug.WriteLine($"Package for gun porting not found: {gunInfo.PackageFileName}");
}
return(null); // No package was found
}
/// <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>
/// Ports an export into a package. Checks if the export already exists, and if it does, returns that instead.
/// </summary>
/// <param name="targetPackage">The target package to port into.</param>
/// <param name="sourceExport">The source export to port over, including all dependencies and references.</param>
/// <param name="targetLink">The target link UIndex. Only used if createParentPackages is false.</param>
/// <param name="createParentPackages">If the export should be ported in the same way as it was cooked into the package natively, e.g. create the parent package paths. The export must directly sit under a Package or an exception will be thrown.</param>
/// <param name="ensureMemoryUniqueness">If this object is an instance, such as a sequence object, and should be made memory-unique so it is properly used</param>
/// <returns></returns>
public static ExportEntry PortExportIntoPackage(IMEPackage targetPackage, ExportEntry sourceExport, int targetLink = 0, bool createParentPackages = true, bool ensureMemoryUniqueness = false, bool useMemorySafeImport = false, PackageCache cache = null)
{
#if DEBUG
// in preprocessor to prevent this from running in release mode
if (sourceExport.FileRef.FilePath != null && targetPackage.FilePath != null)
{
Debug.WriteLine($"Porting {sourceExport.InstancedFullPath} from {Path.GetFileName(sourceExport.FileRef.FilePath)} into {Path.GetFileName(targetPackage.FilePath)}");
}
#endif
var existing = targetPackage.FindExport(sourceExport.InstancedFullPath);
if (existing != null)
{
return(existing);
}
// Create parent hierarchy
IEntry newParent = null;
if (createParentPackages)
{
List <IEntry> parents = new List <IEntry>();
var parent = sourceExport.Parent;
while (parent != null)
{
if (parent.ClassName != "Package")
{
throw new Exception("Parent is not package!");
}
parents.Add(parent);
parent = parent.Parent;
}
// Create the parents
parents.Reverse();
foreach (var p in parents)
{
var sourceFullPath = p.InstancedFullPath;
var matchingParent = targetPackage.FindEntry(sourceFullPath);
if (matchingParent != null)
{
newParent = matchingParent;
continue;
}
newParent = ExportCreator.CreatePackageExport(targetPackage, p.ObjectName, newParent);
}
}
else
{
newParent = targetPackage.GetEntry(targetLink);
}
IEntry newEntry;
if (!useMemorySafeImport)
{
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
var relinkResults = EntryImporter.ImportAndRelinkEntries(EntryImporter.PortingOption.CloneAllDependencies, sourceExport, targetPackage,
newParent, true, out newEntry, crossPCCObjectMap);
if (relinkResults.Any())
{
Debugger.Break();
}
}
else
{
// Memory safe, fixes upstream
var relinkedResults = EntryExporter.ExportExportToPackage(sourceExport, targetPackage, out newEntry, MERFileSystem.GetGlobalCache(), cache);
if (relinkedResults.Any())
{
Debugger.Break();
}
}
#if DEBUG
//(sourceExport.FileRef as MEPackage).CompareToPackageDetailed(targetPackage);
#endif
// Helps ensure we don't have memory duplicates
if (ensureMemoryUniqueness)
{
newEntry.ObjectName = targetPackage.GetNextIndexedName(newEntry.ObjectName);
}
return(newEntry as ExportEntry);
}
