public static void Postfix(Transform elementRoot, Piece.Requirement req, Player player, bool craft, int quality)
{
var instance = InventoryGui.instance;
if ((instance.InCraftTab() || instance.InUpradeTab()) && req?.m_resItem != null)
{
var item = req.m_resItem;
var icon = elementRoot.transform.Find("res_icon").GetComponent <Image>();
var bgIconTransform = elementRoot.Find("bgIcon");
if (item.m_itemData.UseMagicBackground())
{
if (bgIconTransform == null)
{
bgIconTransform = Object.Instantiate(icon, elementRoot, true).transform;
bgIconTransform.name = "bgIcon";
bgIconTransform.SetSiblingIndex(icon.transform.GetSiblingIndex());
}
bgIconTransform.gameObject.SetActive(true);
var bgIcon = bgIconTransform.GetComponent <Image>();
bgIcon.sprite = EpicLoot.GetMagicItemBgSprite();
bgIcon.color = item.m_itemData.GetRarityColor();
}
else if (bgIconTransform != null)
{
bgIconTransform.gameObject.SetActive(false);
}
}
}
private static int ComputeItemQuantity(int fromInventory, Piece.Requirement item, Player player)
{
Stopwatch delta;
GameObject pos = player.GetCurrentCraftingStation()?.gameObject;
if (!pos || !Configuration.Current.CraftFromChest.checkFromWorkbench)
{
pos = player.gameObject;
delta = Inventory_NearbyChests_Cache.delta;
}
else
{
delta = GameObjectAssistant.GetStopwatch(pos);
}
int lookupInterval = Helper.Clamp(Configuration.Current.CraftFromChest.lookupInterval, 1, 10) * 1000;
if (!delta.IsRunning || delta.ElapsedMilliseconds > lookupInterval)
{
Inventory_NearbyChests_Cache.chests = InventoryAssistant.GetNearbyChests(pos, Helper.Clamp(Configuration.Current.CraftFromChest.range, 1, 50), !Configuration.Current.CraftFromChest.ignorePrivateAreaCheck);
delta.Restart();
}
return(fromInventory + InventoryAssistant.GetItemAmountInItemList(InventoryAssistant.GetNearbyChestItemsByContainerList(Inventory_NearbyChests_Cache.chests), item.m_resItem.m_itemData));
}
static void Postfix(InventoryGui __instance, Transform elementRoot, Piece.Requirement req, Player player, bool craft, int quality)
{
if (!AllowByKey())
{
return;
}
Text component3 = elementRoot.transform.Find("res_amount").GetComponent <Text>();
if (req.m_resItem != null)
{
int invAmount = player.GetInventory().CountItems(req.m_resItem.m_itemData.m_shared.m_name);
int amount = req.GetAmount(quality);
if (amount <= 0)
{
return;
}
component3.text = amount.ToString();
if (invAmount < amount)
{
List <Container> nearbyContainers = GetNearbyContainers(Player.m_localPlayer.transform.position);
foreach (Container c in nearbyContainers)
{
invAmount += c.GetInventory().CountItems(req.m_resItem.m_itemData.m_shared.m_name);
}
if (invAmount >= amount)
{
component3.color = ((Mathf.Sin(Time.time * 10f) > 0f) ? flashColor.Value : unFlashColor.Value);
}
}
component3.text = string.Format(resourceString.Value, invAmount, component3.text);
}
}
private void CreateRecipe()
{
if (StaffPrefab == null || ObjectDB.instance.GetRecipe(StaffPrefab.GetComponent <ItemDrop>().m_itemData) != null)
{
return;
}
var recipe = ScriptableObject.CreateInstance <Recipe>();
recipe.name = "Staff";
recipe.m_item = StaffPrefab.GetComponent <ItemDrop>();
var woodDrop = ObjectDB.instance.GetItemPrefab("Wood").GetComponent <ItemDrop>();
var materials = new Piece.Requirement[] {
new Piece.Requirement()
{
m_resItem = woodDrop,
m_amount = 4
}
};
recipe.m_resources = materials;
recipe.m_minStationLevel = 1;
recipe.m_enabled = true;
var namedPrefabsInfo = ZNetScene.instance.GetType().GetField("m_namedPrefabs", BindingFlags.NonPublic | BindingFlags.Instance);
Dictionary <int, GameObject> namedPrefabs = (Dictionary <int, GameObject>)namedPrefabsInfo.GetValue(ZNetScene.instance);
recipe.m_repairStation = namedPrefabs["piece_workbench".GetStableHashCode()].GetComponent <CraftingStation>();
ObjectDB.instance.m_recipes.Add(recipe);
}
private static Recipe RepairRecipe(ItemDrop.ItemData item)
{
float percent = (item.GetMaxDurability() - item.m_durability) / item.GetMaxDurability();
Recipe fullRecipe = ObjectDB.instance.GetRecipe(item);
var fullReqs = fullRecipe.m_resources.ToList();
bool isMagic = false;
if (epicLootAssembly != null)
{
isMagic = (bool)epicLootAssembly.GetType("EpicLoot.ItemDataExtensions").GetMethod("IsMagic", BindingFlags.Public | BindingFlags.Static, null, new Type[] { typeof(ItemDrop.ItemData) }, null).Invoke(null, new[] { item });
}
if (isMagic)
{
int rarity = (int)epicLootAssembly.GetType("EpicLoot.ItemDataExtensions").GetMethod("GetRarity", BindingFlags.Public | BindingFlags.Static).Invoke(null, new[] { item });
List <KeyValuePair <ItemDrop, int> > magicReqs = (List <KeyValuePair <ItemDrop, int> >)epicLootAssembly.GetType("EpicLoot.Crafting.EnchantTabController").GetMethod("GetEnchantCosts", BindingFlags.Public | BindingFlags.Static).Invoke(null, new object[] { item, rarity });
foreach (var kvp in magicReqs)
{
fullReqs.Add(new Piece.Requirement()
{
m_amount = kvp.Value,
m_resItem = kvp.Key
});
}
}
List <Piece.Requirement> reqs = new List <Piece.Requirement>();
Recipe recipe = ScriptableObject.CreateInstance <Recipe>();
for (int i = 0; i < fullReqs.Count; i++)
{
var req = new Piece.Requirement()
{
m_resItem = fullReqs[i].m_resItem,
m_amountPerLevel = Mathf.FloorToInt(fullReqs[i].m_amountPerLevel * percent * materialRequirementMult.Value),
m_amount = Mathf.FloorToInt(fullReqs[i].m_amount * percent * materialRequirementMult.Value),
};
int amount = 0;
for (int j = item.m_quality; j > 0; j--)
{
amount += req.GetAmount(j);
}
if (amount > 0)
{
reqs.Add(req);
}
}
recipe.m_resources = reqs.ToArray();
if (!reqs.Any())
{
return(null);
}
return(recipe);
}
// Token: 0x0600051B RID: 1307 RVA: 0x0002AD30 File Offset: 0x00028F30
private void SetupPieceInfo(Piece piece)
{
if (piece == null)
{
this.m_buildSelection.text = Localization.instance.Localize("$hud_nothingtobuild");
this.m_pieceDescription.text = "";
this.m_buildIcon.enabled = false;
for (int i = 0; i < this.m_requirementItems.Length; i++)
{
this.m_requirementItems[i].SetActive(false);
}
return;
}
Player localPlayer = Player.m_localPlayer;
this.m_buildSelection.text = Localization.instance.Localize(piece.m_name);
this.m_pieceDescription.text = Localization.instance.Localize(piece.m_description);
this.m_buildIcon.enabled = true;
this.m_buildIcon.sprite = piece.m_icon;
for (int j = 0; j < this.m_requirementItems.Length; j++)
{
if (j < piece.m_resources.Length)
{
Piece.Requirement req = piece.m_resources[j];
this.m_requirementItems[j].SetActive(true);
InventoryGui.SetupRequirement(this.m_requirementItems[j].transform, req, localPlayer, false, 0);
}
else
{
this.m_requirementItems[j].SetActive(false);
}
}
if (piece.m_craftingStation)
{
CraftingStation craftingStation = CraftingStation.HaveBuildStationInRange(piece.m_craftingStation.m_name, localPlayer.transform.position);
GameObject gameObject = this.m_requirementItems[piece.m_resources.Length];
gameObject.SetActive(true);
Image component = gameObject.transform.Find("res_icon").GetComponent <Image>();
Text component2 = gameObject.transform.Find("res_name").GetComponent <Text>();
Text component3 = gameObject.transform.Find("res_amount").GetComponent <Text>();
UITooltip component4 = gameObject.GetComponent <UITooltip>();
component.sprite = piece.m_craftingStation.m_icon;
component2.text = Localization.instance.Localize(piece.m_craftingStation.m_name);
component4.m_text = piece.m_craftingStation.m_name;
if (craftingStation != null)
{
craftingStation.ShowAreaMarker();
component.color = Color.white;
component3.text = "";
component3.color = Color.white;
return;
}
component.color = Color.gray;
component3.text = "None";
component3.color = ((Mathf.Sin(Time.time * 10f) > 0f) ? Color.red : Color.white);
}
}
private static Recipe RepairRecipe(ItemDrop.ItemData item, bool log = false)
{
float percent = (item.GetMaxDurability() - item.m_durability) / item.GetMaxDurability();
Recipe fullRecipe = ObjectDB.instance.GetRecipe(item);
if (log)
{
Dbgl($"{Localization.instance.Localize(item.m_shared.m_name)}, quality {item.m_quality} is {percent * 10000 / 100}% broken");
}
Recipe recipe = ScriptableObject.CreateInstance <Recipe>();
List <Piece.Requirement> reqs = new List <Piece.Requirement>();
for (int i = 0; i < fullRecipe.m_resources.Length; i++)
{
var req = new Piece.Requirement()
{
m_resItem = fullRecipe.m_resources[i].m_resItem,
m_amountPerLevel = Mathf.FloorToInt(fullRecipe.m_resources[i].m_amountPerLevel * percent * materialRequirementMult.Value),
m_amount = Mathf.FloorToInt(fullRecipe.m_resources[i].m_amount * percent * materialRequirementMult.Value),
};
if (log)
{
Dbgl($"full required amounts of {Localization.instance.Localize(fullRecipe.m_resources[i].m_resItem.m_itemData.m_shared.m_name)}: {fullRecipe.m_resources[i].m_amount} {fullRecipe.m_resources[i].m_amountPerLevel}; repair amounts: {req.m_amount} {req.m_amountPerLevel}");
}
int amount = 0;
for (int j = item.m_quality; j > 0; j--)
{
amount += req.GetAmount(j);
}
if (amount > 0)
{
if (log)
{
Dbgl($"required amount of {Localization.instance.Localize(fullRecipe.m_resources[i].m_resItem.m_itemData.m_shared.m_name)} is {amount}");
}
reqs.Add(req);
}
}
recipe.m_resources = reqs.ToArray();
if (!reqs.Any())
{
if (log)
{
Dbgl($"no resources required");
}
return(null);
}
return(recipe);
}
/// <summary>
/// Converts the <see cref="RequirementConfig">RequirementConfigs</see> to Valheim style <see cref="Piece.Requirement"/> array.
/// </summary>
/// <returns>The Valheim <see cref="Piece.Requirement"/> array</returns>
public Piece.Requirement[] GetRequirements()
{
Piece.Requirement[] reqs = new Piece.Requirement[Requirements.Length];
for (int i = 0; i < reqs.Length; i++)
{
reqs[i] = Requirements[i].GetRequirement();
}
return(reqs);
}
public static Recipe BuildRecipe(RecipeStub rs, ObjectDB odb)
{
var recipe = ScriptableObject.CreateInstance <Recipe>();
recipe.m_item = rs.Item;
recipe.m_craftingStation = odb.GetItemPrefab(rs.CraftingStation)?.GetComponentInChildren <CraftingStation>(true);
if (recipe.m_craftingStation == null)
{
recipe.m_craftingStation = ZNetScene.instance?.GetPrefab(rs.CraftingStation)?.GetComponentInChildren <CraftingStation>(true);
if (recipe.m_craftingStation == null)
{
Plugin.Log.LogInfo("BuildRecipe couldn't find crafting station " + rs.CraftingStation + " for " + rs.Name);
return(null);
}
}
if (!string.IsNullOrWhiteSpace(rs.RepairStation))
{
recipe.m_repairStation = odb.GetItemPrefab(rs.RepairStation)?.GetComponentInChildren <CraftingStation>(true);
if (recipe.m_repairStation == null)
{
recipe.m_repairStation = ZNetScene.instance?.GetPrefab(rs.RepairStation)?.GetComponentInChildren <CraftingStation>(true);
if (recipe.m_repairStation == null)
{
Plugin.Log.LogInfo("BuildRecipe couldn't find declared repair station " + rs.RepairStation + " for " + rs.Name);
return(null);
}
}
if (recipe.m_repairStation == null)
{
return(null);
}
}
recipe.m_minStationLevel = Mathf.Max(1, rs.MinStationLevel);
List <Piece.Requirement> reqs = new List <Piece.Requirement>();
foreach (RecipeStub.RequirementStub r in rs.Requirements)
{
ItemDrop id = odb.GetItemPrefab(r.Component)?.GetComponentInChildren <ItemDrop>(true);
if (!id)
{
Plugin.Log.LogInfo("BuildRecipe couldn't get requirement component " + r.Component + " for " + rs.Name);
return(null);
}
Piece.Requirement pr = new Piece.Requirement();
pr.m_resItem = id;
pr.m_amount = r.Amount;
pr.m_amountPerLevel = r.AmountPerLevel;
pr.m_recover = r.Recoverable;
reqs.Add(pr);
}
recipe.m_resources = reqs.ToArray();
return(recipe);
}
public static Piece.Requirement Create(string name, int amount = 1, bool recover = true)
{
var requirement = new Piece.Requirement
{
m_recover = recover,
m_amount = amount
};
requirement.m_resItem = Mock <ItemDrop> .Create(name);
return(requirement);
}
public static Piece.Requirement[] CreateArray(Dictionary <string, int> requirements, bool recover = true)
{
List <Piece.Requirement> list = new List <Piece.Requirement>();
foreach (KeyValuePair <string, int> requirement in requirements)
{
Piece.Requirement piece = Create(requirement.Key, requirement.Value, recover);
piece.FixReferences();
list.Add(piece);
}
return(list.ToArray());
}
public static void AddPieceToTool()
{
Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "com.rolopogo.Basement");
MaterialReplacer.GetAllMaterials();
// Load from assetbundle
var bundle = AssetBundle.LoadFromMemory(ResourceUtils.GetResource(Assembly.GetExecutingAssembly(), "Basement.Resources.basement"));
basementPrefab = bundle.LoadAsset <GameObject>("Basement");
basementPrefab.AddComponent <Basement>();
bundle.Unload(false);
Plugin.basementPrefab.name = "basement.basementprefab";
// update material references
MaterialReplacer.ReplaceAllMaterialsWithOriginal(basementPrefab);
var woodRequirement = MockRequirement.Create("Wood", 100, true);
woodRequirement.FixReferences();
var stoneRequirement = MockRequirement.Create("Stone", 100, true);
stoneRequirement.FixReferences();
var customRequirements = new Piece.Requirement[]
{
woodRequirement,
stoneRequirement
};
var piece = basementPrefab.GetComponent <Piece>();
piece.m_resources = customRequirements;
piece.m_category = Piece.PieceCategory.Misc;
piece.m_craftingStation = Mock <CraftingStation> .Create("piece_stonecutter");
piece.m_clipEverything = true;
// Add spawn effect
piece.m_placeEffect = Prefab.Cache.GetPrefab <GameObject>("piece_stonecutter").GetComponent <Piece>().m_placeEffect;
piece.FixReferences();
Prefab.NetworkRegister(basementPrefab);
// Add to tool
var hammerPrefab = Prefab.Cache.GetPrefab <GameObject>("Hammer");
var hammerPieceTable = hammerPrefab.GetComponent <ItemDrop>().m_itemData.m_shared.m_buildPieces;
hammerPieceTable.m_pieces.Add(basementPrefab.gameObject);
}
private void SetupPieceInfo(Piece piece)
{
Player localPlayer = Player.m_localPlayer;
Hud.instance.m_buildSelection.text = Localization.instance.Localize(piece.m_name);
Hud.instance.m_pieceDescription.text = Localization.instance.Localize(piece.m_description);
Hud.instance.m_buildIcon.enabled = true;
Hud.instance.m_buildIcon.sprite = piece.m_icon;
GameObject[] uiRequirementPanels = Hud.instance.m_requirementItems;
for (int j = 0; j < uiRequirementPanels.Length; j++)
{
if (j < piece.m_resources.Length)
{
Piece.Requirement req = piece.m_resources[j];
uiRequirementPanels[j].SetActive(value: true);
SetupRequirement(uiRequirementPanels[j].transform, req, GetResourceCount(GetResourceName(req)));
}
else
{
uiRequirementPanels[j].SetActive(value: false);
}
}
if ((bool)piece.m_craftingStation)
{
CraftingStation craftingStation = CraftingStation.HaveBuildStationInRange(piece.m_craftingStation.m_name, localPlayer.transform.position);
GameObject obj = uiRequirementPanels[piece.m_resources.Length];
obj.SetActive(value: true);
Image component = obj.transform.Find("res_icon").GetComponent <Image>();
Text component2 = obj.transform.Find("res_name").GetComponent <Text>();
Text component3 = obj.transform.Find("res_amount").GetComponent <Text>();
UITooltip component4 = obj.GetComponent <UITooltip>();
component.sprite = piece.m_craftingStation.m_icon;
component2.text = Localization.instance.Localize(piece.m_craftingStation.m_name);
component4.m_text = piece.m_craftingStation.m_name;
if (craftingStation != null)
{
craftingStation.ShowAreaMarker();
component.color = Color.white;
component3.text = "";
component3.color = Color.white;
}
else
{
component.color = Color.gray;
component3.text = "None";
component3.color = ((Mathf.Sin(Time.time * 10f) > 0f) ? Color.red : Color.white);
}
}
}
public static void ScanCultivator()
{
if (scanningCultivator)
{
return;
}
scanningCultivator = true;
foreach (PieceTable table in Resources.FindObjectsOfTypeAll(typeof(PieceTable)))
{
string name = table.gameObject.name;
if (name.Equals("_CultivatorPieceTable"))
{
foreach (GameObject cultivatorRecipe in table.m_pieces)
{
Piece piece = cultivatorRecipe.GetComponent <Piece>();
Plant plant = piece.GetComponent <Plant>();
if (plant)
{
Piece.Requirement[] requirements = piece.m_resources;
if (requirements.Length > 1)
{
logger.LogWarning(" Multiple seeds required for " + plant.m_name + "? Skipping");
continue;
}
Piece.Requirement requirement = requirements[0];
ItemDrop itemData = requirement.m_resItem;
if (!seedPrefabMap.ContainsKey(itemData.m_itemData.m_shared.m_name))
{
logger.LogDebug("Looking for Prefab of " + itemData.m_itemData.m_shared.m_name + " -> " + itemData.gameObject.name);
ItemConversion conversion = new ItemConversion
{
seedDrop = requirement.m_resItem,
plantPiece = piece,
plant = plant
};
logger.LogDebug("Registering seed type: " + conversion);
seedPrefabMap.Add(itemData.m_itemData.m_shared.m_name, conversion);
}
}
}
}
}
scanningCultivator = false;
}
public static void Postfix(Transform elementRoot, Piece.Requirement req, Player player, int quality)
{
var amountText = elementRoot.transform.Find("res_amount").GetComponent <Text>();
if (req.m_resItem != null)
{
if (!player.HaveRequirements(new [] { req }, false, quality))
{
amountText.color = Mathf.Sin(Time.time * 10f) > 0.0 ? Color.red : Color.white;
}
else
{
amountText.color = Color.white;
}
}
}
private static bool Prefix(Transform elementRoot, Piece.Requirement req, Player player, bool craft, int quality, ref bool __result)
{
Image component = elementRoot.transform.Find("res_icon").GetComponent <Image>();
Text component2 = elementRoot.transform.Find("res_name").GetComponent <Text>();
Text component3 = elementRoot.transform.Find("res_amount").GetComponent <Text>();
UITooltip component4 = elementRoot.GetComponent <UITooltip>();
if (req.m_resItem != null)
{
component.gameObject.SetActive(true);
component2.gameObject.SetActive(true);
component3.gameObject.SetActive(true);
component.sprite = req.m_resItem.m_itemData.GetIcon();
component.color = Color.white;
component4.m_text = Localization.instance.Localize(req.m_resItem.m_itemData.m_shared.m_name);
component2.text = Localization.instance.Localize(req.m_resItem.m_itemData.m_shared.m_name);
int num = player.GetInventory().CountItems(req.m_resItem.m_itemData.m_shared.m_name);
int amount = req.GetAmount(quality);
if (amount <= 0)
{
InventoryGui.HideRequirement(elementRoot);
__result = false;
return(false);
}
component3.text = num + "/" + amount.ToString();
if (num < amount)
{
component3.color = ((Mathf.Sin(Time.time * 10f) > 0f) ? Color.red : Color.white);
}
else
{
component3.color = Color.white;
}
component3.fontSize = 14;
if (component3.text.Length > 5)
{
component3.fontSize -= component3.text.Length - 5;
}
}
__result = true;
return(false);
}
static bool Prefix(ref bool __result, Transform elementRoot, Piece.Requirement req, Player player, bool craft, int quality)
{
Image icon = elementRoot.transform.Find("res_icon").GetComponent <Image>();
Text nameText = elementRoot.transform.Find("res_name").GetComponent <Text>();
Text amountText = elementRoot.transform.Find("res_amount").GetComponent <Text>();
UITooltip tooltip = elementRoot.GetComponent <UITooltip>();
if (req.m_resItem != null)
{
icon.gameObject.SetActive(true);
nameText.gameObject.SetActive(true);
amountText.gameObject.SetActive(true);
icon.sprite = req.m_resItem.m_itemData.GetIcon();
icon.color = Color.white;
tooltip.m_text = Localization.instance.Localize(req.m_resItem.m_itemData.m_shared.m_name);
nameText.text = Localization.instance.Localize(req.m_resItem.m_itemData.m_shared.m_name);
int num = ImprovedBuildHud.GetAvailableItems(req.m_resItem.m_itemData.m_shared.m_name);
int amount = req.GetAmount(quality);
if (amount <= 0)
{
InventoryGui.HideRequirement(elementRoot);
__result = false;
return(false);
}
amountText.supportRichText = true;
amountText.horizontalOverflow = HorizontalWrapMode.Overflow;
var inventoryAmount = string.Format(ImprovedBuildHudConfig.InventoryAmountFormat.Value, num);
if (!string.IsNullOrEmpty(ImprovedBuildHudConfig.InventoryAmountColor.Value))
{
inventoryAmount = $"<color={ImprovedBuildHudConfig.InventoryAmountColor.Value}>{inventoryAmount}</color>";
}
amountText.text = $"{amount} {inventoryAmount}";
if (num < amount)
{
amountText.color = (double)Mathf.Sin(Time.time * 10f) > 0.0 ? Color.red : Color.white;
}
else
{
amountText.color = Color.white;
}
}
__result = true;
return(false);
}
private static int CalculateFinalAmount(ItemDrop.ItemData itemData, Piece.Requirement resource,
double amountToCraftedRecipeAmountPercentage, float recyclingRate)
{
var amount = Enumerable.Range(1, itemData.m_quality)
.Select(level => resource.GetAmount(level))
.Sum();
var stackCompensated = amount * amountToCraftedRecipeAmountPercentage;
var realAmount = Math.Floor(stackCompensated * recyclingRate);
var finalAmount = (int)realAmount;
if (realAmount < 1 && itemData.m_shared.m_maxStackSize == 1 &&
Plugin.Settings.UnstackableItemsAlwaysReturnAtLeastOneResource.Value)
{
finalAmount = 1;
}
Plugin.Log.LogDebug("Calculations report.\n" +
$" = = = Input: REA:{resource.m_amount} IQ:{itemData.m_quality} STK:{itemData.m_stack}({itemData.m_shared.m_maxStackSize}) SC:{stackCompensated} ATCRAP:{amountToCraftedRecipeAmountPercentage} A:{amount}, RA:{realAmount}: FA:{finalAmount}");
return(finalAmount);
}
private static void RemoveItemsFromInventoryAndNearbyChests(Player player, Piece.Requirement item, int amount)
{
GameObject pos = player.GetCurrentCraftingStation()?.gameObject;
if (!pos || !Configuration.Current.CraftFromChest.checkFromWorkbench)
{
pos = player.gameObject;
}
int inventoryAmount = player.m_inventory.CountItems(item.m_resItem.m_itemData.m_shared.m_name);
player.m_inventory.RemoveItem(item.m_resItem.m_itemData.m_shared.m_name, amount);
amount -= inventoryAmount;
if (amount <= 0)
{
return;
}
InventoryAssistant.RemoveItemInAmountFromAllNearbyChests(pos, Helper.Clamp(Configuration.Current.CraftFromChest.range, 1, 50), item.m_resItem.m_itemData, amount, !Configuration.Current.CraftFromChest.ignorePrivateAreaCheck);
}
public bool SetupRequirement(Transform elementRoot, Piece.Requirement req, int currentAmount)
{
Image imageResIcon = elementRoot.transform.Find("res_icon").GetComponent <Image>();
Text textResName = elementRoot.transform.Find("res_name").GetComponent <Text>();
Text textResAmount = elementRoot.transform.Find("res_amount").GetComponent <Text>();
UITooltip uiTooltip = elementRoot.GetComponent <UITooltip>();
if (req.m_resItem != null)
{
imageResIcon.gameObject.SetActive(value: true);
textResName.gameObject.SetActive(value: true);
textResAmount.gameObject.SetActive(value: true);
imageResIcon.sprite = req.m_resItem.m_itemData.GetIcon();
imageResIcon.color = Color.white;
uiTooltip.m_text = Localization.instance.Localize(req.m_resItem.m_itemData.m_shared.m_name);
textResName.text = Localization.instance.Localize(req.m_resItem.m_itemData.m_shared.m_name);
int requiredAmount = req.GetAmount(0);
int playerAmount = PlayerGetResourceCount(Player.m_localPlayer, req.m_resItem.m_itemData.m_shared.m_name);
int remaining = requiredAmount - currentAmount;
textResAmount.text = currentAmount + "/" + requiredAmount;
if (remaining > 0 && playerAmount == 0)
{
imageResIcon.color = Color.gray;
textResAmount.color = ((Mathf.Sin(Time.time * 10f) > 0f) ? Color.red : Color.white);
}
else
{
imageResIcon.color = Color.white;
textResAmount.color = Color.white;
}
}
return(true);
}
public Recipe GetRecipe()
{
Piece.Requirement[] reqs = new Piece.Requirement[Requirements.Length];
for (int i = 0; i < reqs.Length; i++)
{
reqs[i] = Requirements[i].GetPieceRequirement();
}
Recipe recipe = ScriptableObject.CreateInstance <Recipe>();
GameObject itemPrefab = PrefabManager.Instance.GetPrefab(Item);
if (itemPrefab == null)
{
Debug.LogError("Error, recipe contained null item prefab for item: " + Item);
return(null);
}
if (string.IsNullOrEmpty(Name))
{
Name = "Recipe_" + Item;
}
recipe.name = Name;
recipe.m_item = itemPrefab.GetComponent <ItemDrop>();
recipe.m_amount = Amount;
recipe.m_enabled = Enabled;
if (CraftingStation != null)
{
GameObject craftingStationPrefab = PrefabManager.Instance.GetPrefab(CraftingStation);
CraftingStation craftingStation = craftingStationPrefab.GetComponent <CraftingStation>();
if (craftingStationPrefab == null || craftingStation == null)
{
Debug.LogError("Crafting station is not valid: " + CraftingStation);
return(null);
}
recipe.m_craftingStation = craftingStation;
}
if (RepairStation != null)
{
GameObject repairStationPrefab = PrefabManager.Instance.GetPrefab(RepairStation);
CraftingStation repairStation = repairStationPrefab.GetComponent <CraftingStation>();
if (repairStationPrefab == null || repairStation == null)
{
Debug.LogError("Repair station is not valid: " + RepairStation);
return(null);
}
recipe.m_craftingStation = repairStation;
}
recipe.m_minStationLevel = MinStationLevel;
recipe.m_resources = reqs;
return(recipe);
}
private static string GetResourceName(Piece.Requirement req)
{
return(req.m_resItem.m_itemData.m_shared.m_name);
}
public static void Postfix()
{
return;
foreach (KeyValuePair <string, CustomItem> kvp in customItems)
{
CustomItem item = kvp.Value;
GameObject customObject = Instantiate(ObjectDB.instance.GetItemPrefab(item.baseItemName));
ItemDrop itemDrop = customObject.GetComponent <ItemDrop>();
Recipe recipe = ObjectDB.instance.GetRecipe(itemDrop.m_itemData);
customObject.name = item.id;
itemDrop.m_itemData.m_shared.m_name = item.name;
itemDrop.m_itemData.m_shared.m_dlc = item.dlc;
itemDrop.m_itemData.m_shared.m_itemType = item.itemType;
itemDrop.m_itemData.m_shared.m_attachOverride = item.attachOverride;
itemDrop.m_itemData.m_shared.m_description = item.description;
itemDrop.m_itemData.m_shared.m_maxStackSize = item.maxStackSize;
itemDrop.m_itemData.m_shared.m_maxQuality = item.maxQuality;
itemDrop.m_itemData.m_shared.m_weight = item.weight;
itemDrop.m_itemData.m_shared.m_value = item.value;
itemDrop.m_itemData.m_shared.m_teleportable = item.teleportable;
itemDrop.m_itemData.m_shared.m_questItem = item.questItem;
itemDrop.m_itemData.m_shared.m_equipDuration = item.equipDuration;
itemDrop.m_itemData.m_shared.m_variants = item.variants;
itemDrop.m_itemData.m_shared.m_trophyPos = item.trophyPos;
itemDrop.m_itemData.m_shared.m_buildPieces = item.buildPieces;
itemDrop.m_itemData.m_shared.m_centerCamera = item.centerCamera;
itemDrop.m_itemData.m_shared.m_setName = item.setName;
itemDrop.m_itemData.m_shared.m_setSize = item.setSize;
itemDrop.m_itemData.m_shared.m_setStatusEffect = item.setStatusEffect;
itemDrop.m_itemData.m_shared.m_equipStatusEffect = item.equipStatusEffect;
itemDrop.m_itemData.m_shared.m_movementModifier = item.movementModifier;
itemDrop.m_itemData.m_shared.m_food = item.food;
itemDrop.m_itemData.m_shared.m_foodStamina = item.foodStamina;
itemDrop.m_itemData.m_shared.m_foodBurnTime = item.foodBurnTime;
itemDrop.m_itemData.m_shared.m_foodRegen = item.foodRegen;
itemDrop.m_itemData.m_shared.m_foodColor = item.foodColor;
itemDrop.m_itemData.m_shared.m_armorMaterial = item.armorMaterial;
itemDrop.m_itemData.m_shared.m_helmetHideHair = item.helmetHideHair;
itemDrop.m_itemData.m_shared.m_armor = item.armor;
itemDrop.m_itemData.m_shared.m_armorPerLevel = item.armorPerLevel;
itemDrop.m_itemData.m_shared.m_damageModifiers = item.damageModifiers;
itemDrop.m_itemData.m_shared.m_blockPower = item.blockPower;
itemDrop.m_itemData.m_shared.m_blockPowerPerLevel = item.blockPowerPerLevel;
itemDrop.m_itemData.m_shared.m_deflectionForce = item.deflectionForce;
itemDrop.m_itemData.m_shared.m_deflectionForcePerLevel = item.deflectionForcePerLevel;
itemDrop.m_itemData.m_shared.m_timedBlockBonus = item.timedBlockBonus;
itemDrop.m_itemData.m_shared.m_animationState = item.animationState;
itemDrop.m_itemData.m_shared.m_skillType = item.skillType;
itemDrop.m_itemData.m_shared.m_toolTier = item.toolTier;
itemDrop.m_itemData.m_shared.m_damages = item.damages;
itemDrop.m_itemData.m_shared.m_damagesPerLevel = item.damagesPerLevel;
itemDrop.m_itemData.m_shared.m_attackForce = item.attackForce;
itemDrop.m_itemData.m_shared.m_backstabBonus = item.backstabBonus;
itemDrop.m_itemData.m_shared.m_dodgeable = item.dodgeable;
itemDrop.m_itemData.m_shared.m_blockable = item.blockable;
itemDrop.m_itemData.m_shared.m_attackStatusEffect = item.attackStatusEffect;
itemDrop.m_itemData.m_shared.m_spawnOnHit = item.spawnOnHit;
itemDrop.m_itemData.m_shared.m_spawnOnHitTerrain = item.spawnOnHitTerrain;
itemDrop.m_itemData.m_shared.m_attack = item.attack;
itemDrop.m_itemData.m_shared.m_secondaryAttack = item.secondaryAttack;
itemDrop.m_itemData.m_shared.m_useDurability = item.useDurability;
itemDrop.m_itemData.m_shared.m_destroyBroken = item.destroyBroken;
itemDrop.m_itemData.m_shared.m_canBeReparied = item.canBeReparied;
itemDrop.m_itemData.m_shared.m_maxDurability = item.maxDurability;
itemDrop.m_itemData.m_shared.m_durabilityPerLevel = item.durabilityPerLevel;
itemDrop.m_itemData.m_shared.m_useDurabilityDrain = item.useDurabilityDrain;
itemDrop.m_itemData.m_shared.m_durabilityDrain = item.durabilityDrain;
itemDrop.m_itemData.m_shared.m_holdDurationMin = item.holdDurationMin;
itemDrop.m_itemData.m_shared.m_holdStaminaDrain = item.holdStaminaDrain;
itemDrop.m_itemData.m_shared.m_holdAnimationState = item.holdAnimationState;
itemDrop.m_itemData.m_shared.m_ammoType = item.ammoType;
itemDrop.m_itemData.m_shared.m_aiAttackRange = item.aiAttackRange;
itemDrop.m_itemData.m_shared.m_aiAttackRangeMin = item.aiAttackRangeMin;
itemDrop.m_itemData.m_shared.m_aiAttackInterval = item.aiAttackInterval;
itemDrop.m_itemData.m_shared.m_aiAttackMaxAngle = item.aiAttackMaxAngle;
itemDrop.m_itemData.m_shared.m_aiWhenFlying = item.aiWhenFlying;
itemDrop.m_itemData.m_shared.m_aiWhenWalking = item.aiWhenWalking;
itemDrop.m_itemData.m_shared.m_aiWhenSwiming = item.aiWhenSwiming;
itemDrop.m_itemData.m_shared.m_aiPrioritized = item.aiPrioritized;
itemDrop.m_itemData.m_shared.m_aiTargetType = item.aiTargetType;
itemDrop.m_itemData.m_shared.m_hitEffect = item.hitEffect;
itemDrop.m_itemData.m_shared.m_hitTerrainEffect = item.hitTerrainEffect;
itemDrop.m_itemData.m_shared.m_blockEffect = item.blockEffect;
itemDrop.m_itemData.m_shared.m_startEffect = item.startEffect;
itemDrop.m_itemData.m_shared.m_holdStartEffect = item.holdStartEffect;
itemDrop.m_itemData.m_shared.m_triggerEffect = item.triggerEffect;
itemDrop.m_itemData.m_shared.m_trailStartEffect = item.trailStartEffect;
itemDrop.m_itemData.m_shared.m_consumeStatusEffect = item.consumeStatusEffect;
recipe.m_item = itemDrop;
recipe.m_amount = item.recipe_amount;
recipe.m_minStationLevel = item.minStationLevel;
List <Piece.Requirement> reqs = new List <Piece.Requirement>();
foreach (RequirementData rd in item.requirements)
{
Piece.Requirement req = new Piece.Requirement();
req.m_amount = rd.amount;
req.m_amountPerLevel = rd.amountPerLevel;
req.m_recover = rd.recover;
req.m_resItem = ObjectDB.instance.GetItemPrefab(rd.name).GetComponent <ItemDrop>();
reqs.Add(req);
}
recipe.m_resources = reqs.ToArray();
if (ObjectDB.instance.GetItemPrefab(customObject.name) == null)
{
Dbgl($"Adding new item {customObject.name} to DB");
ObjectDB.instance.m_items.Add(customObject);
((Dictionary <int, GameObject>) typeof(ObjectDB).GetField("m_itemByHash", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(ObjectDB.instance)).Add(customObject.name.GetStableHashCode(), customObject);
}
if (ObjectDB.instance.GetRecipe(itemDrop.m_itemData) == null)
{
Dbgl($"Adding new recipe {customObject.name} to DB");
ObjectDB.instance.m_recipes.Add(recipe);
}
Traverse.Create(Localization.instance).Method("AddWord", new object[] { item.description_key, item.description });
}
}
private static bool Prefix(Transform elementRoot, Piece.Requirement req, Player player, bool craft, int quality, ref bool __result)
{
if (!Configuration.Current.Hud.IsEnabled && !Configuration.Current.CraftFromChest.IsEnabled || !Configuration.Current.Hud.showRequiredItems && !Configuration.Current.CraftFromChest.IsEnabled)
{
return(true);
}
Image component = elementRoot.transform.Find("res_icon").GetComponent <Image>();
Text component2 = elementRoot.transform.Find("res_name").GetComponent <Text>();
Text component3 = elementRoot.transform.Find("res_amount").GetComponent <Text>();
UITooltip component4 = elementRoot.GetComponent <UITooltip>();
if (req.m_resItem != null)
{
component.gameObject.SetActive(true);
component2.gameObject.SetActive(true);
component3.gameObject.SetActive(true);
component.sprite = req.m_resItem.m_itemData.GetIcon();
component.color = Color.white;
component4.m_text = Localization.instance.Localize(req.m_resItem.m_itemData.m_shared.m_name);
component2.text = Localization.instance.Localize(req.m_resItem.m_itemData.m_shared.m_name);
int num = player.GetInventory().CountItems(req.m_resItem.m_itemData.m_shared.m_name);
int amount = req.GetAmount(quality);
if (amount <= 0)
{
InventoryGui.HideRequirement(elementRoot);
__result = false;
return(false);
}
if (Configuration.Current.CraftFromChest.IsEnabled)
{
Stopwatch delta;
GameObject pos = player.GetCurrentCraftingStation()?.gameObject;
if (!pos || !Configuration.Current.CraftFromChest.checkFromWorkbench)
{
pos = player.gameObject;
delta = Inventory_NearbyChests_Cache.delta;
}
else
{
delta = GameObjectAssistant.GetStopwatch(pos);
}
int lookupInterval = Helper.Clamp(Configuration.Current.CraftFromChest.lookupInterval, 1, 10) * 1000;
if (!delta.IsRunning || delta.ElapsedMilliseconds > lookupInterval)
{
Inventory_NearbyChests_Cache.chests = InventoryAssistant.GetNearbyChests(pos, Helper.Clamp(Configuration.Current.CraftFromChest.range, 1, 50));
delta.Restart();
}
num += InventoryAssistant.GetItemAmountInItemList(InventoryAssistant.GetNearbyChestItemsByContainerList(Inventory_NearbyChests_Cache.chests), req.m_resItem.m_itemData);
}
component3.text = num + "/" + amount.ToString();
if (num < amount)
{
component3.color = ((Mathf.Sin(Time.time * 10f) > 0f) ? Color.red : Color.white);
}
else
{
component3.color = Color.white;
}
component3.fontSize = 14;
if (component3.text.Length > 5)
{
component3.fontSize -= component3.text.Length - 5;
}
}
__result = true;
return(false);
}
private static GameObject GetCustomGameObject(string name, bool ready = false)
{
CustomItem customItem = customItems[name];
GameObject baseObject = ObjectDB.instance.GetItemPrefab(customItem.baseItemName);
GameObject customObject;
ItemDrop itemDrop;
creatingObject = true;
if (ready)
{
customObject = Instantiate(baseObject);
itemDrop = customObject.GetComponent <ItemDrop>();
}
else
{
customObject = new GameObject(name);
itemDrop = customObject.AddComponent <ItemDrop>();
customObject.AddComponent(baseObject.GetComponent <ZNetView>());
if (baseObject.transform.Find("attach"))
{
Dbgl($"Has attach");
Instantiate(baseObject.transform.Find("attach"), customObject.transform);
}
else if (baseObject.transform.Find("model"))
{
Dbgl($"Has model");
Instantiate(baseObject.transform.Find("model"), customObject.transform);
}
}
creatingObject = false;
ItemDrop baseItemDrop = baseObject.GetComponent <ItemDrop>();
customObject.name = name;
customObject.name = ZNetView.GetPrefabName(customObject);
objectsToAdd[customObject.name] = customObject;
customObject.AddComponent <DontDestroy>();
customItems[name].gameObject = customObject;
DontDestroyOnLoad(customItems[name].gameObject);
Dbgl($"baseitemdrop {baseItemDrop?.name} data {baseItemDrop.m_itemData.m_shared.m_name} customObject {customObject?.name}");
GameObject prefab = Instantiate(objectsToAdd[customObject.name]);
DontDestroyOnLoad(prefab);
itemDrop.m_itemData = baseItemDrop.m_itemData.Clone();
itemDrop.m_itemData.m_dropPrefab = prefab;
itemDrop.enabled = true;
Dbgl($"itemdrop {itemDrop.m_itemData.m_dropPrefab.name} data {itemDrop.m_itemData.m_shared.m_name} gameobject {itemDrop.gameObject.name}");
itemDrop.m_itemData.m_shared = new ItemDrop.ItemData.SharedData
{
m_name = "$" + customItem.name_key,
m_dlc = customItem.dlc,
m_itemType = customItem.itemType,
m_attachOverride = customItem.attachOverride,
m_description = "$" + customItem.description_key,
m_maxStackSize = customItem.maxStackSize,
m_maxQuality = customItem.maxQuality,
m_weight = customItem.weight,
m_value = customItem.value,
m_teleportable = customItem.teleportable,
m_questItem = customItem.questItem,
m_equipDuration = customItem.equipDuration,
m_variants = customItem.variants,
m_trophyPos = customItem.trophyPos,
m_buildPieces = customItem.buildPieces,
m_centerCamera = customItem.centerCamera,
m_setName = customItem.setName,
m_setSize = customItem.setSize,
m_setStatusEffect = customItem.setStatusEffect,
m_equipStatusEffect = customItem.equipStatusEffect,
m_movementModifier = customItem.movementModifier,
m_food = customItem.food,
m_foodStamina = customItem.foodStamina,
m_foodBurnTime = customItem.foodBurnTime,
m_foodRegen = customItem.foodRegen,
m_foodColor = customItem.foodColor,
m_armorMaterial = customItem.armorMaterial,
m_helmetHideHair = customItem.helmetHideHair,
m_armor = customItem.armor,
m_armorPerLevel = customItem.armorPerLevel,
m_damageModifiers = customItem.damageModifiers,
m_blockPower = customItem.blockPower,
m_blockPowerPerLevel = customItem.blockPowerPerLevel,
m_deflectionForce = customItem.deflectionForce,
m_deflectionForcePerLevel = customItem.deflectionForcePerLevel,
m_timedBlockBonus = customItem.timedBlockBonus,
m_animationState = customItem.animationState,
m_skillType = customItem.skillType,
m_toolTier = customItem.toolTier,
m_damages = customItem.damages,
m_damagesPerLevel = customItem.damagesPerLevel,
m_attackForce = customItem.attackForce,
m_backstabBonus = customItem.backstabBonus,
m_dodgeable = customItem.dodgeable,
m_blockable = customItem.blockable,
m_attackStatusEffect = customItem.attackStatusEffect,
m_spawnOnHit = customItem.spawnOnHit,
m_spawnOnHitTerrain = customItem.spawnOnHitTerrain,
m_attack = customItem.attack,
m_secondaryAttack = customItem.secondaryAttack,
m_useDurability = customItem.useDurability,
m_destroyBroken = customItem.destroyBroken,
m_canBeReparied = customItem.canBeReparied,
m_maxDurability = customItem.maxDurability,
m_durabilityPerLevel = customItem.durabilityPerLevel,
m_useDurabilityDrain = customItem.useDurabilityDrain,
m_durabilityDrain = customItem.durabilityDrain,
m_holdDurationMin = customItem.holdDurationMin,
m_holdStaminaDrain = customItem.holdStaminaDrain,
m_holdAnimationState = customItem.holdAnimationState,
m_ammoType = customItem.ammoType,
m_aiAttackRange = customItem.aiAttackRange,
m_aiAttackRangeMin = customItem.aiAttackRangeMin,
m_aiAttackInterval = customItem.aiAttackInterval,
m_aiAttackMaxAngle = customItem.aiAttackMaxAngle,
m_aiWhenFlying = customItem.aiWhenFlying,
m_aiWhenWalking = customItem.aiWhenWalking,
m_aiWhenSwiming = customItem.aiWhenSwiming,
m_aiPrioritized = customItem.aiPrioritized,
m_aiTargetType = customItem.aiTargetType,
m_hitEffect = customItem.hitEffect,
m_hitTerrainEffect = customItem.hitTerrainEffect,
m_blockEffect = customItem.blockEffect,
m_startEffect = customItem.startEffect,
m_holdStartEffect = customItem.holdStartEffect,
m_triggerEffect = customItem.triggerEffect,
m_trailStartEffect = customItem.trailStartEffect,
m_consumeStatusEffect = customItem.consumeStatusEffect,
m_icons = baseItemDrop.m_itemData.m_shared.m_icons
};
Recipe origRecipe = ObjectDB.instance.GetRecipe(baseItemDrop.m_itemData);
Recipe recipe = (Recipe)ScriptableObject.CreateInstance("Recipe");
recipe.m_item = itemDrop;
recipe.m_amount = customItem.recipe_amount;
recipe.m_minStationLevel = customItem.minStationLevel;
recipe.m_craftingStation = origRecipe.m_craftingStation;
recipe.m_repairStation = origRecipe.m_repairStation;
//Dbgl($"custom reqs {customItem.requirements.Count}");
List <Piece.Requirement> reqs = new List <Piece.Requirement>();
foreach (string str in customItem.requirements)
{
RequirementData rd = MakeReqData(str);
if (rd == null)
{
continue;
}
Piece.Requirement req = new Piece.Requirement
{
m_amount = rd.amount,
m_amountPerLevel = rd.amountPerLevel,
m_recover = rd.recover,
m_resItem = ObjectDB.instance.GetItemPrefab(rd.name)?.GetComponent <ItemDrop>()
};
// Dbgl($"adding rd {req.m_resItem?.m_itemData?.m_shared?.m_name}");
reqs.Add(req);
}
recipe.m_resources = reqs.ToArray();
if (ObjectDB.instance.GetItemPrefab(customObject.name) == null)
{
Dbgl($"Adding item {customObject.name} to DB");
ObjectDB.instance.m_items.Add(objectsToAdd[customObject.name]);
((Dictionary <int, GameObject>) typeof(ObjectDB).GetField("m_itemByHash", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(ObjectDB.instance)).Add(customObject.name.GetStableHashCode(), objectsToAdd[customObject.name]);
Dbgl($"Added new item {ObjectDB.instance.GetItemPrefab(customObject.name).name} to DB");
}
if (ObjectDB.instance.GetRecipe(itemDrop.m_itemData) == null)
{
Dbgl($"Adding recipe {customObject.name} to DB");
ObjectDB.instance.m_recipes.Add(recipe);
}
return(customObject);
}
public void LoadConfig(LazyPieceSettings settings)
{
m_resources = new Piece.Requirement[settings.requirements.Length];
UnityEngine.Debug.Log($"Enumerating reqs {settings.requirements}");
foreach (var tuple in Utility.enumerate(settings.requirements))
{
var itemDef = tuple.Item1;
var idx = tuple.Item2;
UnityEngine.Debug.Log($"Resolving {itemDef.item}");
m_resources[idx] = new Piece.Requirement {
m_resItem = ZNetScene.instance.GetPrefab(itemDef.item).GetComponent <ItemDrop>(),
m_amount = (int)itemDef.amount,
m_recover = true
};
}
UnityEngine.Debug.Log($"Enumerating place effects {settings.placeEffects}");
m_placeEffect.m_effectPrefabs = new EffectList.EffectData[settings.placeEffects.Length];
foreach (var tuple in Utility.enumerate(settings.placeEffects))
{
var fxDef = tuple.Item1;
var idx = tuple.Item2;
UnityEngine.Debug.Log($"Resolving {fxDef.effect}");
m_placeEffect.m_effectPrefabs[idx] = new EffectList.EffectData {
m_prefab = ZNetScene.instance.GetPrefab(fxDef.effect),
m_enabled = true
};
}
UnityEngine.Debug.Log($"Resolving {settings.craftingStation.station}");
if (settings.craftingStation != null)
{
m_craftingStation = ZNetScene.instance.GetPrefab(settings.craftingStation.station).GetComponent <CraftingStation>();
}
var wearNTear = GetComponent <WearNTear>();
UnityEngine.Debug.Log($"Enumerating destroyed effects {settings.destroyedEffects}");
wearNTear.m_destroyedEffect.m_effectPrefabs = new EffectList.EffectData[settings.destroyedEffects.Length];
foreach (var tuple in Utility.enumerate(settings.destroyedEffects))
{
var fxDef = tuple.Item1;
var idx = tuple.Item2;
UnityEngine.Debug.Log($"Resolving {fxDef.effect}");
wearNTear.m_destroyedEffect.m_effectPrefabs[idx] = new EffectList.EffectData {
m_prefab = ZNetScene.instance.GetPrefab(fxDef.effect),
m_enabled = true
};
}
UnityEngine.Debug.Log($"Enumerating hit effects {settings.hitEffects}");
wearNTear.m_hitEffect.m_effectPrefabs = new EffectList.EffectData[settings.hitEffects.Length];
foreach (var tuple in Utility.enumerate(settings.hitEffects))
{
var fxDef = tuple.Item1;
var idx = tuple.Item2;
UnityEngine.Debug.Log($"Resolving {fxDef.effect}");
wearNTear.m_hitEffect.m_effectPrefabs[idx] = new EffectList.EffectData {
m_prefab = ZNetScene.instance.GetPrefab(fxDef.effect),
m_enabled = true
};
}
if (settings.itemStand != null)
{
UnityEngine.Debug.Log("Resolving itemStand settings");
var itemStand = GetComponent <ArmorStand>();
itemStand.m_effects.m_effectPrefabs = new EffectList.EffectData[settings.itemStand.effects.Length];
foreach (var tuple in Utility.enumerate(settings.itemStand.effects))
{
var fxDef = tuple.Item1;
var idx = tuple.Item2;
UnityEngine.Debug.Log($"Resolving {fxDef.effect}");
itemStand.m_effects.m_effectPrefabs[idx] = new EffectList.EffectData {
m_prefab = ZNetScene.instance.GetPrefab(fxDef.effect),
m_enabled = true
};
}
}
}
