/// <summary>
/// Creates a new linking package relative to a load order.<br/>
/// Will resolve links to the highest overriding mod containing the record being sought. <br/>
/// Modification of the target LoadOrder, or Mods on the LoadOrder is not safe. Internal caches can become
/// incorrect if modifications occur on content already cached.
/// </summary>
/// <param name="loadOrder">LoadOrder to construct the package relative to</param>
/// <returns>LinkPackage attached to given LoadOrder</returns>
public static ImmutableLoadOrderLinkCache <TMod, TModGetter> ToImmutableLinkCache <TMod, TModGetter>(
this LoadOrder <TModGetter> loadOrder)
where TMod : class, IContextMod <TMod>, TModGetter
where TModGetter : class, IContextGetterMod <TMod>
{
return(new ImmutableLoadOrderLinkCache <TMod, TModGetter>(loadOrder.ListedOrder));
}
/// <summary>
/// Will find and return the most overridden version of each record in the load order of the given type
/// USAGE NOTE: <br/>
/// Typically you should only supply the Getter interfaces for the type. <br/>
/// A setter interface being given can result in no records being found, as most LoadOrders are readonly.
/// </summary>
/// <typeparam name="TMod">Mod type that the load order contains</typeparam>
/// <param name="loadOrder">LoadOrder to iterate over</param>
/// <param name="type">
/// Type of record to search for and iterate. <br/>
/// USAGE NOTE: <br/>
/// Typically you should only supply the Getter interfaces for the type. <br/>
/// A setter interface being given can result in no records being found, as most LoadOrders are readonly.
/// </param>
/// <param name="includeDeletedRecords">Whether to include deleted records in the output</param>
/// <returns>Enumerable of the most overridden version of each record of the given type, optionally including deleted ones</returns>
public static IEnumerable <IMajorRecordCommonGetter> WinningOverrides <TMod>(
this LoadOrder <TMod> loadOrder,
Type type,
bool includeDeletedRecords = true)
where TMod : class, IModGetter
{
return(loadOrder.PriorityOrder.WinningOverrides(type, includeDeletedRecords: includeDeletedRecords));
}
/// <summary>
/// Will find and return the most overridden version of each record in the load order of the given type
/// USAGE NOTE: <br/>
/// Typically you should only supply the Getter interfaces for the type. <br/>
/// A setter interface being given can result in no records being found, as most LoadOrders are readonly.
/// </summary>
/// <typeparam name="TMod">Mod type that the load order contains</typeparam>
/// <typeparam name="TMajor">
/// Type of record to search for and iterate. <br/>
/// USAGE NOTE: <br/>
/// Typically you should only supply the Getter interfaces for the type. <br/>
/// A setter interface being given can result in no records being found, as most LoadOrders are readonly.
/// </typeparam>
/// <param name="loadOrder">LoadOrder to iterate over</param>
/// <param name="includeDeletedRecords">Whether to include deleted records in the output</param>
/// <returns>Enumerable of the most overridden version of each record of the given type, optionally including deleted ones</returns>
public static IEnumerable <TMajor> WinningOverrides <TMod, TMajor>(
this LoadOrder <TMod> loadOrder,
bool includeDeletedRecords = false)
where TMod : class, IModGetter
where TMajor : class, IMajorRecordCommonGetter
{
return(loadOrder.PriorityOrder.WinningOverrides <TMajor>(includeDeletedRecords: includeDeletedRecords));
}
public static ILoadOrderGetter <TListing> ToLoadOrder <TListing>(this IEnumerable <TListing> listings)
where TListing : IModListingGetter
{
var ret = new LoadOrder <TListing>();
ret.Add(listings);
return(ret);
}
public void Dispose()
{
if (!_dispose)
{
return;
}
LoadOrder.Dispose();
LinkCache.Dispose();
}
/// <summary>
/// Will find and return the most overridden version of each record in the list of mods of the given type. <br/>
/// <br />
/// Additionally, it will come wrapped in a context object that has knowledge of where each record came from. <br/>
/// This context helps when trying to override deep records such as Cells/PlacedObjects/etc, as the context is able to navigate
/// and insert the record into the proper location for you. <br />
/// <br />
/// This system is overkill for simpler top-level records.
/// </summary>
/// <typeparam name="TMod">Setter Mod type to target</typeparam>
/// <typeparam name="TModGetter">Getter Mod type to target</typeparam>
/// <param name="loadOrder">LoadOrder to iterate over</param>
/// <param name="linkCache">LinkCache to use when creating parent objects</param>
/// <param name="type">
/// Type of record to search for and iterate. <br/>
/// USAGE NOTE: <br/>
/// Typically you should only supply the Getter interfaces for the type. <br/>
/// A setter interface being given can result in no records being found, as most LoadOrders are readonly.
/// </param>
/// <param name="includeDeletedRecords">Whether to include deleted records in the output</param>
/// <returns>Enumerable of the most overridden version of each record of the given type, optionally including deleted ones</returns>
public static IEnumerable <IModContext <TMod, IMajorRecordCommon, IMajorRecordCommonGetter> > WinningOverrideContexts <TMod, TModGetter>(
this LoadOrder <TModGetter> loadOrder,
ILinkCache linkCache,
Type type,
bool includeDeletedRecords = true)
where TMod : class, IMod, TModGetter
where TModGetter : class, IModGetter, IMajorRecordContextEnumerable <TMod>
{
return(loadOrder.PriorityOrder.WinningOverrideContexts <TMod, TModGetter>(linkCache, type, includeDeletedRecords: includeDeletedRecords));
}
/// <summary>
/// Creates a mutable load order link cache by combining an existing immutable load order cache,
/// plus a set of mods to be put at the end of the load order and allow to be mutable.
/// </summary>
/// <param name="immutableBaseCache">LoadOrderCache to use as the immutable base</param>
/// <param name="mutableMods">Set of mods to place at the end of the load order, which are allowed to be modified afterwards</param>
/// <returns>LinkPackage attached to given LoadOrder</returns>
public static MutableLoadOrderLinkCache <TMod, TModGetter> ToMutableLinkCache <TMod, TModGetter>(
this LoadOrder <IModListing <TModGetter> > immutableBaseCache,
params TMod[] mutableMods)
where TMod : class, IContextMod <TMod>, TModGetter
where TModGetter : class, IContextGetterMod <TMod>
{
return(new MutableLoadOrderLinkCache <TMod, TModGetter>(
immutableBaseCache.ToImmutableLinkCache <TMod, TModGetter>(),
mutableMods));
}
/// <summary>
/// Creates a new linking package relative to a load order.<br/>
/// Will resolve links to the highest overriding mod containing the record being sought. <br/>
/// Modification of the target LoadOrder, or Mods on the LoadOrder is not safe. Internal caches can become
/// incorrect if modifications occur on content already cached.
/// </summary>
/// <param name="loadOrder">LoadOrder to construct the package relative to</param>
/// <returns>LinkPackage attached to given LoadOrder</returns>
public static ImmutableLoadOrderLinkCache <TMod, TModGetter> ToImmutableLinkCache <TMod, TModGetter>(
this LoadOrder <IModListing <TModGetter> > loadOrder)
where TMod : class, IContextMod <TMod>, TModGetter
where TModGetter : class, IContextGetterMod <TMod>
{
return(new ImmutableLoadOrderLinkCache <TMod, TModGetter>(
loadOrder
.Select(listing => listing.Value.Mod)
.NotNull()));
}
/// <summary>
/// Constructs a LoadOrderLinkCache around a target load order
/// </summary>
/// <param name="loadOrder">LoadOrder to resolve against when linking</param>
public LoadOrderLinkCache(LoadOrder <TMod> loadOrder)
{
this._loadOrder = loadOrder;
this._loadOrderUntypedMajorRecords = new Cache <IMajorRecordCommonGetter, FormKey>(m => m.FormKey);
this._loadOrderMajorRecords = new Dictionary <Type, InternalTypedCache>();
var firstMod = _loadOrder.FirstOrDefault(m => m.Mod != null);
this._hasAny = firstMod?.Mod != null;
this._gameMode = firstMod?.Mod?.GameMode ?? GameMode.Oblivion;
}
public GameEnvironmentState(
string gameFolderPath,
LoadOrder <IModListing <TModGetter> > loadOrder,
ILinkCache <TModSetter, TModGetter> linkCache,
bool dispose = true)
{
GameFolderPath = gameFolderPath;
LoadOrder = loadOrder;
LinkCache = linkCache;
_dispose = dispose;
}
public static void TypicalPatch <TMod>(
string[] mainArgs,
ModKey outputMod,
IReadOnlyList <ModKey> loadOrderList,
LoadOrder <TMod> .Importer importer,
Func <ModKey, LoadOrder <TMod>, TMod> processor)
where TMod : class, IMod
{
TypicalPatch(
dataFolder: new Noggog.DirectoryPath(mainArgs[0]),
outModKey: outputMod,
loadOrderList: loadOrderList,
processor: processor,
importer: importer);
}
public static void TypicalPatch <TMod>(
DirectoryPath dataFolder,
ModKey outModKey,
IReadOnlyList <ModKey> loadOrderList,
LoadOrder <TMod> .Importer importer,
Func <ModKey, LoadOrder <TMod>, TMod> processor)
where TMod : class, IMod
{
var loadOrderInternal = loadOrderList.ToList();
loadOrderInternal.Remove(outModKey);
var loadOrder = new LoadOrder <TMod>();
loadOrder.Import(
dataFolder,
loadOrderInternal,
importer);
var outMod = processor(outModKey, loadOrder);
foreach (var npc in outMod.EnumerateMajorRecords())
{
npc.IsCompressed = false;
}
var linkCache = loadOrder.CreateLinkCache();
outMod.MasterReferences.SetTo(
outMod.LinkFormKeys
.Where(fk => !fk.IsNull)
.Select(s => s.ModKey)
.Where(modKey => modKey != outModKey)
.Distinct()
.OrderBy(modKey => loadOrder.IndexOf(modKey))
.Select(modKey => new MasterReference()
{
Master = modKey
}));
outMod.SyncRecordCount();
outMod.WriteToBinary(
path: Path.Combine(dataFolder.Path, outModKey.FileName));
}
public static MastersListOrderingByLoadOrder Factory <T>(LoadOrder <T> loadOrder)
where T : IModKeyed
{
return(Factory(loadOrder.Select(listing => listing.Key)));
}
/// <summary>
/// Creates a new linking package relative to a load order.
/// </summary>
/// <typeparam name="TMod">Mod type</typeparam>
/// <param name="loadOrder">LoadOrder to construct the package relative to</param>
/// <returns>LinkPackage attached to given LoadOrder</returns>
public static ILinkCache CreateLinkCache <TMod>(this LoadOrder <TMod> loadOrder)
where TMod : class, IModGetter
{
return(new LoadOrderLinkCache <TMod>(loadOrder));
}
public static IEnumerable <TListing> OrderListings <TListing>(this IEnumerable <TListing> e)
where TListing : IModListingGetter
{
return(LoadOrder.OrderListings(e, i => i.ModKey));
}
public static IEnumerable <ModKey> OrderListings(this IEnumerable <ModKey> e)
{
return(LoadOrder.OrderListings(e, i => i));
}