Mod.cs

Go to the documentation of this file.

using log4net;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Graphics;
using ReLogic.Graphics;
using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using Terraria.Audio;
using Terraria.ID;
using Terraria.Localization;
using Terraria.ModLoader.Audio;
using Terraria.ModLoader.Core;
using Terraria.ModLoader.Exceptions;
using System.Linq;
using Terraria.ModLoader.Config;
using Terraria.ModLoader.UI;
 
namespace Terraria.ModLoader
{
    public abstract partial class Mod
    {
        internal TmodFile File { get; set; }
        public Assembly Code { get; internal set; }
        public ILog Logger { get; internal set; }
 
        public virtual string Name => File.name;
        public Version tModLoaderVersion { get; internal set; }
        public virtual Version Version => File.version;
 
        public ModProperties Properties { get; protected set; } = ModProperties.AutoLoadAll;
        public ModSide Side { get; internal set; }
        public string DisplayName { get; internal set; }
 
        internal short netID = -1;
        public bool IsNetSynced => netID >= 0;
 
        private IDisposable fileHandle;
 
 
        public virtual void Load() {
        }
 
        public virtual void PostSetupContent() {
        }
 
        public virtual void Unload() {
        }
 
        public virtual uint ExtraPlayerBuffSlots { get; }
 
        public virtual void AddRecipeGroups() {
        }
 
        public virtual void AddRecipes() {
        }
 
        public virtual void PostAddRecipes() {
        }
 
        public virtual void LoadResources() {
            if (File == null)
                return;
 
            fileHandle = File.Open();
 
            var skipCache = new HashSet<string>();
            foreach (var entry in File) {
                Interface.loadMods.SubProgressText = entry.Name;
 
                Stream _stream = null;
                Stream GetStream() => _stream = File.GetStream(entry);
 
                if (LoadResource(entry.Name, entry.Length, GetStream))
                    skipCache.Add(entry.Name);
                
                _stream?.Dispose();
            }
            File.CacheFiles(skipCache);
        }
 
        public virtual void Close() {
            fileHandle?.Dispose();
            if (File != null && File.IsOpen)
                throw new IOException($"TModFile has open handles: {File.path}");
        }
 
        public virtual bool LoadResource(string path, int length, Func<Stream> getStream) {
            if (tModLoaderVersion < new Version(0, 11) && LoadResourceLegacy(path, length, getStream)) // TODO LoadResourceLegacy is marked obsolete
                return false;
 
            string extension = Path.GetExtension(path).ToLower();
            path = Path.ChangeExtension(path, null);
            switch (extension) {
                case ".png":
                case ".rawimg":
                    if (!Main.dedServ)
                        LoadTexture(path, getStream(), extension == ".rawimg");
                    return true;
                case ".wav":
                case ".mp3":
                case ".ogg":
                    //Main.engine == null would be more sensible, but only the waveBank fails on Linux when there is no audio hardware
                    if (Main.dedServ || Main.waveBank == null) { }
                    else if (path.Contains("Music/"))
                        musics[path] = LoadMusic(path, extension);
                    else
                        sounds[path] = LoadSound(getStream(), length, extension);
                    return true;
                case ".xnb":
                    if (Main.dedServ) { }
                    else if (path.StartsWith("Fonts/"))
                        fonts[path] = Main.instance.OurLoad<DynamicSpriteFont>("tmod:"+Name+"/"+path);
                    else if (path.StartsWith("Effects/"))
                        effects[path] = Main.ShaderContentManager.Load<Effect>("tmod:"+Name+"/"+path);
                    else
                        throw new ResourceLoadException(Language.GetTextValue("tModLoader.LoadErrorUnknownXNBFileHint", path));
                    return true;
            }
 
            return false;
        }
 
        [Obsolete]
        private bool LoadResourceLegacy(string path, int length, Func<Stream> getStream) {
            using (var stream = getStream()) {
                LoadResourceFromStream(path, length, new BinaryReader(stream));
                return stream.Position > 0;
            }
        }
 
        [Obsolete("Use LoadResource instead", true)]
        public virtual void LoadResourceFromStream(string path, int len, BinaryReader reader) {
        }
 
        internal void AutoloadConfig()
        {
            if (Code == null)
                return;
 
            // TODO: Attribute to specify ordering of ModConfigs
            foreach (Type type in Code.GetTypes().OrderBy(type => type.FullName))
            {
                if (type.IsAbstract)
                {
                    continue;
                }
                if (type.IsSubclassOf(typeof(ModConfig)))
                {
                    var mc = (ModConfig)Activator.CreateInstance(type);
                    // Skip loading ClientSide on Main.dedServ?
                    if (mc.Mode == ConfigScope.ServerSide && (Side == ModSide.Client || Side == ModSide.NoSync)) // Client and NoSync mods can't have ServerSide ModConfigs. Server can, but won't be synced.
                        throw new Exception($"The ModConfig {mc.Name} can't be loaded because the config is ServerSide but this Mods ModSide isn't Both or Server");
                    if (mc.Mode == ConfigScope.ClientSide && Side == ModSide.Server) // Doesn't make sense. 
                        throw new Exception($"The ModConfig {mc.Name} can't be loaded because the config is ClientSide but this Mods ModSide is Server");
                    mc.mod = this;
                    var name = type.Name;
                    if (mc.Autoload(ref name))
                        AddConfig(name, mc);
                }
            }
        }
 
        public void AddConfig(string name, ModConfig mc)
        {
            mc.Name = name;
            mc.mod = this;
 
            ConfigManager.Add(mc);
            ContentInstance.Register(mc);
        }
 
        public void AddItem(string name, ModItem item) {
            if (!loading)
                throw new Exception(Language.GetTextValue("tModLoader.LoadErrorAddItemOnlyInLoad"));
 
            if (items.ContainsKey(name))
                throw new Exception(Language.GetTextValue("tModLoader.LoadError2ModItemSameName", name));
 
            item.mod = this;
            item.Name = name;
            item.DisplayName = GetOrCreateTranslation(string.Format("Mods.{0}.ItemName.{1}", Name, name));
            item.Tooltip = GetOrCreateTranslation(string.Format("Mods.{0}.ItemTooltip.{1}", Name, name), true);
 
            item.item.ResetStats(ItemLoader.ReserveItemID());
            item.item.modItem = item;
 
            items[name] = item;
            ItemLoader.items.Add(item);
            ContentInstance.Register(item);
        }
 
        public ModItem GetItem(string name) => items.TryGetValue(name, out var item) ? item : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetItem<T>() where T : ModItem => ModContent.GetInstance<T>();
 
        public int ItemType(string name) => GetItem(name)?.item.type ?? 0;
 
        [Obsolete("Use ModContent.ItemType<T> instead", true)]
        public int ItemType<T>() where T : ModItem => ModContent.ItemType<T>();
 
        public void AddGlobalItem(string name, GlobalItem globalItem) {
            if (!loading)
                throw new Exception("AddGlobalItem can only be called from Mod.Load or Mod.Autoload");
 
            ItemLoader.VerifyGlobalItem(globalItem);
 
            globalItem.mod = this;
            globalItem.Name = name;
 
            globalItems[name] = globalItem;
            globalItem.index = ItemLoader.globalItems.Count;
            ItemLoader.globalIndexes[Name + ':' + name] = ItemLoader.globalItems.Count;
            if (ItemLoader.globalIndexesByType.ContainsKey(globalItem.GetType())) {
                ItemLoader.globalIndexesByType[globalItem.GetType()] = -1;
            }
            else {
                ItemLoader.globalIndexesByType[globalItem.GetType()] = ItemLoader.globalItems.Count;
            }
            ItemLoader.globalItems.Add(globalItem);
            ContentInstance.Register(globalItem);
        }
 
        public GlobalItem GetGlobalItem(string name) => globalItems.TryGetValue(name, out var globalItem) ? globalItem : null;
 
        public T GetGlobalItem<T>() where T : GlobalItem => (T)GetGlobalItem(typeof(T).Name);
 
        public int AddEquipTexture(ModItem item, EquipType type, string name, string texture,
            string armTexture = "", string femaleTexture = "") {
            return AddEquipTexture(new EquipTexture(), item, type, name, texture, armTexture, femaleTexture);
        }
 
        public int AddEquipTexture(EquipTexture equipTexture, ModItem item, EquipType type, string name, string texture,
            string armTexture = "", string femaleTexture = "") {
            if (!loading)
                throw new Exception("AddEquipTexture can only be called from Mod.Load or Mod.Autoload");
 
            ModContent.GetTexture(texture); //ensure texture exists
 
            equipTexture.Texture = texture;
            equipTexture.mod = this;
            equipTexture.Name = name;
            equipTexture.Type = type;
            equipTexture.item = item;
            int slot = equipTexture.Slot = EquipLoader.ReserveEquipID(type);
 
            EquipLoader.equipTextures[type][slot] = equipTexture;
            equipTextures[Tuple.Create(name, type)] = equipTexture;
 
            if (type == EquipType.Body) {
                if (femaleTexture == null || !ModContent.TextureExists(femaleTexture))
                    femaleTexture = texture;
                EquipLoader.femaleTextures[slot] = femaleTexture;
 
                ModContent.GetTexture(armTexture); //ensure texture exists
                EquipLoader.armTextures[slot] = armTexture;
            }
            if (item != null) {
                IDictionary<EquipType, int> slots;
                if (!EquipLoader.idToSlot.TryGetValue(item.item.type, out slots))
                    EquipLoader.idToSlot[item.item.type] = slots = new Dictionary<EquipType, int>();
 
                slots[type] = slot;
                if (type == EquipType.Head || type == EquipType.Body || type == EquipType.Legs)
                    EquipLoader.slotToId[type][slot] = item.item.type;
            }
            return slot;
        }
 
        public EquipTexture GetEquipTexture(string name, EquipType type) =>
            equipTextures.TryGetValue(Tuple.Create(name, type), out var texture) ? texture : null;
 
        public int GetEquipSlot(string name, EquipType type) => GetEquipTexture(name, type)?.Slot ?? -1;
 
        public sbyte GetAccessorySlot(string name, EquipType type) => (sbyte)GetEquipSlot(name, type);
 
        public void AddPrefix(string name, ModPrefix prefix) {
            if (!loading)
                throw new Exception("AddPrefix can only be called from Mod.Load or Mod.Autoload");
 
            if (prefixes.ContainsKey(name))
                throw new Exception("You tried to add 2 ModPrefixes with the same name: " + name + ". Maybe 2 classes share a classname but in different namespaces while autoloading or you manually called AddPrefix with 2 prefixes of the same name.");
 
            prefix.mod = this;
            prefix.Name = name;
            prefix.DisplayName = GetOrCreateTranslation(string.Format("Mods.{0}.Prefix.{1}", Name, name));
            prefix.Type = ModPrefix.ReservePrefixID();
 
            prefixes[name] = prefix;
            ModPrefix.prefixes.Add(prefix);
            ModPrefix.categoryPrefixes[prefix.Category].Add(prefix);
            ContentInstance.Register(prefix);
        }
 
        public ModPrefix GetPrefix(string name) => prefixes.TryGetValue(name, out var prefix) ? prefix : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetPrefix<T>() where T : ModPrefix => ModContent.GetInstance<T>();
 
        public byte PrefixType(string name) => GetPrefix(name)?.Type ?? 0;
 
        [Obsolete("Use ModContent.PrefixType<T> instead", true)]
        public byte PrefixType<T>() where T : ModPrefix => ModContent.PrefixType<T>();
 
        public void AddDust(string name, ModDust dust, string texture = "") {
            if (!loading)
                throw new Exception("AddDust can only be called from Mod.Load or Mod.Autoload");
 
            dust.mod = this;
            dust.Name = name;
            dust.Type = ModDust.ReserveDustID();
            dust.Texture = !string.IsNullOrEmpty(texture) ? ModContent.GetTexture(texture) : Main.dustTexture;
 
            dusts[name] = dust;
            ModDust.dusts.Add(dust);
            ContentInstance.Register(dust);
        }
 
        public ModDust GetDust(string name) => dusts.TryGetValue(name, out var dust) ? dust : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetDust<T>() where T : ModDust => ModContent.GetInstance<T>();
 
        public int DustType(string name) => GetDust(name)?.Type ?? 0;
 
        [Obsolete("Use ModContent.DustType<T> instead", true)]
        public int DustType<T>() where T : ModDust => ModContent.DustType<T>();
 
        public void AddTile(string name, ModTile tile, string texture) {
            if (!loading)
                throw new Exception("AddItem can only be called from Mod.Load or Mod.Autoload");
 
            if (tiles.ContainsKey(name))
                throw new Exception("You tried to add 2 ModTile with the same name: " + name + ". Maybe 2 classes share a classname but in different namespaces while autoloading or you manually called AddTile with 2 tiles of the same name.");
 
            tile.mod = this;
            tile.Name = name;
            tile.Type = (ushort)TileLoader.ReserveTileID();
            tile.texture = texture;
 
            tiles[name] = tile;
            TileLoader.tiles.Add(tile);
            ContentInstance.Register(tile);
        }
 
        public ModTile GetTile(string name) => tiles.TryGetValue(name, out var tile) ? tile : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetTile<T>() where T : ModTile => ModContent.GetInstance<T>();
 
        public int TileType(string name) => GetTile(name)?.Type ?? 0;
 
        [Obsolete("Use ModContent.TileType<T> instead", true)]
        public int TileType<T>() where T : ModTile => ModContent.TileType<T>();
 
        public void AddGlobalTile(string name, GlobalTile globalTile) {
            if (!loading)
                throw new Exception("AddGlobalTile can only be called from Mod.Load or Mod.Autoload");
 
            globalTile.mod = this;
            globalTile.Name = name;
 
            globalTiles[name] = globalTile;
            TileLoader.globalTiles.Add(globalTile);
            ContentInstance.Register(globalTile);
        }
 
        public GlobalTile GetGlobalTile(string name) => globalTiles.TryGetValue(name, out var globalTile) ? globalTile : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetGlobalTile<T>() where T : GlobalTile => ModContent.GetInstance<T>();
 
        public void AddTileEntity(string name, ModTileEntity entity) {
            if (!loading)
                throw new Exception("AddTileEntity can only be called from Mod.Load or Mod.Autoload");
 
            int id = ModTileEntity.ReserveTileEntityID();
            entity.mod = this;
            entity.Name = name;
            entity.Type = id;
            entity.type = (byte)id;
 
            tileEntities[name] = entity;
            ModTileEntity.tileEntities.Add(entity);
            ContentInstance.Register(entity);
        }
 
        public ModTileEntity GetTileEntity(string name) =>
            tileEntities.TryGetValue(name, out var tileEntity) ? tileEntity : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetTileEntity<T>() where T : ModTileEntity => ModContent.GetInstance<T>();
 
        public int TileEntityType(string name) => GetTileEntity(name)?.Type ?? -1;
 
        [Obsolete("Use ModContent.TileEntityType<T> instead", true)]
        public int TileEntityType<T>() where T : ModTileEntity => ModContent.TileEntityType<T>();
 
        public void AddWall(string name, ModWall wall, string texture) {
            if (!loading)
                throw new Exception("AddWall can only be called from Mod.Load or Mod.Autoload");
 
            wall.mod = this;
            wall.Name = name;
            wall.Type = (ushort)WallLoader.ReserveWallID();
            wall.texture = texture;
 
            walls[name] = wall;
            WallLoader.walls.Add(wall);
            ContentInstance.Register(wall);
        }
 
        public ModWall GetWall(string name) => walls.TryGetValue(name, out var wall) ? wall : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetWall<T>() where T : ModWall => ModContent.GetInstance<T>();
 
        public int WallType(string name) => GetWall(name)?.Type ?? 0;
 
        [Obsolete("Use ModContent.WallType<T> instead", true)]
        public int WallType<T>() where T : ModWall => ModContent.WallType<T>();
 
        public void AddGlobalWall(string name, GlobalWall globalWall) {
            if (!loading)
                throw new Exception("AddGlobalWall can only be called from Mod.Load or Mod.Autoload");
 
            globalWall.mod = this;
            globalWall.Name = name;
 
            globalWalls[name] = globalWall;
            WallLoader.globalWalls.Add(globalWall);
            ContentInstance.Register(globalWall);
        }
 
        public GlobalWall GetGlobalWall(string name) => globalWalls.TryGetValue(name, out var globalWall) ? globalWall : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetGlobalWall<T>() where T : GlobalWall => ModContent.GetInstance<T>();
 
        public void AddProjectile(string name, ModProjectile projectile) {
            if (!loading)
                throw new Exception("AddProjectile can only be called from Mod.Load or Mod.Autoload");
 
            if (projectiles.ContainsKey(name))
                throw new Exception("You tried to add 2 ModProjectile with the same name: " + name + ". Maybe 2 classes share a classname but in different namespaces while autoloading or you manually called AddProjectile with 2 projectiles of the same name.");
 
            projectile.mod = this;
            projectile.Name = name;
            projectile.projectile.type = ProjectileLoader.ReserveProjectileID();
            projectile.DisplayName = GetOrCreateTranslation(string.Format("Mods.{0}.ProjectileName.{1}", Name, name));
 
            projectiles[name] = projectile;
            ProjectileLoader.projectiles.Add(projectile);
            ContentInstance.Register(projectile);
        }
 
        public ModProjectile GetProjectile(string name) => projectiles.TryGetValue(name, out var proj) ? proj : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetProjectile<T>() where T : ModProjectile => ModContent.GetInstance<T>();
 
        public int ProjectileType(string name) => GetProjectile(name)?.projectile.type ?? 0;
 
        [Obsolete("Use ModContent.ProjectileType<T> instead", true)]
        public int ProjectileType<T>() where T : ModProjectile => ModContent.ProjectileType<T>();
 
        public void AddGlobalProjectile(string name, GlobalProjectile globalProjectile) {
            if (!loading)
                throw new Exception("AddGlobalProjectile can only be called from Mod.Load or Mod.Autoload");
 
            ProjectileLoader.VerifyGlobalProjectile(globalProjectile);
 
            globalProjectile.mod = this;
            globalProjectile.Name = name;
 
            globalProjectiles[name] = globalProjectile;
            globalProjectile.index = ProjectileLoader.globalProjectiles.Count;
            ProjectileLoader.globalIndexes[Name + ':' + name] = ProjectileLoader.globalProjectiles.Count;
            if (ProjectileLoader.globalIndexesByType.ContainsKey(globalProjectile.GetType())) {
                ProjectileLoader.globalIndexesByType[globalProjectile.GetType()] = -1;
            }
            else {
                ProjectileLoader.globalIndexesByType[globalProjectile.GetType()] = ProjectileLoader.globalProjectiles.Count;
            }
            ProjectileLoader.globalProjectiles.Add(globalProjectile);
            ContentInstance.Register(globalProjectile);
        }
 
        public GlobalProjectile GetGlobalProjectile(string name) => globalProjectiles.TryGetValue(name, out var globalProj) ? globalProj : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetGlobalProjectile<T>() where T : GlobalProjectile => ModContent.GetInstance<T>();
 
        public void AddNPC(string name, ModNPC npc) {
            if (!loading)
                throw new Exception("AddNPC can only be called from Mod.Load or Mod.Autoload");
 
            if (npcs.ContainsKey(name))
                throw new Exception("You tried to add 2 ModNPC with the same name: " + name + ". Maybe 2 classes share a classname but in different namespaces while autoloading or you manually called AddNPC with 2 npcs of the same name.");
 
            npc.mod = this;
            npc.Name = name;
            npc.npc.type = NPCLoader.ReserveNPCID();
            npc.DisplayName = GetOrCreateTranslation(string.Format("Mods.{0}.NPCName.{1}", Name, name));
 
            npcs[name] = npc;
            NPCLoader.npcs.Add(npc);
            ContentInstance.Register(npc);
        }
 
        public ModNPC GetNPC(string name) => npcs.TryGetValue(name, out var npc) ? npc : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetNPC<T>() where T : ModNPC => ModContent.GetInstance<T>();
 
        public int NPCType(string name) => GetNPC(name)?.npc.type ?? 0;
 
        [Obsolete("Use ModContent.NPCType<T> instead", true)]
        public int NPCType<T>() where T : ModNPC => ModContent.NPCType<T>();
 
        public void AddGlobalNPC(string name, GlobalNPC globalNPC) {
            if (!loading)
                throw new Exception("AddGlobalNPC can only be called from Mod.Load or Mod.Autoload");
 
            NPCLoader.VerifyGlobalNPC(globalNPC);
 
            globalNPC.mod = this;
            globalNPC.Name = name;
 
            globalNPCs[name] = globalNPC;
            globalNPC.index = NPCLoader.globalNPCs.Count;
            NPCLoader.globalIndexes[Name + ':' + name] = NPCLoader.globalNPCs.Count;
            if (NPCLoader.globalIndexesByType.ContainsKey(globalNPC.GetType())) {
                NPCLoader.globalIndexesByType[globalNPC.GetType()] = -1;
            }
            else {
                NPCLoader.globalIndexesByType[globalNPC.GetType()] = NPCLoader.globalNPCs.Count;
            }
            NPCLoader.globalNPCs.Add(globalNPC);
            ContentInstance.Register(globalNPC);
        }
 
        public GlobalNPC GetGlobalNPC(string name) => globalNPCs.TryGetValue(name, out var globalNPC) ? globalNPC : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetGlobalNPC<T>() where T : GlobalNPC => ModContent.GetInstance<T>();
 
        public void AddNPCHeadTexture(int npcType, string texture) {
            if (!loading)
                throw new Exception("AddNPCHeadTexture can only be called from Mod.Load or Mod.Autoload");
 
            int slot = NPCHeadLoader.ReserveHeadSlot();
            NPCHeadLoader.heads[texture] = slot;
            if (!Main.dedServ) {
                ModContent.GetTexture(texture);
            }
            /*else if (Main.dedServ && !(ModLoader.FileExists(texture + ".png") || ModLoader.FileExists(texture + ".rawimg")))
            {
                throw new MissingResourceException(texture);
            }*/
            NPCHeadLoader.npcToHead[npcType] = slot;
            NPCHeadLoader.headToNPC[slot] = npcType;
        }
 
        public void AddBossHeadTexture(string texture, int npcType = -1) {
            if (!loading)
                throw new Exception("AddBossHeadTexture can only be called from Mod.Load or Mod.Autoload");
 
            int slot = NPCHeadLoader.ReserveBossHeadSlot(texture);
            NPCHeadLoader.bossHeads[texture] = slot;
            ModContent.GetTexture(texture);
            if (npcType >= 0) {
                NPCHeadLoader.npcToBossHead[npcType] = slot;
            }
        }
 
        public void AddPlayer(string name, ModPlayer player) {
            if (!loading)
                throw new Exception("AddPlayer can only be called from Mod.Load or Mod.Autoload");
 
            player.mod = this;
            player.Name = name;
 
            players[name] = player;
            PlayerHooks.Add(player);
            ContentInstance.Register(player);
        }
 
        public ModPlayer GetPlayer(string name) => players.TryGetValue(name, out var player) ? player : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetPlayer<T>() where T : ModPlayer => ModContent.GetInstance<T>();
 
        public void AddBuff(string name, ModBuff buff, string texture) {
            if (!loading)
                throw new Exception("AddBuff can only be called from Mod.Load or Mod.Autoload");
 
            if (buffs.ContainsKey(name))
                throw new Exception("You tried to add 2 ModBuff with the same name: " + name + ". Maybe 2 classes share a classname but in different namespaces while autoloading or you manually called AddBuff with 2 buffs of the same name.");
 
            buff.mod = this;
            buff.Name = name;
            buff.Type = BuffLoader.ReserveBuffID();
            buff.texture = texture;
            buff.DisplayName = GetOrCreateTranslation(string.Format("Mods.{0}.BuffName.{1}", Name, name));
            buff.Description = GetOrCreateTranslation(string.Format("Mods.{0}.BuffDescription.{1}", Name, name));
 
            buffs[name] = buff;
            BuffLoader.buffs.Add(buff);
            ContentInstance.Register(buff);
        }
 
        public ModBuff GetBuff(string name) => buffs.TryGetValue(name, out var buff) ? buff : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetBuff<T>() where T : ModBuff => ModContent.GetInstance<T>();
 
        public int BuffType(string name) => GetBuff(name)?.Type ?? 0;
 
        [Obsolete("Use ModContent.BuffType<T> instead", true)]
        public int BuffType<T>() where T : ModBuff => ModContent.BuffType<T>();
 
        public void AddGlobalBuff(string name, GlobalBuff globalBuff) {
            globalBuff.mod = this;
            globalBuff.Name = name;
 
            globalBuffs[name] = globalBuff;
            BuffLoader.globalBuffs.Add(globalBuff);
            ContentInstance.Register(globalBuff);
        }
 
        public GlobalBuff GetGlobalBuff(string name) => globalBuffs.TryGetValue(name, out var globalBuff) ? globalBuff : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetGlobalBuff<T>() where T : GlobalBuff => ModContent.GetInstance<T>();
 
        public void AddMount(string name, ModMountData mount, string texture,
            IDictionary<MountTextureType, string> extraTextures = null) {
            if (!loading)
                throw new Exception("AddMount can only be called from Mod.Load or Mod.Autoload");
 
            if (Mount.mounts == null || Mount.mounts.Length == MountID.Count)
                Mount.Initialize();
 
            mount.mod = this;
            mount.Name = name;
            mount.Type = MountLoader.ReserveMountID();
            mount.texture = texture;
 
            mountDatas[name] = mount;
            MountLoader.mountDatas[mount.Type] = mount;
            ContentInstance.Register(mount);
 
            if (extraTextures == null)
                return;
 
            foreach (var entry in extraTextures) {
                if (!ModContent.TextureExists(entry.Value))
                    continue;
 
                Texture2D extraTexture = ModContent.GetTexture(entry.Value);
                switch (entry.Key) {
                    case MountTextureType.Back:
                        mount.mountData.backTexture = extraTexture;
                        break;
                    case MountTextureType.BackGlow:
                        mount.mountData.backTextureGlow = extraTexture;
                        break;
                    case MountTextureType.BackExtra:
                        mount.mountData.backTextureExtra = extraTexture;
                        break;
                    case MountTextureType.BackExtraGlow:
                        mount.mountData.backTextureExtraGlow = extraTexture;
                        break;
                    case MountTextureType.Front:
                        mount.mountData.frontTexture = extraTexture;
                        break;
                    case MountTextureType.FrontGlow:
                        mount.mountData.frontTextureGlow = extraTexture;
                        break;
                    case MountTextureType.FrontExtra:
                        mount.mountData.frontTextureExtra = extraTexture;
                        break;
                    case MountTextureType.FrontExtraGlow:
                        mount.mountData.frontTextureExtraGlow = extraTexture;
                        break;
                }
            }
        }
 
        public ModMountData GetMount(string name) => mountDatas.TryGetValue(name, out var modMountData) ? modMountData : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetMount<T>() where T : ModMountData => ModContent.GetInstance<T>();
 
        public int MountType(string name) => GetMount(name)?.Type ?? 0;
 
        [Obsolete("Use ModContent.MountType<T> instead", true)]
        public int MountType<T>() where T : ModMountData => ModContent.MountType<T>();
 
        public void AddModWorld(string name, ModWorld modWorld) {
            if (!loading)
                throw new Exception("AddModWorld can only be called from Mod.Load or Mod.Autoload");
 
            modWorld.mod = this;
            modWorld.Name = name;
 
            worlds[name] = modWorld;
            WorldHooks.Add(modWorld);
            ContentInstance.Register(modWorld);
        }
 
        public ModWorld GetModWorld(string name) => worlds.TryGetValue(name, out var world) ? world : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetModWorld<T>() where T : ModWorld => ModContent.GetInstance<T>();
 
        public void AddUgBgStyle(string name, ModUgBgStyle ugBgStyle) {
            if (!loading)
                throw new Exception("AddUgBgStyle can only be called from Mod.Load or Mod.Autoload");
 
            ugBgStyle.mod = this;
            ugBgStyle.Name = name;
            ugBgStyle.Slot = UgBgStyleLoader.ReserveBackgroundSlot();
 
            ugBgStyles[name] = ugBgStyle;
            UgBgStyleLoader.ugBgStyles.Add(ugBgStyle);
            ContentInstance.Register(ugBgStyle);
        }
 
        public ModUgBgStyle GetUgBgStyle(string name) => ugBgStyles.TryGetValue(name, out var bgStyle) ? bgStyle : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetUgBgStyle<T>() where T : ModUgBgStyle => ModContent.GetInstance<T>();
 
        public void AddSurfaceBgStyle(string name, ModSurfaceBgStyle surfaceBgStyle) {
            if (!loading)
                throw new Exception("AddSurfaceBgStyle can only be called from Mod.Load or Mod.Autoload");
 
            surfaceBgStyle.mod = this;
            surfaceBgStyle.Name = name;
            surfaceBgStyle.Slot = SurfaceBgStyleLoader.ReserveBackgroundSlot();
 
            surfaceBgStyles[name] = surfaceBgStyle;
            SurfaceBgStyleLoader.surfaceBgStyles.Add(surfaceBgStyle);
            ContentInstance.Register(surfaceBgStyle);
        }
 
        public ModSurfaceBgStyle GetSurfaceBgStyle(string name) => surfaceBgStyles.TryGetValue(name, out var bgStyle) ? bgStyle : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetSurfaceBgStyle<T>() where T : ModSurfaceBgStyle => ModContent.GetInstance<T>();
 
        public int GetSurfaceBgStyleSlot(string name) => GetSurfaceBgStyle(name)?.Slot ?? -1;
 
        public int GetSurfaceBgStyleSlot<T>() where T : ModSurfaceBgStyle => GetSurfaceBgStyleSlot(typeof(T).Name);
 
        public void AddGlobalBgStyle(string name, GlobalBgStyle globalBgStyle) {
            if (!loading)
                throw new Exception("AddGlobalBgStyle can only be called from Mod.Load or Mod.Autoload");
 
            globalBgStyle.mod = this;
            globalBgStyle.Name = name;
 
            globalBgStyles[name] = globalBgStyle;
            GlobalBgStyleLoader.globalBgStyles.Add(globalBgStyle);
            ContentInstance.Register(globalBgStyle);
        }
 
        public GlobalBgStyle GetGlobalBgStyle(string name) => globalBgStyles.TryGetValue(name, out var bgStyle) ? bgStyle : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetGlobalBgStyle<T>() where T : GlobalBgStyle => ModContent.GetInstance<T>();
 
        public void AddWaterStyle(string name, ModWaterStyle waterStyle, string texture, string blockTexture) {
            if (!loading)
                throw new Exception("AddWaterStyle can only be called from Mod.Load or Mod.Autoload");
 
            waterStyle.mod = this;
            waterStyle.Name = name;
            waterStyle.Type = WaterStyleLoader.ReserveStyle();
            waterStyle.texture = texture;
            waterStyle.blockTexture = blockTexture;
 
            waterStyles[name] = waterStyle;
            WaterStyleLoader.waterStyles.Add(waterStyle);
            ContentInstance.Register(waterStyle);
        }
 
        public ModWaterStyle GetWaterStyle(string name) => waterStyles.TryGetValue(name, out var waterStyle) ? waterStyle : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetWaterStyle<T>() where T : ModWaterStyle => ModContent.GetInstance<T>();
 
        public void AddWaterfallStyle(string name, ModWaterfallStyle waterfallStyle, string texture) {
            if (!loading)
                throw new Exception("AddWaterfallStyle can only be called from Mod.Load or Mod.Autoload");
 
            waterfallStyle.mod = this;
            waterfallStyle.Name = name;
            waterfallStyle.Type = WaterfallStyleLoader.ReserveStyle();
            waterfallStyle.texture = texture;
 
            waterfallStyles[name] = waterfallStyle;
            WaterfallStyleLoader.waterfallStyles.Add(waterfallStyle);
            ContentInstance.Register(waterfallStyle);
        }
 
        public ModWaterfallStyle GetWaterfallStyle(string name) => waterfallStyles.TryGetValue(name, out var waterfallStyle) ? waterfallStyle : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetWaterfallStyle<T>() where T : ModWaterfallStyle => ModContent.GetInstance<T>();
 
        public int GetWaterfallStyleSlot(string name) => GetWaterfallStyle(name)?.Type ?? -1;
 
        public int GetWaterfallStyleSlot<T>() where T : ModWaterfallStyle => GetWaterfallStyleSlot(typeof(T).Name);
 
        public void AddGore(string texture, ModGore modGore = null) {
            if (!loading)
                throw new Exception("AddGore can only be called from Mod.Load or Mod.Autoload");
 
            int id = ModGore.ReserveGoreID();
            ModGore.gores[texture] = id;
            if (modGore != null) {
                ModGore.modGores[id] = modGore;
                ContentInstance.Register(modGore);
            }
        }
 
        public int GetGoreSlot(string name) => ModGore.GetGoreSlot(Name + '/' + name);
 
        public int GetGoreSlot<T>() where T : ModGore => GetGoreSlot(typeof(T).Name);
 
        public void AddSound(SoundType type, string soundPath, ModSound modSound = null) {
            if (!loading)
                throw new Exception("AddSound can only be called from Mod.Load or Mod.Autoload");
            int id = SoundLoader.ReserveSoundID(type);
            SoundLoader.sounds[type][soundPath] = id;
            if (modSound != null) {
                SoundLoader.modSounds[type][id] = modSound;
                modSound.sound = ModContent.GetSound(soundPath);
            }
        }
 
        public int GetSoundSlot(SoundType type, string name) => SoundLoader.GetSoundSlot(type, Name + '/' + name);
 
        public LegacySoundStyle GetLegacySoundSlot(SoundType type, string name) => SoundLoader.GetLegacySoundSlot(type, Name + '/' + name);
 
        public void AddBackgroundTexture(string texture) {
            if (!loading)
                throw new Exception("AddBackgroundTexture can only be called from Mod.Load or Mod.Autoload");
 
            BackgroundTextureLoader.backgrounds[texture] = BackgroundTextureLoader.ReserveBackgroundSlot();
            ModContent.GetTexture(texture);
        }
 
        public int GetBackgroundSlot(string name) => BackgroundTextureLoader.GetBackgroundSlot(Name + '/' + name);
 
        public void AddGlobalRecipe(string name, GlobalRecipe globalRecipe) {
            if (!loading)
                throw new Exception("AddGlobalRecipe can only be called from Mod.Load or Mod.Autoload");
 
            globalRecipe.mod = this;
            globalRecipe.Name = name;
 
            globalRecipes[name] = globalRecipe;
            RecipeHooks.Add(globalRecipe);
            ContentInstance.Register(globalRecipe);
        }
 
        public GlobalRecipe GetGlobalRecipe(string name) => globalRecipes.TryGetValue(name, out var globalRecipe) ? globalRecipe : null;
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetGlobalRecipe<T>() where T : GlobalRecipe => ModContent.GetInstance<T>();
 
        public void AddCommand(string name, ModCommand mc) {
            if (!loading)
                throw new Exception("AddCommand can only be called from Mod.Load or Mod.Autoload");
 
            mc.mod = this;
            mc.Name = name;
            CommandManager.Add(mc);
        }
 
        public void AddMusicBox(int musicSlot, int itemType, int tileType, int tileFrameY = 0) {
            if (!loading)
                throw new Exception("AddMusicBox can only be called from Mod.Load or Mod.Autoload");
 
            if (Main.waveBank == null)
                return;
 
            if (musicSlot < Main.maxMusic) {
                throw new ArgumentOutOfRangeException("Cannot assign music box to vanilla music ID " + musicSlot);
            }
            if (musicSlot >= SoundLoader.SoundCount(SoundType.Music)) {
                throw new ArgumentOutOfRangeException("Music ID " + musicSlot + " does not exist");
            }
            if (itemType < ItemID.Count) {
                throw new ArgumentOutOfRangeException("Cannot assign music box to vanilla item ID " + itemType);
            }
            if (ItemLoader.GetItem(itemType) == null) {
                throw new ArgumentOutOfRangeException("Item ID " + itemType + " does not exist");
            }
            if (tileType < TileID.Count) {
                throw new ArgumentOutOfRangeException("Cannot assign music box to vanilla tile ID " + tileType);
            }
            if (TileLoader.GetTile(tileType) == null) {
                throw new ArgumentOutOfRangeException("Tile ID " + tileType + " does not exist");
            }
            if (SoundLoader.musicToItem.ContainsKey(musicSlot)) {
                throw new ArgumentException("Music ID " + musicSlot + " has already been assigned a music box");
            }
            if (SoundLoader.itemToMusic.ContainsKey(itemType)) {
                throw new ArgumentException("Item ID " + itemType + " has already been assigned a music");
            }
            if (!SoundLoader.tileToMusic.ContainsKey(tileType)) {
                SoundLoader.tileToMusic[tileType] = new Dictionary<int, int>();
            }
            if (SoundLoader.tileToMusic[tileType].ContainsKey(tileFrameY)) {
                string message = "Y-frame " + tileFrameY + " of tile type " + tileType + " has already been assigned a music";
                throw new ArgumentException(message);
            }
            if (tileFrameY % 36 != 0) {
                throw new ArgumentException("Y-frame must be divisible by 36");
            }
            SoundLoader.musicToItem[musicSlot] = itemType;
            SoundLoader.itemToMusic[itemType] = musicSlot;
            SoundLoader.tileToMusic[tileType][tileFrameY] = musicSlot;
        }
 
        public ModHotKey RegisterHotKey(string name, string defaultKey) {
            if (!loading)
                throw new Exception("RegisterHotKey can only be called from Mod.Load or Mod.Autoload");
 
            return HotKeyLoader.RegisterHotKey(new ModHotKey(this, name, defaultKey));
        }
 
        public ModTranslation CreateTranslation(string key) =>
            new ModTranslation(string.Format("Mods.{0}.{1}", Name, key));
 
        public void AddTranslation(ModTranslation translation) {
            translations[translation.Key] = translation;
        }
 
        internal ModTranslation GetOrCreateTranslation(string key, bool defaultEmpty = false) {
            key = key.Replace(" ", "_");
            return translations.TryGetValue(key, out var translation) ? translation : new ModTranslation(key, defaultEmpty);
        }
 
        public byte[] GetFileBytes(string name) => File?.GetBytes(name);
 
        public Stream GetFileStream(string name, bool newFileStream = false) => File?.GetStream(name, newFileStream);
 
        public bool FileExists(string name) => File != null && File.HasFile(name);
 
        public Texture2D GetTexture(string name) {
            if (!textures.TryGetValue(name, out var t))
                throw new MissingResourceException(name, textures.Keys);
 
            return t;
        }
 
        public bool TextureExists(string name) => textures.ContainsKey(name);
 
        public void AddTexture(string name, Texture2D texture) {
            if (Main.dedServ)
                return;
 
            if (TextureExists(name))
                throw new Exception("Texture already exist: " + name);
 
            textures[name] = texture;
        }
 
        public SoundEffect GetSound(string name) {
            if (!sounds.TryGetValue(name, out var sound))
                throw new MissingResourceException(name);
 
            return sound;
        }
 
        public bool SoundExists(string name) => sounds.ContainsKey(name);
 
        public Music GetMusic(string name) {
            if (!musics.TryGetValue(name, out var music))
                throw new MissingResourceException(name);
 
            return music;
        }
 
        public bool MusicExists(string name) => musics.ContainsKey(name);
 
        public DynamicSpriteFont GetFont(string name) {
            if (!fonts.TryGetValue(name, out var font))
                throw new MissingResourceException(name);
 
            return font;
        }
 
        public bool FontExists(string name) => fonts.ContainsKey(name);
 
        public Effect GetEffect(string name) {
            if (!effects.TryGetValue(name, out var effect))
                throw new MissingResourceException(name);
 
            return effect;
        }
 
        public bool EffectExists(string name) => effects.ContainsKey(name);
 
        public virtual object Call(params object[] args) {
            return null;
        }
 
        public ModPacket GetPacket(int capacity = 256) {
            if (netID < 0)
                throw new Exception("Cannot get packet for " + Name + " because it does not exist on the other side");
 
            var p = new ModPacket(MessageID.ModPacket, capacity + 5);
            if (ModNet.NetModCount < 256)
                p.Write((byte)netID);
            else
                p.Write(netID);
 
            p.netID = netID;
            return p;
        }
 
        public ModConfig GetConfig(string name)
        {
            List<ModConfig> configs;
            if (ConfigManager.Configs.TryGetValue(this, out configs))
            {
                return configs.Single(x => x.Name == name);
            }
            return null;
        }
 
        [Obsolete("Use ModContent.GetInstance<T> instead", true)]
        public T GetConfig<T>() where T : ModConfig => (T)GetConfig(typeof(T).Name);
    }
}