using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Microsoft.Xna.Framework.Graphics;
using StardewModdingAPI.Framework.Reflection;
using StardewValley;
using StardewValley.BellsAndWhistles;
using StardewValley.Buildings;
using StardewValley.Characters;
using StardewValley.Locations;
using StardewValley.Menus;
using StardewValley.Objects;
using StardewValley.Projectiles;
using StardewValley.TerrainFeatures;
namespace StardewModdingAPI.Metadata
{
/// Propagates changes to core assets to the game state.
internal class CoreAssetPropagator
{
/*********
** Properties
*********/
/// Normalises an asset key to match the cache key.
private readonly Func GetNormalisedPath;
/// Simplifies access to private game code.
private readonly Reflector Reflection;
/*********
** Public methods
*********/
/// Initialise the core asset data.
/// Normalises an asset key to match the cache key.
/// Simplifies access to private code.
public CoreAssetPropagator(Func getNormalisedPath, Reflector reflection)
{
this.GetNormalisedPath = getNormalisedPath;
this.Reflection = reflection;
}
/// Reload one of the game's core assets (if applicable).
/// The content manager through which to reload the asset.
/// The asset key to reload.
/// Returns whether an asset was reloaded.
public bool Propagate(LocalizedContentManager content, string key)
{
object result = this.PropagateImpl(content, key);
if (result is bool b)
return b;
return result != null;
}
/*********
** Private methods
*********/
/// Reload one of the game's core assets (if applicable).
/// The content manager through which to reload the asset.
/// The asset key to reload.
/// Returns any non-null value to indicate an asset was loaded.
private object PropagateImpl(LocalizedContentManager content, string key)
{
Reflector reflection = this.Reflection;
switch (key.ToLower().Replace("/", "\\")) // normalised key so we can compare statically
{
/****
** Animals
****/
case "animals\\cat":
return this.ReloadPetOrHorseSprites(content, key);
case "animals\\dog":
return this.ReloadPetOrHorseSprites(content, key);
case "animals\\horse":
return this.ReloadPetOrHorseSprites(content, key);
/****
** Buildings
****/
case "buildings\\houses": // Farm
reflection.GetField(typeof(Farm), nameof(Farm.houseTextures)).SetValue(content.Load(key));
return true;
/****
** Content\Characters\Farmer
****/
case "characters\\farmer\\accessories": // Game1.loadContent
return FarmerRenderer.accessoriesTexture = content.Load(key);
case "characters\\farmer\\farmer_base": // Farmer
if (Game1.player == null || !Game1.player.IsMale)
return false;
return Game1.player.FarmerRenderer = new FarmerRenderer(key);
case "characters\\farmer\\farmer_girl_base": // Farmer
if (Game1.player == null || Game1.player.IsMale)
return false;
return Game1.player.FarmerRenderer = new FarmerRenderer(key);
case "characters\\farmer\\hairstyles": // Game1.loadContent
return FarmerRenderer.hairStylesTexture = content.Load(key);
case "characters\\farmer\\hats": // Game1.loadContent
return FarmerRenderer.hatsTexture = content.Load(key);
case "characters\\farmer\\shirts": // Game1.loadContent
return FarmerRenderer.shirtsTexture = content.Load(key);
/****
** Content\Data
****/
case "data\\achievements": // Game1.loadContent
return Game1.achievements = content.Load>(key);
case "data\\bigcraftablesinformation": // Game1.loadContent
return Game1.bigCraftablesInformation = content.Load>(key);
case "data\\cookingrecipes": // CraftingRecipe.InitShared
return CraftingRecipe.cookingRecipes = content.Load>(key);
case "data\\craftingrecipes": // CraftingRecipe.InitShared
return CraftingRecipe.craftingRecipes = content.Load>(key);
case "data\\npcgifttastes": // Game1.loadContent
return Game1.NPCGiftTastes = content.Load>(key);
case "data\\objectinformation": // Game1.loadContent
return Game1.objectInformation = content.Load>(key);
/****
** Content\Fonts
****/
case "fonts\\spritefont1": // Game1.loadContent
return Game1.dialogueFont = content.Load(key);
case "fonts\\smallfont": // Game1.loadContent
return Game1.smallFont = content.Load(key);
case "fonts\\tinyfont": // Game1.loadContent
return Game1.tinyFont = content.Load(key);
case "fonts\\tinyfontborder": // Game1.loadContent
return Game1.tinyFontBorder = content.Load(key);
/****
** Content\Lighting
****/
case "loosesprites\\lighting\\greenlight": // Game1.loadContent
return Game1.cauldronLight = content.Load(key);
case "loosesprites\\lighting\\indoorwindowlight": // Game1.loadContent
return Game1.indoorWindowLight = content.Load(key);
case "loosesprites\\lighting\\lantern": // Game1.loadContent
return Game1.lantern = content.Load(key);
case "loosesprites\\lighting\\sconcelight": // Game1.loadContent
return Game1.sconceLight = content.Load(key);
case "loosesprites\\lighting\\windowlight": // Game1.loadContent
return Game1.windowLight = content.Load(key);
/****
** Content\LooseSprites
****/
case "loosesprites\\controllermaps": // Game1.loadContent
return Game1.controllerMaps = content.Load(key);
case "loosesprites\\cursors": // Game1.loadContent
return Game1.mouseCursors = content.Load(key);
case "loosesprites\\daybg": // Game1.loadContent
return Game1.daybg = content.Load(key);
case "loosesprites\\font_bold": // Game1.loadContent
return SpriteText.spriteTexture = content.Load(key);
case "loosesprites\\font_colored": // Game1.loadContent
return SpriteText.coloredTexture = content.Load(key);
case "loosesprites\\nightbg": // Game1.loadContent
return Game1.nightbg = content.Load(key);
case "loosesprites\\shadow": // Game1.loadContent
return Game1.shadowTexture = content.Load(key);
/****
** Content\Critters
****/
case "tilesheets\\crops": // Game1.loadContent
return Game1.cropSpriteSheet = content.Load(key);
case "tilesheets\\debris": // Game1.loadContent
return Game1.debrisSpriteSheet = content.Load(key);
case "tilesheets\\emotes": // Game1.loadContent
return Game1.emoteSpriteSheet = content.Load(key);
case "tilesheets\\furniture": // Game1.loadContent
return Furniture.furnitureTexture = content.Load(key);
case "tilesheets\\projectiles": // Game1.loadContent
return Projectile.projectileSheet = content.Load(key);
case "tilesheets\\rain": // Game1.loadContent
return Game1.rainTexture = content.Load(key);
case "tilesheets\\tools": // Game1.ResetToolSpriteSheet
Game1.ResetToolSpriteSheet();
return true;
case "tilesheets\\weapons": // Game1.loadContent
return Tool.weaponsTexture = content.Load(key);
/****
** Content\Maps
****/
case "maps\\menutiles": // Game1.loadContent
return Game1.menuTexture = content.Load(key);
case "maps\\springobjects": // Game1.loadContent
return Game1.objectSpriteSheet = content.Load(key);
case "maps\\walls_and_floors": // Wallpaper
return Wallpaper.wallpaperTexture = content.Load(key);
/****
** Content\Minigames
****/
case "minigames\\clouds": // TitleMenu
if (Game1.activeClickableMenu is TitleMenu)
{
reflection.GetField(Game1.activeClickableMenu, "cloudsTexture").SetValue(content.Load(key));
return true;
}
return false;
case "minigames\\titlebuttons": // TitleMenu
if (Game1.activeClickableMenu is TitleMenu titleMenu)
{
Texture2D texture = content.Load(key);
reflection.GetField(titleMenu, "titleButtonsTexture").SetValue(texture);
foreach (TemporaryAnimatedSprite bird in reflection.GetField>(titleMenu, "birds").GetValue())
bird.texture = texture;
return true;
}
return false;
/****
** Content\TileSheets
****/
case "tilesheets\\animations": // Game1.loadContent
return Game1.animations = content.Load(key);
case "tilesheets\\buffsicons": // Game1.loadContent
return Game1.buffsIcons = content.Load(key);
case "tilesheets\\bushes": // new Bush()
reflection.GetField>(typeof(Bush), "texture").SetValue(new Lazy(() => content.Load(key)));
return true;
case "tilesheets\\craftables": // Game1.loadContent
return Game1.bigCraftableSpriteSheet = content.Load(key);
case "tilesheets\\fruittrees": // FruitTree
return FruitTree.texture = content.Load(key);
/****
** Content\TerrainFeatures
****/
case "terrainfeatures\\flooring": // Flooring
return Flooring.floorsTexture = content.Load(key);
case "terrainfeatures\\hoedirt": // from HoeDirt
return HoeDirt.lightTexture = content.Load(key);
case "terrainfeatures\\hoedirtdark": // from HoeDirt
return HoeDirt.darkTexture = content.Load(key);
case "terrainfeatures\\hoedirtsnow": // from HoeDirt
return HoeDirt.snowTexture = content.Load(key);
case "terrainfeatures\\mushroom_tree": // from Tree
return this.ReloadTreeTextures(content, key, Tree.mushroomTree);
case "terrainfeatures\\tree_palm": // from Tree
return this.ReloadTreeTextures(content, key, 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 this.ReloadTreeTextures(content, key, 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 this.ReloadTreeTextures(content, key, Tree.leafyTree);
case "terrainfeatures\\tree3_fall": // from Tree
case "terrainfeatures\\tree3_spring": // from Tree
case "terrainfeatures\\tree3_winter": // from Tree
return this.ReloadTreeTextures(content, key, Tree.pineTree);
}
// dynamic textures
if (this.IsInFolder(key, "Animals"))
return this.ReloadFarmAnimalSprites(content, key);
if (this.IsInFolder(key, "Buildings"))
return this.ReloadBuildings(content, key);
if (this.IsInFolder(key, "Characters"))
return this.ReloadNpcSprites(content, key, monster: false);
if (this.IsInFolder(key, "Characters\\Monsters"))
return this.ReloadNpcSprites(content, key, monster: true);
if (key.StartsWith(this.GetNormalisedPath("LooseSprites\\Fence"), StringComparison.InvariantCultureIgnoreCase))
return this.ReloadFenceTextures(content, key);
if (this.IsInFolder(key, "Portraits"))
return this.ReloadNpcPortraits(content, key);
return false;
}
/*********
** Private methods
*********/
/****
** Reload methods
****/
/// Reload the sprites for matching pets or horses.
/// The animal type.
/// The content manager through which to reload the asset.
/// The asset key to reload.
/// Returns whether any textures were reloaded.
private bool ReloadPetOrHorseSprites(LocalizedContentManager content, string key)
where TAnimal : NPC
{
// find matches
TAnimal[] animals = this.GetCharacters().OfType().ToArray();
if (!animals.Any())
return false;
// update sprites
Texture2D texture = content.Load(key);
foreach (TAnimal animal in animals)
this.SetSpriteTexture(animal.Sprite, texture);
return true;
}
/// Reload the sprites for matching farm animals.
/// The content manager through which to reload the asset.
/// The asset key to reload.
/// Returns whether any textures were reloaded.
/// Derived from .
private bool ReloadFarmAnimalSprites(LocalizedContentManager content, string key)
{
// find matches
FarmAnimal[] animals = this.GetFarmAnimals().ToArray();
if (!animals.Any())
return false;
// update sprites
Lazy texture = new Lazy(() => content.Load(key));
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 (expectedKey == key)
this.SetSpriteTexture(animal.Sprite, texture.Value);
}
return texture.IsValueCreated;
}
/// Reload building textures.
/// The content manager through which to reload the asset.
/// The asset key to reload.
/// Returns whether any textures were reloaded.
private bool ReloadBuildings(LocalizedContentManager content, string key)
{
// get buildings
string type = Path.GetFileName(key);
Building[] buildings = Game1.locations
.OfType()
.SelectMany(p => p.buildings)
.Where(p => p.buildingType.Value == type)
.ToArray();
// reload buildings
if (buildings.Any())
{
Lazy texture = new Lazy(() => content.Load(key));
foreach (Building building in buildings)
building.texture = texture;
return true;
}
return false;
}
/// Reload the sprites for a fence type.
/// The content manager through which to reload the asset.
/// The asset key to reload.
/// Returns whether any textures were reloaded.
private bool ReloadFenceTextures(LocalizedContentManager content, string key)
{
// get fence type
if (!int.TryParse(this.GetSegments(key)[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)
this.Reflection.GetField>(fence, "fenceTexture").SetValue(new Lazy(fence.loadFenceTexture));
return true;
}
/// Reload the sprites for matching NPCs.
/// The content manager through which to reload the asset.
/// The asset key to reload.
/// Whether to match monsters (true) or non-monsters (false).
/// Returns whether any textures were reloaded.
private bool ReloadNpcSprites(LocalizedContentManager content, string key, bool monster)
{
// get NPCs
string name = this.GetNpcNameFromFileName(Path.GetFileName(key));
NPC[] characters = this.GetCharacters().Where(npc => npc.Name == name && npc.IsMonster == monster).ToArray();
if (!characters.Any())
return false;
// update portrait
Texture2D texture = content.Load(key);
foreach (NPC character in characters)
this.SetSpriteTexture(character.Sprite, texture);
return true;
}
/// Reload the portraits for matching NPCs.
/// The content manager through which to reload the asset.
/// The asset key to reload.
/// Returns whether any textures were reloaded.
private bool ReloadNpcPortraits(LocalizedContentManager content, string key)
{
// get NPCs
string name = this.GetNpcNameFromFileName(Path.GetFileName(key));
NPC[] villagers = this.GetCharacters().Where(npc => npc.Name == name && npc.isVillager()).ToArray();
if (!villagers.Any())
return false;
// update portrait
Texture2D texture = content.Load(key);
foreach (NPC villager in villagers)
villager.Portrait = texture;
return true;
}
/// Reload tree textures.
/// The content manager through which to reload the asset.
/// The asset key to reload.
/// The type to reload.
/// Returns whether any textures were reloaded.
private bool ReloadTreeTextures(LocalizedContentManager content, string key, int type)
{
Tree[] trees = Game1.locations
.SelectMany(p => p.terrainFeatures.Values.OfType())
.Where(tree => tree.treeType.Value == type)
.ToArray();
if (trees.Any())
{
Lazy texture = new Lazy(() => content.Load(key));
foreach (Tree tree in trees)
this.Reflection.GetField>(tree, "texture").SetValue(texture);
return true;
}
return false;
}
/****
** Helpers
****/
/// Reload the texture for an animated sprite.
/// The animated sprite to update.
/// The texture to set.
private void SetSpriteTexture(AnimatedSprite sprite, Texture2D texture)
{
this.Reflection.GetField(sprite, "spriteTexture").SetValue(texture);
}
/// Get an NPC name from the name of their file under Content/Characters.
/// The file name.
/// Derived from .
private string GetNpcNameFromFileName(string name)
{
switch (name)
{
case "Mariner":
return "Old Mariner";
case "DwarfKing":
return "Dwarf King";
case "MrQi":
return "Mister Qi";
default:
return name;
}
}
/// Get all NPCs in the game (excluding farm animals).
private IEnumerable GetCharacters()
{
return this.GetLocations().SelectMany(p => p.characters);
}
/// 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.
private IEnumerable GetLocations()
{
foreach (GameLocation location in Game1.locations)
{
yield return location;
if (location is BuildableGameLocation buildableLocation)
{
foreach (Building building in buildableLocation.buildings)
{
GameLocation indoors = building.indoors.Value;
if (indoors != null)
yield return indoors;
}
}
}
}
/// Get whether a normalised asset key is in the given folder.
/// The normalised asset key (like Animals/cat).
/// The key folder (like Animals); doesn't need to be normalised.
/// Whether to return true if the key is inside a subfolder of the .
private bool IsInFolder(string key, string folder, bool allowSubfolders = false)
{
return
key.StartsWith(this.GetNormalisedPath($"{folder}\\"), StringComparison.InvariantCultureIgnoreCase)
&& (allowSubfolders || this.CountSegments(key) == this.CountSegments(folder) + 1);
}
/// Get the segments in a path (e.g. 'a/b' is 'a' and 'b').
/// The path to check.
private string[] GetSegments(string path)
{
if (path == null)
return new string[0];
return path.Split(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
}
/// Count the number of segments in a path (e.g. 'a/b' is 2).
/// The path to check.
private int CountSegments(string path)
{
return this.GetSegments(path).Length;
}
}
}