#nullable disable
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.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;
/// Whether to enable more aggressive memory optimizations.
private readonly bool AggressiveMemoryOptimizations;
/// 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
};
/*********
** 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.
/// Whether to enable more aggressive memory optimizations.
/// Parse a raw asset name.
public CoreAssetPropagator(LocalizedContentManager mainContent, GameContentManagerForAssetPropagation disposableContent, IMonitor monitor, Reflector reflection, bool aggressiveMemoryOptimizations, Func parseAssetName)
{
this.MainContentManager = mainContent;
this.DisposableContentManager = disposableContent;
this.Monitor = monitor;
this.Reflection = reflection;
this.AggressiveMemoryOptimizations = aggressiveMemoryOptimizations;
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.ReloadNpcSprites(propagatedAssets);
break;
case AssetBucket.Portrait:
if (!ignoreWorld)
this.ReloadNpcPortraits(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.ReloadMap(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.ReloadPetOrHorseSprites(content, assetName);
/****
** Buildings
****/
case "buildings/houses": // Farm
Farm.houseTextures = this.LoadAndDisposeIfNeeded(Farm.houseTextures, 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.LoadAndDisposeIfNeeded(FarmerRenderer.accessoriesTexture, 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.ReloadPlayerSprites(assetName);
case "characters/farmer/hairstyles": // Game1.LoadContent
FarmerRenderer.hairStylesTexture = this.LoadAndDisposeIfNeeded(FarmerRenderer.hairStylesTexture, key);
return true;
case "characters/farmer/hats": // Game1.LoadContent
FarmerRenderer.hatsTexture = this.LoadAndDisposeIfNeeded(FarmerRenderer.hatsTexture, key);
return true;
case "characters/farmer/pants": // Game1.LoadContent
FarmerRenderer.pantsTexture = this.LoadAndDisposeIfNeeded(FarmerRenderer.pantsTexture, key);
return true;
case "characters/farmer/shirts": // Game1.LoadContent
FarmerRenderer.shirtsTexture = this.LoadAndDisposeIfNeeded(FarmerRenderer.shirtsTexture, 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.ReloadFarmAnimalData();
case "data/hairdata": // Farmer.GetHairStyleMetadataFile
return this.ReloadHairData();
case "data/movies": // MovieTheater.GetMovieData
case "data/moviesreactions": // MovieTheater.GetMovieReactions
MovieTheater.ClearCachedLocalizedData();
return true;
case "data/npcdispositions": // NPC constructor
return !ignoreWorld && this.ReloadNpcDispositions(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.ReloadDoorSprites(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.ReloadSuspensionBridges(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.ReloadTitleButtons(content, assetName);
/****
** Content\Strings
****/
case "strings/stringsfromcsfiles":
return this.ReloadStringsFromCsFiles(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.ReloadChairTiles(content, assetName, ignoreWorld);
case "tilesheets/craftables": // Game1.LoadContent
Game1.bigCraftableSpriteSheet = content.Load(key);
return true;
case "tilesheets/critters": // Critter constructor
return !ignoreWorld && this.ReloadCritterTextures(content, assetName) > 0;
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.ReloadGrassTextures(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.ReloadTreeTextures(content, assetName, Tree.mushroomTree);
case "terrainfeatures/tree_palm": // from Tree
return !ignoreWorld && this.ReloadTreeTextures(content, assetName, 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.ReloadTreeTextures(content, assetName, 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.ReloadTreeTextures(content, assetName, Tree.leafyTree);
case "terrainfeatures/tree3_fall": // from Tree
case "terrainfeatures/tree3_spring": // from Tree
case "terrainfeatures/tree3_winter": // from Tree
return !ignoreWorld && this.ReloadTreeTextures(content, assetName, Tree.pineTree);
}
/****
** Dynamic assets
****/
if (!ignoreWorld)
{
// dynamic textures
if (assetName.StartsWith("animals/cat"))
return this.ReloadPetOrHorseSprites(content, assetName);
if (assetName.StartsWith("animals/dog"))
return this.ReloadPetOrHorseSprites(content, assetName);
if (assetName.IsDirectlyUnderPath("Animals"))
return this.ReloadFarmAnimalSprites(content, assetName);
if (assetName.IsDirectlyUnderPath("Buildings"))
return this.ReloadBuildings(assetName);
if (assetName.StartsWith("LooseSprites/Fence"))
return this.ReloadFenceTextures(assetName);
// dynamic data
if (assetName.IsDirectlyUnderPath("Characters/Dialogue"))
return this.ReloadNpcDialogue(assetName);
if (assetName.IsDirectlyUnderPath("Characters/schedules"))
return this.ReloadNpcSchedules(assetName);
}
return false;
}
/*********
** Private methods
*********/
/****
** Reload texture methods
****/
/// Reload buttons on the title screen.
/// The content manager through which to reload the asset.
/// The asset name to reload.
/// Returns whether any textures were reloaded.
/// Derived from the constructor and .
private bool ReloadTitleButtons(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;
}
/// Reload the sprites for matching pets or horses.
/// The animal type.
/// The content manager through which to reload the asset.
/// The asset name to reload.
/// Returns whether any textures were reloaded.
private bool ReloadPetOrHorseSprites(LocalizedContentManager content, IAssetName assetName)
where TAnimal : NPC
{
// find matches
TAnimal[] animals = this.GetCharacters()
.OfType()
.Where(p => this.IsSameBaseName(assetName, p.Sprite?.Texture?.Name))
.ToArray();
if (!animals.Any())
return false;
// update sprites
Texture2D texture = content.Load(assetName.BaseName);
foreach (TAnimal animal in animals)
animal.Sprite.spriteTexture = texture;
return true;
}
/// Reload the sprites for matching farm animals.
/// The content manager through which to reload the asset.
/// The asset name to reload.
/// Returns whether any textures were reloaded.
/// Derived from .
private bool ReloadFarmAnimalSprites(LocalizedContentManager content, IAssetName assetName)
{
// find matches
FarmAnimal[] animals = this.GetFarmAnimals().ToArray();
if (!animals.Any())
return false;
// update sprites
Lazy texture = new Lazy(() => content.Load(assetName.BaseName));
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))
animal.Sprite.spriteTexture = texture.Value;
}
return texture.IsValueCreated;
}
/// Reload building textures.
/// The asset name to reload.
/// Returns whether any textures were reloaded.
private bool ReloadBuildings(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.Substring(0, type.Length - 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;
}
/// Reload map seat textures.
/// The content manager through which to reload the asset.
/// The asset name 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.
/// Returns whether any textures were reloaded.
private bool ReloadChairTiles(LocalizedContentManager content, IAssetName assetName, bool ignoreWorld)
{
MapSeat.mapChairTexture = content.Load(assetName.BaseName);
if (!ignoreWorld)
{
foreach (var location in this.GetLocations())
{
foreach (MapSeat seat in location.mapSeats.Where(p => p != null))
{
if (this.IsSameBaseName(assetName, seat._loadedTextureFile))
seat.overlayTexture = MapSeat.mapChairTexture;
}
}
}
return true;
}
/// Reload critter textures.
/// The content manager through which to reload the asset.
/// The asset name to reload.
/// Returns the number of reloaded assets.
private int ReloadCritterTextures(LocalizedContentManager content, 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?.Texture?.Name)
select critter
)
.ToArray();
if (!critters.Any())
return 0;
// update sprites
Texture2D texture = content.Load(assetName.BaseName);
foreach (var entry in critters)
entry.sprite.spriteTexture = texture;
return critters.Length;
}
/// Reload the sprites for interior doors.
/// The content manager through which to reload the asset.
/// The asset name to reload.
/// Returns whether any doors were affected.
private bool ReloadDoorSprites(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;
}
}
return texture.IsValueCreated;
}
/// Reload the data for matching farm animals.
/// Returns whether any farm animals were affected.
/// Derived from the constructor.
private bool ReloadFarmAnimalData()
{
bool changed = false;
foreach (FarmAnimal animal in this.GetFarmAnimals())
{
animal.reloadData();
changed = true;
}
return changed;
}
/// Reload the sprites for a fence type.
/// The asset name to reload.
/// Returns whether any textures were reloaded.
private bool ReloadFenceTextures(IAssetName assetName)
{
// get fence type (e.g. LooseSprites/Fence3 => 3)
if (!int.TryParse(this.GetSegments(assetName.BaseName)[1].Substring("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
foreach (Fence fence in fences)
fence.fenceTexture = new Lazy(fence.loadFenceTexture);
return true;
}
/// Reload tree textures.
/// The content manager through which to reload the asset.
/// The asset name to reload.
/// Returns whether any textures were reloaded.
private bool ReloadGrassTextures(LocalizedContentManager content, IAssetName assetName)
{
Grass[] grasses =
(
from location in this.GetLocations()
from grass in location.terrainFeatures.Values.OfType()
where this.IsSameBaseName(assetName, grass.textureName())
select grass
)
.ToArray();
if (grasses.Any())
{
Lazy texture = new Lazy(() => content.Load(assetName.BaseName));
foreach (Grass grass in grasses)
grass.texture = texture;
return true;
}
return false;
}
/// Reload hair style metadata.
/// Returns whether any assets were reloaded.
/// Derived from the and .
private bool ReloadHairData()
{
if (Farmer.hairStyleMetadataFile == null)
return false;
Farmer.hairStyleMetadataFile = null;
Farmer.allHairStyleIndices = null;
Farmer.hairStyleMetadata.Clear();
return true;
}
/// Reload the map for a location.
/// The location whose map to reload.
private void ReloadMap(LocationInfo locationInfo)
{
GameLocation location = locationInfo.Location;
Vector2? playerPos = Game1.player?.Position;
if (this.AggressiveMemoryOptimizations)
location.map.DisposeTileSheets(Game1.mapDisplayDevice);
// 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;
}
/// Reload the disposition data for matching NPCs.
/// The content manager through which to reload the asset.
/// The asset name to reload.
/// Returns whether any NPCs were affected.
private bool ReloadNpcDispositions(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;
}
/// Reload the sprites for matching NPCs.
/// The asset keys which are being propagated.
private void ReloadNpcSprites(IDictionary propagated)
{
// get NPCs
var characters =
(
from npc in this.GetCharacters()
let key = this.ParseAssetNameOrNull(npc.Sprite?.Texture?.Name)?.GetBaseAssetName()
where key != null && propagated.ContainsKey(key)
select new { Npc = npc, AssetName = key }
)
.ToArray();
if (!characters.Any())
return;
// update sprite
foreach (var target in characters)
{
target.Npc.Sprite.spriteTexture = this.LoadAndDisposeIfNeeded(target.Npc.Sprite.spriteTexture, target.AssetName.BaseName);
propagated[target.AssetName] = true;
}
}
/// Reload the portraits for matching NPCs.
/// The asset keys which are being propagated.
private void ReloadNpcPortraits(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)
characters.Add(new { Npc = this.Reflection.GetField(adventureGuild, "Gil").GetValue(), AssetName = gilKey });
}
}
// update portrait
foreach (var target in characters)
{
target.Npc.Portrait = this.LoadAndDisposeIfNeeded(target.Npc.Portrait, target.AssetName.BaseName);
propagated[target.AssetName] = true;
}
}
/// Reload the sprites for matching players.
/// The asset name to reload.
private bool ReloadPlayerSprites(IAssetName assetName)
{
Farmer[] players =
(
from player in Game1.getOnlineFarmers()
where this.IsSameBaseName(assetName, player.getTexture())
select player
)
.ToArray();
foreach (Farmer player in players)
{
this.Reflection.GetField>>>(typeof(FarmerRenderer), "_recolorOffsets").GetValue().Remove(player.getTexture());
player.FarmerRenderer.MarkSpriteDirty();
}
return players.Any();
}
/// Reload suspension bridge textures.
/// The content manager through which to reload the asset.
/// The asset name to reload.
/// Returns whether any textures were reloaded.
private bool ReloadSuspensionBridges(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);
if (field == null || !typeof(IEnumerable).IsAssignableFrom(field.FieldInfo.FieldType))
continue;
// update textures
foreach (SuspensionBridge bridge in field.GetValue())
this.Reflection.GetField(bridge, "_texture").SetValue(texture.Value);
}
return texture.IsValueCreated;
}
/// Reload tree textures.
/// The content manager through which to reload the asset.
/// The asset name to reload.
/// The type to reload.
/// Returns whether any textures were reloaded.
private bool ReloadTreeTextures(LocalizedContentManager content, IAssetName assetName, int type)
{
Tree[] trees = this.GetLocations()
.SelectMany(p => p.terrainFeatures.Values.OfType())
.Where(tree => tree.treeType.Value == type)
.ToArray();
if (trees.Any())
{
Lazy texture = new Lazy(() => content.Load(assetName.BaseName));
foreach (Tree tree in trees)
tree.texture = texture;
return true;
}
return false;
}
/****
** Reload data methods
****/
/// Reload the dialogue data for matching NPCs.
/// The asset name to reload.
/// Returns whether any assets were reloaded.
private bool ReloadNpcDialogue(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;
}
/// Reload the schedules for matching NPCs.
/// The asset name to reload.
/// Returns whether any assets were reloaded.
private bool ReloadNpcSchedules(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;
}
/// Reload cached translations from the Strings\StringsFromCSFiles asset.
/// The content manager through which to reload the asset.
/// Returns whether any data was reloaded.
/// Derived from the .
private bool ReloadStringsFromCsFiles(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;
}
/****
** Helpers
****/
/// Get all NPCs in the game (excluding farm animals).
private IEnumerable GetCharacters()
{
foreach (NPC character in this.GetLocations().SelectMany(p => p.characters))
yield return character;
if (Game1.CurrentEvent?.actors != null)
{
foreach (NPC character in Game1.CurrentEvent.actors)
yield return character;
}
}
/// Get all farm animals in the game.
private IEnumerable GetFarmAnimals()
{
foreach (GameLocation location in this.GetLocations())
{
if (location is Farm farm)
{
foreach (FarmAnimal animal in farm.animals.Values)
yield return animal;
}
else if (location is AnimalHouse animalHouse)
foreach (FarmAnimal animal in animalHouse.animals.Values)
yield return animal;
}
}
/// Get all locations in the game.
/// Whether to also get the interior locations for constructable buildings.
private IEnumerable GetLocations(bool buildingInteriors = true)
{
return this.GetLocationsWithInfo(buildingInteriors).Select(info => info.Location);
}
/// Get all locations in the game.
/// Whether to also get the interior locations for constructable buildings.
private IEnumerable GetLocationsWithInfo(bool buildingInteriors = true)
{
// get available root locations
IEnumerable rootLocations = Game1.locations;
if (SaveGame.loaded?.locations != null)
rootLocations = rootLocations.Concat(SaveGame.loaded.locations);
// yield root + child locations
foreach (GameLocation location in rootLocations)
{
yield return new LocationInfo(location, null);
if (buildingInteriors && location is BuildableGameLocation buildableLocation)
{
foreach (Building building in buildableLocation.buildings)
{
GameLocation indoors = building.indoors.Value;
if (indoors != null)
yield return new LocationInfo(indoors, building);
}
}
}
}
/// 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, and dispose the old one if is enabled and it's different from the new instance.
/// The previous texture to dispose.
/// The asset key to load.
private Texture2D LoadAndDisposeIfNeeded(Texture2D oldTexture, string key)
{
// if aggressive memory optimizations are enabled, load the asset from the disposable
// content manager and dispose the old instance if needed.
if (this.AggressiveMemoryOptimizations)
{
GameContentManagerForAssetPropagation content = this.DisposableContentManager;
Texture2D newTexture = content.Load(key);
if (oldTexture?.IsDisposed == false && !object.ReferenceEquals(oldTexture, newTexture) && content.IsResponsibleFor(oldTexture))
oldTexture.Dispose();
return newTexture;
}
// else just (re)load it from the main content manager
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.
private readonly struct LocationInfo
{
/*********
** Accessors
*********/
/// The location instance.
public GameLocation Location { get; }
/// The building which contains the location, if any.
public Building ParentBuilding { get; }
/*********
** Public methods
*********/
/// Construct an instance.
/// The location instance.
/// The building which contains the location, if any.
public LocationInfo(GameLocation location, Building parentBuilding)
{
this.Location = location;
this.ParentBuilding = parentBuilding;
}
}
}
}