//Buys additional Smelters
public void BuySmelter()
{
if (CurrencyControl.Cash >= NewSmelterCost)
{
CurrencyControl.Cash -= NewSmelterCost;
//TODO BETTER FORMULA
NewSmelterCost = NewSmelterCost * 5;
SmelterCostText.text = NewSmelterCost.ToString();
//int SmelterIndex,int Duration,float CurrentTime,Sprite OutputIcon,bool IsSmelting,int CurrentRecipe
var Smelter = new Smelter(1, 0, 0, Resources.Load <Sprite>("Bars/1CopperBar"), false, -1);
Smelters.Add(Smelter);
var smelterIndex = Smelters.Count;
//instantiate another smelter
var copy = Instantiate(SmelterUI);
copy.transform.SetParent(SmelterContent.transform, false);
copy.transform.localPosition = Vector3.zero;
copy.name = ("Smelter" + smelterIndex);
//to index tou kathe smelter, de xreiazete -1 giati ton prwto tha ton valw na ginete instantiate apo research
copy.GetComponentsInChildren <Button>()[0].onClick.AddListener(() => {
//opens recipe panel
StartCoroutine(WaitForSelection(smelterIndex - 1));
});
//CANCEL BUTTON
//Stops production
copy.GetComponentsInChildren <Button>()[1].onClick.AddListener(() => {
StopSmelter(smelterIndex - 1);
});
RefSmelterList.Add(copy);
}
}
public static void SetSmelterInputAmounts(Smelter instance)
{
if (Configuration.Current.ProductionInputAmounts.IsEnabled)
{
var prefab = instance.m_nview.GetPrefabName();
if (prefab == "piece_spinningwheel")
{
instance.m_maxOre = Configuration.Current.ProductionInputAmounts.spinningWheelFlachsAmount;
}
else if (prefab == "charcoal_kiln")
{
instance.m_maxOre = Configuration.Current.ProductionInputAmounts.kilnWoodAmount;
}
else if (prefab == "blastfurnace")
{
instance.m_maxOre = Configuration.Current.ProductionInputAmounts.blastfurnaceOreAmount;
instance.m_maxFuel = Configuration.Current.ProductionInputAmounts.blastfurnaceCoalAmount;
}
else if (prefab == "smelter")
{
instance.m_maxOre = Configuration.Current.ProductionInputAmounts.furnaceOreAmount;
instance.m_maxFuel = Configuration.Current.ProductionInputAmounts.furnaceCoalAmount;
}
else if (prefab == "windmill")
{
instance.m_maxOre = Configuration.Current.ProductionInputAmounts.windmillBarleyAmount;
}
}
}
//unlocks production panel and adds 1st Smelter
public void BuySmelterResearch()
{
if (CurrencyControl.Cash >= 1000)
{
CurrencyControl.Cash -= 1000;
ProductionPanelBtn.interactable = true;
UnlockProductionResearch.interactable = false;
//int SmelterIndex,int Duration,float CurrentTime,Sprite OutputIcon,bool IsSmelting,int CurrentRecipe
var Smelter = new Smelter(1, 0, 0, Resources.Load <Sprite>("Bars/1CopperBar"), false, -1);
Smelters.Add(Smelter);
var smelterIndex = Smelters.Count;
var copy = Instantiate(SmelterUI);
copy.transform.SetParent(SmelterContent.transform, false);
copy.transform.localPosition = Vector3.zero;
copy.name = ("Smelter" + smelterIndex);
//plin 1 giati ksekinaei apo to 0 kai oxi apo to 1 o pinakas
copy.GetComponentInChildren <Button>().onClick.AddListener(() => {
//opens recipe panel
StartCoroutine(WaitForSelection(smelterIndex - 1));
});
//CANCEL BUTTON
//Stops production
copy.GetComponentsInChildren <Button>()[1].onClick.AddListener(() => {
StopSmelter((smelterIndex - 1));
});
RefSmelterList.Add(copy);
}
}
public static void PatchSmelter(Smelter smelter)
{
if (smelter.m_emptyOreSwitch && smelter.m_spawnStack)
{
int processedQueueSize = smelter.GetProcessedQueueSize();
smelter.m_emptyOreSwitch.m_hoverText = $"{smelter.m_name} {processedQueueSize} $piece_smelter_ready \n{useKey} {smelter.m_emptyOreTooltip}";
}
int queueSize = smelter.GetQueueSize();
smelter.m_addOreSwitch.m_hoverText = $"{smelter.m_name} ({queueSize}/{smelter.m_maxOre}) ";
if (queueSize > 0) // This codeline is run every tick when windmill is on!!
{
Debug.Log($"{smelter.GetBakeTimer()}, {smelter.m_secPerProduct}, {queueSize}");
smelter.m_addOreSwitch.m_hoverText += $"{Helpers.TimeString(smelter.m_secPerProduct * queueSize - smelter.GetBakeTimer())}";
// 8sec - 10sec (30sec)
// 9sec - 10sec (30sec)
}
if (smelter.m_requiresRoof && !smelter.m_haveRoof && Mathf.Sin(Time.time * 10f) > 0f)
{
Switch addOreSwitch = smelter.m_addOreSwitch;
addOreSwitch.m_hoverText += $" {smelterRoof}";
}
Switch addOreSwitch2 = smelter.m_addOreSwitch;
addOreSwitch2.m_hoverText = $"{addOreSwitch2.m_hoverText} \n{useKey} {smelter.m_addOreTooltip}";
}
private static void Prefix(ref Smelter __instance)
{
if (Config["Furnace"]["enabled"] == "true")
{
int MaximumOre = int.Parse(Config["Furnace"]["maximumOre"]);
int MaximumFuel = int.Parse(Config["Furnace"]["maximumCoal"]);
float ProductionSpeed = toFloat(Config["Furnace"]["productionSpeed"]);
int CoalPerProduct = int.Parse(Config["Furnace"]["coalUsedPerProduct"]);
if (!__instance.m_addWoodSwitch && Config["Kiln"]["enabled"] == "true")
{
float ProductionSpeed_k = toFloat(Config["Kiln"]["productionSpeed"]);
__instance.m_secPerProduct = ProductionSpeed_k;
}
else
{
// is furnace
__instance.m_maxOre = MaximumOre;
__instance.m_maxFuel = MaximumFuel;
__instance.m_secPerProduct = ProductionSpeed;
__instance.m_fuelPerProduct = CoalPerProduct;
}
}
}
private static void SetSmelterInputAmounts(On.Smelter.orig_Awake orig, Smelter self)
{
orig(self);
var prefab = self.m_nview.GetPrefabName();
if (prefab == "piece_spinningwheel")
{
self.m_maxOre = ConfigUtil.Get <int>("ProductionInputAmounts", "spinningWheelFlachsAmount");
}
else if (prefab == "charcoal_kiln")
{
self.m_maxOre = ConfigUtil.Get <int>("ProductionInputAmounts", "kilnWoodAmount");
}
else if (prefab == "blastfurnace")
{
self.m_maxOre = ConfigUtil.Get <int>("ProductionInputAmounts", "blastfurnaceOreAmount");
self.m_maxFuel = ConfigUtil.Get <int>("ProductionInputAmounts", "blastfurnaceCoalAmount");
}
else if (prefab == "smelter")
{
self.m_maxOre = ConfigUtil.Get <int>("ProductionInputAmounts", "furnaceOreAmount");
self.m_maxFuel = ConfigUtil.Get <int>("ProductionInputAmounts", "furnaceCoalAmount");
}
else if (prefab == "windmill")
{
self.m_maxOre = ConfigUtil.Get <int>("ProductionInputAmounts", "windmillBarleyAmount");
}
}
void NewBlock()
{
GameObject b = new GameObject(blockName);
Block bBlock = b.AddComponent <Block>();
SpriteRenderer s = b.AddComponent <SpriteRenderer>();
b.AddComponent <Snap>();
b.AddComponent <BoxCollider2D>();
if (addSmelter)
{
Smelter smelt = b.AddComponent <Smelter>();
smelt.recipe = recipe;
smelt.smelterTier = smelterTier;
if (recipe == null && cancelIfRecipeIsNull)
{
Destroy(b);
Debug.LogError("Error!, can't spawn the object because the smelter recipe is null, change it and try again");
return;
}
}
bBlock.breakTime = blockBreakingTime;
bBlock.minimumMiningPower = blockMinimumMiningPower;
s.color = blockColor;
s.sprite = blockSprite;
b.transform.position = Vector3.zero;
Debug.Log("Block created at " + Vector3.zero);
}
public static void StartSmelter(ref Smelter __instance)
{
if (QualityOfLife.EnableSmelterModification.Value)
{
QualityOfLife.Log.LogInfo(__instance.m_name);
switch (__instance.m_name)
{
case "$piece_smelter":
__instance.m_maxOre *= QualityOfLife.SmelterOreMultiplier.Value;
__instance.m_maxFuel *= QualityOfLife.SmelterFuelMultiplier.Value;
if (QualityOfLife.SmelterFuelPerProduct.Value >= 1 && QualityOfLife.SmelterSecPerProduct.Value >= 1)
{
__instance.m_fuelPerProduct = QualityOfLife.SmelterFuelPerProduct.Value;
__instance.m_secPerProduct = QualityOfLife.SmelterSecPerProduct.Value;
}
else
{
QualityOfLife.Log.LogInfo("Smelter fuel per product or smelter sec per product is too low, lowest is 1.");
}
break;
case "$piece_blastfurnace":
__instance.m_maxOre *= QualityOfLife.BlastFurnaceOreMultiplier.Value;
__instance.m_maxFuel *= QualityOfLife.BlastFurnaceFuelMultiplier.Value;
if (QualityOfLife.BlastFurnaceFuelPerProduct.Value >= 1 && QualityOfLife.BlastFurnaceSecPerProduct.Value >= 1)
{
__instance.m_fuelPerProduct = QualityOfLife.BlastFurnaceFuelPerProduct.Value;
__instance.m_secPerProduct = QualityOfLife.BlastFurnaceSecPerProduct.Value;
}
else
{
QualityOfLife.Log.LogInfo("Blast Furnace fuel per product or smelter sec per product is too low, lowest is 1.");
}
break;
case "$piece_charcoalkiln":
__instance.m_maxOre *= QualityOfLife.CharcoalKilnMultiplier.Value;
if (QualityOfLife.CharcoalKilnSecPerProduct.Value >= 1)
{
__instance.m_secPerProduct = QualityOfLife.CharcoalKilnSecPerProduct.Value;
}
else
{
QualityOfLife.Log.LogInfo("Charcoal Kiln sec per product is too low, lowest is 1.");
}
break;
default:
break;
}
}
else
{
QualityOfLife.Log.LogInfo("Smelter mod is disabled.");
}
}
static void Prefix(Smelter __instance)
{
SurtlingCoreOverclocking surtlingCoreOverclocking = __instance.GetComponentInParent <SurtlingCoreOverclocking>();
if (surtlingCoreOverclocking == null)
{
logger.LogInfo("Adding SurtlingCoreOverclocking Component to smelter");
__instance.gameObject.AddComponent <SurtlingCoreOverclocking>();
}
}
private static void Postfix(Smelter __instance)
{
try
{
PostfixEvent?.Invoke(__instance);
}
catch (Exception ex)
{
Logger.LogError(ex.Message + Environment.NewLine + ex.StackTrace);
}
}
private static bool PreventUsingSpecificWood(Smelter smelter, Smelter.ItemConversion itemConversion)
{
if (smelter.m_name.Equals(SmelterDefinitions.KilnName))
{
if (Configuration.Current.Kiln.dontProcessFineWood && itemConversion.m_from.m_itemData.m_shared.m_name.Equals(WoodDefinitions.FineWoodName) ||
Configuration.Current.Kiln.dontProcessRoundLog && itemConversion.m_from.m_itemData.m_shared.m_name.Equals(WoodDefinitions.RoundLogName))
{
return(true);
}
}
return(false);
}
static void Postfix(Smelter __instance, float __result)
{
SurtlingCoreOverclocking surtlingCoreOverclocking = __instance.GetComponentInParent <SurtlingCoreOverclocking>();
if (surtlingCoreOverclocking)
{
surtlingCoreOverclocking.OnGetFuel(__result);
}
else
{
logger.LogWarning("No SurtlingCoreOverclocking component on smelter " + __instance.transform.position);
}
}
static void Prefix(Smelter __instance, ref float fuel)
{
SurtlingCoreOverclocking surtlingCoreOverclocking = __instance.GetComponentInParent <SurtlingCoreOverclocking>();
if (surtlingCoreOverclocking)
{
fuel = surtlingCoreOverclocking.OnSetFuel(fuel);
}
else
{
logger.LogWarning("No SurtlingCoreOverclocking component on smelter " + __instance.transform.position);
}
}
private void UpdateSmelterValues()
{
if (!this.m_nview.IsValid())
{
return;
}
Smelter smelter = GetComponent <Smelter>();
float speedMultiplier = (float)GetSpeedMultiplier(GetSpeedCoreCount(), GetEfficiencyCoreCount(), GetProductivityCoreCount());
Debug.Log("SpeedMultiplier: " + speedMultiplier);
smelter.m_secPerProduct = original_m_secPerProduct / speedMultiplier;
Debug.Log("Updated Smelter.m_secPerProduct from " + original_m_secPerProduct + " to " + smelter.m_secPerProduct);
}
static void Prefix(Smelter __instance, string ore, ref int stack)
{
SurtlingCoreOverclocking surtlingCoreOverclocking = __instance.GetComponentInParent <SurtlingCoreOverclocking>();
if (surtlingCoreOverclocking)
{
int aditional = surtlingCoreOverclocking.OnSpawn(ore);
stack += aditional;
}
else
{
logger.LogWarning("No SurtlingCoreOverclocking component on smelter " + __instance.transform.position);
}
}
private static void CalculateSmelterBakeTime(Smelter smelter)
{
double deltaTime = smelter.GetDeltaTime();
float accumulator = smelter.GetAccumulator();
accumulator += (float)deltaTime;
float power = smelter.m_windmill ? smelter.m_windmill.GetPowerOutput() : 1f;
while (accumulator >= 1f)
{
accumulator -= 1f;
float fuel = smelter.GetFuel();
string queuedOre = smelter.GetQueuedOre();
if ((smelter.m_maxFuel == 0 || fuel > 0f) && queuedOre != "" && smelter.m_secPerProduct > 0f && (!smelter.m_requiresRoof || smelter.m_haveRoof))
{
float speed = 1f * power;
if (smelter.m_maxFuel > 0)
{
float usage = smelter.m_secPerProduct / (float)smelter.m_fuelPerProduct;
fuel -= speed / usage;
if (fuel < 0f)
{
fuel = 0f;
}
smelter.SetFuel(fuel);
}
float bakeTime = smelter.GetBakeTimer();
bakeTime += speed;
smelter.SetBakeTimer(bakeTime);
if (bakeTime > smelter.m_secPerProduct)
{
smelter.SetBakeTimer(0f);
smelter.RemoveOneOre();
smelter.QueueProcessed(queuedOre);
}
}
}
if (smelter.GetQueuedOre() == "" || ((float)smelter.m_maxFuel > 0f && smelter.GetFuel() == 0f))
{
smelter.SpawnProcessed();
}
smelter.SetAccumulator(accumulator);
}
public static void Postfix(Smelter __instance)
{
if (ItsJustWood.AllowAncientBarkForCoal.Value)
{
var ancientWood = ObjectDB.instance.GetItemPrefab("ElderBark").GetComponent <ItemDrop>();
var itemConversion = __instance.m_conversion.Find(x => x.m_from == ancientWood);
if (itemConversion == null)
{
var coal = ObjectDB.instance.GetItemPrefab("Coal").GetComponent <ItemDrop>();
itemConversion = new Smelter.ItemConversion()
{
m_from = ancientWood,
m_to = coal
};
__instance.m_conversion.Add(itemConversion);
}
}
}
static void Postfix(Smelter __instance, ZNetView ___m_nview)
{
if (!Player.m_localPlayer || !isOn.Value || ___m_nview == null || !___m_nview.IsOwner())
{
return;
}
if (Time.time - lastFuel < 0.1)
{
fuelCount++;
RefuelSmelter(__instance, ___m_nview, fuelCount * 33);
}
else
{
fuelCount = 0;
lastFuel = Time.time;
RefuelSmelter(__instance, ___m_nview, 0);
}
}
static void BlastFurnacePatch(ref Smelter __instance)
{
if (__instance.m_name != "$piece_blastfurnace")
{
//UnityEngine.Debug.Log("Ignored non-blast furnace smelter.");
return;
}
//UnityEngine.Debug.Log("Found a blast furnace! Applying fix.");
ObjectDB instance = ObjectDB.instance;
List <ItemDrop> materials = instance.GetAllItems(ItemDrop.ItemData.ItemType.Material, "");
foreach (ItemDrop material in materials)
{
if (BFFix.metals.Keys.Contains(material.m_itemData.m_shared.m_name))
{
//UnityEngine.Debug.Log("Adding " + material.m_itemData.m_shared.m_name + " to list of materials.");
BFFix.metals[material.m_itemData.m_shared.m_name] = material;
}
}
List <Smelter.ItemConversion> conversions = new List <Smelter.ItemConversion>()
{
new Smelter.ItemConversion {
m_from = BFFix.metals["$item_copperore"], m_to = BFFix.metals["$item_copper"]
},
new Smelter.ItemConversion {
m_from = BFFix.metals["$item_tinore"], m_to = BFFix.metals["$item_tin"]
},
new Smelter.ItemConversion {
m_from = BFFix.metals["$item_ironscrap"], m_to = BFFix.metals["$item_iron"]
},
new Smelter.ItemConversion {
m_from = BFFix.metals["$item_silverore"], m_to = BFFix.metals["$item_silver"]
}
};
foreach (Smelter.ItemConversion conversion in conversions)
{
__instance.m_conversion.Add(conversion);
}
}
static bool Prefix(Smelter __instance, ref bool __result, ZNetView ___m_nview, Humanoid user, ItemDrop.ItemData item)
{
if (!AllowByKey() || user.GetInventory().HaveItem(__instance.m_fuelItem.m_itemData.m_shared.m_name) || item != null)
{
return(true);
}
if (((float)typeof(Smelter).GetMethod("GetFuel", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(__instance, new object[] { })) > __instance.m_maxFuel - 1)
{
user.Message(MessageHud.MessageType.Center, "$msg_itsfull", 0, null);
return(false);
}
Dbgl($"missing fuel in player inventory");
List <Container> nearbyContainers = GetNearbyContainers(__instance.transform.position);
foreach (Container c in nearbyContainers)
{
ItemDrop.ItemData newItem = c.GetInventory().GetItem(__instance.m_fuelItem.m_itemData.m_shared.m_name);
if (newItem != null)
{
if (fuelDisallowTypes.Value.Split(',').Contains(newItem.m_dropPrefab.name))
{
Dbgl($"container at {c.transform.position} has {newItem.m_stack} {newItem.m_dropPrefab.name} but it's forbidden by config");
continue;
}
Dbgl($"container at {c.transform.position} has {newItem.m_stack} {newItem.m_dropPrefab.name}, taking one");
user.Message(MessageHud.MessageType.Center, "$msg_added " + __instance.m_fuelItem.m_itemData.m_shared.m_name, 0, null);
___m_nview.InvokeRPC("AddFuel", new object[] { });
c.GetInventory().RemoveItem(__instance.m_fuelItem.m_itemData.m_shared.m_name, 1);
typeof(Container).GetMethod("Save", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(c, new object[] { });
typeof(Inventory).GetMethod("Changed", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(c.GetInventory(), new object[] { });
__result = true;
return(false);
}
}
return(true);
}
private static void Prefix(ref Smelter __instance)
{
if (Conf.Furnace != null)
{
if (!__instance.m_addWoodSwitch && Conf.Kiln != null)
{
float ProductionSpeed_k = Conf.Kiln.ProductionSpeed;//toFloat(Config["Kiln"]["productionSpeed"]);
__instance.m_secPerProduct = ProductionSpeed_k;
}
else
{
// is furnace
__instance.m_maxOre = Conf.Furnace.MaximumOre;
__instance.m_maxFuel = Conf.Furnace.MaximumCoal;
__instance.m_secPerProduct = Conf.Furnace.ProductionSpeed;
__instance.m_fuelPerProduct = Conf.Furnace.CoalUsedPerProduct;
}
}
}
private static bool Prefix(Smelter __instance)
{
var cancel = false;
BlockingPrefixEvent?.Invoke(__instance, ref cancel);
if (!cancel)
{
try
{
PrefixEvent?.Invoke(__instance);
}
catch (Exception ex)
{
Logger.LogError(ex.Message + Environment.NewLine + ex.StackTrace);
}
}
return(!cancel);
}
private static void Prefix(ref Smelter __instance)
{
if (!__instance.m_addWoodSwitch && Settings.isEnabled("Kiln"))
{
// is kiln
__instance.m_maxOre = Settings.getInt("Kiln", "maximumWood");
__instance.m_secPerProduct = Settings.getFloat("Kiln", "productionSpeed");
}
else
{
// is furnace
if (Settings.isEnabled("Furnace"))
{
__instance.m_maxOre = Settings.getInt("Furnace", "maximumOre");
__instance.m_maxFuel = Settings.getInt("Furnace", "maximumCoal");
__instance.m_secPerProduct = Settings.getFloat("Furnace", "productionSpeed");
__instance.m_fuelPerProduct = Settings.getInt("Furnace", "coalUsedPerProduct");
}
}
}
private static void Prefix(ref Smelter __instance)
{
if (!__instance.m_addWoodSwitch)
{
// is kiln
if (Configuration.Current.Kiln.IsEnabled)
{
__instance.m_maxOre = Configuration.Current.Kiln.maximumWood;
__instance.m_secPerProduct = Configuration.Current.Kiln.productionSpeed;
}
}
else
{
// is furnace
if (Configuration.Current.Furnace.IsEnabled)
{
__instance.m_maxOre = Configuration.Current.Furnace.maximumOre;
__instance.m_maxFuel = Configuration.Current.Furnace.maximumCoal;
__instance.m_secPerProduct = Configuration.Current.Furnace.productionSpeed;
__instance.m_fuelPerProduct = Configuration.Current.Furnace.coalUsedPerProduct;
}
}
}
private static void Prefix(ref Smelter __instance)
{
if (__instance.m_name.Equals(SmelterDefinitions.KilnName) && Configuration.Current.Kiln.IsEnabled)
{
__instance.m_maxOre = Configuration.Current.Kiln.maximumWood;
__instance.m_secPerProduct = Configuration.Current.Kiln.productionSpeed;
}
else if (__instance.m_name.Equals(SmelterDefinitions.SmelterName) && Configuration.Current.Smelter.IsEnabled)
{
__instance.m_maxOre = Configuration.Current.Smelter.maximumOre;
__instance.m_maxFuel = Configuration.Current.Smelter.maximumCoal;
__instance.m_secPerProduct = Configuration.Current.Smelter.productionSpeed;
__instance.m_fuelPerProduct = Configuration.Current.Smelter.coalUsedPerProduct;
}
else if (__instance.m_name.Equals(SmelterDefinitions.FurnaceName) && Configuration.Current.Furnace.IsEnabled)
{
__instance.m_maxOre = Configuration.Current.Furnace.maximumOre;
__instance.m_maxFuel = Configuration.Current.Furnace.maximumCoal;
__instance.m_secPerProduct = Configuration.Current.Furnace.productionSpeed;
__instance.m_fuelPerProduct = Configuration.Current.Furnace.coalUsedPerProduct;
if (Configuration.Current.Furnace.allowAllOres)
{
__instance.m_conversion.AddRange(FurnaceDefinitions.AdditionalConversions);
}
}
else if (__instance.m_name.Equals(SmelterDefinitions.WindmillName) && Configuration.Current.Windmill.IsEnabled)
{
__instance.m_maxOre = Configuration.Current.Windmill.maximumBarley;
__instance.m_secPerProduct = Configuration.Current.Windmill.productionSpeed;
}
else if (__instance.m_name.Equals(SmelterDefinitions.SpinningWheelName) && Configuration.Current.SpinningWheel.IsEnabled)
{
__instance.m_maxOre = Configuration.Current.SpinningWheel.maximumFlax;
__instance.m_secPerProduct = Configuration.Current.SpinningWheel.productionSpeed;
}
}
static void Postfix(Smelter __instance, ref ItemDrop.ItemData __result)
{
if (!AllowByKey() || __result != null || ((int)typeof(Smelter).GetMethod("GetQueueSize", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(__instance, new object[] { })) >= __instance.m_maxOre)
{
return;
}
Dbgl($"missing cookable in player inventory");
List <Container> nearbyContainers = GetNearbyContainers(__instance.transform.position);
foreach (Smelter.ItemConversion itemConversion in __instance.m_conversion)
{
foreach (Container c in nearbyContainers)
{
ItemDrop.ItemData item = c.GetInventory().GetItem(itemConversion.m_from.m_itemData.m_shared.m_name);
if (item != null)
{
if (oreDisallowTypes.Value.Split(',').Contains(item.m_dropPrefab.name))
{
Dbgl($"container at {c.transform.position} has {item.m_stack} {item.m_dropPrefab.name} but it's forbidden by config");
continue;
}
Dbgl($"container at {c.transform.position} has {item.m_stack} {item.m_dropPrefab.name}, taking one");
__result = item;
c.GetInventory().RemoveItem(itemConversion.m_from.m_itemData.m_shared.m_name, 1);
typeof(Container).GetMethod("Save", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(c, new object[] { });
typeof(Inventory).GetMethod("Changed", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(c.GetInventory(), new object[] { });
return;
}
}
}
}
public static async void RefuelSmelter(Smelter __instance, ZNetView ___m_nview, int delay)
{
await Task.Delay(delay);
int maxOre = __instance.m_maxOre - Traverse.Create(__instance).Method("GetQueueSize").GetValue <int>();
int maxFuel = __instance.m_maxFuel - Mathf.CeilToInt(___m_nview.GetZDO().GetFloat("fuel", 0f));
List <Container> nearbyOreContainers = GetNearbyContainers(__instance.transform.position, smelterOreRange.Value);
List <Container> nearbyFuelContainers = GetNearbyContainers(__instance.transform.position, smelterFuelRange.Value);
Vector3 position = __instance.transform.position + Vector3.up;
foreach (Collider collider in Physics.OverlapSphere(position, dropRange.Value, LayerMask.GetMask(new string[] { "item" })))
{
if (collider?.attachedRigidbody)
{
ItemDrop item = collider.attachedRigidbody.GetComponent <ItemDrop>();
//Dbgl($"nearby item name: {item.m_itemData.m_dropPrefab.name}");
if (item?.GetComponent <ZNetView>()?.IsValid() != true)
{
continue;
}
string name = GetPrefabName(item.gameObject.name);
foreach (Smelter.ItemConversion itemConversion in __instance.m_conversion)
{
if (item.m_itemData.m_shared.m_name == itemConversion.m_from.m_itemData.m_shared.m_name && maxOre > 0)
{
if (oreDisallowTypes.Value.Split(',').Contains(name))
{
//Dbgl($"container at {c.transform.position} has {item.m_itemData.m_stack} {item.m_dropPrefab.name} but it's forbidden by config");
continue;
}
Dbgl($"auto adding ore {name} from ground");
int amount = Mathf.Min(item.m_itemData.m_stack, maxOre);
maxOre -= amount;
for (int i = 0; i < amount; i++)
{
if (item.m_itemData.m_stack <= 1)
{
if (___m_nview.GetZDO() == null)
{
Destroy(item.gameObject);
}
else
{
ZNetScene.instance.Destroy(item.gameObject);
}
___m_nview.InvokeRPC("AddOre", new object[] { name });
break;
}
item.m_itemData.m_stack--;
___m_nview.InvokeRPC("AddOre", new object[] { name });
Traverse.Create(item).Method("Save").GetValue();
}
}
}
if (__instance.m_fuelItem && item.m_itemData.m_shared.m_name == __instance.m_fuelItem.m_itemData.m_shared.m_name && maxFuel > 0)
{
if (fuelDisallowTypes.Value.Split(',').Contains(name))
{
//Dbgl($"ground has {item.m_itemData.m_dropPrefab.name} but it's forbidden by config");
continue;
}
Dbgl($"auto adding fuel {name} from ground");
int amount = Mathf.Min(item.m_itemData.m_stack, maxFuel);
maxFuel -= amount;
for (int i = 0; i < amount; i++)
{
if (item.m_itemData.m_stack <= 1)
{
if (___m_nview.GetZDO() == null)
{
Destroy(item.gameObject);
}
else
{
ZNetScene.instance.Destroy(item.gameObject);
}
___m_nview.InvokeRPC("AddFuel", new object[] { });
break;
}
item.m_itemData.m_stack--;
___m_nview.InvokeRPC("AddFuel", new object[] { });
Traverse.Create(item).Method("Save").GetValue();
}
}
}
}
foreach (Container c in nearbyOreContainers)
{
foreach (Smelter.ItemConversion itemConversion in __instance.m_conversion)
{
ItemDrop.ItemData oreItem = c.GetInventory().GetItem(itemConversion.m_from.m_itemData.m_shared.m_name);
if (oreItem != null && maxOre > 0)
{
maxOre--;
if (oreDisallowTypes.Value.Split(',').Contains(oreItem.m_dropPrefab.name))
{
continue;
}
Dbgl($"container at {c.transform.position} has {oreItem.m_stack} {oreItem.m_dropPrefab.name}, taking one");
___m_nview.InvokeRPC("AddOre", new object[] { oreItem.m_dropPrefab?.name });
c.GetInventory().RemoveItem(itemConversion.m_from.m_itemData.m_shared.m_name, 1);
typeof(Container).GetMethod("Save", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(c, new object[] { });
typeof(Inventory).GetMethod("Changed", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(c.GetInventory(), new object[] { });
}
}
}
foreach (Container c in nearbyFuelContainers)
{
if (__instance.m_fuelItem && maxFuel > 0)
{
ItemDrop.ItemData fuelItem = c.GetInventory().GetItem(__instance.m_fuelItem.m_itemData.m_shared.m_name);
if (fuelItem != null)
{
maxFuel--;
if (fuelDisallowTypes.Value.Split(',').Contains(fuelItem.m_dropPrefab.name))
{
//Dbgl($"container at {c.transform.position} has {item.m_stack} {item.m_dropPrefab.name} but it's forbidden by config");
continue;
}
Dbgl($"container at {c.transform.position} has {fuelItem.m_stack} {fuelItem.m_dropPrefab.name}, taking one");
___m_nview.InvokeRPC("AddFuel", new object[] { });
c.GetInventory().RemoveItem(__instance.m_fuelItem.m_itemData.m_shared.m_name, 1);
typeof(Container).GetMethod("Save", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(c, new object[] { });
typeof(Inventory).GetMethod("Changed", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(c.GetInventory(), new object[] { });
}
}
}
}
public static void Postfix(Smelter __instance)
{
//__instance. += $"\n[<color=yellow><b>{WorkshopImprovementsConfig.LoadMaxHotkey}</b></color>] Load maximum " + __instance.m_fuelItem
}
private static bool Prefix(string ore, int stack, ref Smelter __instance)
{
Smelter smelter = __instance; // allowing access to local function
if (!smelter.m_nview.IsOwner())
{
return(true);
}
if (__instance.m_name.Equals(SmelterDefinitions.KilnName) && Configuration.Current.Kiln.IsEnabled && Configuration.Current.Kiln.autoDeposit)
{
return(spawn(Helper.Clamp(Configuration.Current.Kiln.autoRange, 1, 50), Configuration.Current.Kiln.ignorePrivateAreaCheck));
}
if (__instance.m_name.Equals(SmelterDefinitions.SmelterName) && Configuration.Current.Smelter.IsEnabled && Configuration.Current.Smelter.autoDeposit)
{
return(spawn(Helper.Clamp(Configuration.Current.Smelter.autoRange, 1, 50), Configuration.Current.Smelter.ignorePrivateAreaCheck));
}
if (__instance.m_name.Equals(SmelterDefinitions.FurnaceName) && Configuration.Current.Furnace.IsEnabled && Configuration.Current.Furnace.autoDeposit)
{
return(spawn(Helper.Clamp(Configuration.Current.Furnace.autoRange, 1, 50), Configuration.Current.Furnace.ignorePrivateAreaCheck));
}
if (__instance.m_name.Equals(SmelterDefinitions.WindmillName) && Configuration.Current.Windmill.IsEnabled && Configuration.Current.Windmill.autoDeposit)
{
return(spawn(Helper.Clamp(Configuration.Current.Windmill.autoRange, 1, 50), Configuration.Current.Windmill.ignorePrivateAreaCheck));
}
if (__instance.m_name.Equals(SmelterDefinitions.SpinningWheelName) && Configuration.Current.SpinningWheel.IsEnabled && Configuration.Current.SpinningWheel.autoDeposit)
{
return(spawn(Helper.Clamp(Configuration.Current.SpinningWheel.autoRange, 1, 50), Configuration.Current.Windmill.ignorePrivateAreaCheck));
}
bool spawn(float autoDepositRange, bool ignorePrivateAreaCheck)
{
List <Container> nearbyChests = InventoryAssistant.GetNearbyChests(smelter.gameObject, autoDepositRange, !ignorePrivateAreaCheck);
if (nearbyChests.Count == 0)
{
return(true);
}
if (autoDepositRange > 50)
{
autoDepositRange = 50;
}
else if (autoDepositRange < 1)
{
autoDepositRange = 1;
}
// Replicating original code, just "spawning/adding" the item inside the chest makes it "not have a prefab"
GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(smelter.GetItemConversion(ore).m_to.gameObject.name);
// Also replication of original code, really have no idead what it is for, didn't bother look
ZNetView.m_forceDisableInit = true;
GameObject spawnedOre = Object.Instantiate <GameObject>(itemPrefab);
ZNetView.m_forceDisableInit = false;
// assign stack size, nobody wants a 0/20 stack of metals (its not very usefull)
ItemDrop comp = spawnedOre.GetComponent <ItemDrop>();
comp.m_itemData.m_stack = stack;
bool result = spawnNearbyChest(true);
Object.Destroy(spawnedOre);
bool spawnNearbyChest(bool mustHaveItem)
{
foreach (Container chest in nearbyChests)
{
Inventory cInventory = chest.GetInventory();
if (mustHaveItem && !cInventory.HaveItem(comp.m_itemData.m_shared.m_name))
{
continue;
}
bool added = cInventory.AddItem(comp.m_itemData);
if (!added)
{
// Chest full, move to the next
continue;
}
smelter.m_produceEffects.Create(smelter.transform.position, smelter.transform.rotation, null, 1f);
InventoryAssistant.ConveyContainerToNetwork(chest);
return(false);
}
if (mustHaveItem)
{
return(spawnNearbyChest(false));
}
return(true);
}
return(result);
}
return(true);
}
static void Prefix(Smelter __instance)
{
if (__instance == null || !Player.m_localPlayer || __instance.m_nview == null || !__instance.m_nview.IsOwner())
{
return;
}
Smelter smelter = __instance;
Stopwatch delta = GameObjectAssistant.GetStopwatch(smelter.gameObject);
if (delta.IsRunning && delta.ElapsedMilliseconds < 1000)
{
return;
}
delta.Restart();
float autoFuelRange = 0f;
bool ignorePrivateAreaCheck = false;
bool isKiln = false;
if (smelter.m_name.Equals(SmelterDefinitions.KilnName))
{
if (!Configuration.Current.Kiln.IsEnabled || !Configuration.Current.Kiln.autoFuel)
{
return;
}
isKiln = true;
autoFuelRange = Configuration.Current.Kiln.autoRange;
ignorePrivateAreaCheck = Configuration.Current.Kiln.ignorePrivateAreaCheck;
}
else if (smelter.m_name.Equals(SmelterDefinitions.SmelterName))
{
if (!Configuration.Current.Smelter.IsEnabled || !Configuration.Current.Smelter.autoFuel)
{
return;
}
autoFuelRange = Configuration.Current.Smelter.autoRange;
ignorePrivateAreaCheck = Configuration.Current.Smelter.ignorePrivateAreaCheck;
}
else if (smelter.m_name.Equals(SmelterDefinitions.FurnaceName))
{
if (!Configuration.Current.Furnace.IsEnabled || !Configuration.Current.Furnace.autoFuel)
{
return;
}
autoFuelRange = Configuration.Current.Furnace.autoRange;
ignorePrivateAreaCheck = Configuration.Current.Furnace.ignorePrivateAreaCheck;
}
else if (__instance.m_name.Equals(SmelterDefinitions.WindmillName))
{
if (!Configuration.Current.Windmill.IsEnabled || !Configuration.Current.Windmill.autoFuel)
{
return;
}
autoFuelRange = Configuration.Current.Windmill.autoRange;
ignorePrivateAreaCheck = Configuration.Current.Windmill.ignorePrivateAreaCheck;
}
else if (__instance.m_name.Equals(SmelterDefinitions.SpinningWheelName))
{
if (!Configuration.Current.SpinningWheel.IsEnabled || !Configuration.Current.SpinningWheel.autoFuel)
{
return;
}
autoFuelRange = Configuration.Current.SpinningWheel.autoRange;
ignorePrivateAreaCheck = Configuration.Current.SpinningWheel.ignorePrivateAreaCheck;
}
autoFuelRange = Helper.Clamp(autoFuelRange, 1, 50);
int toMaxOre = smelter.m_maxOre - smelter.GetQueueSize();
int toMaxFuel = smelter.m_maxFuel - (int)System.Math.Ceiling(smelter.GetFuel());
if (smelter.m_fuelItem && toMaxFuel > 0)
{
ItemDrop.ItemData fuelItemData = smelter.m_fuelItem.m_itemData;
// Check for fuel in nearby containers
int addedFuel = InventoryAssistant.RemoveItemInAmountFromAllNearbyChests(smelter.gameObject, autoFuelRange, fuelItemData, toMaxFuel, !ignorePrivateAreaCheck);
for (int i = 0; i < addedFuel; i++)
{
smelter.m_nview.InvokeRPC("AddFuel", new object[] { });
}
if (addedFuel > 0)
{
ZLog.Log("Added " + addedFuel + " fuel(" + fuelItemData.m_shared.m_name + ") in " + smelter.m_name);
}
}
if (toMaxOre > 0)
{
List <Container> nearbyChests = InventoryAssistant.GetNearbyChests(smelter.gameObject, autoFuelRange);
foreach (Container c in nearbyChests)
{
foreach (Smelter.ItemConversion itemConversion in smelter.m_conversion)
{
if (isKiln)
{
if (Configuration.Current.Kiln.dontProcessFineWood && itemConversion.m_from.m_itemData.m_shared.m_name.Equals(WoodDefinitions.FineWoodName))
{
continue;
}
if (Configuration.Current.Kiln.dontProcessRoundLog && itemConversion.m_from.m_itemData.m_shared.m_name.Equals(WoodDefinitions.RoundLogName))
{
continue;
}
int threshold = Configuration.Current.Kiln.stopAutoFuelThreshold < 0 ? 0 : Configuration.Current.Kiln.stopAutoFuelThreshold;
if (threshold > 0 && InventoryAssistant.GetItemAmountInItemList(InventoryAssistant.GetNearbyChestItemsByContainerList(nearbyChests), itemConversion.m_to.m_itemData) >= threshold)
{
return;
}
}
ItemDrop.ItemData oreItem = itemConversion.m_from.m_itemData;
int addedOres = InventoryAssistant.RemoveItemFromChest(c, oreItem, toMaxOre);
if (addedOres > 0)
{
GameObject orePrefab = ObjectDB.instance.GetItemPrefab(itemConversion.m_from.gameObject.name);
for (int i = 0; i < addedOres; i++)
{
smelter.m_nview.InvokeRPC("AddOre", new object[] { orePrefab.name });
}
toMaxOre -= addedOres;
if (addedOres > 0)
{
ZLog.Log("Added " + addedOres + " ores(" + oreItem.m_shared.m_name + ") in " + smelter.m_name);
}
if (toMaxOre == 0)
{
return;
}
}
}
}
}
}
