using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.IO; using System.Linq; using Microsoft.Xna.Framework; using Microsoft.Xna.Framework.Graphics; using StardewModdingAPI.Framework.ContentManagers; using StardewModdingAPI.Framework.Reflection; using StardewModdingAPI.Framework.Utilities; using StardewModdingAPI.Internal; using StardewModdingAPI.Toolkit.Utilities; using StardewValley; using StardewValley.BellsAndWhistles; using StardewValley.Buildings; using StardewValley.Characters; using StardewValley.GameData.Movies; using StardewValley.Locations; using StardewValley.Menus; using StardewValley.Objects; using StardewValley.Projectiles; using StardewValley.TerrainFeatures; using xTile; using xTile.Tiles; namespace StardewModdingAPI.Metadata { /// Propagates changes to core assets to the game state. internal class CoreAssetPropagator { /********* ** Fields *********/ /// The main content manager through which to reload assets. private readonly LocalizedContentManager MainContentManager; /// An internal content manager used only for asset propagation. See remarks on . private readonly GameContentManagerForAssetPropagation DisposableContentManager; /// Writes messages to the console. private readonly IMonitor Monitor; /// Simplifies access to private game code. private readonly Reflector Reflection; /// Parse a raw asset name. private readonly Func ParseAssetName; /// Optimized bucket categories for batch reloading assets. private enum AssetBucket { /// NPC overworld sprites. Sprite, /// Villager dialogue portraits. Portrait, /// Any other asset. Other }; /// A cache of world data fetched for the current tick. private readonly TickCacheDictionary WorldCache = new(); /********* ** Public methods *********/ /// Initialize the core asset data. /// The main content manager through which to reload assets. /// An internal content manager used only for asset propagation. /// Writes messages to the console. /// Simplifies access to private code. /// Parse a raw asset name. public CoreAssetPropagator(LocalizedContentManager mainContent, GameContentManagerForAssetPropagation disposableContent, IMonitor monitor, Reflector reflection, Func parseAssetName) { this.MainContentManager = mainContent; this.DisposableContentManager = disposableContent; this.Monitor = monitor; this.Reflection = reflection; this.ParseAssetName = parseAssetName; } /// Reload one of the game's core assets (if applicable). /// The asset keys and types to reload. /// Whether the in-game world is fully unloaded (e.g. on the title screen), so there's no need to propagate changes into the world. /// A lookup of asset names to whether they've been propagated. /// Whether the NPC pathfinding cache was reloaded. public void Propagate(IDictionary assets, bool ignoreWorld, out IDictionary propagatedAssets, out bool updatedNpcWarps) { // get base name lookup propagatedAssets = assets .Select(asset => asset.Key.GetBaseAssetName()) .Distinct() .ToDictionary(name => name, _ => false); // group into optimized lists var buckets = assets.GroupBy(p => { if (p.Key.IsDirectlyUnderPath("Characters") || p.Key.IsDirectlyUnderPath("Characters/Monsters")) return AssetBucket.Sprite; if (p.Key.IsDirectlyUnderPath("Portraits")) return AssetBucket.Portrait; return AssetBucket.Other; }); // reload assets updatedNpcWarps = false; foreach (var bucket in buckets) { switch (bucket.Key) { case AssetBucket.Sprite: if (!ignoreWorld) this.UpdateNpcSprites(propagatedAssets); break; case AssetBucket.Portrait: if (!ignoreWorld) this.UpdateNpcPortraits(propagatedAssets); break; default: foreach (var entry in bucket) { bool changed = false; bool curChangedMapWarps = false; try { changed = this.PropagateOther(entry.Key, entry.Value, ignoreWorld, out curChangedMapWarps); } catch (Exception ex) { this.Monitor.Log($"An error occurred while propagating asset changes. Error details:\n{ex.GetLogSummary()}", LogLevel.Error); } propagatedAssets[entry.Key] = changed; updatedNpcWarps = updatedNpcWarps || curChangedMapWarps; } break; } } // reload NPC pathfinding cache if any map changed if (updatedNpcWarps) NPC.populateRoutesFromLocationToLocationList(); } /********* ** Private methods *********/ /// Reload one of the game's core assets (if applicable). /// The asset name to reload. /// The asset type to reload. /// Whether the in-game world is fully unloaded (e.g. on the title screen), so there's no need to propagate changes into the world. /// Whether any map warps were changed as part of this propagation. /// Returns whether an asset was loaded. The return value may be true or false, or a non-null value for true. [SuppressMessage("ReSharper", "StringLiteralTypo", Justification = "These deliberately match the asset names.")] private bool PropagateOther(IAssetName assetName, Type type, bool ignoreWorld, out bool changedWarps) { var content = this.MainContentManager; string key = assetName.BaseName; changedWarps = false; /**** ** Special case: current map tilesheet ** We only need to do this for the current location, since tilesheets are reloaded when you enter a location. ** Just in case, we should still propagate by key even if a tilesheet is matched. ****/ if (!ignoreWorld && Game1.currentLocation?.map?.TileSheets != null) { foreach (TileSheet tilesheet in Game1.currentLocation.map.TileSheets) { if (this.IsSameBaseName(assetName, tilesheet.ImageSource)) Game1.mapDisplayDevice.LoadTileSheet(tilesheet); } } /**** ** Propagate map changes ****/ if (type == typeof(Map)) { bool anyChanged = false; if (!ignoreWorld) { foreach (LocationInfo info in this.GetLocationsWithInfo()) { GameLocation location = info.Location; if (this.IsSameBaseName(assetName, location.mapPath.Value)) { static ISet GetWarpSet(GameLocation location) { return new HashSet( location.warps.Select(p => $"{p.X} {p.Y} {p.TargetName} {p.TargetX} {p.TargetY}") ); } var oldWarps = GetWarpSet(location); this.UpdateMap(info); var newWarps = GetWarpSet(location); changedWarps = changedWarps || oldWarps.Count != newWarps.Count || oldWarps.Any(p => !newWarps.Contains(p)); anyChanged = true; } } } return anyChanged; } /**** ** Propagate by key ****/ switch (assetName.BaseName.ToLower().Replace("\\", "/")) // normalized key so we can compare statically { /**** ** Animals ****/ case "animals/horse": return !ignoreWorld && this.UpdatePetOrHorseSprites(assetName); /**** ** Buildings ****/ case "buildings/houses": // Farm Farm.houseTextures = this.LoadTexture(key); return true; case "buildings/houses_paintmask": // Farm { bool removedFromCache = this.RemoveFromPaintMaskCache(assetName); Farm farm = Game1.getFarm(); farm?.ApplyHousePaint(); return removedFromCache || farm != null; } /**** ** Content\Characters\Farmer ****/ case "characters/farmer/accessories": // Game1.LoadContent FarmerRenderer.accessoriesTexture = this.LoadTexture(key); return true; case "characters/farmer/farmer_base": // Farmer case "characters/farmer/farmer_base_bald": case "characters/farmer/farmer_girl_base": case "characters/farmer/farmer_girl_base_bald": return !ignoreWorld && this.UpdatePlayerSprites(assetName); case "characters/farmer/hairstyles": // Game1.LoadContent FarmerRenderer.hairStylesTexture = this.LoadTexture(key); return true; case "characters/farmer/hats": // Game1.LoadContent FarmerRenderer.hatsTexture = this.LoadTexture(key); return true; case "characters/farmer/pants": // Game1.LoadContent FarmerRenderer.pantsTexture = this.LoadTexture(key); return true; case "characters/farmer/shirts": // Game1.LoadContent FarmerRenderer.shirtsTexture = this.LoadTexture(key); return true; /**** ** Content\Data ****/ case "data/achievements": // Game1.LoadContent Game1.achievements = content.Load>(key); return true; case "data/bigcraftablesinformation": // Game1.LoadContent Game1.bigCraftablesInformation = content.Load>(key); return true; case "data/clothinginformation": // Game1.LoadContent Game1.clothingInformation = content.Load>(key); return true; case "data/concessions": // MovieTheater.GetConcessions MovieTheater.ClearCachedLocalizedData(); return true; case "data/concessiontastes": // MovieTheater.GetConcessionTasteForCharacter this.Reflection .GetField>(typeof(MovieTheater), "_concessionTastes") .SetValue(content.Load>(key)); return true; case "data/cookingrecipes": // CraftingRecipe.InitShared CraftingRecipe.cookingRecipes = content.Load>(key); return true; case "data/craftingrecipes": // CraftingRecipe.InitShared CraftingRecipe.craftingRecipes = content.Load>(key); return true; case "data/farmanimals": // FarmAnimal constructor return !ignoreWorld && this.UpdateFarmAnimalData(); case "data/hairdata": // Farmer.GetHairStyleMetadataFile return this.UpdateHairData(); case "data/movies": // MovieTheater.GetMovieData case "data/moviesreactions": // MovieTheater.GetMovieReactions MovieTheater.ClearCachedLocalizedData(); return true; case "data/npcdispositions": // NPC constructor return !ignoreWorld && this.UpdateNpcDispositions(content, assetName); case "data/npcgifttastes": // Game1.LoadContent Game1.NPCGiftTastes = content.Load>(key); return true; case "data/objectcontexttags": // Game1.LoadContent Game1.objectContextTags = content.Load>(key); return true; case "data/objectinformation": // Game1.LoadContent Game1.objectInformation = content.Load>(key); return true; /**** ** Content\Fonts ****/ case "fonts/spritefont1": // Game1.LoadContent Game1.dialogueFont = content.Load(key); return true; case "fonts/smallfont": // Game1.LoadContent Game1.smallFont = content.Load(key); return true; case "fonts/tinyfont": // Game1.LoadContent Game1.tinyFont = content.Load(key); return true; case "fonts/tinyfontborder": // Game1.LoadContent Game1.tinyFontBorder = content.Load(key); return true; /**** ** Content\LooseSprites\Lighting ****/ case "loosesprites/lighting/greenlight": // Game1.LoadContent Game1.cauldronLight = content.Load(key); return true; case "loosesprites/lighting/indoorwindowlight": // Game1.LoadContent Game1.indoorWindowLight = content.Load(key); return true; case "loosesprites/lighting/lantern": // Game1.LoadContent Game1.lantern = content.Load(key); return true; case "loosesprites/lighting/sconcelight": // Game1.LoadContent Game1.sconceLight = content.Load(key); return true; case "loosesprites/lighting/windowlight": // Game1.LoadContent Game1.windowLight = content.Load(key); return true; /**** ** Content\LooseSprites ****/ case "loosesprites/birds": // Game1.LoadContent Game1.birdsSpriteSheet = content.Load(key); return true; case "loosesprites/concessions": // Game1.LoadContent Game1.concessionsSpriteSheet = content.Load(key); return true; case "loosesprites/controllermaps": // Game1.LoadContent Game1.controllerMaps = content.Load(key); return true; case "loosesprites/cursors": // Game1.LoadContent Game1.mouseCursors = content.Load(key); foreach (DayTimeMoneyBox menu in Game1.onScreenMenus.OfType()) { foreach (ClickableTextureComponent button in new[] { menu.questButton, menu.zoomInButton, menu.zoomOutButton }) button.texture = Game1.mouseCursors; } if (!ignoreWorld) this.UpdateDoorSprites(content, assetName); return true; case "loosesprites/cursors2": // Game1.LoadContent Game1.mouseCursors2 = content.Load(key); return true; case "loosesprites/daybg": // Game1.LoadContent Game1.daybg = content.Load(key); return true; case "loosesprites/font_bold": // Game1.LoadContent SpriteText.spriteTexture = content.Load(key); return true; case "loosesprites/font_colored": // Game1.LoadContent SpriteText.coloredTexture = content.Load(key); return true; case "loosesprites/giftbox": // Game1.LoadContent Game1.giftboxTexture = content.Load(key); return true; case "loosesprites/nightbg": // Game1.LoadContent Game1.nightbg = content.Load(key); return true; case "loosesprites/shadow": // Game1.LoadContent Game1.shadowTexture = content.Load(key); return true; case "loosesprites/suspensionbridge": // SuspensionBridge constructor return !ignoreWorld && this.UpdateSuspensionBridges(content, assetName); /**** ** Content\Maps ****/ case "maps/menutiles": // Game1.LoadContent Game1.menuTexture = content.Load(key); return true; case "maps/menutilesuncolored": // Game1.LoadContent Game1.uncoloredMenuTexture = content.Load(key); return true; case "maps/springobjects": // Game1.LoadContent Game1.objectSpriteSheet = content.Load(key); return true; /**** ** Content\Minigames ****/ case "minigames/clouds": // TitleMenu { if (Game1.activeClickableMenu is TitleMenu titleMenu) { titleMenu.cloudsTexture = content.Load(key); return true; } } return false; case "minigames/titlebuttons": // TitleMenu return this.UpdateTitleButtons(content, assetName); /**** ** Content\Strings ****/ case "strings/stringsfromcsfiles": return this.UpdateStringsFromCsFiles(content); /**** ** Content\TileSheets ****/ case "tilesheets/animations": // Game1.LoadContent Game1.animations = content.Load(key); return true; case "tilesheets/buffsicons": // Game1.LoadContent Game1.buffsIcons = content.Load(key); return true; case "tilesheets/bushes": // new Bush() Bush.texture = new Lazy(() => content.Load(key)); return true; case "tilesheets/chairtiles": // Game1.LoadContent return this.UpdateChairTiles(content, assetName, ignoreWorld); case "tilesheets/craftables": // Game1.LoadContent Game1.bigCraftableSpriteSheet = content.Load(key); return true; case "tilesheets/critters": // Critter constructor return !ignoreWorld && this.UpdateCritterTextures(assetName); case "tilesheets/crops": // Game1.LoadContent Game1.cropSpriteSheet = content.Load(key); return true; case "tilesheets/debris": // Game1.LoadContent Game1.debrisSpriteSheet = content.Load(key); return true; case "tilesheets/emotes": // Game1.LoadContent Game1.emoteSpriteSheet = content.Load(key); return true; case "tilesheets/fruittrees": // FruitTree FruitTree.texture = content.Load(key); return true; case "tilesheets/furniture": // Game1.LoadContent Furniture.furnitureTexture = content.Load(key); return true; case "tilesheets/furniturefront": // Game1.LoadContent Furniture.furnitureFrontTexture = content.Load(key); return true; case "tilesheets/projectiles": // Game1.LoadContent Projectile.projectileSheet = content.Load(key); return true; case "tilesheets/rain": // Game1.LoadContent Game1.rainTexture = content.Load(key); return true; case "tilesheets/tools": // Game1.ResetToolSpriteSheet Game1.ResetToolSpriteSheet(); return true; case "tilesheets/weapons": // Game1.LoadContent Tool.weaponsTexture = content.Load(key); return true; /**** ** Content\TerrainFeatures ****/ case "terrainfeatures/flooring": // from Flooring Flooring.floorsTexture = content.Load(key); return true; case "terrainfeatures/flooring_winter": // from Flooring Flooring.floorsTextureWinter = content.Load(key); return true; case "terrainfeatures/grass": // from Grass return !ignoreWorld && this.UpdateGrassTextures(content, assetName); case "terrainfeatures/hoedirt": // from HoeDirt HoeDirt.lightTexture = content.Load(key); return true; case "terrainfeatures/hoedirtdark": // from HoeDirt HoeDirt.darkTexture = content.Load(key); return true; case "terrainfeatures/hoedirtsnow": // from HoeDirt HoeDirt.snowTexture = content.Load(key); return true; case "terrainfeatures/mushroom_tree": // from Tree return !ignoreWorld && this.UpdateTreeTextures(Tree.mushroomTree); case "terrainfeatures/tree_palm": // from Tree return !ignoreWorld && this.UpdateTreeTextures(Tree.palmTree); case "terrainfeatures/tree1_fall": // from Tree case "terrainfeatures/tree1_spring": // from Tree case "terrainfeatures/tree1_summer": // from Tree case "terrainfeatures/tree1_winter": // from Tree return !ignoreWorld && this.UpdateTreeTextures(Tree.bushyTree); case "terrainfeatures/tree2_fall": // from Tree case "terrainfeatures/tree2_spring": // from Tree case "terrainfeatures/tree2_summer": // from Tree case "terrainfeatures/tree2_winter": // from Tree return !ignoreWorld && this.UpdateTreeTextures(Tree.leafyTree); case "terrainfeatures/tree3_fall": // from Tree case "terrainfeatures/tree3_spring": // from Tree case "terrainfeatures/tree3_winter": // from Tree return !ignoreWorld && this.UpdateTreeTextures(Tree.pineTree); } /**** ** Dynamic assets ****/ if (!ignoreWorld) { // dynamic textures if (assetName.StartsWith("animals/cat")) return this.UpdatePetOrHorseSprites(assetName); if (assetName.StartsWith("animals/dog")) return this.UpdatePetOrHorseSprites(assetName); if (assetName.IsDirectlyUnderPath("Animals")) return this.UpdateFarmAnimalSprites(assetName); if (assetName.IsDirectlyUnderPath("Buildings")) return this.UpdateBuildings(assetName); if (assetName.StartsWith("LooseSprites/Fence")) return this.UpdateFenceTextures(assetName); // dynamic data if (assetName.IsDirectlyUnderPath("Characters/Dialogue")) return this.UpdateNpcDialogue(assetName); if (assetName.IsDirectlyUnderPath("Characters/schedules")) return this.UpdateNpcSchedules(assetName); } return false; } /********* ** Private methods *********/ /**** ** Update texture methods ****/ /// Update buttons on the title screen. /// The content manager through which to update the asset. /// The asset name to update. /// Returns whether any references were updated. /// Derived from the constructor and . private bool UpdateTitleButtons(LocalizedContentManager content, IAssetName assetName) { if (Game1.activeClickableMenu is TitleMenu titleMenu) { Texture2D texture = content.Load(assetName.BaseName); titleMenu.titleButtonsTexture = texture; titleMenu.backButton.texture = texture; titleMenu.aboutButton.texture = texture; titleMenu.languageButton.texture = texture; foreach (ClickableTextureComponent button in titleMenu.buttons) button.texture = texture; foreach (TemporaryAnimatedSprite bird in titleMenu.birds) bird.texture = texture; return true; } return false; } /// Update the sprites for matching pets or horses. /// The animal type. /// The asset name to update. /// Returns whether any references were updated. private bool UpdatePetOrHorseSprites(IAssetName assetName) where TAnimal : NPC { // find matches TAnimal[] animals = this.GetCharacters() .OfType() .Where(p => this.IsSameBaseName(assetName, p.Sprite?.spriteTexture?.Name)) .ToArray(); // update sprites bool changed = false; foreach (TAnimal animal in animals) changed |= this.MarkSpriteDirty(animal.Sprite); return changed; } /// Update the sprites for matching farm animals. /// The asset name to update. /// Returns whether any references were updated. /// Derived from . private bool UpdateFarmAnimalSprites(IAssetName assetName) { // find matches FarmAnimal[] animals = this.GetFarmAnimals().ToArray(); if (!animals.Any()) return false; // update sprites bool changed = true; foreach (FarmAnimal animal in animals) { // get expected key string expectedKey = animal.age.Value < animal.ageWhenMature.Value ? $"Baby{(animal.type.Value == "Duck" ? "White Chicken" : animal.type.Value)}" : animal.type.Value; if (animal.showDifferentTextureWhenReadyForHarvest.Value && animal.currentProduce.Value <= 0) expectedKey = $"Sheared{expectedKey}"; expectedKey = $"Animals/{expectedKey}"; // reload asset if (this.IsSameBaseName(assetName, expectedKey)) changed |= this.MarkSpriteDirty(animal.Sprite); } return changed; } /// Update building textures. /// The asset name to update. /// Returns whether any references were updated. private bool UpdateBuildings(IAssetName assetName) { // get paint mask info const string paintMaskSuffix = "_PaintMask"; bool isPaintMask = assetName.BaseName.EndsWith(paintMaskSuffix, StringComparison.OrdinalIgnoreCase); // get building type string type = Path.GetFileName(assetName.BaseName); if (isPaintMask) type = type[..^paintMaskSuffix.Length]; // get buildings Building[] buildings = this.GetLocations(buildingInteriors: false) .OfType() .SelectMany(p => p.buildings) .Where(p => p.buildingType.Value == type) .ToArray(); // remove from paint mask cache bool removedFromCache = this.RemoveFromPaintMaskCache(assetName); // reload textures if (buildings.Any()) { foreach (Building building in buildings) building.resetTexture(); return true; } return removedFromCache; } /// Update map seat textures. /// The content manager through which to reload the asset. /// The asset name to update. /// Whether the in-game world is fully unloaded (e.g. on the title screen), so there's no need to propagate changes into the world. /// Returns whether any references were updated. private bool UpdateChairTiles(LocalizedContentManager content, IAssetName assetName, bool ignoreWorld) { MapSeat.mapChairTexture = content.Load(assetName.BaseName); if (!ignoreWorld) { foreach (GameLocation location in this.GetLocations()) { foreach (MapSeat seat in location.mapSeats.Where(p => p != null)) { if (this.IsSameBaseName(assetName, seat._loadedTextureFile)) seat._loadedTextureFile = null; } } } return true; } /// Update critter textures. /// The asset name to update. /// Returns whether any references were updated. private bool UpdateCritterTextures(IAssetName assetName) { // get critters Critter[] critters = ( from location in this.GetLocations() where location.critters != null from Critter critter in location.critters where this.IsSameBaseName(assetName, critter.sprite?.spriteTexture?.Name) select critter ) .ToArray(); // update sprites bool changed = false; foreach (Critter entry in critters) changed |= this.MarkSpriteDirty(entry.sprite); return changed; } /// Update the sprites for interior doors. /// The content manager through which to reload the asset. /// The asset name to update. /// Returns whether any references were updated. private void UpdateDoorSprites(LocalizedContentManager content, IAssetName assetName) { Lazy texture = new Lazy(() => content.Load(assetName.BaseName)); foreach (GameLocation location in this.GetLocations()) { IEnumerable? doors = location.interiorDoors?.Doors; if (doors == null) continue; foreach (InteriorDoor? door in doors) { if (door?.Sprite == null) continue; string? curKey = this.Reflection.GetField(door.Sprite, "textureName").GetValue(); if (this.IsSameBaseName(assetName, curKey)) door.Sprite.texture = texture.Value; } } } /// Update the sprites for a fence type. /// The asset name to update. /// Returns whether any references were updated. private bool UpdateFenceTextures(IAssetName assetName) { // get fence type (e.g. LooseSprites/Fence3 => 3) if (!int.TryParse(this.GetSegments(assetName.BaseName)[1]["Fence".Length..], out int fenceType)) return false; // get fences Fence[] fences = ( from location in this.GetLocations() from fence in location.Objects.Values.OfType() where fence.whichType.Value == fenceType || (fence.isGate.Value && fenceType == 1) // gates are hardcoded to draw fence type 1 select fence ) .ToArray(); // update fence textures bool changed = false; foreach (Fence fence in fences) { if (fence.fenceTexture.IsValueCreated) { fence.fenceTexture = new Lazy(fence.loadFenceTexture); changed = true; } } return changed; } /// Update tree textures. /// The content manager through which to reload the asset. /// The asset name to update. /// Returns whether any references were updated. private bool UpdateGrassTextures(LocalizedContentManager content, IAssetName assetName) { Grass[] grasses = ( from grass in this.GetTerrainFeatures().OfType() where this.IsSameBaseName(assetName, grass.textureName()) select grass ) .ToArray(); bool changed = false; foreach (Grass grass in grasses) { if (grass.texture.IsValueCreated) { grass.texture = new Lazy(() => content.Load(assetName.BaseName)); changed = true; } } return changed; } /// Update the sprites for matching NPCs. /// The asset names being propagated. private void UpdateNpcSprites(IDictionary propagated) { // get NPCs var characters = ( from npc in this.GetCharacters() let key = this.ParseAssetNameOrNull(npc.Sprite?.spriteTexture?.Name)?.GetBaseAssetName() where key != null && propagated.ContainsKey(key) select new { Npc = npc, AssetName = key } ) .ToArray(); // update sprite foreach (var target in characters) { if (this.MarkSpriteDirty(target.Npc.Sprite)) propagated[target.AssetName] = true; } } /// Update the portraits for matching NPCs. /// The asset names being propagated. private void UpdateNpcPortraits(IDictionary propagated) { // get NPCs var characters = ( from npc in this.GetCharacters() where npc.isVillager() let key = this.ParseAssetNameOrNull(npc.Portrait?.Name)?.GetBaseAssetName() where key != null && propagated.ContainsKey(key) select new { Npc = npc, AssetName = key } ) .ToList(); // special case: Gil is a private NPC field on the AdventureGuild class (only used for the portrait) { IAssetName gilKey = this.ParseAssetName("Portraits/Gil"); if (propagated.ContainsKey(gilKey)) { GameLocation adventureGuild = Game1.getLocationFromName("AdventureGuild"); if (adventureGuild != null) { NPC? gil = this.Reflection.GetField(adventureGuild, "Gil").GetValue(); if (gil != null) characters.Add(new { Npc = gil, AssetName = gilKey }); } } } // update portrait foreach (var target in characters) { target.Npc.resetPortrait(); propagated[target.AssetName] = true; } } /// Update the sprites for matching players. /// The asset name to update. private bool UpdatePlayerSprites(IAssetName assetName) { Farmer[] players = ( from player in Game1.getOnlineFarmers() where this.IsSameBaseName(assetName, player.getTexture()) select player ) .ToArray(); foreach (Farmer player in players) { var recolorOffsets = this.Reflection.GetField>>?>(typeof(FarmerRenderer), "_recolorOffsets").GetValue(); recolorOffsets?.Clear(); player.FarmerRenderer.MarkSpriteDirty(); } return players.Any(); } /// Update suspension bridge textures. /// The content manager through which to reload the asset. /// The asset name to update. /// Returns whether any references were updated. private bool UpdateSuspensionBridges(LocalizedContentManager content, IAssetName assetName) { Lazy texture = new Lazy(() => content.Load(assetName.BaseName)); foreach (GameLocation location in this.GetLocations(buildingInteriors: false)) { // get suspension bridges field var field = this.Reflection.GetField?>(location, nameof(IslandNorth.suspensionBridges), required: false); // ReSharper disable once ConditionIsAlwaysTrueOrFalse -- field is nullable when required: false if (field == null || !typeof(IEnumerable).IsAssignableFrom(field.FieldInfo.FieldType)) continue; // update textures IEnumerable? bridges = field.GetValue(); if (bridges != null) { foreach (SuspensionBridge bridge in bridges) this.Reflection.GetField(bridge, "_texture").SetValue(texture.Value); } } return texture.IsValueCreated; } /// Update tree textures. /// The type to update. /// Returns whether any references were updated. private bool UpdateTreeTextures(int type) { Tree[] trees = this .GetTerrainFeatures() .OfType() .Where(tree => tree.treeType.Value == type) .ToArray(); bool changed = false; foreach (Tree tree in trees) { if (tree.texture.IsValueCreated) { this.Reflection.GetMethod(tree, "resetTexture").Invoke(); changed = true; } } return changed; } /// Mark an animated sprite's texture dirty, so it's reloaded next time it's rendered. /// The animated sprite to change. /// Returns whether the sprite was changed. private bool MarkSpriteDirty(AnimatedSprite sprite) { if (sprite.loadedTexture is null && sprite.spriteTexture is null) return false; sprite.loadedTexture = null; sprite.spriteTexture = null; return true; } /**** ** Update data methods ****/ /// Update the data for matching farm animals. /// Returns whether any farm animals were updated. /// Derived from the constructor. private bool UpdateFarmAnimalData() { bool changed = false; foreach (FarmAnimal animal in this.GetFarmAnimals()) { animal.reloadData(); changed = true; } return changed; } /// Update hair style metadata. /// Returns whether any data was updated. /// Derived from the and . private bool UpdateHairData() { if (Farmer.hairStyleMetadataFile == null) return false; Farmer.hairStyleMetadataFile = null; Farmer.allHairStyleIndices = null; Farmer.hairStyleMetadata.Clear(); return true; } /// Update the dialogue data for matching NPCs. /// The asset name to update. /// Returns whether any NPCs were updated. private bool UpdateNpcDialogue(IAssetName assetName) { // get NPCs string name = Path.GetFileName(assetName.BaseName); NPC[] villagers = this.GetCharacters().Where(npc => npc.Name == name && npc.isVillager()).ToArray(); if (!villagers.Any()) return false; // update dialogue // Note that marriage dialogue isn't reloaded after reset, but it doesn't need to be // propagated anyway since marriage dialogue keys can't be added/removed and the field // doesn't store the text itself. foreach (NPC villager in villagers) { bool shouldSayMarriageDialogue = villager.shouldSayMarriageDialogue.Value; MarriageDialogueReference[] marriageDialogue = villager.currentMarriageDialogue.ToArray(); villager.resetSeasonalDialogue(); // doesn't only affect seasonal dialogue villager.resetCurrentDialogue(); villager.shouldSayMarriageDialogue.Set(shouldSayMarriageDialogue); villager.currentMarriageDialogue.Set(marriageDialogue); } return true; } /// Update the disposition data for matching NPCs. /// The content manager through which to reload the asset. /// The asset name to update. /// Returns whether any NPCs were updated. private bool UpdateNpcDispositions(LocalizedContentManager content, IAssetName assetName) { IDictionary data = content.Load>(assetName.BaseName); bool changed = false; foreach (NPC npc in this.GetCharacters()) { if (npc.isVillager() && data.ContainsKey(npc.Name)) { npc.reloadData(); changed = true; } } return changed; } /// Update the schedules for matching NPCs. /// The asset name to update. /// Returns whether any NPCs were updated. private bool UpdateNpcSchedules(IAssetName assetName) { // get NPCs string name = Path.GetFileName(assetName.BaseName); NPC[] villagers = this.GetCharacters().Where(npc => npc.Name == name && npc.isVillager()).ToArray(); if (!villagers.Any()) return false; // update schedule foreach (NPC villager in villagers) { // reload schedule this.Reflection.GetField(villager, "_hasLoadedMasterScheduleData").SetValue(false); this.Reflection.GetField?>(villager, "_masterScheduleData").SetValue(null); villager.Schedule = villager.getSchedule(Game1.dayOfMonth); // switch to new schedule if needed if (villager.Schedule != null) { int lastScheduleTime = villager.Schedule.Keys.Where(p => p <= Game1.timeOfDay).OrderByDescending(p => p).FirstOrDefault(); if (lastScheduleTime != 0) { villager.queuedSchedulePaths.Clear(); villager.lastAttemptedSchedule = 0; villager.checkSchedule(lastScheduleTime); } } } return true; } /// Update cached translations from the Strings\StringsFromCSFiles asset. /// The content manager through which to reload the asset. /// Returns whether any data was updated. /// Derived from the . private bool UpdateStringsFromCsFiles(LocalizedContentManager content) { Game1.samBandName = content.LoadString("Strings/StringsFromCSFiles:Game1.cs.2156"); Game1.elliottBookName = content.LoadString("Strings/StringsFromCSFiles:Game1.cs.2157"); string[] dayNames = this.Reflection.GetField(typeof(Game1), "_shortDayDisplayName").GetValue(); dayNames[0] = content.LoadString("Strings/StringsFromCSFiles:Game1.cs.3042"); dayNames[1] = content.LoadString("Strings/StringsFromCSFiles:Game1.cs.3043"); dayNames[2] = content.LoadString("Strings/StringsFromCSFiles:Game1.cs.3044"); dayNames[3] = content.LoadString("Strings/StringsFromCSFiles:Game1.cs.3045"); dayNames[4] = content.LoadString("Strings/StringsFromCSFiles:Game1.cs.3046"); dayNames[5] = content.LoadString("Strings/StringsFromCSFiles:Game1.cs.3047"); dayNames[6] = content.LoadString("Strings/StringsFromCSFiles:Game1.cs.3048"); return true; } /**** ** Update map methods ****/ /// Update the map for a location. /// The location whose map to update. private void UpdateMap(LocationInfo locationInfo) { GameLocation location = locationInfo.Location; Vector2? playerPos = Game1.player?.Position; // reload map location.interiorDoors.Clear(); // prevent errors when doors try to update tiles which no longer exist location.reloadMap(); // reload interior doors location.interiorDoors.Clear(); location.interiorDoors.ResetSharedState(); // load doors from map properties location.interiorDoors.ResetLocalState(); // reapply door tiles // reapply map changes (after reloading doors so they apply theirs too) location.MakeMapModifications(force: true); // update for changes location.updateWarps(); location.updateDoors(); locationInfo.ParentBuilding?.updateInteriorWarps(); // reset player position // The game may move the player as part of the map changes, even if they're not in that // location. That's not needed in this case, and it can have weird effects like players // warping onto the wrong tile (or even off-screen) if a patch changes the farmhouse // map on location change. if (playerPos.HasValue) Game1.player!.Position = playerPos.Value; } /**** ** Helpers ****/ /// Get all NPCs in the game (excluding farm animals). private IEnumerable GetCharacters() { return this.WorldCache.GetOrSet( nameof(this.GetCharacters), () => { List characters = new(); foreach (NPC character in this.GetLocations().SelectMany(p => p.characters)) characters.Add(character); if (Game1.CurrentEvent?.actors != null) { foreach (NPC character in Game1.CurrentEvent.actors) characters.Add(character); } return characters; } ); } /// Get all farm animals in the game. private IEnumerable GetFarmAnimals() { return this.WorldCache.GetOrSet( nameof(this.GetFarmAnimals), () => { List animals = new(); foreach (GameLocation location in this.GetLocations()) { if (location is Farm farm) { foreach (FarmAnimal animal in farm.animals.Values) animals.Add(animal); } else if (location is AnimalHouse animalHouse) { foreach (FarmAnimal animal in animalHouse.animals.Values) animals.Add(animal); } } return animals; } ); } /// Get all locations in the game. /// Whether to also get the interior locations for constructable buildings. private IEnumerable GetLocations(bool buildingInteriors = true) { return this.WorldCache.GetOrSet( $"{nameof(this.GetLocations)}_{buildingInteriors}", () => this.GetLocationsWithInfo(buildingInteriors).Select(info => info.Location).ToArray() ); } /// Get all locations in the game. /// Whether to also get the interior locations for constructable buildings. private IEnumerable GetLocationsWithInfo(bool buildingInteriors = true) { return this.WorldCache.GetOrSet( $"{nameof(this.GetLocationsWithInfo)}_{buildingInteriors}", () => { List locations = new(); // get root locations foreach (GameLocation location in Game1.locations) locations.Add(new LocationInfo(location, null)); if (SaveGame.loaded?.locations != null) { foreach (GameLocation location in SaveGame.loaded.locations) locations.Add(new LocationInfo(location, null)); } // get child locations if (buildingInteriors) { foreach (BuildableGameLocation location in locations.Select(p => p.Location).OfType().ToArray()) { foreach (Building building in location.buildings) { GameLocation indoors = building.indoors.Value; if (indoors is not null) locations.Add(new LocationInfo(indoors, building)); } } } return locations; }); } /// Get all terrain features in the game. private IEnumerable GetTerrainFeatures() { return this.WorldCache.GetOrSet( $"{nameof(this.GetTerrainFeatures)}", () => this.GetLocations().SelectMany(p => p.terrainFeatures.Values).ToArray() ); } /// Get whether two asset names are equivalent if you ignore the locale code. /// The first value to compare. /// The second value to compare. private bool IsSameBaseName(IAssetName? left, string? right) { if (left is null || right is null) return false; IAssetName? parsedB = this.ParseAssetNameOrNull(right); return this.IsSameBaseName(left, parsedB); } /// Get whether two asset names are equivalent if you ignore the locale code. /// The first value to compare. /// The second value to compare. private bool IsSameBaseName(IAssetName? left, IAssetName? right) { if (left is null || right is null) return false; return left.IsEquivalentTo(right.BaseName, useBaseName: true); } /// Normalize an asset key to match the cache key and assert that it's valid, but don't raise an error for null or empty values. /// The asset key to normalize. private IAssetName? ParseAssetNameOrNull(string? path) { if (string.IsNullOrWhiteSpace(path)) return null; return this.ParseAssetName(path); } /// Get the segments in a path (e.g. 'a/b' is 'a' and 'b'). /// The path to check. private string[] GetSegments(string? path) { return path != null ? PathUtilities.GetSegments(path) : Array.Empty(); } /// Load a texture from the main content manager. /// The asset key to load. private Texture2D LoadTexture(string key) { return this.MainContentManager.Load(key); } /// Remove a case-insensitive key from the paint mask cache. /// The paint mask asset name. private bool RemoveFromPaintMaskCache(IAssetName assetName) { // make cache case-insensitive // This is needed for cache invalidation since mods may specify keys with a different capitalization if (!object.ReferenceEquals(BuildingPainter.paintMaskLookup.Comparer, StringComparer.OrdinalIgnoreCase)) BuildingPainter.paintMaskLookup = new Dictionary>>(BuildingPainter.paintMaskLookup, StringComparer.OrdinalIgnoreCase); // remove key from cache return BuildingPainter.paintMaskLookup.Remove(assetName.BaseName); } /// Metadata about a location used in asset propagation. /// The location instance. /// The building which contains the location, if any. private record LocationInfo(GameLocation Location, Building? ParentBuilding); } }