public static void InvItem_SetupDetails(InvItem __instance) { bool debug = RogueFramework.IsDebugEnabled(DebugFlags.Items); bool debug2 = RogueFramework.IsDebugEnabled(DebugFlags.Abilities); foreach (IHookFactory <InvItem> factory in RogueFramework.ItemFactories) { if (factory.TryCreate(__instance, out IHook <InvItem> hook)) { if (debug2 && hook is CustomAbility) { RogueFramework.LogDebug($"Initializing custom ability {hook} ({__instance.invItemName})."); } else if (debug) { if (hook is CustomItem) { RogueFramework.LogDebug($"Initializing custom item {hook} ({__instance.invItemName})."); } else { RogueFramework.LogDebug($"Initializing item hook {hook} for \"{__instance.invItemName}\"."); } } __instance.AddHook(hook); } } }
public static bool CharacterCreation_PushedButton(CharacterCreation __instance, ButtonHelper myButton) { bool debug = RogueFramework.IsDebugEnabled(DebugFlags.UnlockMenus); if (__instance.selectedSpace == "Load") { if (debug) { RogueFramework.LogDebug("Redirecting the button push to the original method."); } return(true); } if (debug) { RogueFramework.LogDebug($"Pressing \"{myButton.myText.text}\" ({myButton.scrollingButtonNum}, {myButton.scrollingButtonType}) button."); } string type = myButton.scrollingButtonUnlock.unlockType; List <ButtonData> buttonsData = type == UnlockTypes.Item ? __instance.buttonsDataItems : type == UnlockTypes.Trait ? __instance.buttonsDataTraits : type == UnlockTypes.Ability ? __instance.buttonsDataAbilities : type == UnlockTypes.BigQuest ? __instance.buttonsDataBigQuests : null; ButtonData buttonData = buttonsData[myButton.scrollingButtonNum]; DisplayedUnlock du = (DisplayedUnlock)buttonData.__RogueLibsCustom; try { du.OnPushedButton(); } catch (Exception e) { RogueFramework.LogError(e, "DisplayedUnlock.OnPushedButton", du, du.Menu); } __instance.curSelectedButton = myButton; __instance.curSelectedButtonNum = myButton.scrollingButtonNum; return(false); }
public static void StatusEffects_GiveSpecialAbility(StatusEffects __instance) { if (GameController.gameController.levelType == "HomeBase" && !__instance.agent.isDummy && __instance.agent.agentName != VanillaAgents.MechEmpty) { return; } CustomAbility custom = __instance.agent.GetAbility(); if (custom is null) { return; } if (RogueFramework.IsDebugEnabled(DebugFlags.Abilities)) { RogueFramework.LogDebug($"Giving ability {custom} ({__instance.agent.specialAbility}, {__instance.agent.agentName})."); } try { custom.OnAdded(); } catch (Exception e) { RogueFramework.LogError(e, "CustomAbility.OnAdded", custom, __instance.agent); } if (custom is IAbilityTargetable) { __instance.SpecialAbilityInterfaceCheck(); } if (custom is IAbilityRechargeable) { __instance.RechargeSpecialAbility(custom.ItemInfo.Name); } }
public static void SetupEffectHook(StatusEffect effect, StatusEffects parent) { bool debug = RogueFramework.IsDebugEnabled(DebugFlags.Effects); effect.__RogueLibsContainer = parent; foreach (IHookFactory <StatusEffect> factory in RogueFramework.EffectFactories) { if (factory.TryCreate(effect, out IHook <StatusEffect> hook)) { if (debug) { if (hook is CustomEffect) { RogueFramework.LogDebug($"Initializing custom effect {hook} ({effect.statusEffectName}, {parent.agent.agentName})."); } else { RogueFramework.LogDebug($"Initializing effect hook {hook} ({effect.statusEffectName}, {parent.agent.agentName})."); } } effect.AddHook(hook); // CustomEffect does not call OnAdded when initialized, // because of the GetStatusEffectTime/Hate patches if (hook is CustomEffect custom) { custom.OnAdded(); } } } }
public static bool ScrollingMenu_PushedButton(ScrollingMenu __instance, ButtonHelper myButton) { bool debug = RogueFramework.IsDebugEnabled(DebugFlags.UnlockMenus); if (__instance.menuType.EndsWith("Configs")) { if (debug) { RogueFramework.LogDebug("Redirecting the button push to the original method."); } return(true); } if (debug) { RogueFramework.LogDebug($"Pressing \"{myButton.myText.text}\" ({myButton.scrollingButtonNum}, {myButton.scrollingButtonType}) button."); } ButtonData buttonData = __instance.buttonsData[myButton.scrollingButtonNum]; DisplayedUnlock du = (DisplayedUnlock)buttonData.__RogueLibsCustom; try { du.OnPushedButton(); } catch (Exception e) { RogueFramework.LogError(e, "DisplayedUnlock.OnPushedButton", du, du.Menu); } return(false); }
public static void SetupTraitHook(Trait trait, StatusEffects parent) { bool debug = RogueFramework.IsDebugEnabled(DebugFlags.Traits); bool updateable = false; trait.__RogueLibsContainer = parent; foreach (IHookFactory <Trait> factory in RogueFramework.TraitFactories) { if (factory.TryCreate(trait, out IHook <Trait> hook)) { if (debug) { if (hook is CustomTrait) { RogueFramework.LogDebug($"Initializing custom trait {hook} ({trait.traitName}, {parent.agent.agentName})."); } else { RogueFramework.LogDebug($"Initializing trait hook {hook} ({trait.traitName}, {parent.agent.agentName})."); } } trait.AddHook(hook); if (hook is CustomTrait && hook is ITraitUpdateable) { updateable = true; } } } if (updateable && parent.agent.name != "DummyAgent" && !parent.agent.name.Contains("Backup")) { parent.StartCoroutine(parent.UpdateTrait(trait)); trait.requiresUpdates = true; } }
public static void StatusEffects_PressedSpecialAbility(StatusEffects __instance) { CustomAbility custom = __instance.agent.GetAbility(); if (custom is null) { return; } if (custom.Item.invItemName != __instance.agent.specialAbility) { return; } if (RogueFramework.IsDebugEnabled(DebugFlags.Abilities)) { RogueFramework.LogDebug($"Pressing ability ability {custom} ({__instance.agent.specialAbility}, {__instance.agent.agentName})."); } try { custom.OnPressed(); } catch (Exception e) { RogueFramework.LogError(e, "CustomAbility.OnPressed", custom, __instance.agent); } if (custom.Count > 0) { __instance.agent.inventory.buffDisplay.specialAbilitySlot.MakeNotUsable(); } }
public static bool ScrollingMenu_SortUnlocks(ScrollingMenu __instance, List <Unlock> myUnlockList, List <Unlock> ___listUnlocks) { List <DisplayedUnlock> displayedList = myUnlockList.ConvertAll(u => (DisplayedUnlock)u.__RogueLibsCustom); if (__instance.menuType == "FreeItems") { displayedList.RemoveAll(u => u is ItemUnlock itemUnlock && !itemUnlock.IsAvailableInItemTeleporter); } displayedList.Sort(); CustomScrollingMenu menu = new CustomScrollingMenu(__instance, displayedList); if (RogueFramework.IsDebugEnabled(DebugFlags.UnlockMenus)) { RogueFramework.LogDebug($"Setting up \"{menu.Type}\" menu."); } ___listUnlocks.Clear(); ___listUnlocks.AddRange(menu.Unlocks.Select(du => du.Unlock)); foreach (DisplayedUnlock du in menu.Unlocks) { du.Menu = menu; } if (menu.Type == UnlocksMenuType.Loadouts) { reRollLoadouts.Menu = menu; ___listUnlocks.Insert(0, reRollLoadouts.Unlock); if (RogueFramework.IsDebugEnabled(DebugFlags.EnableTools)) { RogueFramework.LogDebug("Adding \"GiveNuggets\" debug tool to the menu."); giveNuggets.Menu = menu; ___listUnlocks.Insert(0, giveNuggets.Unlock); } } if (menu.Type == UnlocksMenuType.MutatorMenu) { __instance.nuggetSlot.gameObject.SetActive(true); clearAllMutators.Menu = menu; ___listUnlocks.Insert(0, clearAllMutators.Unlock); } else if (menu.Type == UnlocksMenuType.RewardsMenu) { __instance.nuggetSlot.gameObject.SetActive(true); // clearAllItems.Menu = menu; // ___listUnlocks.Insert(0, clearAllItems.Unlock); } else if (menu.Type == UnlocksMenuType.TraitsMenu) { __instance.nuggetSlot.gameObject.SetActive(true); // clearAllTraits.Menu = menu; // ___listUnlocks.Insert(0, clearAllTraits.Unlock); } __instance.numButtons = ___listUnlocks.Count; return(false); }
public override void OnPushedButton() { if (RogueFramework.IsDebugEnabled(DebugFlags.UnlockMenus)) { RogueFramework.LogDebug("Added 10 nuggets with the debug tool."); } gc.unlocks.AddNuggets(10); PlaySound(VanillaAudio.BuyItem); UpdateMenu(); }
public static void StatusEffects_RemoveStatusEffect(StatusEffect __state) { CustomEffect effect = __state?.GetHook <CustomEffect>(); if (__state != null && RogueFramework.IsDebugEnabled(DebugFlags.Effects)) { RogueFramework.LogDebug($"Removing effect {effect} ({__state.statusEffectName}, {__state.GetStatusEffects().agent.agentName})."); } effect?.OnRemoved(); }
public static void StatusEffects_RemoveTrait(Trait __state) { CustomTrait trait = __state?.GetHook <CustomTrait>(); if (__state != null && RogueFramework.IsDebugEnabled(DebugFlags.Traits)) { RogueFramework.LogDebug($"Removing trait {trait} ({__state.traitName}, {__state.GetStatusEffects().agent.agentName})."); } trait?.OnRemoved(); }
public static void ScrollingMenu_OpenScrollingMenu_Prefix(ScrollingMenu __instance, out float __state) { float x = 1f - __instance.scrollBar.value; __state = x * (__instance.numButtons - __instance.numButtonsOnScreen + 1f); if (RogueFramework.IsDebugEnabled(DebugFlags.UnlockMenus)) { RogueFramework.LogDebug($"Stored menu's scrolling value of {__state} units."); } }
/// <summary> /// <para>Prevents ghost agents from using items.</para> /// </summary> /// <param name="e">The item usage event args.</param> public static void GhostCheck(OnItemUsingArgs e) { if (e.User.ghost) { if (RogueFramework.IsDebugEnabled(DebugFlags.Items)) { RogueFramework.LogDebug("---- Triggered \"Ghost\" inventory check."); } e.User.gc.audioHandler.Play(e.User, "CantDo"); e.Cancel = e.Handled = true; } }
public static void Unlocks_LoadInitialUnlocks_Helper(bool dontClear) { if (dontClear) { return; } if (RogueFramework.IsDebugEnabled(DebugFlags.Unlocks)) { RogueFramework.LogDebug("Reloading unlocks."); } RogueFramework.Unlocks.Clear(); }
/// <summary> /// <para>Adds the specified <typeparamref name="TTrait"/> type to the factory.</para> /// </summary> /// <typeparam name="TTrait">The <see cref="CustomTrait"/> type to add.</typeparam> /// <returns>The added trait's metadata.</returns> public TraitInfo AddTrait <TTrait>() where TTrait : CustomTrait, new() { TraitInfo info = TraitInfo.Get <TTrait>(); if (RogueFramework.IsDebugEnabled(DebugFlags.Traits)) { RogueFramework.LogDebug($"Created custom trait {typeof(TTrait)} ({info.Name})."); } traitsDict.Add(info.Name, new TraitEntry { Initializer = () => new TTrait(), TraitInfo = info }); return(info); }
/// <summary> /// <para>Prevents "Electronic" agents from using medicine.</para> /// </summary> /// <param name="e">The item usage event args.</param> public static void OnlyChargeMedicineCheck(OnItemUsingArgs e) { if (e.User.electronic && e.Item.itemType == ItemTypes.Consumable && e.Item.Categories.Contains("Health")) { if (RogueFramework.IsDebugEnabled(DebugFlags.Items)) { RogueFramework.LogDebug("---- Triggered \"OnlyChargeMedicine\" inventory check."); } e.User.SayDialogue("OnlyChargeGivesHealth"); e.User.gc.audioHandler.Play(e.User, "CantDo"); e.Cancel = e.Handled = true; } }
/// <summary> /// <para>Prevents agents with full health from consuming healing items.</para> /// </summary> /// <param name="e">The item usage event args.</param> public static void FullHealthCheck(OnItemUsingArgs e) { if (e.Item.healthChange > 0 && e.User.health == e.User.healthMax) { if (RogueFramework.IsDebugEnabled(DebugFlags.Items)) { RogueFramework.LogDebug("---- Triggered \"FullHealth\" inventory check."); } e.User.SayDialogue("HealthFullCantUseItem"); e.User.gc.audioHandler.Play(e.User, "CantDo"); e.Cancel = e.Handled = true; } }
/// <summary> /// <para>Prevents "Pea-Brained" agents from using non-Food items.</para> /// </summary> /// <param name="e">The item usage event args.</param> public static void PeaBrainedCheck(OnItemUsingArgs e) { if (e.Item.itemType != ItemTypes.Food && e.User.HasTrait("CantInteract")) { if (RogueFramework.IsDebugEnabled(DebugFlags.Items)) { RogueFramework.LogDebug("---- Triggered \"PeaBrained\" inventory check."); } e.User.SayDialogue("CantInteract"); e.User.gc.audioHandler.Play(e.User, "CantDo"); e.Cancel = e.Handled = true; } }
/// <summary> /// <para>Prevents "Oil-Reliant" agents from consuming food.</para> /// </summary> /// <param name="e">The item usage event args.</param> public static void OnlyOilCheck(OnItemUsingArgs e) { if (e.Item.itemType == ItemTypes.Food && (e.Item.Categories.Contains("Food") || e.Item.Categories.Contains("Alcohol")) && e.User.HasTrait("OilRestoresHealth")) { if (RogueFramework.IsDebugEnabled(DebugFlags.Items)) { RogueFramework.LogDebug("---- Triggered \"OnlyOil\" inventory check."); } e.User.SayDialogue("OnlyOilGivesHealth"); e.User.gc.audioHandler.Play(e.User, "CantDo"); e.Cancel = e.Handled = true; } }
public static void NameDB_RealAwake(NameDB __instance) { if (!LanguageService.Languages.TryGetValue(__instance.language, out LanguageCode code)) { code = LanguageCode.English; } if (RogueFramework.IsDebugEnabled(DebugFlags.Names)) { RogueFramework.LogDebug($"Current language: {LanguageService.GetLanguageName(code)} ({(int)code})"); } LanguageService.NameDB = __instance; LanguageService.Current = code; }
/// <summary> /// <para>Forcefully unlocks an unlock with the specified <paramref name="unlockName"/> and <paramref name="unlockType"/>.</para> /// </summary> /// <param name="unlocks">The current unlocks.</param> /// <param name="unlockName">The name of the unlock to unlock.</param> /// <param name="unlockType">The type of the unlock to unlock.</param> /// <exception cref="ArgumentNullException"><paramref name="unlocks"/> is <see langword="null"/>.</exception> public static void DoUnlockForced(this Unlocks unlocks, string unlockName, string unlockType) { if (unlocks is null) { throw new ArgumentNullException(nameof(unlocks)); } if (RogueFramework.IsDebugEnabled(DebugFlags.Unlocks)) { RogueFramework.LogDebug($"Force-unlocking \"{unlockName}\" ({unlockType})"); } bool prev = AllowUnlocksAnyway; AllowUnlocksAnyway = true; unlocks.DoUnlock(unlockName, unlockType); AllowUnlocksAnyway = prev; }
public static void RefreshEffect(StatusEffect effect, int newTime) { CustomEffect custom = effect.GetHook <CustomEffect>(); float oldTime = effect.curTime; if (custom is null) { effect.curTime = newTime; } else { custom.OnRefreshed(); } if (RogueFramework.IsDebugEnabled(DebugFlags.Effects)) { RogueFramework.LogDebug($"Refreshed {custom} ({effect.statusEffectName}, {effect.GetStatusEffects().agent.agentName}): {oldTime} > {effect.curTime}."); } }
#pragma warning restore CS0618 // Type or member is obsolete public static void AddUnlockFull(UnlockWrapper wrapper, bool alreadyLoaded = false) { try { // integrating custom unlocks Unlock result = alreadyLoaded ? wrapper.Unlock : GameController.gameController.unlocks.AddUnlock(wrapper.Unlock); if (wrapper.Unlock != result) { if (RogueFramework.IsDebugEnabled(DebugFlags.Unlocks)) { RogueFramework.LogDebug($"Loaded state for \"{wrapper.Name}\" ({wrapper.Type}): unlocked - {result.unlocked}, enabled - {!result.notActive}"); } List <Unlock> list = GameController.gameController.sessionDataBig.unlocks; list.Remove(result); list.Add(wrapper.Unlock); wrapper.IsUnlocked = result.unlocked; if (!(wrapper is MutatorUnlock)) { wrapper.IsEnabled = !result.notActive; } } wrapper.IsAvailable = wrapper.IsAvailable; if (wrapper is IUnlockInCC inCC) { inCC.IsAvailableInCC = inCC.IsAvailableInCC; } if (wrapper is ItemUnlock item) { item.IsAvailableInItemTeleporter = item.IsAvailableInItemTeleporter; } // make sure that the Unlocks are in their appropriate lists wrapper.SetupUnlock(); } catch (Exception e) { RogueFramework.Logger.LogError($"Error setting up {wrapper.Unlock?.unlockName} ({wrapper.Unlock?.unlockType}) unlock."); RogueFramework.Logger.LogError(e); } }
private EffectInfo(Type type) { if (!typeof(CustomEffect).IsAssignableFrom(type)) { throw new ArgumentException($"The specified {nameof(type)} is not a {nameof(CustomEffect)}.", nameof(type)); } EffectNameAttribute attr = type.GetCustomAttributes <EffectNameAttribute>().FirstOrDefault(); Name = attr?.Name ?? type.Name; EffectParametersAttribute parsAttr = type.GetCustomAttributes <EffectParametersAttribute>().FirstOrDefault(); if (parsAttr is null) { RogueFramework.LogWarning($"Type {type} does not have a {nameof(EffectParametersAttribute)}!"); } Limitations = parsAttr?.Limitations ?? EffectLimitations.RemoveOnDeath; RemoveOnDeath = (Limitations & EffectLimitations.RemoveOnDeath) != 0; RemoveOnKnockOut = (Limitations & EffectLimitations.RemoveOnKnockOut) != 0; RemoveOnNextLevel = (Limitations & EffectLimitations.RemoveOnNextLevel) != 0; }
public static void ScrollingMenu_RefreshLoadouts(List <Unlock> ___loadoutList) { bool debug = RogueFramework.IsDebugEnabled(DebugFlags.UnlockMenus); if (debug) { RogueFramework.LogDebug("Refreshing the loadouts."); } ___loadoutList.RemoveAt(0); for (int i = 0; i < ___loadoutList.Count; i++) { Unlock unlock = ___loadoutList[i]; if (unlock.__RogueLibsCustom is null) { if (debug) { RogueFramework.LogDebug("Hooking up an unhooked unlock."); } Unlock normalized = GameController.gameController.sessionDataBig.unlocks .Find(u => u.unlockName == unlock.unlockName && u.unlockType == unlock.unlockType); unlock.__RogueLibsCustom = normalized.__RogueLibsCustom; } } }
public static bool CharacterCreation_SortUnlocks(CharacterCreation __instance, List <Unlock> myUnlockList, string unlockType) { if (unlockType == UnlockTypes.BigQuest) { myUnlockList = __instance.gc.sessionDataBig.bigQuestUnlocks; } List <DisplayedUnlock> displayedList = myUnlockList.Select(u => u.__RogueLibsCustom).OfType <DisplayedUnlock>().ToList(); if (unlockType == UnlockTypes.Ability || unlockType == UnlockTypes.BigQuest) { displayedList.RemoveAll(u => u is IUnlockInCC inCC && !inCC.IsAvailableInCC); } displayedList.Sort(); CustomCharacterCreation menu = new CustomCharacterCreation(__instance, displayedList); if (RogueFramework.IsDebugEnabled(DebugFlags.UnlockMenus)) { RogueFramework.LogDebug($"Setting up \"{menu.Type}\" menu."); } List <Unlock> listUnlocks = unlockType == UnlockTypes.Item ? __instance.listUnlocksItems : unlockType == UnlockTypes.Trait ? __instance.listUnlocksTraits : unlockType == UnlockTypes.Ability ? __instance.listUnlocksAbilities : unlockType == UnlockTypes.BigQuest ? __instance.listUnlocksBigQuests : null; listUnlocks.Clear(); listUnlocks.AddRange(menu.Unlocks.Select(du => du.Unlock)); foreach (DisplayedUnlock du in menu.Unlocks) { du.Menu = menu; } if (unlockType == UnlockTypes.Item) { clearAllItems.Menu = menu; listUnlocks.Insert(0, clearAllItems.Unlock); } else if (unlockType == UnlockTypes.Trait) { clearAllTraits.Menu = menu; listUnlocks.Insert(0, clearAllTraits.Unlock); } if (unlockType == UnlockTypes.Item) { __instance.numButtonsItems = listUnlocks.Count - 1; } else if (unlockType == UnlockTypes.Trait) { __instance.numButtonsTraits = listUnlocks.Count - 1; } else if (unlockType == UnlockTypes.Ability) { __instance.numButtonsAbilities = listUnlocks.Count; } else if (unlockType == UnlockTypes.BigQuest) { __instance.numButtonsBigQuests = listUnlocks.Count; } return(false); }
public static bool InvItem_TargetObject(InvItem __instance, PlayfieldObject otherObject, string combineType, ref bool __result) { bool debug = RogueFramework.IsDebugEnabled(DebugFlags.Items); bool actualCombining = combineType == "Combine"; CustomItem custom = __instance.GetHook <CustomItem>(); if (debug && actualCombining) { RogueFramework.LogDebug($"Targeting {custom} ({__instance.invItemName}) on {otherObject.objectName}:"); } if (Vector2.Distance(__instance.agent.curPosition, otherObject.curPosition) > 15f && InventoryChecks.IsCheckAllowed(custom, "Distance")) { if (debug && actualCombining) { RogueFramework.LogDebug("---- Triggered \"Distance\" inventory check."); RogueFramework.LogDebug("---- Targeting was prevented by an inventory check."); } __result = false; return(false); } if ((otherObject as Agent)?.butlerBot == true && InventoryChecks.IsCheckAllowed(custom, "ButlerBot")) { if (debug && actualCombining) { RogueFramework.LogDebug("---- Triggered \"ButlerBot\" inventory check."); RogueFramework.LogDebug("---- Targeting was prevented by an inventory check."); } __result = false; return(false); } if ((otherObject as Agent)?.mechEmpty == true && InventoryChecks.IsCheckAllowed(custom, "EmptyMech")) { if (debug && actualCombining) { RogueFramework.LogDebug("---- Triggered \"EmptyMech\" inventory check."); RogueFramework.LogDebug("---- Targeting was prevented by an inventory check."); } __result = false; return(false); } __result = custom is IItemTargetable targetable ? targetable.TargetFilter(otherObject) : new ItemFunctions().TargetObject(__instance, __instance.agent, otherObject, string.Empty); if (actualCombining) { OnItemTargetingArgs args = new OnItemTargetingArgs(__instance, otherObject, __instance.agent); if (InventoryChecks.onItemTargeting.Raise(args, custom?.ItemInfo.IgnoredChecks)) { otherObject = args.Target; using (AgentSwapper swapper = new AgentSwapper(__instance, args.User)) { if (custom is IItemTargetable targetable2) { bool success = targetable2.TargetObject(otherObject); if (debug) { RogueFramework.LogDebug($"---- Targeting {(success ? "was successful" : "failed")}."); } if (success) { new ItemFunctions().UseItemAnim(__instance, __instance.agent); } } else { if (debug) { RogueFramework.LogDebug("---- Running the original method."); } new ItemFunctions().TargetObject(__instance, __instance.agent, otherObject, "Combine"); } if (__instance.invItemCount < 1 || !__instance.database.InvItemList.Contains(__instance) && InventoryChecks.IsCheckAllowed(custom, "StopOnZero")) { if (debug) { RogueFramework.LogDebug("---- Triggered \"StopOnZero\" inventory check."); } __instance.agent.mainGUI.invInterface.HideDraggedItem(); __instance.agent.mainGUI.invInterface.HideTarget(); } } } else { if (debug) { RogueFramework.LogDebug("---- Targeting was prevented by an inventory check."); } } } return(false); }
#pragma warning disable CS0618 // Type or member is obsolete public static void InitializeUnlockWrappers() { GameController gc = GameController.gameController; SessionDataBig sdb = gc.sessionDataBig; foreach (Unlock unlock in sdb.unlocks.ToList()) { // wrapping original unlocks if (string.IsNullOrEmpty(gc.unlocks.GetSpecialUnlockInfo(unlock.unlockName, unlock))) { unlock.cost = -2; if (RogueFramework.IsDebugEnabled(DebugFlags.Unlocks)) { RogueFramework.LogDebug($"\"{unlock.unlockName}\" ({unlock.unlockType}) has special unlock conditions."); } } UnlockWrapper wrapper; if (unlock.unlockType == UnlockTypes.Mutator) { unlock.unavailable = false; wrapper = new MutatorUnlock(unlock); } else if (unlock.unlockType == UnlockTypes.Item) { if (unlock.onlyInCharacterCreation && !unlock.unavailable) { unlock.unavailable = true; } if (!unlock.unavailable && !unlock.onlyInCharacterCreation && !unlock.freeItem) { unlock.onlyInCharacterCreation = unlock.freeItem = true; } wrapper = new ItemUnlock(unlock); } else if (unlock.unlockType == UnlockTypes.Trait) { if (unlock.onlyInCharacterCreation && !unlock.unavailable) { unlock.unavailable = true; } wrapper = new TraitUnlock(unlock); } else if (unlock.unlockType == UnlockTypes.Ability) { if (unlock.onlyInCharacterCreation && !unlock.unavailable) { unlock.unavailable = true; } wrapper = new AbilityUnlock(unlock); } else if (unlock.unlockType == UnlockTypes.Floor) { wrapper = new FloorUnlock(unlock); } else if (unlock.unlockType == UnlockTypes.BigQuest) { wrapper = new BigQuestUnlock(unlock); } else if (unlock.unlockType == UnlockTypes.Extra) { wrapper = new ExtraUnlock(unlock); } else if (unlock.unlockType == UnlockTypes.Agent) { wrapper = new AgentUnlock(unlock) { IsSSA = unlock.unlockName == VanillaAgents.SuperCop || unlock.unlockName == VanillaAgents.UpperCruster || unlock.unlockName == VanillaAgents.Supergoon }; } else if (unlock.unlockType == "Achievement") { wrapper = new AchievementUnlock(unlock); } else if (unlock.unlockType == "HomeBase") { wrapper = new HomeBaseUnlock(unlock); } else if (unlock.unlockType == "Loadout") { wrapper = new LoadoutUnlock(unlock); } else { RogueFramework.LogError($"Unknown unlock type \"{unlock.unlockName}\" ({unlock.unlockType})"); sdb.unlocks.Remove(unlock); continue; } if (wrapper is IUnlockInCC inCC && !inCC.IsAvailableInCC) { inCC.IsAvailableInCC = wrapper.IsAvailable; } RogueFramework.Unlocks.Add(wrapper); AddUnlockFull(wrapper, true); } FixPrerequisites(); foreach (UnlockWrapper wrapper in RogueFramework.CustomUnlocks) { if (RogueFramework.IsDebugEnabled(DebugFlags.Unlocks)) { RogueFramework.LogDebug($"Initializing custom unlock \"{wrapper.Name}\" ({wrapper.Type})."); } RogueFramework.Unlocks.Add(wrapper); AddUnlockFull(wrapper); } }
public static void InvInterface_TargetAnywhere(InvInterface __instance, Vector2 myPos, bool pressedButton) { __instance.cursorTextString3.color = Color.white; bool debug = RogueFramework.IsDebugEnabled(DebugFlags.Items); InvItem invItem = __instance.mainGUI.targetItem; if (invItem != null) { CustomItem custom = invItem.GetHook <CustomItem>(); __instance.cursorHighlightTargetObjects = custom is IItemTargetable; if (custom is IItemTargetableAnywhere targetable) { if (debug && pressedButton) { RogueFramework.LogDebug($"Targeting {custom} ({invItem.invItemName}) anywhere:"); } bool filter = targetable.TargetFilter(myPos); __instance.cursorHighlight = filter; __instance.cursorHighlightTargetAnywhere = filter; __instance.mainGUI.agent.targetImage.tr.localScale = Vector3.one; CustomTooltip tooltip = targetable.TargetCursorText(myPos); __instance.cursorTextCanvas3.enabled = !string.IsNullOrEmpty(tooltip.Text); __instance.cursorTextString3.text = tooltip.Text ?? string.Empty; __instance.cursorTextString3.color = tooltip.Color ?? Color.white; if (pressedButton) { OnItemTargetingAnywhereArgs args = new OnItemTargetingAnywhereArgs(invItem, myPos, invItem.agent); if (InventoryChecks.onItemTargetingAnywhere.Raise(args, custom?.ItemInfo.IgnoredChecks)) { myPos = args.Target; using (AgentSwapper swapper = new AgentSwapper(invItem, args.User)) { bool success = targetable.TargetPosition(myPos); if (debug) { RogueFramework.LogDebug($"---- Targeting {(success ? "was successful" : "failed")}."); } if (success) { new ItemFunctions().UseItemAnim(invItem, invItem.agent); } if (custom.Count < 1 || !custom.Inventory.InvItemList.Contains(custom.Item) && InventoryChecks.IsCheckAllowed(custom, "StopOnZero")) { if (debug) { RogueFramework.LogDebug("---- Triggered \"StopOnZero\" inventory check."); } __instance.HideDraggedItem(); __instance.HideTarget(); } } } else { if (debug) { RogueFramework.LogDebug("---- Targeting was prevented by an inventory check."); } } } } } }
public static bool ItemFunctions_UseItem(InvItem item, Agent agent) { bool debug = RogueFramework.IsDebugEnabled(DebugFlags.Items); CustomItem custom = item.GetHook <CustomItem>(); if (custom is IItemTargetable || custom is IItemTargetableAnywhere) { if (debug) { RogueFramework.LogDebug($"Showing target for {custom} ({item.invItemName})."); } item.invInterface.ShowOrHideTarget(item); return(false); } if (debug) { RogueFramework.LogDebug($"Using {custom} ({item.invItemName}):"); } Agent originalAgent = agent; OnItemUsingArgs args = new OnItemUsingArgs(item, agent); if (InventoryChecks.onItemUsing.Raise(args, custom?.ItemInfo.IgnoredChecks)) { agent = args.User; // in case an inventory check redirected the use of an item on someone else using (AgentSwapper swapper = new AgentSwapper(item, agent)) { if (agent.localPlayer) { if (!originalAgent.inventory.HasItem(item.invItemName) && originalAgent.inventory.equippedSpecialAbility?.invItemName != item.invItemName) { return(false); } else if (!item.used && (item.Categories.Contains(RogueCategories.Usable) || item.itemType == ItemTypes.Consumable)) { item.used = true; if (agent.isPlayer > 0) { agent.gc.sessionData.endStats[agent.isPlayer].itemsUsed++; } } } // if it's not a custom item, run the original method if (!(custom is IItemUsable usable)) { if (debug) { RogueFramework.LogDebug("---- Running the original method."); } return(true); } bool success = usable.UseItem(); if (debug) { RogueFramework.LogDebug($"---- Usage {(success ? "was successful" : "failed")}."); } if (success) { new ItemFunctions().UseItemAnim(item, agent); } } } else { if (debug) { RogueFramework.LogDebug("---- Usage was prevented by an inventory check."); } } return(false); }