ModContent.cs

Go to the documentation of this file.

using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Graphics;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using Terraria.DataStructures;
using Terraria.GameContent.UI;
using Terraria.GameInput;
using Terraria.Localization;
using Terraria.ModLoader.Audio;
using Terraria.ModLoader.Core;
using Terraria.ModLoader.Engine;
using Terraria.ModLoader.Exceptions;
using Terraria.ModLoader.IO;
using Terraria.ModLoader.UI;
using Terraria.UI;
 
namespace Terraria.ModLoader
{
    public static class ModContent
    {
        public static T GetInstance<T>() where T : class => ContentInstance<T>.Instance;
 
        public static void SplitName(string name, out string domain, out string subName) {
            int slash = name.IndexOf('/');
            if (slash < 0)
                throw new MissingResourceException("Missing mod qualifier: " + name);
 
            domain = name.Substring(0, slash);
            subName = name.Substring(slash + 1);
        }
 
        public static byte[] GetFileBytes(string name) {
            string modName, subName;
            SplitName(name, out modName, out subName);
 
            Mod mod = ModLoader.GetMod(modName);
            if (mod == null)
                throw new MissingResourceException("Missing mod: " + name);
 
            return mod.GetFileBytes(subName);
        }
 
        public static bool FileExists(string name) {
            if (!name.Contains('/'))
                return false;
 
            string modName, subName;
            SplitName(name, out modName, out subName);
 
            Mod mod = ModLoader.GetMod(modName);
            return mod != null && mod.FileExists(subName);
        }
 
        public static Texture2D GetTexture(string name) {
            if (Main.dedServ)
                return null;
 
            string modName, subName;
            SplitName(name, out modName, out subName);
            if (modName == "Terraria")
                return Main.instance.Content.Load<Texture2D>("Images" + Path.DirectorySeparatorChar + subName);
 
            Mod mod = ModLoader.GetMod(modName);
            if (mod == null)
                throw new MissingResourceException("Missing mod: " + name);
 
            return mod.GetTexture(subName);
        }
 
        public static bool TextureExists(string name) {
            if (Main.dedServ || string.IsNullOrWhiteSpace(name) || !name.Contains('/'))
                return false;
 
            SplitName(name, out string modName, out string subName);
 
            if (modName == "Terraria")
                return (Main.instance.Content as TMLContentManager).ImageExists(subName);
 
            Mod mod = ModLoader.GetMod(modName);
 
            return mod != null && mod.TextureExists(subName);
        }
 
        internal static bool TryGetTexture(string name, out Texture2D texture) {
            if (Main.dedServ || string.IsNullOrWhiteSpace(name) || !name.Contains('/')) {
                texture = null;
 
                return false;
            }
 
            SplitName(name, out string modName, out string subName);
 
            if (modName == "Terraria") {
                if ((Main.instance.Content as TMLContentManager).ImageExists(subName)) {
                    texture = Main.instance.Content.Load<Texture2D>("Images" + Path.DirectorySeparatorChar + subName);
 
                    return true;
                }
 
                texture = null;
 
                return false;
            }
 
            Mod mod = ModLoader.GetMod(modName);
 
            if (mod == null) {
                texture = null;
 
                return false;
            }
 
            return mod.textures.TryGetValue(subName, out texture);
        }
 
        public static SoundEffect GetSound(string name) {
            if (Main.dedServ)
                return null;
 
            string modName, subName;
            SplitName(name, out modName, out subName);
 
            Mod mod = ModLoader.GetMod(modName);
            if (mod == null)
                throw new MissingResourceException("Missing mod: " + name);
 
            return mod.GetSound(subName);
        }
 
        public static bool SoundExists(string name) {
            if (!name.Contains('/'))
                return false;
 
            string modName, subName;
            SplitName(name, out modName, out subName);
 
            Mod mod = ModLoader.GetMod(modName);
            return mod != null && mod.SoundExists(subName);
        }
 
        public static Music GetMusic(string name) {
            if (Main.dedServ) { return null; }
            string modName, subName;
            SplitName(name, out modName, out subName);
            Mod mod = ModLoader.GetMod(modName);
            if (mod == null) { throw new MissingResourceException("Missing mod: " + name); }
            return mod.GetMusic(subName);
        }
 
        public static bool MusicExists(string name) {
            if (!name.Contains('/')) { return false; }
            string modName, subName;
            SplitName(name, out modName, out subName);
            Mod mod = ModLoader.GetMod(modName);
            return mod != null && mod.MusicExists(subName);
        }
 
        public static ModNPC GetModNPC(int type) => NPCLoader.GetNPC(type);
 
        public static int GetModBossHeadSlot(string texture) => NPCHeadLoader.GetBossHeadSlot(texture);
 
        public static int GetModHeadSlot(string texture) => NPCHeadLoader.GetHeadSlot(texture);
 
        public static ModItem GetModItem(int type) => ItemLoader.GetItem(type);
 
        public static ModDust GetModDust(int type) => ModDust.GetDust(type);
 
        public static ModProjectile GetModProjectile(int type) => ProjectileLoader.GetProjectile(type);
 
        public static ModBuff GetModBuff(int type) => BuffLoader.GetBuff(type);
 
        public static EquipTexture GetEquipTexture(EquipType type, int slot) => EquipLoader.GetEquipTexture(type, slot);
 
        public static ModMountData GetModMountData(int type) => MountLoader.GetMount(type);
 
        public static ModTile GetModTile(int type) => TileLoader.GetTile(type);
 
        public static ModWall GetModWall(int type) => WallLoader.GetWall(type);
 
        public static ModWaterStyle GetModWaterStyle(int style) => WaterStyleLoader.GetWaterStyle(style);
 
        public static ModWaterfallStyle GetModWaterfallStyle(int style) => WaterfallStyleLoader.GetWaterfallStyle(style);
 
        public static int GetModBackgroundSlot(string texture) => BackgroundTextureLoader.GetBackgroundSlot(texture);
 
        public static ModSurfaceBgStyle GetModSurfaceBgStyle(int style) => SurfaceBgStyleLoader.GetSurfaceBgStyle(style);
 
        public static ModUgBgStyle GetModUgBgStyle(int style) => UgBgStyleLoader.GetUgBgStyle(style);
 
        public static int ItemType<T>() where T : ModItem => GetInstance<T>()?.item.type ?? 0;
 
        public static byte PrefixType<T>() where T : ModPrefix => GetInstance<T>()?.Type ?? 0;
 
        public static int DustType<T>() where T : ModDust => GetInstance<T>()?.Type ?? 0;
 
        public static int TileType<T>() where T : ModTile => GetInstance<T>()?.Type ?? 0;
 
        public static int TileEntityType<T>() where T : ModTileEntity => GetInstance<T>()?.Type ?? 0;
 
        public static int WallType<T>() where T : ModWall => GetInstance<T>()?.Type ?? 0;
 
        public static int ProjectileType<T>() where T : ModProjectile => GetInstance<T>()?.projectile.type ?? 0;
 
        public static int NPCType<T>() where T : ModNPC => GetInstance<T>()?.npc.type ?? 0;
 
        public static int BuffType<T>() where T : ModBuff => GetInstance<T>()?.Type ?? 0;
 
        public static int MountType<T>() where T : ModMountData => GetInstance<T>()?.Type ?? 0;
 
        private static LocalizedText SetLocalizedText(Dictionary<string, LocalizedText> dict, LocalizedText value) {
            if (dict.ContainsKey(value.Key)) {
                dict[value.Key].SetValue(value.Value);
            }
            else {
                dict[value.Key] = value;
            }
            return dict[value.Key];
        }
 
        internal static void Load(CancellationToken token) {
            CacheVanillaState();
 
            Interface.loadMods.SetLoadStage("tModLoader.MSIntializing", ModLoader.Mods.Length);
            LoadModContent(token, mod => {
                ContentInstance.Register(mod);
                mod.loading = true;
                mod.AutoloadConfig();
                mod.LoadResources();
                mod.Autoload();
                mod.Load();
                mod.loading = false;
            });
 
            Interface.loadMods.SetLoadStage("tModLoader.MSSettingUp");
            ResizeArrays();
            RecipeGroupHelper.FixRecipeGroupLookups();
 
            Interface.loadMods.SetLoadStage("tModLoader.MSLoading", ModLoader.Mods.Length);
            LoadModContent(token, mod => {
                mod.SetupContent();
                mod.PostSetupContent();
            });
 
            MemoryTracking.Finish();
 
            if (Main.dedServ)
                ModNet.AssignNetIDs();
 
            Main.player[255] = new Player(false); // setup inventory is unnecessary 
 
            RefreshModLanguage(Language.ActiveCulture);
            MapLoader.SetupModMap();
            ItemSorting.SetupWhiteLists();
            PlayerInput.reinitialize = true;
            SetupRecipes(token);
        }
 
        private static void CacheVanillaState() {
            EffectsTracker.CacheVanillaState();
        }
 
        internal static Mod LoadingMod { get; private set; }
        private static void LoadModContent(CancellationToken token, Action<Mod> loadAction) {
            MemoryTracking.Checkpoint();
            int num = 0;
            foreach (var mod in ModLoader.Mods) {
                token.ThrowIfCancellationRequested();
                Interface.loadMods.SetCurrentMod(num++, $"{mod.Name} ({mod.DisplayName}) v{mod.Version}");
                try {
                    LoadingMod = mod;
                    loadAction(mod);
                }
                catch (Exception e) {
                    e.Data["mod"] = mod.Name;
                    throw;
                }
                finally {
                    LoadingMod = null;
                    MemoryTracking.Update(mod.Name);
                }
            }
        }
 
        private static void SetupRecipes(CancellationToken token) {
            Interface.loadMods.SetLoadStage("tModLoader.MSAddingRecipes");
            for (int k = 0; k < Recipe.maxRecipes; k++) {
                token.ThrowIfCancellationRequested();
                Main.recipe[k] = new Recipe();
            }
 
            Recipe.numRecipes = 0;
            RecipeGroupHelper.ResetRecipeGroups();
            RecipeHooks.setupRecipes = true;
            Recipe.SetupRecipes();
            RecipeHooks.setupRecipes = false;
        }
 
        internal static void UnloadModContent() {
            int i = 0;
            foreach (var mod in ModLoader.Mods.Reverse()) {
                try {
                    if (Main.dedServ)
                        Console.WriteLine($"Unloading {mod.DisplayName}...");
                    else
                        Interface.loadMods.SetCurrentMod(i++, $"{mod.Name} ({mod.DisplayName}) v{mod.Version}");
                    mod.Close();
                    mod.UnloadContent();
                }
                catch (Exception e) {
                    e.Data["mod"] = mod.Name;
                    throw;
                }
                finally {
                    MonoModHooks.RemoveAll(mod);
                }
            }
        }
 
        internal static void Unload() {
            ContentInstance.Clear();
            ItemLoader.Unload();
            EquipLoader.Unload();
            ModPrefix.Unload();
            ModDust.Unload();
            TileLoader.Unload();
            ModTileEntity.Unload();
            WallLoader.Unload();
            ProjectileLoader.Unload();
            NPCLoader.Unload();
            NPCHeadLoader.Unload();
            PlayerHooks.Unload();
            BuffLoader.Unload();
            MountLoader.Unload();
            ModGore.Unload();
            SoundLoader.Unload();
            DisposeMusic();
            BackgroundTextureLoader.Unload();
            UgBgStyleLoader.Unload();
            SurfaceBgStyleLoader.Unload();
            GlobalBgStyleLoader.Unload();
            WaterStyleLoader.Unload();
            WaterfallStyleLoader.Unload();
            WorldHooks.Unload();
            ResizeArrays(true);
            for (int k = 0; k < Recipe.maxRecipes; k++) {
                Main.recipe[k] = new Recipe();
            }
            Recipe.numRecipes = 0;
            RecipeGroupHelper.ResetRecipeGroups();
            Recipe.SetupRecipes();
            MapLoader.UnloadModMap();
            ItemSorting.SetupWhiteLists();
            HotKeyLoader.Unload();
            RecipeHooks.Unload();
            CommandManager.Unload();
            TagSerializer.Reload();
            ModNet.Unload();
            Config.ConfigManager.Unload();
            CustomCurrencyManager.Initialize();
            EffectsTracker.RemoveModEffects();
 
            CleanupModReferences();
        }
 
        private static void ResizeArrays(bool unloading = false) {
            ItemLoader.ResizeArrays(unloading);
            EquipLoader.ResizeAndFillArrays();
            ModPrefix.ResizeArrays();
            Main.InitializeItemAnimations();
            ModDust.ResizeArrays();
            TileLoader.ResizeArrays(unloading);
            WallLoader.ResizeArrays(unloading);
            ProjectileLoader.ResizeArrays();
            NPCLoader.ResizeArrays(unloading);
            NPCHeadLoader.ResizeAndFillArrays();
            ModGore.ResizeAndFillArrays();
            SoundLoader.ResizeAndFillArrays();
            MountLoader.ResizeArrays();
            BuffLoader.ResizeArrays();
            PlayerHooks.RebuildHooks();
            BackgroundTextureLoader.ResizeAndFillArrays();
            UgBgStyleLoader.ResizeAndFillArrays();
            SurfaceBgStyleLoader.ResizeAndFillArrays();
            GlobalBgStyleLoader.ResizeAndFillArrays(unloading);
            WaterStyleLoader.ResizeArrays();
            WaterfallStyleLoader.ResizeArrays();
            WorldHooks.ResizeArrays();
            foreach (LocalizedText text in LanguageManager.Instance._localizedTexts.Values) {
                text.Override = null;
            }
        }
 
        public static void RefreshModLanguage(GameCulture culture) {
            Dictionary<string, LocalizedText> dict = LanguageManager.Instance._localizedTexts;
            foreach (ModItem item in ItemLoader.items) {
                LocalizedText text = new LocalizedText(item.DisplayName.Key, item.DisplayName.GetTranslation(culture));
                Lang._itemNameCache[item.item.type] = SetLocalizedText(dict, text);
                text = new LocalizedText(item.Tooltip.Key, item.Tooltip.GetTranslation(culture));
                if (text.Value != null) {
                    text = SetLocalizedText(dict, text);
                    Lang._itemTooltipCache[item.item.type] = ItemTooltip.FromLanguageKey(text.Key);
                }
            }
            foreach (ModPrefix prefix in ModPrefix.prefixes) {
                LocalizedText text = new LocalizedText(prefix.DisplayName.Key, prefix.DisplayName.GetTranslation(culture));
                Lang.prefix[prefix.Type] = SetLocalizedText(dict, text);
            }
            foreach (var keyValuePair in MapLoader.tileEntries) {
                foreach (MapEntry entry in keyValuePair.Value) {
                    if (entry.translation != null) {
                        LocalizedText text = new LocalizedText(entry.translation.Key, entry.translation.GetTranslation(culture));
                        SetLocalizedText(dict, text);
                    }
                }
            }
            foreach (var keyValuePair in MapLoader.wallEntries) {
                foreach (MapEntry entry in keyValuePair.Value) {
                    if (entry.translation != null) {
                        LocalizedText text = new LocalizedText(entry.translation.Key, entry.translation.GetTranslation(culture));
                        SetLocalizedText(dict, text);
                    }
                }
            }
            foreach (ModProjectile proj in ProjectileLoader.projectiles) {
                LocalizedText text = new LocalizedText(proj.DisplayName.Key, proj.DisplayName.GetTranslation(culture));
                Lang._projectileNameCache[proj.projectile.type] = SetLocalizedText(dict, text);
            }
            foreach (ModNPC npc in NPCLoader.npcs) {
                LocalizedText text = new LocalizedText(npc.DisplayName.Key, npc.DisplayName.GetTranslation(culture));
                Lang._npcNameCache[npc.npc.type] = SetLocalizedText(dict, text);
            }
            foreach (ModBuff buff in BuffLoader.buffs) {
                LocalizedText text = new LocalizedText(buff.DisplayName.Key, buff.DisplayName.GetTranslation(culture));
                Lang._buffNameCache[buff.Type] = SetLocalizedText(dict, text);
                text = new LocalizedText(buff.Description.Key, buff.Description.GetTranslation(culture));
                Lang._buffDescriptionCache[buff.Type] = SetLocalizedText(dict, text);
            }
            foreach (Mod mod in ModLoader.Mods) {
                foreach (ModTranslation translation in mod.translations.Values) {
                    LocalizedText text = new LocalizedText(translation.Key, translation.GetTranslation(culture));
                    SetLocalizedText(dict, text);
                }
            }
            LanguageManager.Instance.ProcessCopyCommandsInTexts();
        }
 
        private static void DisposeMusic() {
            foreach (var music in Main.music.OfType<MusicStreaming>())
                music.Dispose();
        }
 
        internal static void CleanupModReferences()
        {
            // Clear references to ModPlayer instances
            for (int i = 0; i < Main.player.Length; i++) {
                Main.player[i] = new Player();
                // player.whoAmI is only set for active players
            }
 
            Main.clientPlayer = new Player(false);
            Main.ActivePlayerFileData = new Terraria.IO.PlayerFileData();
            Main._characterSelectMenu._playerList?.Clear();
            Main.PlayerList.Clear();
 
            for (int i = 0; i < Main.npc.Length; i++) {
                Main.npc[i] = new NPC();
                Main.npc[i].whoAmI = i;
            }
 
            for (int i = 0; i < Main.item.Length; i++) {
                Main.item[i] = new Item();
                // item.whoAmI is never used
            }
 
            if (ItemSlot.singleSlotArray[0] != null) {
                ItemSlot.singleSlotArray[0] = new Item();
            }
 
            for (int i = 0; i < Main.chest.Length; i++) {
                Main.chest[i] = new Chest();
            }
 
            for (int i = 0; i < Main.projectile.Length; i++) {
                Main.projectile[i] = new Projectile();
                // projectile.whoAmI is only set for active projectiles
            }
 
            TileEntity.Clear(); // drop all possible references to mod TEs
        }
 
        public static Stream OpenRead(string assetName, bool newFileStream = false) {
            if (!assetName.StartsWith("tmod:"))
                return File.OpenRead(assetName);
 
            SplitName(assetName.Substring(5).Replace('\\', '/'), out var modName, out var entryPath);
            return ModLoader.GetMod(modName).GetFileStream(entryPath, newFileStream);
        }
    }
}