////////////////
private bool SetOverhaulMenuDataOffset(Vector2 newValue)
{
Mod ohMod = ModLoader.GetMod("OverhaulMod");
if (ohMod == null)
{
return(false);
}
Type ohModType = ohMod.GetType();
var ohLogoPosField = ohModType.GetField("mainMenuDataOffset", ReflectionLibraries.MostAccess);
if (ohLogoPosField != null)
{
if (this.OldOverhaulLogoPos != default(Vector2))
{
this.OldOverhaulLogoPos = (Vector2)ohLogoPosField.GetValue(ohMod);
}
ohLogoPosField.SetValue(ohMod, newValue);
}
else // For version 3.3
{
Type classType = ReflectionLibraries.GetTypeFromAssembly(ohModType.AssemblyQualifiedName, "TerrariaOverhaul.UI.OverhaulUI");
if (classType == null)
{
return(false);
}
ReflectionLibraries.Set(classType, null, "mainMenuDataOffset", newValue);
}
return(true);
}
/// <summary>
/// Gets the recommended element to add content to an "inner" container element of a given menu UI.
/// </summary>
/// <param name="uiInnerContainer"></param>
/// <returns></returns>
public static UIElement GetMenuContainerInsertPoint(UIElement uiInnerContainer)
{
List <UIElement> uiContainerElems;
if (!ReflectionLibraries.Get(uiInnerContainer, "Elements", out uiContainerElems) ||
uiContainerElems == null)
{
LogLibraries.AlertOnce("No Elements for " + uiInnerContainer?.GetType().Name);
return(null);
}
//Type uiContainerType = uiInnerContainer.GetType();
//FieldInfo uiContainerElemsField = uiContainerType.GetField( "Elements", BindingFlags.Instance | BindingFlags.NonPublic );
//List<UIElement> uiContainerElems = (List<UIElement>)uiContainerElemsField.GetValue( uiInnerContainer );
for (int i = 0; i < uiContainerElems.Count; i++)
{
if (uiContainerElems[i] is UIElement &&
!(uiContainerElems[i] is UIList) &&
!(uiContainerElems[i] is UIScrollbar))
{
return(uiContainerElems[i]);
}
}
LogLibraries.AlertOnce("Not found");
return(null);
}
/// <summary>
/// Gets the mod name of a mod-representing menu UI (sometimes needs the previous UI for context).
/// </summary>
/// <param name="prevUi"></param>
/// <param name="currUi"></param>
/// <returns></returns>
public static string GetModName(UIState prevUi, UIState currUi)
{
// = uiType.GetField( "_localMod", BindingFlags.NonPublic | BindingFlags.Instance );
object localmod; // <- is a LocalMod class
if (!ReflectionLibraries.Get(currUi, "_localMod", out localmod))
{
LogLibraries.Warn("No '_localMod' field in " + currUi.GetType());
return(null);
}
if (localmod != null)
{
return(ModMenuLibraries.GetLocalMod(localmod).name);
}
else
{
if (prevUi?.GetType().Name == "UIModBrowser")
{
return(ModMenuLibraries.GetSelectedModBrowserModName(prevUi));
}
}
LogLibraries.Alert("No mod loaded.");
return(null);
}
////////////////
private static void RemoveWingSlotProperty(ModPlayer mywingplayer, string propName)
{
object wingEquipSlot;
if (ReflectionLibraries.Get(mywingplayer, propName, out wingEquipSlot) && wingEquipSlot != null)
{
Item wingItem;
if (ReflectionLibraries.Get(wingEquipSlot, "Item", out wingItem))
{
if (wingItem != null && !wingItem.IsAir)
{
ReflectionLibraries.Set(wingEquipSlot, "Item", new Item());
ReflectionLibraries.Set(mywingplayer, propName, wingEquipSlot);
}
}
else
{
LogLibraries.Warn("Invalid Wing Mod item slot for " + propName);
}
}
else
{
LogLibraries.Log("No Wing Mod item slot recognized for " + propName);
}
}
////
public void SetOverride <T>(string propName, T value)
{
if (!ReflectionLibraries.Get(this, propName, out T _))
{
throw new ModLibsException("Invalid property " + propName + " of type " + typeof(T).Name);
}
this.Overrides[propName] = value;
}
public bool UnsetOverride <T>(string propName)
{
if (!ReflectionLibraries.Get(this, propName, out T _))
{
throw new ModLibsException("Invalid property " + propName + " of type " + typeof(T).Name);
}
return(this.Overrides.Remove(propName));
}
/// <summary>
/// Gets a menu UI corresponding to a given menu definition.
/// </summary>
/// <param name="menuDef"></param>
/// <returns></returns>
public static UIState GetMenuUI(MenuUIDefinition menuDef)
{
string menuUiName = Enum.GetName(typeof(MenuUIDefinition), menuDef);
UIState menuUi;
ReflectionLibraries.Get(typeof(MenuUIs), null, menuUiName, out menuUi);
return(menuUi);
}
/// <summary>
/// Clears mod data for a player.
/// </summary>
/// <param name="player"></param>
/// <param name="exemptMods">Names of mods to skip (internal names).</param>
public static void ModdedExtensionsReset(Player player, ISet <string> exemptMods)
{
foreach (Mod mod in ModLoader.Mods)
{
if (exemptMods.Contains(mod.Name))
{
continue;
}
try {
mod.Call("ResetPlayerModData", player);
} catch (Exception e) {
LogLibraries.Warn("Mod.Call failed for " + mod.Name + ": " + e.ToString());
}
}
var wingSlotMod = ModLoader.GetMod("WingSlot");
var thoriumMod = ModLoader.GetMod("ThoriumMod");
var weaponOutMod = ModLoader.GetMod("WeaponOut");
var weaponOutLiteMod = ModLoader.GetMod("WeaponOutLite");
if (wingSlotMod != null && !exemptMods.Contains("WingSlot"))
{
ModPlayer modplayer = player.GetModPlayer(wingSlotMod, "WingSlotPlayer");
PlayerModLibraries.RemoveWingSlotProperty(modplayer, "EquipSlot");
PlayerModLibraries.RemoveWingSlotProperty(modplayer, "VanitySlot");
PlayerModLibraries.RemoveWingSlotProperty(modplayer, "DyeSlot");
}
if (thoriumMod != null && !exemptMods.Contains("ThoriumMod"))
{
ModPlayer modplayer = player.GetModPlayer(thoriumMod, "ThoriumPlayer");
// "Inspiration" resets to the recommended default:
ReflectionLibraries.Set(modplayer, "bardResource", 8);
}
if (weaponOutMod != null && !exemptMods.Contains("WeaponOut"))
{
ModPlayer modplayer = player.GetModPlayer(weaponOutMod, "PlayerFX");
// "Frenzy Heart" resets:
ReflectionLibraries.Set(modplayer, "demonBlood", false);
}
if (weaponOutLiteMod != null && !exemptMods.Contains("WeaponOutLite"))
{
ModPlayer modplayer = player.GetModPlayer(weaponOutLiteMod, "PlayerFX");
// "Frenzy Heart" resets:
ReflectionLibraries.Set(modplayer, "demonBlood", false);
}
}
////////////////
private static UIState GetMainMenuUI(string menuFieldName)
{
UIState menuUI;
if (!ReflectionLibraries.Get(typeof(Main), null, menuFieldName, out menuUI))
{
LogLibraries.Warn("Could not find Main." + menuFieldName);
return(null);
}
return(menuUI);
}
private static TmodFile GetLocalMod(object localmod)
{
object rawModFile;
if (!ReflectionLibraries.Get(localmod, "modFile", out rawModFile) || rawModFile == null)
{
LogLibraries.Warn("Empty 'modFile' field");
return(null);
}
return((TmodFile)rawModFile);
}
/*public static readonly string[] VanillaWorldGenTaskNames = new string[] {
* "Reset",
* "Terrain",
* "Tunnels",
* "Sand",
* "Mount Caves",
* "Dirt Wall Backgrounds",
* "Rocks In Dirt",
* "Dirt In Rocks",
* "Clay",
* "Small Holes",
* "Dirt Layer Caves",
* "Rock Layer Caves",
* "Surface Caves",
* "Slush Check",
* "Grass",
* "Jungle",
* "Marble",
* "Granite",
* "Mud Caves To Grass",
* "Full Desert",
* "Floating Islands",
* "Mushroom Patches",
* "Mud To Dirt",
* "Silt",
* "Shinies",
* "Webs",
* "Underworld",
* "Lakes",
* "Dungeon",
* "Corruption",
* "Slush",
* "Mud Caves To Grass",
* "Beaches",
* "Gems",
* "Gravitating Sand",
* "Clean Up Dirt",
* "Pyramids",
* "Dirt Rock Wall Runner",
* "Living Trees",
* "Wood Tree Walls",
* "Altars",
* "Wet Jungle",
* "Remove Water From Sand",
* "Jungle Temple",
* "Hives",
* "Jungle Chests",
* "Smooth World",
* "Settle Liquids",
* "Waterfalls",
* "Ice",
* "Wall Variety",
* "Traps",
* "Life Crystals",
* "Statues",
* "Buried Chests",
* "Surface Chests",
* "Jungle Chests Placement",
* "Water Chests",
* "Spider Caves",
* "Gem Caves",
* "Moss",
* "Temple",
* "Ice Walls",
* "Jungle Trees",
* "Floating Island Houses",
* "Quick Cleanup",
* "Pots",
* "Hellforge",
* "Spreading Grass",
* "Piles",
* "Moss",
* "Spawn Point",
* "Grass Wall",
* "Guide",
* "Sunflowers",
* "Planting Trees",
* "Herbs",
* "Dye Plants",
* "Webs And Honey",
* "Weeds",
* "Mud Caves To Grass",
* "Jungle Plants",
* "Vines",
* "Flowers",
* "Mushrooms",
* "Stalac",
* "Gems In Ice Biome",
* "Random Gems",
* "Moss Grass",
* "Muds Walls In Jungle",
* "Larva",
* "Settle Liquids Again",
* "Tile Cleanup",
* "Lihzahrd Altars",
* "Micro Biomes",
* "Final Cleanup",
* };*/
////////////////
/// <summary>
/// Gets the full list of world gen passes.
/// </summary>
/// <returns></returns>
public static IList <GenPass> GetWorldGenPasses()
{
if (!ReflectionLibraries.Get(typeof(WorldGen), null, "_generator", out WorldGenerator generator))
{
return(null);
}
if (!ReflectionLibraries.Get(typeof(WorldGenerator), generator, "_passes", out IList <GenPass> passes))
{
return(null);
}
return(passes);
}
////////////////
public T Get <T>(string propName)
{
if (!this.Overrides.TryGetValue(propName, out object val))
{
if (!ReflectionLibraries.Get(this, propName, out T myval))
{
throw new ModLibsException("Invalid property " + propName + " of type " + typeof(T).Name);
}
return(myval);
}
if (val.GetType() != typeof(T))
{
throw new ModLibsException("Invalid type (" + typeof(T).Name + ") of property " + propName + ".");
}
return((T)val);
}
/// <summary>
/// Loads the mod browser menu.
/// </summary>
public static void OpenModBrowserMenu()
{
Type interfaceType = ReflectionLibraries.GetMainAssembly()
.GetType("Terraria.ModLoader.UI.Interface");
int modBrowserMenuMode;
if (!ReflectionLibraries.Get(interfaceType, null, "modBrowserID", out modBrowserMenuMode))
{
LogLibraries.Warn("Could not switch to mod browser menu context.");
return;
}
Main.PlaySound(SoundID.MenuTick);
Main.menuMode = modBrowserMenuMode;
UIState modBrowserUi;
if (!ReflectionLibraries.Get(interfaceType, null, "modBrowser", out modBrowserUi))
{
LogLibraries.Warn("Could not acquire mod browser UI.");
return;
}
Timers.SetTimer("ModLibsModDownloadPrompt", 5, true, () => {
if (MenuContextService.GetCurrentMenuUI()?.GetType().Name != "UIModBrowser")
{
return(false);
}
bool isLoading;
if (!ReflectionLibraries.Get(modBrowserUi, "loading", out isLoading))
{
return(false);
}
if (isLoading)
{
return(true);
}
ModMenuLibraries.ApplyModBrowserFilter("", false, new List <string>());
return(false);
});
}
/// <summary>
/// Gets the "outer" container element (the element as positioned on the screen) of a menu's UI class.
/// </summary>
/// <param name="ui"></param>
/// <returns></returns>
public static UIElement GetMenuContainerOuter(UIState ui)
{
UIElement elem;
if (!ReflectionLibraries.Get(ui, "uIElement", out elem) || elem == null)
{
LogLibraries.AlertOnce("No uiElement for " + ui?.GetType().Name);
return(null);
}
return(elem);
//Type uiType = ui.GetType();
//FieldInfo uiOuterBoxField = uiType.GetField( "uIElement", BindingFlags.Instance | BindingFlags.NonPublic );
//UIElement uiOuterBox = (UIElement)uiOuterBoxField.GetValue( ui );
//
//return uiOuterBox;
}
/// <summary>
/// Loads the UI for mod configs.
/// </summary>
/// <param name="config"></param>
public static void OpenModConfigUI(ModConfig config)
{
Type interfaceType = ReflectionLibraries.GetMainAssembly()
.GetType("Terraria.ModLoader.UI.Interface");
if (!Main.gameMenu)
{
IngameOptions.Close();
IngameFancyUI.CoverNextFrame();
Main.playerInventory = false;
Main.editChest = false;
Main.npcChatText = "";
Main.inFancyUI = true;
}
else
{
if (!ReflectionLibraries.Get(interfaceType, null, "modConfigID", out Main.menuMode))
{
LogLibraries.Warn("Could not get Interface.modConfigID");
return;
}
}
UIState modConfigInterfaceObj;
if (!ReflectionLibraries.Get(interfaceType, null, "modConfig", out modConfigInterfaceObj) || modConfigInterfaceObj == null)
{
LogLibraries.Warn("Could not get Interface.modConfig");
return;
}
object _;
if (!ReflectionLibraries.RunMethod(modConfigInterfaceObj, "SetMod", new object[] { config.mod, config }, out _))
{
LogLibraries.Warn("Could not run Interface.modConfig.SetMod");
return;
}
Main.InGameUI.SetState(modConfigInterfaceObj);
Main.PlaySound(SoundID.MenuTick);
}
////
private void BlockWingSlotIfDisabled(string fieldName)
{
var mymod = (NihilismMod)this.mod;
var myworld = ModContent.GetInstance <NihilismWorld>();
if (myworld.Logic == null)
{
return;
}
ModPlayer mywingplayer = this.player.GetModPlayer(mymod.WingSlotMod, "WingSlotPlayer");
object wingEquipSlot;
if (!ReflectionLibraries.Get(mywingplayer, fieldName, out wingEquipSlot) || wingEquipSlot == null)
{
return;
}
Item wingItem;
if (!ReflectionLibraries.Get(wingEquipSlot, "Item", out wingItem) || wingItem == null || wingItem.IsAir)
{
return;
}
bool _;
if (!myworld.Logic.DataAccess.IsItemEnabled(wingItem, out _, out _))
{
int idx = Item.NewItem(player.position, wingItem.width, wingItem.height, wingItem.type, wingItem.stack, false, wingItem.prefix, false, false);
wingItem.position = Main.item[idx].position;
Main.item[idx] = wingItem;
if (Main.netMode == 1) // Client
{
NetMessage.SendData(21, -1, -1, null, idx, 1f, 0f, 0f, 0, 0, 0);
}
ReflectionLibraries.Set(wingEquipSlot, "Item", new Item());
ReflectionLibraries.Set(mywingplayer, fieldName, wingEquipSlot);
}
}
/// <summary>
/// Gets the "inner" container element (contains the UI's components) of a menu's UI class's "outer" container
/// element.
/// </summary>
/// <param name="uiOuterBox"></param>
/// <returns></returns>
public static UIElement GetMenuContainerInner(UIElement uiOuterBox)
{
List <UIElement> uiOuterBoxElems;
if (!ReflectionLibraries.Get(uiOuterBox, "Elements", out uiOuterBoxElems) ||
uiOuterBoxElems == null ||
uiOuterBoxElems.Count == 0)
{
LogLibraries.AlertOnce("No Elements for " + uiOuterBox?.GetType().Name);
return(null);
}
return(uiOuterBoxElems[0]);
//Type uiOuterBoxType = uiOuterBox.GetType();
//FieldInfo uiOuterBoxElemsField = uiOuterBoxType.GetField( "Elements", BindingFlags.Instance | BindingFlags.NonPublic );
//List<UIElement> uiOuterBoxElems = (List<UIElement>)uiOuterBoxElemsField.GetValue( uiOuterBox );
//
//return uiOuterBoxElems[0];
}
////////////////
/// <summary>
/// Retrieves the file data for a given mod within a given mod-representing menu UI (typically the Mod Info menu page).
/// </summary>
/// <param name="ui"></param>
/// <returns></returns>
public static TmodFile GetModFile(UIState ui)
{
FieldInfo uiLocalmodField; // = uiType.GetField( "_localMod", BindingFlags.NonPublic | BindingFlags.Instance );
if (!ReflectionLibraries.Get(ui, "_localMod", out uiLocalmodField) || uiLocalmodField == null)
{
LogLibraries.Warn("No '_localMod' field in " + ui.GetType());
return(null);
}
object localmod = uiLocalmodField.GetValue(ui);
if (localmod != null)
{
return(ModMenuLibraries.GetLocalMod(localmod));
}
LogLibraries.Alert("No mod loaded.");
return(null);
}
////
private static string GetSelectedModBrowserModName(UIState modBrowserUi)
{
object modDownloadItem;
if (!ReflectionLibraries.Get(modBrowserUi, "SelectedItem", out modDownloadItem) || modDownloadItem == null)
{
LogLibraries.Warn("No 'selectedItem' list item in " + modBrowserUi.GetType().ToString());
return(null);
}
string modName;
if (!ReflectionLibraries.Get(modDownloadItem, "ModName", out modName))
{
LogLibraries.Warn("Invalid 'mod' data in mod browser listed entry.");
return(null);
}
return(modName);
}
private void ApplyTabButtonMouseOver(string tabName)
{
UITextPanelButton button = this.TabButtonsByName[tabName];
var evt = new UIMouseEvent(button, new Vector2(Main.mouseX, Main.mouseY));
if (!this.TabButtonHover[tabName])
{
this.TabButtonHover[tabName] = true;
ReflectionLibraries.Set(button, "_isMouseHovering", true);
Timers.RunNow(() => button.MouseOver(evt));
}
if (Main.mouseLeft && Main.mouseLeftRelease)
{
Timers.RunNow(() => {
button.Click(evt);
});
}
}
private static UIState GetInterfacesMenuUI(string menuFieldName)
{
Assembly ass = ReflectionLibraries.GetMainAssembly();
//Type interfaceType = ass.GetType( "Terraria.ModLoader.Interface" );
Type type = ReflectionLibraries.GetTypeFromAssembly(ass, "Terraria.ModLoader.UI.Interface");
if (type == null)
{
LogLibraries.Warn("Could not find Terraria.ModLoader.UI.Interface");
return(null);
}
UIState menuUI;
if (!ReflectionLibraries.Get(type, null, menuFieldName, out menuUI))
{
LogLibraries.Warn("Could not find Terraria.ModLoader.UI.Interface." + menuFieldName);
return(null);
}
return(menuUI);
}
private void ProcessUnloadedShells(Player plr, int shells)
{
int shellGoreSlot = TMRMod.Instance.GetGoreSlot("Gores/ShellCasing");
Vector2 itemScrPos;
ReflectionLibraries.RunMethod(
Main.instance,
"DrawPlayerItemPos",
new object[] { plr.gravDir, plr.HeldItem.type },
out itemScrPos
);
Texture2D itemTex = Main.itemTexture[plr.HeldItem.type];
var itemTexOffset = new Vector2(itemTex.Width / 2, itemScrPos.Y);
Vector2 itemWldPos = plr.itemLocation + itemTexOffset;
for (int i = 0; i < shells; i++)
{
Gore.NewGore(itemWldPos, ShellCasing.GetVelocity(), shellGoreSlot, ShellCasing.GetScale());
}
}
////
/// <summary>
/// Gets the shown description text from the given mod-representing UI, if applicable.
/// </summary>
/// <param name="output"></param>
/// <returns></returns>
public static bool GetModDescriptionFromCurrentMenuUI(out string output)
{
UIState modUI = Main.MenuUI.CurrentState;
if (modUI == null)
{
output = "No current UI state found.";
return(false);
}
if (modUI.GetType().Name != "UIModInfo")
{
output = "Not currently viewing mod info (or no such UI found).";
return(false);
}
UIPanel msgBox;
if (!ReflectionLibraries.Get(modUI, "_modInfo", out msgBox))
{
output = "No _modInfo field.";
return(false);
}
string modDesc;
if (!ReflectionLibraries.Get(msgBox, "_text", out modDesc))
{
if (!ReflectionLibraries.Get(msgBox, "text", out modDesc))
{
output = "No modInfo._text or text field.";
return(false);
}
}
output = modDesc;
return(true);
}
////////////////
public static IEnumerable <DrawData> GetPlayerLayerForHeldItem(
PlayerDrawInfo plrDrawInfo,
Color plrLight,
float shadow = 0f)
{
DrawData drawData;
Player plr = plrDrawInfo.drawPlayer;
Color itemLight = PlayerDraw.GetItemLightColor(plr, plrLight);
Vector2 itemScrPos;
ReflectionLibraries.RunMethod(
Main.instance,
"DrawPlayerItemPos",
new object[] { plr.gravDir, plr.HeldItem.type },
out itemScrPos
);
Texture2D itemTex = Main.itemTexture[plr.HeldItem.type];
var itemTexOffset = new Vector2(itemTex.Width / 2, itemScrPos.Y);
Vector2 itemWldPos = plr.itemLocation.Floor(); //plr.position + (plr.itemLocation - plr.position);
Vector2 origin = new Vector2(
(float)(-itemScrPos.X),
(float)(itemTex.Height / 2)
);
if (plr.direction == -1)
{
origin.X = (float)(itemTex.Width + itemScrPos.X);
}
//
Vector2 pos = (itemWldPos - Main.screenPosition) + itemTexOffset;
pos.Y += plrDrawInfo.drawPlayer.gfxOffY;
pos.Y *= plr.gravDir;
DrawData getDrawData(Texture2D tex, Color color)
{
return(new DrawData(
texture: tex,
position: pos,
sourceRect: new Rectangle(0, 0, itemTex.Width, itemTex.Height),
color: color,
rotation: plr.itemRotation,
origin: origin,
scale: plr.HeldItem.scale,
effect: plrDrawInfo.spriteEffects,
inactiveLayerDepth: 0
));
}
//
drawData = getDrawData(itemTex, plr.HeldItem.GetAlpha(itemLight));
//drawInfo.Draw( Main.spriteBatch );
yield return(drawData);
if (plr.HeldItem.color != default(Color))
{
drawData = getDrawData(itemTex, plr.HeldItem.GetColor(itemLight));
//drawInfo.Draw( Main.spriteBatch );
yield return(drawData);
}
if (plr.HeldItem.glowMask != -1)
{
drawData = getDrawData(
Main.glowMaskTexture[(int)plr.HeldItem.glowMask],
new Color(250, 250, 250, plr.HeldItem.alpha)
);
//drawInfo.Draw( Main.spriteBatch );
yield return(drawData);
}
}
/// <summary>
/// Filters the mod browser mod list to a specific set of mods, or none.
/// </summary>
/// <param name="filterName">Name of the filter (appears on the Download All button).</param>
/// <param name="isFiltered">Indicates whether to simply clear the filter list and filtered state.</param>
/// <param name="modNames">List of (internal) mod names to filter the list to.</param>
public static void ApplyModBrowserFilter(string filterName, bool isFiltered, List <string> modNames)
{
Type interfaceType = ReflectionLibraries.GetMainAssembly()
.GetType("Terraria.ModLoader.UI.Interface");
UIState modBrowserUi;
if (!ReflectionLibraries.Get(interfaceType, null, "modBrowser", out modBrowserUi) || modBrowserUi == null)
{
LogLibraries.Warn("Could not acquire mod browser UI.");
return;
}
Type uiType = modBrowserUi.GetType();
PropertyInfo specialFilterProp = uiType.GetProperty("SpecialModPackFilter", BindingFlags.Instance | BindingFlags.Public);
PropertyInfo filterTitleProp = uiType.GetProperty("SpecialModPackFilterTitle", BindingFlags.Instance | BindingFlags.NonPublic);
if (specialFilterProp == null)
{
LogLibraries.Warn("Could not acquire mod browser UI 'SpecialModPackFilter'");
return;
}
if (filterTitleProp == null)
{
LogLibraries.Warn("Could not acquire mod browser UI 'SpecialModPackFilterTitle'");
return;
}
object _;
if (!ReflectionLibraries.RunMethod(modBrowserUi, "Activate", new object[] { }, out _))
{
LogLibraries.Warn("Could not acquire run method 'Activate' for mod browser");
return;
}
if (!ReflectionLibraries.Set(modBrowserUi, "UpdateNeeded", true))
{
LogLibraries.Warn("Could not acquire set 'updateNeeded' for mod browser");
return;
}
if (!ReflectionLibraries.Set(modBrowserUi, "UpdateFilterMode", (UpdateFilter)0))
{
LogLibraries.Warn("Could not acquire set 'UpdateFilterMode' for mod browser");
return;
}
UIElement inputTextUi; //UIInputTextField
if (ReflectionLibraries.Get(modBrowserUi, "FilterTextBox", out inputTextUi) && inputTextUi != null)
{
if (!ReflectionLibraries.Set(inputTextUi, "_currentString", (object)""))
{
LogLibraries.Alert("Could not acquire set '_currentString' of mod browser's filter box");
}
}
else
{
LogLibraries.Alert("Could not acquire get 'FilterTextBox' from mod browser");
}
//UIElement filterToggle;
//ReflectionLibaries.GetProperty<UIElement>( modBrowserUi, "UpdateFilterToggle", out filterToggle );
//ReflectionLibaries.SetProperty( filterToggle, "CurrentState", 0 );
if (isFiltered)
{
specialFilterProp.SetValue(modBrowserUi, modNames);
filterTitleProp.SetValue(modBrowserUi, filterName);
}
else
{
specialFilterProp.SetValue(modBrowserUi, null);
filterTitleProp.SetValue(modBrowserUi, "");
}
}
internal static void MergeConfigsForType(Type configType, ModConfig toConfig, ModConfig froConfig)
{
var defaultConfig = (ModConfig)Activator.CreateInstance(
configType,
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
null,
new object[] { },
null
);
if (defaultConfig == null)
{
throw new ModLibsException("Could generate default template for ModConfig " + configType.Name);
}
JsonConvert.PopulateObject("{}", defaultConfig, ConfigManager.serializerSettings);
object froVal, defaultVal;
IEnumerable <MemberInfo> members = configType.GetMembers(BindingFlags.Public | BindingFlags.Instance);
foreach (MemberInfo memb in members)
{
if (memb.MemberType == MemberTypes.Property)
{
var prop = (PropertyInfo)memb;
if (!prop.CanWrite || !prop.CanRead)
{
continue;
}
if (prop.GetCustomAttribute <JsonIgnoreAttribute>() != null)
{
continue;
}
}
else if (memb.MemberType != MemberTypes.Field)
{
continue;
}
if (!ReflectionLibraries.Get(froConfig, memb.Name, out froVal))
{
throw new ModLibsException("Could retrieve member " + memb.Name + " from 'fro' instance of " + configType.Name);
}
if (!ReflectionLibraries.Get(defaultConfig, memb.Name, out defaultVal))
{
throw new ModLibsException("Could retrieve member " + memb.Name + " from template instance of " + configType.Name);
}
bool froValueIsDefault = froVal?.Equals(defaultVal)
?? froVal == defaultVal; // <- default is null
bool froValueIsCollection = froVal is IEnumerable;
bool froValueIsEmpty = froValueIsCollection &&
(froVal == null || ((IEnumerable)froVal).Cast <object>().Count() == 0);
if ((!froValueIsCollection && !froValueIsDefault) || (froValueIsCollection && !froValueIsEmpty))
{
if (!ReflectionLibraries.Set(toConfig, memb.Name, froVal))
{
throw new ModLibsException("Could set merged field/property " + memb.Name + " for " + configType.Name);
}
}
}
}
/// <summary>
/// Applies standard disabled text input theming to a UI text area.
/// </summary>
/// <param name="panel"></param>
public virtual void ApplyInputDisable(UIPanel panel)
{
panel.BackgroundColor = this.InputBgDisabledColor;
panel.BorderColor = this.InputEdgeDisabledColor;
ReflectionLibraries.Set(panel, "TextColor", this.InputTextDisabledColor);
}
public static void DrawPlayerHead(SpriteBatch sb, Player player, float x, float y, float alpha = 1f, float scale = 1f)
{
object _;
ReflectionLibraries.RunMethod(Main.instance, "DrawPlayerHead", new object[] { player, x, y, alpha, scale }, out _);
}
/// <summary>
/// Loads the mod browser menu with a given set of mods to one-click bulk download
/// (via. `ModMenuLibaries.ApplyModBrowserFilter(...)`).
/// </summary>
/// <param name="packTitle">Name of the set.</param>
/// <param name="modNames">Mod (internal) names of the set.</param>
public static void OpenModBrowserWithDownloadList(string packTitle, List <string> modNames)
{
Type interfaceType = ReflectionLibraries.GetMainAssembly()
.GetType("Terraria.ModLoader.UI.Interface");
int modBrowserMenuMode;
if (!ReflectionLibraries.Get(interfaceType, null, "modBrowserID", out modBrowserMenuMode))
{
LogLibraries.Warn("Could not switch to mod browser menu context.");
return;
}
Main.PlaySound(SoundID.MenuTick);
Main.menuMode = modBrowserMenuMode;
UIState modBrowserUi;
if (!ReflectionLibraries.Get(interfaceType, null, "modBrowser", out modBrowserUi))
{
LogLibraries.Warn("Could not acquire mod browser UI.");
return;
}
Timers.SetTimer("ModLibsModDownloadPrompt", 5, true, () => {
if (MenuContextService.GetCurrentMenuUI()?.GetType().Name != "UIModBrowser")
{
return(false);
}
bool isLoading;
if (!ReflectionLibraries.Get(modBrowserUi, "loading", out isLoading))
{
return(false);
}
if (isLoading)
{
return(true);
}
ModMenuLibraries.ApplyModBrowserFilter(packTitle, true, modNames);
return(false);
});
/*Assembly tmlAsm = typeof( ModLoader ).Assembly;
* Type interfaceType = tmlAsm.GetType( "Interface" );
*
* Type uiModDlType = tmlAsm.GetType( "UIModDownloadItem" );
* object uiModDl = Activator.CreateInstance( uiModDlType, "ModName", "0.0.0", "hamstar", "", ModSide.Both, "", "http://javid.ddns.net/tModLoader/download.php?Down=mods/ModLibsUI.tmod", 0, 0, "", false, false, null );
* //UIModDownloadItem modItem = new UIModDownloadItem( displayname, name, version, author, modreferences, modside, modIconURL, download, downloads, hot, timeStamp, update, updateIsDowngrade, installed );
* items.Add( modItem );
*
* Interface.downloadMods.SetDownloading( packTitle );
* Interface.downloadMods.SetModsToDownload( modFilter, items );
* Interface.modBrowser.updateNeeded = true;
*
* int menuMode;
* if( !ReflectionLibaries.GetField<int>( interfaceType, null, "downloadModsID", out menuMode ) ) {
* LogLibaries.Log( "Could not switch to downloads menu." );
* return;
* }
* Main.PlaySound( SoundID.MenuTick );
* Main.menuMode = menuMode;*/
}
