public static void RunPatch(IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
ScriptEntry FFCLS = new ScriptEntry
{
Name = "ANDR_FollowerFavorCarryLimitScript",
Flags = ScriptEntry.Flag.Local
};
ScriptObjectProperty prop = new ScriptObjectProperty
{
Name = "VendorItemArrow",
Object = Skyrim.Keyword.VendorItemArrow,
Flags = ScriptProperty.Flag.Edited
};
FFCLS.Properties.Add(prop);
foreach (var npc in state.LoadOrder.PriorityOrder.WinningOverrides <INpcGetter>())
{
if (npc.Configuration.TemplateFlags.HasFlag(NpcConfiguration.TemplateFlag.SpellList) || npc.EditorID == null || npc.Factions == null)
{
continue;
}
foreach (var faction in npc.Factions)
{
if (!faction.Faction.Equals(Skyrim.Faction.PotentialFollowerFaction))
{
continue;
}
(state.PatchMod.Npcs.GetOrAddAsOverride(npc).VirtualMachineAdapter ??= new VirtualMachineAdapter()).Scripts.Add(FFCLS);
break;
}
}
}
private static void DistributeJewelaryUsingSPID(IPatcherState <ISkyrimMod, ISkyrimModGetter> state, ISkyrimMod mod)
{
Logger.InfoFormat("Distributing Jewelary using Spell Perk Item Distributor.... ");
string iniName = mod.ModKey.Name + "_DISTR.ini";
List <string> lines = new();
Random random = new();
// Distributing jewelry
string jPrefix = Configuration.Patcher.LeveledListPrefix + "_LL_Jewels_";
foreach (ILeveledItemGetter ll in state.LoadOrder.PriorityOrder
.WinningOverrides <ILeveledItemGetter>()
.Where(x => x.EditorID.Contains(jPrefix)))
{
string eid = ll.EditorID;
string gender = Configuration.User.JewelryForMales &&
Regex.Match(eid, "Amulet|Ring|Circlet", RegexOptions.IgnoreCase).Success &&
!eid.Contains("_F_") ? "NONE" : "F";
string line = "Item = 0x00" +
ll.FormKey.ToString().Replace(":", " - ") +
" | ActorTypeNPC " +
" | Citizen " +
" | NONE " +
" | " + gender +
" | 1 " +
" | " + random.Next(50, 99);
lines.Add(line);
}
File.WriteAllLines(Path.Combine(state.DataFolderPath, iniName), lines);
}
public static void RunPatch(IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
var lvliMap = LVLIMap.CreateMap();
foreach (var leveledList in state.LoadOrder.PriorityOrder.LeveledItem().WinningOverrides())
{
if (lvliMap.ContainsValue(leveledList.FormKey))
{
continue;
}
if (leveledList.Entries == null)
{
continue;
}
for (var i = 0; i < leveledList.Entries.Count; i++)
{
var entry = leveledList.Entries[i];
if (entry.Data == null)
{
continue;
}
if (!lvliMap.ContainsKey(entry.Data.Reference.FormKey))
{
continue;
}
var modifiedList = state.PatchMod.LeveledItems.GetOrAddAsOverride(leveledList);
modifiedList.Entries ![i].Data !.Reference.SetTo(lvliMap[entry.Data.Reference.FormKey]);
public static void RunPatch(IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
foreach (var spell in state.LoadOrder.PriorityOrder.Spell().WinningOverrides())
{
if (!spell.MenuDisplayObject.Equals(Skyrim.Static.MAGINVSummon))
{
continue;
}
if (spell.Flags.HasFlag(SpellDataFlag.NoAbsorbOrReflect))
{
continue;
}
foreach (var effect in spell.Effects)
{
if (!effect.BaseEffect.TryResolve(state.LinkCache, out var magicEffect))
{
continue;
}
if (magicEffect.Archetype.Type != MagicEffectArchetype.TypeEnum.SummonCreature)
{
continue;
}
var modifiedSpell = state.PatchMod.Spells.GetOrAddAsOverride(spell);
modifiedSpell.Flags = modifiedSpell.Flags.SetFlag(SpellDataFlag.NoAbsorbOrReflect, true);
}
}
}
public static void RunPatch(IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
// determine the file path for meshes
string meshRoot = state.Settings.DataFolderPath;
Console.WriteLine("Process meshes relative to {0}", meshRoot);
}
public static LeveledListDistributor <TItem, TKey> Create <TItem, TKey>(Func <TItem, TKey> indexer,
IPatcherState <ISkyrimMod, ISkyrimModGetter> state, MajorRecordExclusionList <ILeveledItemGetter>?listExclusions = null)
where TKey : struct
where TItem : IItemGetter
{
return(new(indexer, state, listExclusions));
}
private static void ConfigureServices(IServiceCollection collection, IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
collection.AddLogging(logging =>
{
logging.SetMinimumLevel(LogLevel.Trace);
logging.ClearProviders();
if (AddLogger != null)
{
AddLogger(logging);
}
else
{
logging.AddConsole();
}
});
collection.AddTransient <OverlayLoader>();
collection.AddSingleton <DataStorage>();
collection.AddTransient <PatcherRunner>();
collection.AddSingleton(state);
collection.AddSingleton <MaterialEnum>();
collection.AddSingleton <BaseWeaponTypeEnum>();
collection.AddSingleton <WeaponClassEnum>();
collection.AddAllOfInterface <IPatcher>();
collection.AddAllOfInterface <IInjectedConverter>();
collection.AddAllOfInterface <IFormLinkJsonConverter>();
}
public static void RunPatch(IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
state.LoadOrder.PriorityOrder.OnlyEnabled().Tree().WinningOverrides().ForEach(tree =>
{
if (tree.VirtualMachineAdapter == null)
{
var otree = state.PatchMod.Trees.GetOrAddAsOverride(tree);
Console.WriteLine($"Patching TREE {otree.EditorID}");
otree.VirtualMachineAdapter = new VirtualMachineAdapter();
otree.VirtualMachineAdapter.Scripts.Add(new ScriptEntry()
{
Name = "florafix",
});
}
});
state.LoadOrder.PriorityOrder.OnlyEnabled().Flora().WinningOverrides().ForEach(flora =>
{
if (flora.VirtualMachineAdapter == null)
{
var otree = state.PatchMod.Florae.GetOrAddAsOverride(flora);;
Console.WriteLine($"Patching FLOR {otree.EditorID}");
otree.VirtualMachineAdapter = new VirtualMachineAdapter();
otree.VirtualMachineAdapter.Scripts.Add(new ScriptEntry()
{
Name = "florafix",
});
}
});
}
public static void RunPatch(IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
new Program(loadOrder: state.LoadOrder,
linkCache: state.LinkCache,
patchMod: state.PatchMod,
gameRelease: state.GameRelease).RunPatch();
}
public static void RunPatch(IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
foreach (var lightGetter in state.LoadOrder.PriorityOrder.Light().WinningOverrides())
{
if (lightGetter.Flags.HasFlag(Light.Flag.ShadowHemisphere) || lightGetter.Flags.HasFlag(Light.Flag.ShadowOmnidirectional) || lightGetter.Flags.HasFlag(Light.Flag.ShadowSpotlight))
{
var light = state.PatchMod.Lights.GetOrAddAsOverride(lightGetter);
if (lightGetter.Flags.HasFlag(Light.Flag.ShadowHemisphere))
{
light.Flags -= Light.Flag.ShadowHemisphere;
}
if (lightGetter.Flags.HasFlag(Light.Flag.ShadowOmnidirectional))
{
light.Flags -= Light.Flag.ShadowOmnidirectional;
}
if (lightGetter.Flags.HasFlag(Light.Flag.ShadowSpotlight))
{
light.Flags -= Light.Flag.ShadowSpotlight;
}
}
}
}
/// <summary>
/// Locate and confirm the existence of a config file from either the user data folder
/// or the default data folder as it exists in the source repository.
/// </summary>
/// <param name="state">Patcher state to refer to</param>
/// <param name="relativePath">Path to the config file, relative to the data folder.</param>
/// <exception cref="FileNotFoundException">If a config file could not be located that exists in either location.</exception>
/// <returns>Located config file that exists</returns>
public static string RetrieveConfigFile(this IPatcherState state, string relativePath)
{
if (TryRetrieveConfigFile(state, relativePath, out var resolved))
{
return(resolved);
}
throw new FileNotFoundException($"Could not locate config file: {relativePath}");
}
public static void RunPatch(IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
foreach (var npc in state.LoadOrder.PriorityOrder.WinningOverrides <INpcGetter>().
Where(candidate => candidate.Configuration.Flags.HasFlag(NpcConfiguration.Flag.OppositeGenderAnims)))
{
Console.WriteLine("Unflag NPC {0}", npc.EditorID);
var modifiedNPc = state.PatchMod.Npcs.GetOrAddAsOverride(npc);
modifiedNPc.Configuration.Flags &= ~NpcConfiguration.Flag.OppositeGenderAnims;
}
}
public OverlayLoader(ILogger <OverlayLoader> logger, IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
_logger = logger;
_state = state;
Roots = new()
{
((AbsolutePath)_state.DataFolderPath).Combine("config"),
AbsolutePath.EntryPoint.Combine("config")
};
}
/*private static void PatchSpells()
* {
* static bool Predicate(IEffectGetter x)
* {
* if (x.Data == null) return false;
* var effect = x.BaseEffect.Resolve(_linkCache);
* return effect.Archetype.ActorValue == ActorValue.MagickaRate;
* }
*
* List<ISpellGetter> spellsToPatch = _loadOrder.PriorityOrder.Spell().WinningOverrides()
* .AsParallel()
* .Where(spell => spell.Effects.Any(Predicate))
* .ToList();
* foreach (var spellCopy in spellsToPatch.Select(spell => _patchMod.Spells.GetOrAddAsOverride(spell)))
* {
* spellCopy.Effects.Where(Predicate).ForEach(x =>
* {
* x.Data!.Magnitude *= _settings.Value.MagickaRegen.Scale;
* });
* }
* }*/
public static void RunPatch(IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
_linkCache = state.LinkCache;
_loadOrder = state.LoadOrder;
_patchMod = state.PatchMod;
CreateAbility();
PatchClasses();
PatchNPCs();
PatchGameSettings();
PatchRaces();
}
public static void RunPatch(IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
// Part 1 - Patch every placed light in worldspaces/cells
foreach (var placedObjectGetter in state.LoadOrder.PriorityOrder.PlacedObject().WinningContextOverrides(state.LinkCache))
{
if (placedObjectGetter.ModKey == enbLightPluginNameWithExtension)
{
continue;
}
var placedObject = placedObjectGetter.Record;
if (placedObject.LightData == null)
{
continue;
}
placedObject.Base.TryResolve <ILightGetter>(state.LinkCache, out var placedObjectBase);
if (placedObjectBase == null || placedObjectBase.EditorID == null)
{
continue;
}
if (lightNamesToAdjust.Any(placedObjectBase.EditorID.ContainsInsensitive))
{
if (placedObject != null && placedObject.LightData != null && placedObject.LightData.FadeOffset > 0)
{
IPlacedObject modifiedObject = placedObjectGetter.GetOrAddAsOverride(state.PatchMod);
modifiedObject.LightData !.FadeOffset *= fadeMultiplier;
}
}
else
{
continue;
}
}
// Part 2 - Patch every LIGH record
foreach (var lightGetter in state.LoadOrder.PriorityOrder.Light().WinningContextOverrides())
{
if (lightGetter.ModKey == enbLightPluginNameWithExtension)
{
continue;
}
var light = lightGetter.Record;
if (light.EditorID == null)
{
continue;
}
if (lightNamesToAdjust.Any(light.EditorID.ContainsInsensitive))
{
Light modifiedLight = state.PatchMod.Lights.GetOrAddAsOverride(light);
modifiedLight.FadeValue *= fadeMultiplier;
}
}
}
public static void RunPatch(IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
foreach (var npc in state.LoadOrder.PriorityOrder.Npc().WinningOverrides())
{
if (!npc.Configuration.Flags.HasFlag(NpcConfiguration.Flag.OppositeGenderAnims))
{
continue;
}
var modifiedNPc = state.PatchMod.Npcs.GetOrAddAsOverride(npc);
modifiedNPc.Configuration.Flags &= ~NpcConfiguration.Flag.OppositeGenderAnims;
}
}
public static void ProcessAndDistributeJewelary(IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
Logger.InfoFormat("Creating Leveled list for Jewelary.....");
ISkyrimMod patchedMod = FileUtils.GetOrAddPatch("ZZZ Jewelry");
Dictionary <string, HashSet <IArmorGetter> > jewelleries = new Dictionary <string, HashSet <IArmorGetter> >();
// Adding all the patches to load order
foreach (IModListing <ISkyrimModGetter> modlist in state.LoadOrder.PriorityOrder
.Where(x => Configuration.User.JewelryMods.Contains(x.ModKey.FileName) &&
x.Mod.Armors.Count > 0))
{
// Getting Jewelary Armors
ISkyrimModGetter mod = modlist.Mod;
IEnumerable <IArmorGetter> armors = mod.Armors
.Where(x => ArmorUtils.IsValidArmor(x) &&
x.Name != null);
for (int i = 0; i < armors.Count(); i++)
{
IArmorGetter armor = armors.ElementAtOrDefault(i);
IArmorAddonGetter addon = armor.Armature.FirstOrDefault().Resolve(Configuration.Cache);
string gender = (addon.WorldModel.Male != null && addon.WorldModel.Female != null
? "_C_" : addon.WorldModel.Male == null ? "_F_" : "_M_");
var bodyFlags = armor.BodyTemplate.FirstPersonFlags;
var key = bodyFlags.ToString() + gender;
if (!jewelleries.ContainsKey(key))
{
jewelleries.Add(key, new HashSet <IArmorGetter>());
}
jewelleries.GetValueOrDefault(key).Add(armor);
}
}
// Creating leveled list for the jewelleries
string prefix = Configuration.Patcher.LeveledListPrefix + "_LL_Jewels_";
jewelleries.Where(x => !Regex.Match(x.Key.ToString(), "Decapitate", RegexOptions.IgnoreCase).Success)
.ForEach(j =>
{
string lvli_eid = prefix + j.Key.ToString().Replace(" ", "_");
OutfitUtils.CreateLeveledList(patchedMod, j.Value, lvli_eid, 1, LeveledItem.Flag.CalculateForEachItemInCount);
});
Logger.InfoFormat("Leveled List created for Jewelary....");
// Writing patched mod to disk
DistributeJewelaryUsingSPID(state, patchedMod);
Logger.InfoFormat("Distribution of Jewelaries is completed...\n\n");
}
public static void RunPatch(IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
var csv = new StringBuilder();
foreach (var race in state.LoadOrder.PriorityOrder.Race().WinningOverrides())
{
float startingHealth = race.Starting.Values.ElementAt(0);
// Not using Math.Round since the result will be different from JS Math.round
// Using this trick from https://stackoverflow.com/questions/1862992/how-close-is-the-javascript-math-round-to-the-c-sharp-math-round (second answer
csv.Append(race.EditorID + "," + Math.Floor((startingHealth / 10) + 0.5) + '\n');
}
loadPath = state.DataFolderPath;
Directory.CreateDirectory(state.DataFolderPath + @"\SKSE\Plugins\Experience\Races\");
File.WriteAllText(state.DataFolderPath + @"\SKSE\Plugins\Experience\Races\experiencePatch.csv", csv.ToString());
}
public static void SaveMod(IPatcherState <ISkyrimMod, ISkyrimModGetter> state, ISkyrimMod patch)
{
var patchFile = patch.ModKey.FileName;
var records = patch.EnumerateMajorRecords().Where(r => r.FormKey.ModKey.Equals(patch.ModKey));
if (records.Count() < 2048)
{
patch.ModHeader.Flags = SkyrimModHeader.HeaderFlag.LightMaster;
}
string location = Path.Combine(state.DataFolderPath, patchFile);
patch.WriteToBinary(location, FileUtils.SafeBinaryWriteParameters);
Logger.InfoFormat("Saved Patch: {0} ", patchFile);
}
public static void RunPatch(IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
var JOBJ = JObject.Parse(File.ReadAllText(Path.Combine(state.ExtraSettingsDataPath, "settings.json"))).ToObject <Settings>();
var stat = state.PatchMod.Statics.AddNew("None");
foreach (var ls in state.LoadOrder.PriorityOrder.LoadScreen().WinningOverrides())
{
var nls = state.PatchMod.LoadScreens.GetOrAddAsOverride(ls);
nls.LoadingScreenNif.SetTo(stat);
if (JOBJ.RemoveLoreText)
{
nls.Description = "";
}
}
}
public static void RunPatch(IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
foreach (var water in state.LoadOrder.PriorityOrder.WinningOverrides <IWaterGetter>())
{
if (water.Flags != null && !water.Flags.Value.HasFlag(Water.Flag.CausesDamage))
{
var damageWater = state.PatchMod.Waters.GetOrAddAsOverride(water);
damageWater.Flags |= Mutagen.Bethesda.Skyrim.Water.Flag.CausesDamage;
}
else
{
continue;
}
}
}
public Program(IPatcherState <ISkyrimMod, ISkyrimModGetter> state, IFileSystem?fileSystem = null)
{
State = state;
LinkCache = state.LinkCache;
PatchMod = state.PatchMod;
LoadOrder = state.LoadOrder;
_fileSystem = fileSystem ?? new FileSystem();
Path = _fileSystem.Path;
TexturePaths = new TexturePaths(_fileSystem);
MeshPaths = new MeshPaths(_fileSystem);
TextureSets = new TextureSets(PatchMod, LinkCache, texturePaths: TexturePaths, fileSystem: _fileSystem);
HeadParts = new HeadParts(PatchMod, LinkCache, TextureSets, MeshPaths, _fileSystem);
}
public static async Task RunPatch(IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
var host = Host.CreateDefaultBuilder(Array.Empty <string>())
.ConfigureAppConfiguration((hostingContext, configuration) =>
{
configuration.Sources.Clear();
var env = hostingContext.HostingEnvironment;
configuration.AddJsonFile(AbsolutePath.EntryPoint.Combine("appsettings.json").ToString(), optional: false, reloadOnChange: false);
})
.ConfigureServices(c => ConfigureServices(c, state))
.Build();
var runner = host.Services.GetService <PatcherRunner>();
runner !.RunPatchers();
}
public static void RunPatch(IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
if (!state.LoadOrder.ContainsKey(ultimateDodgeMod))
{
throw new Exception("ERROR: The Ultimate Dodge Mod hasn't been detected in your load order. You need to install TUDM prior to running this patcher!");
}
FormKey UDRollNakedLandingSetKey = ultimateDodgeMod.MakeFormKey(0x011591);
FormKey UDRollLightLandingSetKey = ultimateDodgeMod.MakeFormKey(0x011590);
FormKey UDRollHeavyLandingSetKey = ultimateDodgeMod.MakeFormKey(0x01158F);
if (!state.LinkCache.TryResolve <IFootstepSetGetter>(UDRollNakedLandingSetKey, out var UDRollNakedLandingSet) || UDRollNakedLandingSet == null)
{
throw new Exception("ERROR: UDRollNakedLandingSet FormKey not found! Are you on the latest TUDM x64 version?");
}
if (!state.LinkCache.TryResolve <IFootstepSetGetter>(UDRollLightLandingSetKey, out var UDRollLightLandingSet) || UDRollLightLandingSet == null)
{
throw new Exception("ERROR: UDRollLightLandingSet FormKey not found! Are you on the latest TUDM x64 version?");
}
if (!state.LinkCache.TryResolve <IFootstepSetGetter>(UDRollHeavyLandingSetKey, out var UDRollHeavyLandingSet) || UDRollHeavyLandingSet == null)
{
throw new Exception("ERROR: UDRollHeavyLandingSet FormKey not found! Are you on the latest TUDM x64 version?");
}
foreach (var armor in state.LoadOrder.PriorityOrder.WinningOverrides <IArmorGetter>())
{
if (armor.Keywords == null)
{
continue;
}
if (armor.Keywords.Contains(Skyrim.Keyword.ArmorCuirass) || armor.Keywords.Contains(Skyrim.Keyword.ClothingBody))
{
foreach (var armature in armor.Armature)
{
armature.TryResolve(state.LinkCache, out var armorAddonVar);
if (armorAddonVar == null)
{
continue;
}
else
{
ArmorAddon armorAddon = armorAddonVar.DeepCopy();
if (HasBodyFlag(armorAddon))
{
switch (armor.DeepCopy().BodyTemplate !.ArmorType)
{
public int AddGameSettings(IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
if (!Enabled)
{
return(0);
}
state.PatchMod.GameSettings.Add(new GameSettingFloat(state.PatchMod.GetNextFormKey(), state.PatchMod.SkyrimRelease)
{
EditorID = "fCombatDistance",
Data = fCombatDistance
});
state.PatchMod.GameSettings.Add(new GameSettingFloat(state.PatchMod.GetNextFormKey(), state.PatchMod.SkyrimRelease)
{
EditorID = "fCombatBashReach",
Data = fCombatBashReach
});
return(2);
}
private Dictionary <string, int> materialRanks; // In memory rep of armor_materials.json
public ArmorPatcher(IPatcherState <ISkyrimMod, ISkyrimModGetter> state, ActionSpeedX.Settings settings)
{
this.state = state;
this.settings = settings;
// This is looped through when adding descriptions. See PatchArmorDescription for usage.
this.descriptionSettings = new Dictionary <string, bool> {
{ ATTACK_SPEED, this.settings.AttackSpeed },
{ MOVEMENT_SPEED, this.settings.MoveSpeed },
{ MAGICKA, this.settings.MagickaRegen },
{ POWER_ATTACK, this.settings.PowerAttacks },
{ RANGED_ATTACK, this.settings.RangedAttack },
{ SPELL_COST, this.settings.SpellCosts },
{ STAMINA, this.settings.StaminaRegen }
};
this.materialRanks = loadMaterialsFromDisk();
this.armorDescriptions = loadDescriptionsFromDisk();
}
private List <FormKey> perksToAdd; // Contains form ids of perks to add to every npc.
public NpcPatcher(IPatcherState <ISkyrimMod, ISkyrimModGetter> state, ActionSpeedX.Settings settings)
{
this.state = state;
this.settings = settings;
this.racesToPatch = loadRaces();
this.perksToAdd = new List <FormKey>();
if (this.settings.AttackSpeed)
{
perksToAdd.AddRange(ActionSpeedX.FormKeys.Perks.AttackSpeed);
}
if (this.settings.MagickaRegen)
{
perksToAdd.AddRange(ActionSpeedX.FormKeys.Perks.MagickaRegen);
}
if (this.settings.MoveSpeed)
{
perksToAdd.AddRange(ActionSpeedX.FormKeys.Perks.MoveSpeed);
}
if (this.settings.RangedAttack)
{
perksToAdd.AddRange(ActionSpeedX.FormKeys.Perks.RangedSpeed);
}
if (this.settings.PowerAttacks)
{
perksToAdd.AddRange(ActionSpeedX.FormKeys.Perks.PowerAttacks);
}
if (this.settings.StaminaRegen)
{
perksToAdd.AddRange(ActionSpeedX.FormKeys.Perks.StaminaRegen);
}
if (this.settings.SpellCosts)
{
perksToAdd.AddRange(ActionSpeedX.FormKeys.Perks.SpellCosts);
}
}
public static void RunPatch(IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
//Your code here!
var keyword_IsAdultRace = FormKey.Factory("045AF7:ImCh.esm");
var keyword_IsChildRace = FormKey.Factory("005901:ImCh.esm");
foreach (var furnitureGetter in state.LoadOrder.PriorityOrder.Furniture().WinningOverrides())
{
if (furnitureGetter.InteractionKeyword == Skyrim.Keyword.ActorTypeNPC && !furnitureGetter.MajorFlags.HasFlag(Furniture.MajorFlag.ChildCanUse))
{
var furniture = state.PatchMod.Furniture.GetOrAddAsOverride(furnitureGetter);
furniture.InteractionKeyword.SetTo(keyword_IsAdultRace);
}
}
foreach (var raceGetter in state.LoadOrder.PriorityOrder.Race().WinningOverrides())
{
if (raceGetter.Keywords != null && raceGetter.Keywords.Contains(Skyrim.Keyword.ActorTypeNPC))
{
var race = state.PatchMod.Races.GetOrAddAsOverride(raceGetter);
if (race.Flags.HasFlag(Race.Flag.Child))
{
if (race.Keywords != null)
{
race.Flags -= Race.Flag.Child;
race.Flags |= Race.Flag.AllowPickpocket;
race.Keywords.Add(keyword_IsChildRace);
}
}
else
{
if (race.Keywords != null)
{
race.Keywords.Add(keyword_IsAdultRace);
}
}
}
}
}
public static void RunPatch(IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
state.LoadOrder.PriorityOrder.OnlyEnabled().Weapon().WinningOverrides().ForEach(weap =>
{
{
if (weap.HasKeyword(Skyrim.Keyword.WeapTypeStaff))
{
if (!weap.FormKey.ModKey.FileName.String.Contains("CGOStaves", StringComparison.OrdinalIgnoreCase))
{
Console.WriteLine($"Patching staff {weap.Name}");
var newweap = state.PatchMod.Weapons.GetOrAddAsOverride(weap);
newweap.BlockBashImpact.SetTo(Skyrim.ImpactDataSet.WPNBashBowImpactSet);
newweap.AlternateBlockMaterial.SetTo(Skyrim.MaterialType.MaterialBlockBowsStaves);
newweap.ImpactDataSet.SetTo(Skyrim.ImpactDataSet.WPNzBluntImpactSet);
newweap.AttackFailSound.SetTo(Skyrim.SoundDescriptor.WPNSwing2Hand);
}
}
}
});
}
private static void RunPatch(IPatcherState <ISkyrimMod, ISkyrimModGetter> state)
{
var armor = new ArmorAnalyzer(state);
var weapon = new WeaponAnalyzer(state);
Console.WriteLine("Analyzing mod list");
var th1 = new Thread(() => armor.Analyze());
var th2 = new Thread(() => weapon.Analyze());
th1.Start();
th2.Start();
th1.Join();
th2.Join();
Console.WriteLine("Generating armor enchantments");
armor.Generate();
Console.WriteLine("Generating weapon enchantments");
weapon.Generate();
}
