public static void Postfix(XUiC_ItemActionList __instance, XUiC_ItemActionList.ItemActionListTypes _actionListType, XUiController itemController) { // Check if this feature is enabled. if (!Configuration.CheckFeatureStatus(AdvFeatureClass, Feature)) { return; } if (_actionListType == XUiC_ItemActionList.ItemActionListTypes.Item) { XUiC_ItemStack xuiC_ItemStack = (XUiC_ItemStack)itemController; ItemStack itemStack = xuiC_ItemStack.ItemStack; ItemValue itemValue = itemStack.itemValue; if (itemValue.MaxUseTimes > 0 && itemValue.UseTimes > 0f) { if (ItemsUtilities.CheckProperty(itemValue.ItemClass, "RepairItems")) { __instance.AddActionListEntry(new ItemActionEntryRepair(itemController)); } if (ItemsUtilities.CheckProperty(itemValue.ItemClass, "Resharpen")) { __instance.AddActionListEntry(new ItemActionEntryResharpenSDX(itemController)); } } } }
private void highlight(string _text) { int i = 0; XUiController[] controllers = this.backpackGrid.GetItemStackControllers(); ItemStack[] backpack_stacks = this.backpackGrid.GetSlots(); // Debug.Log("# controllers:" + controllers.Length); // Debug.Log("# backpack_stacks:" + backpack_stacks.Length); while (i < controllers.Length) { // is_ = backpack_stacks[i]; XUiC_ItemStack controller = (XUiC_ItemStack)controllers[i]; if (controller.ItemStack.itemValue.ItemClass != null) { String name = controller.ItemStack.itemValue.ItemClass.GetLocalizedItemName().ToLower(); if (_text.Length > 0 && name.Contains(_text.ToLower())) { controller.backgroundColor = XUiC_mirashii_BackpackWindow.highlight_color; } else { controller.backgroundColor = XUiC_mirashii_BackpackWindow.normal_color; } } i += 1; } }
public static void Postfix(XUiC_ItemStack __instance, bool ___bLocked, bool ___isDragAndDrop) { if (!Configuration.CheckFeatureStatus(AdvFeatureClass, Feature)) { return; } // Make sure we are dealing with legitimate stacks. if (__instance.ItemStack.IsEmpty()) { return; } if (__instance.ItemStack.itemValue == null) { return; } if (___bLocked && ___isDragAndDrop) { return; } // if (__instance.ItemStack.itemValue.NextSpoilageTick < (int)GameManager.Instance.World.GetWorldTime()) { if (__instance.ItemStack.itemValue.ItemClass != null && __instance.ItemStack.itemValue.ItemClass.Properties.Contains("Spoilable")) { float DegradationMax = 1000f; if (__instance.ItemStack.itemValue.ItemClass.Properties.Contains("SpoilageMax")) { DegradationMax = __instance.ItemStack.itemValue.ItemClass.Properties.GetFloat("SpoilageMax"); } __instance.durability.IsVisible = true; __instance.durabilityBackground.IsVisible = true; float PerCent = 1f - Mathf.Clamp01(__instance.ItemStack.itemValue.CurrentSpoilage / DegradationMax); int TierColor = 7 + (int)Math.Round(8 * PerCent); if (TierColor < 0) { TierColor = 0; } if (TierColor > 7) { TierColor = 7; } // allow over-riding of the color. if (__instance.ItemStack.itemValue.ItemClass.Properties.Contains("QualityTierColor")) { TierColor = __instance.ItemStack.itemValue.ItemClass.Properties.GetInt("QualityTierColor"); } __instance.durability.Color = QualityInfo.GetQualityColor(TierColor); __instance.durability.Fill = PerCent; } } }
static void Postfix(XUiC_ItemStack __instance, ref float _dt) { if (__instance.itemClass != null) { if (__instance.itemStack.itemValue.HasQuality || __instance.itemStack.itemValue.HasModSlots || __instance.itemStack.itemValue.IsMod) { if (__instance.durability != null && __instance.lockType != XUiC_ItemStack.LockTypes.Crafting) { if (__instance.itemStack.itemValue.PercentUsesLeft < 0.2f) { __instance.background.Color = new Color(1f, 0f, 0f); } } } } }
public static bool Prefix(XUiC_ItemStack __instance, bool ___bLocked, bool ___isDragAndDrop) { if (!Configuration.CheckFeatureStatus(AdvFeatureClass, Feature)) { return(true); } // Make sure we are dealing with legitimate stacks. if (__instance.ItemStack.IsEmpty()) { return(true); } if (__instance.ItemStack.itemValue == null) { return(true); } if (___bLocked && ___isDragAndDrop) { return(true); } // Reset the durability //__instance.durability.IsVisible = false; // If the item class has a SpoilageTime, that means it can spoil over time. if (__instance.ItemStack.itemValue.ItemClass != null && __instance.ItemStack.itemValue.ItemClass.Properties.Contains("Spoilable")) { String strDisplay = "XUiC_ItemStack: " + __instance.ItemStack.itemValue.ItemClass.GetItemName(); float DegradationMax = 0f; float DegradationPerUse = 0f; if (__instance.ItemStack.itemValue.ItemClass.Properties.Contains("SpoilageMax")) { DegradationMax = __instance.ItemStack.itemValue.ItemClass.Properties.GetFloat("SpoilageMax"); } if (__instance.ItemStack.itemValue.ItemClass.Properties.Contains("SpoilagePerTick")) { DegradationPerUse = __instance.ItemStack.itemValue.ItemClass.Properties.GetFloat("SpoilagePerTick"); } // By default, have a spoiler hit every 100 ticks, but allow it to be over-rideable in the xml. int TickPerLoss = 100; // Check if there's a Global Ticks Per Loss Set BlockValue ConfigurationBlock = Block.GetBlockValue("ConfigFeatureBlock"); TickPerLoss = int.Parse(Configuration.GetPropertyValue("FoodSpoilage", "TickPerLoss")); // Check if there's a item-specific TickPerLoss if (__instance.ItemStack.itemValue.ItemClass.Properties.Contains("TickPerLoss")) { TickPerLoss = __instance.ItemStack.itemValue.ItemClass.Properties.GetInt("TickPerLoss"); } strDisplay += " Ticks Per Loss: " + TickPerLoss; // NextSpoilageTick will hold the world time + how many ticks until the next spoilage. if (__instance.ItemStack.itemValue.NextSpoilageTick == 0) { __instance.ItemStack.itemValue.NextSpoilageTick = (int)GameManager.Instance.World.GetWorldTime() + TickPerLoss; } // Throttles the amount of times it'll trigger the spoilage, based on the TickPerLoss if (__instance.ItemStack.itemValue.NextSpoilageTick < (int)GameManager.Instance.World.GetWorldTime()) { // How much spoilage to apply float PerUse = DegradationPerUse; // Check if there's a player involved, which could change the spoilage rate. //EntityPlayerLocal player = GameManager.Instance.World.GetPrimaryPlayer(); //if(player) // PerUse = EffectManager.GetValue(PassiveEffects.DegradationPerUse, __instance.ItemStack.itemValue, 1f, player, null, __instance.ItemStack.itemValue.ItemClass.ItemTags, true, true, true, true, 1, true); //else // PerUse = EffectManager.GetValue(PassiveEffects.DegradationPerUse, __instance.ItemStack.itemValue, 1f, null, null, __instance.ItemStack.itemValue.ItemClass.ItemTags, true, true, true, true, 1, true); float BasePerUse = PerUse; strDisplay += " Base Spoil: " + PerUse; float containerValue = 0; // Additional Spoiler flags to increase or decrease the spoil rate switch (__instance.StackLocation) { case XUiC_ItemStack.StackLocationTypes.ToolBelt: // Tool belt Storage check containerValue = float.Parse(Configuration.GetPropertyValue("FoodSpoilage", "Toolbelt")); strDisplay += " Storage Type: Tool Belt ( " + containerValue + " )"; PerUse += containerValue; break; case XUiC_ItemStack.StackLocationTypes.Backpack: // Back pack storage check containerValue = float.Parse(Configuration.GetPropertyValue("FoodSpoilage", "Backpack")); strDisplay += " Storage Type: Backpack ( " + containerValue + " )"; PerUse += containerValue; break; case XUiC_ItemStack.StackLocationTypes.LootContainer: // Loot Container Storage check TileEntityLootContainer container = __instance.xui.lootContainer; if (container != null) { BlockValue Container = GameManager.Instance.World.GetBlock(container.ToWorldPos()); String lootContainerName = Localization.Get(Block.list[Container.type].GetBlockName()); strDisplay += " " + lootContainerName; containerValue = float.Parse(Configuration.GetPropertyValue("FoodSpoilage", "Container")); strDisplay += " Storage Type: Container ( " + containerValue + " )"; PerUse += containerValue; if (Container.Block.Properties.Contains("PreserveBonus")) { strDisplay += " Preservation Bonus ( " + Container.Block.Properties.GetFloat("PreserveBonus") + " )"; PerUse -= Container.Block.Properties.GetFloat("PreserveBonus"); } } else { strDisplay += " Storage Type: Container ( Undefined Configuration Block: +10 )"; PerUse += 10; } break; case XUiC_ItemStack.StackLocationTypes.Creative: // Ignore Creative Containers return(true); default: containerValue = float.Parse(Configuration.GetPropertyValue("FoodSpoilage", "Container")); strDisplay += " Storage Type: Generic ( Default Container) ( " + containerValue + " )"; PerUse += containerValue; break; } strDisplay += " Spoiled This Tick: " + (PerUse - BasePerUse); float MinimumSpoilage = float.Parse(Configuration.GetPropertyValue("FoodSpoilage", "MinimumSpoilage")); MinimumSpoilage = Math.Max(0.1f, MinimumSpoilage); // Worse case scenario, no matter what, Spoilage will increment. if (PerUse <= MinimumSpoilage) { strDisplay += " Minimum spoilage Detected (PerUse: " + PerUse + " Minimum: " + MinimumSpoilage + " )"; PerUse = MinimumSpoilage; } // Calculate how many Spoils we may have missed over time. If we left our base and came back to our storage box, this will help accurately determine how much // spoilage should apply. String temp = "World Time: " + (int)GameManager.Instance.World.GetWorldTime() + " Minus NextSpoilageTick: " + __instance.ItemStack.itemValue.NextSpoilageTick + " Tick Per Loss: " + TickPerLoss; AdvLogging.DisplayLog(AdvFeatureClass, temp); int TotalSpoilageMultiplier = (int)(GameManager.Instance.World.GetWorldTime() - __instance.ItemStack.itemValue.NextSpoilageTick) / TickPerLoss; if (TotalSpoilageMultiplier == 0) { TotalSpoilageMultiplier = 1; } float TotalSpoilage = PerUse * TotalSpoilageMultiplier; strDisplay += " Spoilage Ticks Missed: " + TotalSpoilageMultiplier; strDisplay += " Total Spoilage: " + TotalSpoilage; __instance.ItemStack.itemValue.CurrentSpoilage += TotalSpoilage; strDisplay += " Next Spoilage Tick: " + (int)GameManager.Instance.World.GetWorldTime() + TickPerLoss; strDisplay += " Recorded Spoilage: " + __instance.ItemStack.itemValue.CurrentSpoilage; AdvLogging.DisplayLog(AdvFeatureClass, strDisplay); // Update the NextSpoilageTick value __instance.ItemStack.itemValue.NextSpoilageTick = (int)GameManager.Instance.World.GetWorldTime() + TickPerLoss; __instance.ItemStack.itemValue.NextSpoilageTick = (int)GameManager.Instance.World.GetWorldTime() + TickPerLoss; // If the spoil time is is greater than the degradation, loop around the stack, removing each layer of items. while (DegradationMax <= __instance.ItemStack.itemValue.CurrentSpoilage) //if(DegradationMax <= __instance.ItemStack.itemValue.CurrentSpoilage) { // If not defined, set the foodRottingFlesh as a spoiled product. Otherwise use the global / item. String strSpoiledItem = Configuration.GetPropertyValue("FoodSpoilage", "SpoiledItem"); if (string.IsNullOrEmpty(strSpoiledItem)) { strSpoiledItem = "foodRottingFlesh"; } if (__instance.ItemStack.itemValue.ItemClass.Properties.Contains("SpoiledItem")) { strSpoiledItem = __instance.ItemStack.itemValue.ItemClass.Properties.GetString("SpoiledItem"); } //EntityPlayerLocal player = __instance.xui.playerUI.entityPlayer; EntityPlayerLocal player = GameManager.Instance.World.GetPrimaryPlayer(); if (player) { int Count = 1; if (Configuration.CheckFeatureStatus(AdvFeatureClass, "FullStackSpoil")) { AdvLogging.DisplayLog(AdvFeatureClass, __instance.ItemStack.itemValue.ItemClass.GetItemName() + ":Full Stack Spoil"); Count = __instance.ItemStack.count; __instance.ItemStack = new ItemStack(ItemClass.GetItem(strSpoiledItem, false), Count); break; } ItemStack itemStack = new ItemStack(ItemClass.GetItem(strSpoiledItem, false), Count); if (itemStack.itemValue.ItemClass.GetItemName() != __instance.ItemStack.itemValue.ItemClass.GetItemName()) { if (!LocalPlayerUI.GetUIForPlayer(player).xui.PlayerInventory.AddItem(itemStack, true)) { player.world.gameManager.ItemDropServer(itemStack, player.GetPosition(), Vector3.zero, -1, 60f, false); } } } if (__instance.ItemStack.count > 2) { AdvLogging.DisplayLog(AdvFeatureClass, __instance.ItemStack.itemValue.ItemClass.GetItemName() + ": Reducing Stack by 1"); __instance.ItemStack.count--; __instance.ItemStack.itemValue.CurrentSpoilage -= DegradationMax; } else { AdvLogging.DisplayLog(AdvFeatureClass, __instance.ItemStack.itemValue.ItemClass.GetItemName() + ": Stack Depleted. Removing."); __instance.ItemStack = new ItemStack(ItemValue.None.Clone(), 0); break; // Nothing more to spoil } // break; } __instance.ForceRefreshItemStack(); } } return(true); }
public static bool Prefix(ItemActionEntryScrap __instance) { // Check if this feature is enabled. if (!Configuration.CheckFeatureStatus(AdvFeatureClass, Feature)) { return(true); } #region vanilla_code XUi xui = __instance.ItemController.xui; XUiC_ItemStack xuiC_ItemStack = (XUiC_ItemStack)__instance.ItemController; ItemStack itemStack = xuiC_ItemStack.ItemStack.Clone(); Recipe scrapableRecipe = CraftingManager.GetScrapableRecipe(itemStack.itemValue, itemStack.count); if (scrapableRecipe == null) { return(true); } XUiController xuiController = __instance.ItemController.xui.FindWindowGroupByName("workstation_workbench"); if (xuiController == null || !xuiController.WindowGroup.isShowing) { xuiController = xui.FindWindowGroupByName("crafting"); } XUiC_CraftingWindowGroup childByType = xuiController.GetChildByType <XUiC_CraftingWindowGroup>(); if (childByType == null) { return(true); } #endregion vanilla_code LocalPlayerUI uiforPlayer = LocalPlayerUI.GetUIForPlayer(__instance.ItemController.xui.playerUI.entityPlayer); List <ItemStack> scrapItems = new List <ItemStack>(); ItemClass forId = ItemClass.GetForId(itemStack.itemValue.type); // Check if ScrapItems is specified if (forId.Properties.Classes.ContainsKey("ScrapItems")) { DynamicProperties dynamicProperties3 = forId.Properties.Classes["ScrapItems"]; scrapItems = ItemsUtilities.ParseProperties(dynamicProperties3); ItemsUtilities.Scrap(scrapItems, itemStack, __instance.ItemController); return(false); } else if (forId.Properties.Contains("ScrapItems")) // Support for <property name="ScrapItems" value="resourceWood,0,resourceLeather,2" /> { string strData = forId.Properties.Values["ScrapItems"].ToString(); scrapItems = ItemsUtilities.ParseProperties(strData); ItemsUtilities.Scrap(scrapItems, itemStack, __instance.ItemController); return(false); } // Check if Repair Items is specified, if the ScrapItems wasn't. else if (forId.Properties.Classes.ContainsKey("RepairItems")) { DynamicProperties dynamicProperties3 = forId.Properties.Classes["RepairItems"]; scrapItems = ItemsUtilities.ParseProperties(dynamicProperties3); ItemsUtilities.Scrap(scrapItems, itemStack, __instance.ItemController); return(false); } else if (forId.RepairTools == null || forId.RepairTools.Length <= 0) { if (CraftingManager.GetRecipe(forId.GetItemName()) == null) { return(true); } if (CraftingManager.GetRecipe(forId.GetItemName()).tags.Test_AnySet(FastTags.Parse("usevanillascrap"))) { return(true); } // If there's a recipe, reduce it Recipe recipe = ItemsUtilities.GetReducedRecipes(forId.GetItemName(), 2); ItemsUtilities.Scrap(recipe.ingredients, itemStack, __instance.ItemController); return(false); } return(true); }
public static bool Prefix(ItemActionEntryUse __instance, ItemActionEntryUse.ConsumeType ___consumeType, ref int ___oldToolbeltFocusID) { if (__instance.ItemController.xui.isUsingItemActionEntryUse) { return(false); } XUiC_ItemStack stackControl = (XUiC_ItemStack)__instance.ItemController; if (!stackControl.ItemStack.itemValue.ItemClass.CanExecuteAction(0, __instance.ItemController.xui.playerUI.entityPlayer, stackControl.ItemStack.itemValue) || !stackControl.ItemStack.itemValue.ItemClass.CanExecuteAction(1, __instance.ItemController.xui.playerUI.entityPlayer, stackControl.ItemStack.itemValue)) { GameManager.ShowTooltipWithAlert(__instance.ItemController.xui.playerUI.entityPlayer, "You cannot use that at this time.", "ui_denied"); return(false); } __instance.ItemController.xui.isUsingItemActionEntryUse = true; ItemStack itemStack = new ItemStack(stackControl.ItemStack.itemValue.Clone(), 1); ItemStack itemStack2 = new ItemStack(stackControl.ItemStack.itemValue.Clone(), stackControl.ItemStack.count - 1); if (itemStack2.count == 0) { itemStack2 = ItemStack.Empty.Clone(); } Inventory inventory = __instance.ItemController.xui.PlayerInventory.Toolbelt; if (___consumeType == ItemActionEntryUse.ConsumeType.Quest) { __instance.ItemController.xui.FindWindowGroupByName("questOffer").GetChildByType <XUiC_QuestOfferWindow>().ItemStackController = stackControl; stackControl.QuestLock = true; } else { stackControl.HiddenLock = true; } stackControl.WindowGroup.Controller.SetAllChildrenDirty(); __instance.RefreshEnabled(); ___oldToolbeltFocusID = inventory.GetFocusedItemIdx(); int num = 0; if (stackControl.ItemStack.itemValue.ItemClass != null) { for (int i = 0; i < stackControl.ItemStack.itemValue.ItemClass.Actions.Length; i++) { bool flag = false; switch (___consumeType) { case ItemActionEntryUse.ConsumeType.Eat: case ItemActionEntryUse.ConsumeType.Drink: case ItemActionEntryUse.ConsumeType.Heal: if (stackControl.ItemStack.itemValue.ItemClass.Actions[i] != null) { flag = true; } break; case ItemActionEntryUse.ConsumeType.Read: if (stackControl.ItemStack.itemValue.ItemClass.Actions[i] is ItemActionLearnRecipe) { flag = true; } break; case ItemActionEntryUse.ConsumeType.Quest: if (stackControl.ItemStack.itemValue.ItemClass.Actions[i] is ItemActionQuest) { flag = true; } break; case ItemActionEntryUse.ConsumeType.Open: if (stackControl.ItemStack.itemValue.ItemClass.Actions[i] is ItemActionOpenBundle) { flag = true; } break; } if (flag) { num = i; break; } } } if (___consumeType != ItemActionEntryUse.ConsumeType.Quest) { stackControl.ItemStack = itemStack2; } if (!itemStack.itemValue.ItemClass.Actions[num].UseAnimation && itemStack.itemValue.ItemClass.Actions[num].ExecuteInstantAction(__instance.ItemController.xui.playerUI.entityPlayer, itemStack, false, stackControl)) { if (___consumeType != ItemActionEntryUse.ConsumeType.Quest) { stackControl.HiddenLock = false; stackControl.WindowGroup.Controller.SetAllChildrenDirty(); } __instance.ItemController.xui.isUsingItemActionEntryUse = false; return(false); } int oldSlot = ___oldToolbeltFocusID; Inventory tempInventory = __instance.ItemController.xui.playerUI.entityPlayer.inventory; GameManager.Instance.StartCoroutine(SphereII_ItemActionEntryUseOnActivated.SimulateActionExecution(tempInventory, num, itemStack, delegate { stackControl.WindowGroup.Controller.SetAllChildrenDirty(); inventory.SetHoldingItemIdx(oldSlot); inventory.SetItem(10, ItemStack.Empty.Clone()); inventory.OnUpdate(); GameManager.Instance.StartCoroutine(__instance.switchBack(inventory)); })); return(false); }
public override bool ExecuteInstantAction(EntityAlive ent, ItemStack stack, bool isHeldItem, XUiC_ItemStack stackController) { if (Properties.Values.ContainsKey("OutputCountMultiplier") && Properties.Params1.ContainsKey("OutputCountMultiplier")) { var progressionName = Properties.Values["OutputCountMultiplier"]; if (!string.IsNullOrEmpty(progressionName)) { var progression = ent.Progression.GetProgressionValue(progressionName); if (progression == null) { Debug.Log("Could not find the progression item from the value attribute. Multiplier will not be applied"); return(base.ExecuteInstantAction(ent, stack, isHeldItem, stackController)); } var countString = Properties.Params1["OutputCountMultiplier"]; if (string.IsNullOrEmpty(countString)) { Debug.Log("The params1 value was empty, or the OutputCountMultiplier element was not found. Multiplier will not be applied"); return(base.ExecuteInstantAction(ent, stack, isHeldItem, stackController)); } if (progression.Level == 0) { Debug.Log("The progression level is 0. This shouldn't happen in normal gameplay. Multiplier will not be applied"); return(base.ExecuteInstantAction(ent, stack, isHeldItem, stackController)); } else { var counts = countString.Split(','); var multiplier = 1; if (counts.Length > 1) { for (var i = 0; i < counts.Length; i++) { if (i == progression.Level - 1) { multiplier = int.Parse(counts[i]); } } } else { multiplier = int.Parse(counts[0]); } for (var i = 0; i < _originalCreateItemCount.Count; i++) { var itemCount = _originalCreateItemCount[i]; var newItemCount = itemCount * multiplier; CreateItemCount[i] = newItemCount.ToString(); } } } } return(base.ExecuteInstantAction(ent, stack, isHeldItem, stackController)); }