public static bool IsCraftRecipeFulfilled(TechType techType)
{
if (Inventory.main == null)
{
return(false);
}
if (!GameModeUtils.RequiresIngredients())
{
return(true);
}
var itemContainers = FindAllItemsContainersInRange();
ITechData techData = CraftData.Get(techType, false);
if (techData != null)
{
int i = 0;
int ingredientCount = techData.ingredientCount;
while (i < ingredientCount)
{
IIngredient ingredient = techData.GetIngredient(i);
if (GetTotalPickupCount(ingredient.techType, itemContainers) < ingredient.amount)
{
return(false);
}
i++;
}
return(true);
}
return(false);
}
public static bool ConsumeResources(TechType techType)
{
if (!IsCraftRecipeFulfilled(techType))
{
ErrorMessage.AddWarning(Language.main.Get("DontHaveNeededIngredients"));
return(false);
}
var itemsContainers = FindAllItemsContainersInRange();
ITechData techData = CraftData.Get(techType, false);
if (techData == null)
{
return(false);
}
int i = 0;
int ingredientCount = techData.ingredientCount;
while (i < ingredientCount)
{
IIngredient ingredient = techData.GetIngredient(i);
TechType techType2 = ingredient.techType;
int j = 0;
int amount = ingredient.amount;
while (j < amount)
{
DestroyItemInContainers(techType2, itemsContainers);
uGUI_IconNotifier.main.Play(techType2, uGUI_IconNotifier.AnimationType.To, null);
j++;
}
i++;
}
return(true);
}
public static void Postfix(ITechData data, ref List <TooltipIcon> icons)
{
if (data == null)
{
return;
}
var ingredientCount = data.ingredientCount;
for (var i = 0; i < ingredientCount; i++)
{
var ingredient = data.GetIngredient(i);
var techType = ingredient.techType;
if (!KnownTech.Contains(techType) && PDAScanner.ContainsCompleteEntry(techType))
{
KnownTech.Add(techType);
continue;
}
if (!CrafterLogic.IsCraftRecipeUnlocked(techType))
{
var icon = icons.Find((TooltipIcon) => TooltipIcon.sprite == SpriteManager.Get(techType) && TooltipIcon.text.Contains(Language.main.GetOrFallback(TooltipFactory.techTypeIngredientStrings.Get(techType), techType)));
if (icons.Contains(icon))
{
icons.Remove(icon);
var tooltipIcon = new TooltipIcon()
{
sprite = SpriteManager.Get(TechType.None), text = Main.Config.UnKnownTitle
};
icons.Add(tooltipIcon);
}
}
}
}
public static void Postfix(ref ITechData __result, ref TechType techType)
{
if (Settings.Instance.Recipes.RecipesByType.ContainsKey((int)techType))
{
__result = Settings.Instance.Recipes.RecipesByType[(int)techType];
}
}
private static bool CheckRequirements(Trashcan __instance, Pickupable item, ITechData techData)
{
bool check = true;
int craftCountNeeded = techData.craftAmount;
IList <InventoryItem> inventoryItems = __instance.storageContainer.container.GetItems(item.GetTechType());
if (inventoryItems != null && inventoryItems.Count >= craftCountNeeded)
{
while (craftCountNeeded > 0)
{
Trashcan_Update.inventoryItems.Add(inventoryItems[craftCountNeeded - 1]);
craftCountNeeded--;
}
List <TechType> linkedItems = new List <TechType>();
for (int i = 0; i < techData.linkedItemCount; i++)
{
linkedItems.Add(techData.GetLinkedItem(i));
}
foreach (TechType techType in linkedItems)
{
int linkedCountNeeded = linkedItems.FindAll((TechType tt) => tt == techType).Count;
IList <InventoryItem> inventoryItems2 = __instance.storageContainer.container.GetItems(techType);
IList <InventoryItem> inventoryItems3 = Inventory.main.container.GetItems(techType);
int count = (inventoryItems2?.Count ?? 0) + (inventoryItems3?.Count ?? 0);
if (count < linkedCountNeeded)
{
ErrorMessage.AddMessage($"Missing {linkedCountNeeded - (inventoryItems2?.Count + inventoryItems3?.Count)} {techType}");
Inventory.main.ForcePickup(item);
Trashcan_Update.inventoryItems.Clear();
return(false);
}
int count1 = inventoryItems2?.Count ?? 0;
int count2 = inventoryItems3?.Count ?? 0;
while (linkedCountNeeded > 0)
{
if (count1 > 0)
{
Trashcan_Update.inventoryItems.Add(inventoryItems2[count1 - 1]);
count1--;
}
else if (count2 > 0)
{
Trashcan_Update.inventoryItems.Add(inventoryItems3[count2 - 1]);
count2--;
}
linkedCountNeeded--;
}
}
}
else
{
check = false;
}
return(check);
}
public static void SetTechData(TechType techType, ITechData techData)
{
if (techType == TechType.None)
{
throw new ArgumentException("techType == None");
}
CraftDataWrapper.techData[techType] = techData;
}
private static bool Prefix(TechType techType, ref ITechData __result)
{
if (techData.TryGetValue(techType, out __result))
{
return(false);
}
return(true);
}
private static bool Prefix(ref ITechData __result, ref TechType techType, ref bool skipWarnings)
{
ITechData result = BuilderUtils.GetTechData(techType);
if (result != null)
{
__result = result;
return(false);
}
return(true);
}
public static void CrafterLogic_IsCraftRecipeFulfilled_Postfix(TechType techType, ref bool __result)
{
if (__result && GameModeUtils.RequiresIngredients())
{
Inventory main = Inventory.main;
#if SN1
ITechData techData = CraftData.Get(techType, true);
if (techData != null)
{
int i = 0;
int ingredientCount = techData.ingredientCount;
while (i < ingredientCount)
{
IIngredient ingredient = techData.GetIngredient(i);
#elif BZ
IList <Ingredient> ingredients = TechData.GetIngredients(techType);
if (ingredients != null)
{
int i = 0;
int ingredientCount = ingredients.Count;
while (i < ingredientCount)
{
Ingredient ingredient = ingredients[i];
#endif
int count = 0;
IList <InventoryItem> inventoryItems = main.container.GetItems(ingredient.techType);
if (inventoryItems != null)
{
foreach (InventoryItem inventoryItem in inventoryItems)
{
if (Main.BatteryCheck(inventoryItem.item))
{
count++;
}
}
}
if (count < ingredient.amount)
{
__result = false;
return;
}
i++;
}
__result = true;
return;
}
__result = false;
return;
}
}
}
}
public static void Postfix(ref ITechData __result, ref TechType techType)
{
var patchedTech = HCPTechData.GetFromTechData(__result);
for (int i = 0; i < patchedTech.ingredientCount; i++)
{
var ingredientTechType = patchedTech._ingredients[i].techType;
var patchedIngredientAmount = patchedTech._ingredients[i].amount * HCPSettings.Instance.CraftingCostMultiplier;
patchedTech._ingredients[i] = new HCPIngredient(ingredientTechType, patchedIngredientAmount);
}
__result = patchedTech;
}
private void SetTechType(TechType techType)
{
this.techType = techType;
ITechData techData = CraftData.Get(techType, true);
if (techData == null)
{
Logger.Error("Could not find tech data for techtype: " + techType);
return;
}
if (Mod.Left)
{
mainIcon = BlueprintTrackerIcon.Create(contents.transform, null, SpriteManager.Get(techType), true, false);
}
else
{
removeButton = BlueprintTrackerRemoveButton.Create(contents.transform, techType, true, false);
}
icons.Clear();
for (int i = 0; i < techData.ingredientCount; ++i)
{
IIngredient ingredient = techData.GetIngredient(i);
Atlas.Sprite sprite = SpriteManager.Get(ingredient.techType);
var icon = BlueprintTrackerIcon.Create(contents.transform, ingredient, sprite,
Mod.Left ? false : i == 0,
Mod.Left ? i == techData.ingredientCount - 1 : false
);
icons.Add(icon);
}
if (!Mod.Left)
{
mainIcon = BlueprintTrackerIcon.Create(contents.transform, null, SpriteManager.Get(techType), false, true);
}
else
{
removeButton = BlueprintTrackerRemoveButton.Create(contents.transform, techType, false, true);
}
}
public static void WriteIngredients(ITechData data, List <TooltipIcon> icons)
{
int ingredientCount = data.ingredientCount;
ItemsContainer[] itemContainers = FindAllItemsContainersInRange();
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < ingredientCount; i++)
{
stringBuilder.Length = 0;
IIngredient ingredient = data.GetIngredient(i);
TechType techType = ingredient.techType;
int totalPickupCount = GetTotalPickupCount(techType, itemContainers);
int amount = ingredient.amount;
bool flag = totalPickupCount >= amount || !GameModeUtils.RequiresIngredients();
Atlas.Sprite sprite = SpriteManager.Get(techType);
if (flag)
{
stringBuilder.Append("<color=#94DE00FF>");
}
else
{
stringBuilder.Append("<color=#DF4026FF>");
}
string orFallback = Language.main.GetOrFallback(TooltipFactory.techTypeIngredientStrings.Get(techType), techType);
stringBuilder.Append(orFallback);
if (amount > 1)
{
stringBuilder.Append(" x");
stringBuilder.Append(amount);
}
if (totalPickupCount > 0 && totalPickupCount < amount)
{
stringBuilder.Append(" (");
stringBuilder.Append(totalPickupCount);
stringBuilder.Append(")");
}
stringBuilder.Append("</color>");
icons.Add(new TooltipIcon(sprite, stringBuilder.ToString()));
}
}
private static TechData ConvertToTechData(ITechData iTechData)
{
var techData = new TechData()
{
craftAmount = iTechData.craftAmount
};
for (int i = 0; i < iTechData.ingredientCount; i++)
{
IIngredient ingredient = iTechData.GetIngredient(i);
var smlingredient = new Ingredient(ingredient.techType, ingredient.amount);
techData.Ingredients.Add(smlingredient);
}
for (int i = 0; i < iTechData.linkedItemCount; i++)
{
techData.LinkedItems.Add(iTechData.GetLinkedItem(i));
}
return(techData);
}
public static void Postfix(ref ITechData __result)
{
var patchedTech = new TechData()
{
craftAmount = __result.craftAmount
};
for (int i = 0; i < __result.ingredientCount; i++)
{
IIngredient ingredient = __result.GetIngredient(i);
Ingredient patchedIngredient = new Ingredient(ingredient.techType, ingredient.amount * HCPSettings.Instance.CraftingCostMultiplier);
patchedTech.Ingredients.Add(patchedIngredient);
}
for (int i = 0; i < __result.ingredientCount; i++)
{
patchedTech.LinkedItems.Add(__result.GetLinkedItem(i));
}
__result = patchedTech;
}
internal static void AddToCustomTechData(TechType techType, ITechData techData)
{
CustomTechData.Add(techType, techData);
}
private static void PatchCustomTechData()
{
short added = 0;
short replaced = 0;
foreach (TechType techType in CustomTechData.Keys)
{
bool techExists = CraftData.techData.TryGetValue(techType, out CraftData.TechData techData);
ITechData smlTechData = CustomTechData[techType];
bool sameData = false;
if (techExists)
{
sameData = smlTechData.craftAmount == techData.craftAmount &&
smlTechData.ingredientCount == techData.ingredientCount &&
smlTechData.linkedItemCount == techData.linkedItemCount;
if (sameData)
{
for (int i = 0; i < smlTechData.ingredientCount; i++)
{
if (smlTechData.GetIngredient(i).techType != techData.GetIngredient(i).techType)
{
sameData = false;
break;
}
if (smlTechData.GetIngredient(i).amount != techData.GetIngredient(i).amount)
{
sameData = false;
break;
}
}
}
if (sameData)
{
for (int i = 0; i < smlTechData.linkedItemCount; i++)
{
if (smlTechData.GetLinkedItem(i) != techData.GetLinkedItem(i))
{
sameData = false;
break;
}
}
}
}
if (!techExists || !sameData)
{
var techDataInstance = new CraftData.TechData
{
_techType = techType,
_craftAmount = smlTechData.craftAmount
};
var ingredientsList = new CraftData.Ingredients();
if (smlTechData.ingredientCount > 0)
{
for (int i = 0; i < smlTechData.ingredientCount; i++)
{
IIngredient smlIngredient = smlTechData.GetIngredient(i);
var ingredient = new CraftData.Ingredient(smlIngredient.techType, smlIngredient.amount);
ingredientsList.Add(smlIngredient.techType, smlIngredient.amount);
}
techDataInstance._ingredients = ingredientsList;
}
if (smlTechData.linkedItemCount > 0)
{
var linkedItems = new List <TechType>();
for (int l = 0; l < smlTechData.linkedItemCount; l++)
{
linkedItems.Add(smlTechData.GetLinkedItem(l));
}
techDataInstance._linkedItems = linkedItems;
}
if (techExists)
{
CraftData.techData.Remove(techType);
Logger.Log($"{techType} TechType already existed in the CraftData.techData dictionary. Original value was replaced.", LogLevel.Warn);
replaced++;
}
else
{
added++;
}
CraftData.techData.Add(techType, techDataInstance);
}
}
if (added > 0)
{
Logger.Log($"Added {added} new entries to the CraftData.techData dictionary.", LogLevel.Info);
}
if (replaced > 0)
{
Logger.Log($"Replaced {replaced} existing entries to the CraftData.techData dictionary.", LogLevel.Info);
}
}
private static void HandleModifiedRecipe(IModifiedRecipe modifiedRecipe)
{
bool overrideRecipe = false;
ITechData original = CraftData.Get(modifiedRecipe.ItemID);
var replacement = new TechData();
// Amount
if (modifiedRecipe.AmountCrafted.HasValue)
{
overrideRecipe |= true;
replacement.craftAmount = modifiedRecipe.AmountCrafted.Value;
}
else
{
replacement.craftAmount = original.craftAmount;
}
// Ingredients
if (modifiedRecipe.IngredientsCount.HasValue)
{
overrideRecipe |= true;
foreach (EmIngredient ingredient in modifiedRecipe.Ingredients)
{
replacement.Ingredients.Add(
new Ingredient(
ingredient.ItemID,
ingredient.Required));
}
}
else
{
for (int i = 0; i < original.ingredientCount; i++)
{
replacement.Ingredients.Add(
new Ingredient(
original.GetIngredient(i).techType,
original.GetIngredient(i).amount));
}
}
// Linked Items
if (modifiedRecipe.LinkedItemsCount.HasValue)
{
overrideRecipe |= true;
foreach (TechType linkedItem in modifiedRecipe.LinkedItems)
{
replacement.LinkedItems.Add(linkedItem);
}
}
else
{
for (int i = 0; i < original.linkedItemCount; i++)
{
replacement.LinkedItems.Add(original.GetLinkedItem(i));
}
}
if (overrideRecipe)
{
CraftDataHandler.SetTechData(modifiedRecipe.ItemID, replacement);
}
}
private static void AddCustomTechDataToOriginalDictionary()
{
short added = 0;
short replaced = 0;
foreach (TechType techType in CustomTechData.Keys)
{
ITechData smlTechData = CustomTechData[techType];
var techDataInstance = new CraftData.TechData
{
_techType = techType,
_craftAmount = smlTechData.craftAmount
};
var ingredientsList = new CraftData.Ingredients();
if (smlTechData.ingredientCount > 0)
{
for (int i = 0; i < smlTechData.ingredientCount; i++)
{
IIngredient smlIngredient = smlTechData.GetIngredient(i);
var ingredient = new CraftData.Ingredient(smlIngredient.techType, smlIngredient.amount);
ingredientsList.Add(smlIngredient.techType, smlIngredient.amount);
}
techDataInstance._ingredients = ingredientsList;
}
if (smlTechData.linkedItemCount > 0)
{
var linkedItems = new List <TechType>();
for (int l = 0; l < smlTechData.linkedItemCount; l++)
{
linkedItems.Add(smlTechData.GetLinkedItem(l));
}
techDataInstance._linkedItems = linkedItems;
}
bool techDataExists = CraftData.techData.ContainsKey(techType);
if (techDataExists)
{
CraftData.techData.Remove(techType);
Logger.Log($"{techType} TechType already existed in the CraftData.techData dictionary. Original value was replaced.", LogLevel.Warn);
replaced++;
}
else
{
added++;
}
CraftData.techData.Add(techType, techDataInstance);
}
if (added > 0)
{
Logger.Log($"Added {added} new entries to the CraftData.techData dictionary.", LogLevel.Info);
}
if (replaced > 0)
{
Logger.Log($"Replaced {replaced} existing entries to the CraftData.techData dictionary.", LogLevel.Info);
}
}
public static bool Prefix(Trashcan __instance)
{
if (__instance.biohazard)
{
return(true);
}
__instance.storageContainer.hoverText = "Recycling Bin";
__instance.storageContainer.storageLabel = "Recycling Bin";
__instance.storageContainer.container._label = "Recycling Bin";
inventoryItems = new List <InventoryItem>();
forcePickupItems = new List <Pickupable>();
foreach (Trashcan.Waste waste in __instance.wasteList)
{
InventoryItem item = waste.inventoryItem;
if (item is null)
{
continue;
}
TechType techType = item.item.GetTechType();
ITechData techData = CraftData.Get(techType);
bool inputcheck = GameInput.GetButtonHeld(GameInput.Button.Deconstruct);
if (!inputcheck && techType != TechType.Titanium && Main.BatteryCheck(item.item) && techData != null)
{
if (CheckRequirements(__instance, item.item, techData))
{
for (int i = 0; i < techData.ingredientCount; i++)
{
IIngredient ingredient = techData.GetIngredient(i);
for (int j = 0; j < ingredient.amount; j++)
{
GameObject gameObject = CraftData.InstantiateFromPrefab(ingredient.techType, false);
if (gameObject.GetComponent <LiveMixin>() != null)
{
GameObject.Destroy(gameObject);
break;
}
gameObject.SetActive(true);
Pickupable pickupable = gameObject.GetComponent <Pickupable>();
pickupable.Pickup(false);
forcePickupItems.Add(pickupable);
}
}
break;
}
}
else
{
if (inputcheck)
{
inventoryItems.Add(item);
}
else
{
forcePickupItems.Add(item.item);
}
break;
}
}
forcePickupItems.ForEach((rejectedItem) => Inventory.main.ForcePickup(rejectedItem));
inventoryItems.ForEach((item) => UnityEngine.Object.Destroy(item.item.gameObject));
return(false);
}
/// <summary>
/// <para>Allows you to edit recipes, i.e. TechData for TechTypes.</para>
/// <para>Can be used for existing TechTypes too.</para>
/// </summary>
/// <param name="techType">The TechType whose TechData you want to edit.</param>
/// <param name="techData">The TechData for that TechType.</param>
/// <seealso cref="TechData"/>
void ICraftDataHandler.SetTechData(TechType techType, ITechData techData)
{
CraftDataPatcher.CustomTechData[techType] = techData;
}
/// <summary>
/// <para>Allows you to edit recipes, i.e. TechData for TechTypes.</para>
/// <para>Can be used for existing TechTypes too.</para>
/// </summary>
/// <param name="techType">The TechType whose TechData you want to edit.</param>
/// <param name="techData">The TechData for that TechType.</param>
/// <seealso cref="TechData"/>
public static void SetTechData(TechType techType, ITechData techData)
{
Main.SetTechData(techType, techData);
}
