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));
}
