void OnConsumeFuel(BaseOven oven, Item fuel, ItemModBurnable burnable)
{
if (config.Trigger != 2)
{
return;
}
if (oven == null)
{
return;
}
if (sky.IsNight)
{
if (TurnedOff.Contains(oven.net.ID))
{
return;
}
else
{
TurnedOff.Add(oven.net.ID);
}
if (!Activated)
{
Activated = true;
}
CheckOven(oven);
}
if (sky.IsDay)
{
Activated = false;
TurnedOff.Clear();
}
}
void OnConsumeFuel(BaseOven oven, Item fuel, ItemModBurnable burnable)
{
if (oven.panelName == "Lantern")
{
fuel.amount++;
}
}
public void Cook()
{
Item item = FindBurnable();
if (Interface.CallHook("OnOvenCook", this, item) != null)
{
return;
}
if (item == null)
{
StopCooking();
return;
}
base.inventory.OnCycle(0.5f);
BaseEntity slot = GetSlot(Slot.FireMod);
if ((bool)slot)
{
slot.SendMessage("Cook", 0.5f, SendMessageOptions.DontRequireReceiver);
}
ItemModBurnable component = item.info.GetComponent <ItemModBurnable>();
item.fuel -= 0.5f * (cookingTemperature / 200f);
if (!item.HasFlag(Item.Flag.OnFire))
{
item.SetFlag(Item.Flag.OnFire, true);
item.MarkDirty();
}
if (item.fuel <= 0f)
{
ConsumeFuel(item, component);
}
Interface.CallHook("OnOvenCooked", this, item, slot);
}
public void ConsumeFuel(Item fuel, ItemModBurnable burnable)
{
if (Interface.CallHook("OnFuelConsume", this, fuel, burnable) != null)
{
return;
}
if (allowByproductCreation && burnable.byproductItem != null && UnityEngine.Random.Range(0f, 1f) > burnable.byproductChance)
{
Item item = ItemManager.Create(burnable.byproductItem, burnable.byproductAmount, 0uL);
if (!item.MoveToContainer(base.inventory))
{
OvenFull();
item.Drop(base.inventory.dropPosition, base.inventory.dropVelocity);
}
}
if (fuel.amount <= 1)
{
fuel.Remove();
return;
}
fuel.amount--;
fuel.fuel = burnable.fuelAmount;
fuel.MarkDirty();
Interface.CallHook("OnFuelConsumed", this, fuel, burnable);
}
void OnConsumeFuel(BaseOven oven, Item fuel, ItemModBurnable burnable)
{
if (!MessageDone)
{
Puts("Fire Burning.... LIGHTS OUT !! time is " + sky.Cycle.DateTime + "|" + oven.ToString());
//PrintToChat("Night time, Fires Buring.... LIGHTS OUT !! time is " + sky.Cycle.DateTime + " Dont forget to /vote ^_*");
PrintToChat(lang.GetMessage("nightTime", this).Replace("{time}", sky.Cycle.DateTime.ToString()));
lightsList.Add("MessageDone");
MessageDone = true;
}
//DEBUG LINE //PrintToChat(" Is Night: " + sky.IsNight.ToString() + "|" + oven.ToString() + "| RUST Time: " + sky.Cycle.DateTime.ToString("HH:mm:ss")); //DEBUG
//if (sky.Cycle.Hour >= 18 && sky.Cycle.Hour <= 6) // <-- another way to do it with more targeted times ?
if (sky.IsNight)
{
if (lightsList != null)
{
if (lightsList.Contains(oven.ToString()) == false)
{
oven.StopCooking();
oven.SetFlag(BaseEntity.Flags.On, false);
lightsList.Add(oven.ToString());
}
}
}
else
{
if (lightsList != null)
{
if (lightsList.Count > 0)
{
lightsList.Clear();
}
}
}
}
private void OnConsumeFuel(BaseOven oven, Item fuel, ItemModBurnable burnable)
{
if (compatibleOvens.Contains(oven.ShortPrefabName))
{
queuedUiUpdates.Push(oven);
}
}
public void Cook()
{
Item item = this.FindBurnable();
if (item == null)
{
this.StopCooking();
return;
}
this.inventory.OnCycle(0.5f);
BaseEntity slot = base.GetSlot(BaseEntity.Slot.FireMod);
if (slot)
{
slot.SendMessage("Cook", 0.5f, SendMessageOptions.DontRequireReceiver);
}
ItemModBurnable component = item.info.GetComponent <ItemModBurnable>();
Item item1 = item;
item1.fuel = item1.fuel - 0.5f * (this.cookingTemperature / 200f);
if (!item.HasFlag(Item.Flag.OnFire))
{
item.SetFlag(Item.Flag.OnFire, true);
item.MarkDirty();
}
if (item.fuel <= 0f)
{
this.ConsumeFuel(item, component);
}
}
private void OnConsumeFuel(BaseOven oven, Item fuel, ItemModBurnable burnable)
{
if (!isInitialized || oven == null || fuel == null)
{
return;
}
ConsumeType type = StringToType(oven?.ShortPrefabName ?? string.Empty);
if (type == ConsumeType.None)
{
return;
}
if (IsActiveType(type))
{
if (usingPermissions && oven.OwnerID != 0U)
{
if (!HasPermission(oven.OwnerID.ToString(), type))
{
return;
}
}
fuel.amount += 1;
}
}
void OnConsumeFuel(BaseOven oven, Item fuel, ItemModBurnable burnable)
{
/* Lantern */
if ((bool)Config["lantern"])
{
if (oven.temperature == BaseOven.TemperatureType.Warming)
{
++fuel.amount;
}
}
/* Campfire */
if ((bool)Config["campfire"])
{
if (oven.temperature == BaseOven.TemperatureType.Cooking)
{
++fuel.amount;
}
}
/* Furnace */
if ((bool)Config["furnace"])
{
if (oven.temperature == BaseOven.TemperatureType.Smelting)
{
++fuel.amount;
}
}
}
void OnConsumeFuel(BaseOven oven, Item fuel, ItemModBurnable burnable)
{
/* Lantern */
if ((bool) Config["lantern"])
{
if (oven.temperature == BaseOven.TemperatureType.Warming)
{
++fuel.amount;
}
}
/* Campfire */
if ((bool) Config["campfire"])
{
if (oven.temperature == BaseOven.TemperatureType.Cooking)
{
++fuel.amount;
}
}
/* Furnace */
if ((bool) Config["furnace"])
{
if (oven.temperature == BaseOven.TemperatureType.Smelting)
{
++fuel.amount;
}
}
}
public void CookOverride()
{
SmeltTicks++;
if (SmeltTicks % 2 == 0)
{
TrySmeltItems();
}
var burnable = _plugin.FindBurnable(Furnace);
if (burnable == null)
{
_plugin.StopCooking(Furnace);
return;
}
ItemModBurnable component = burnable.info.GetComponent <ItemModBurnable>();
burnable.fuel -= 0.5f * Furnace.cookingTemperature / 200f;
if (!burnable.HasFlag(global::Item.Flag.OnFire))
{
burnable.SetFlag(global::Item.Flag.OnFire, true);
burnable.MarkDirty();
}
if (burnable.fuel <= 0f)
{
var array = ArrayPool.Get(2);
array[0] = burnable;
array[1] = component;
ConsumeFuelMethod.Invoke(Furnace, array);
ArrayPool.Free(array);
}
}
public void Cook()
{
Item burnable = this.FindBurnable();
if (burnable == null)
{
this.StopCooking();
}
else
{
this.inventory.OnCycle(0.5f);
BaseEntity slot = this.GetSlot(BaseEntity.Slot.FireMod);
if (Object.op_Implicit((Object)slot))
{
((Component)slot).SendMessage(nameof(Cook), (object)0.5f, (SendMessageOptions)1);
}
ItemModBurnable component = (ItemModBurnable)((Component)burnable.info).GetComponent <ItemModBurnable>();
burnable.fuel -= (float)(0.5 * ((double)this.cookingTemperature / 200.0));
if (!burnable.HasFlag(Item.Flag.OnFire))
{
burnable.SetFlag(Item.Flag.OnFire, true);
burnable.MarkDirty();
}
if ((double)burnable.fuel > 0.0)
{
return;
}
this.ConsumeFuel(burnable, component);
}
}
void OnConsumeFuel(BaseOven oven, Item fuel, ItemModBurnable burnable)
{
BaseEntity slot = oven.GetSlot(BaseEntity.Slot.FireMod);
if (slot != null)
{
//Usually 0.5f for cook tick, fuel is only consumed twice per second
slot.SendMessage("Cook", 2f * Settings.SmeltSpeed * Settings.WaterPurifierMultiplier, SendMessageOptions.DontRequireReceiver);
}
if (oven == null || oven is BaseFuelLightSource)
{
return;
}
// Check if permissions are enabled and player has permission
if (Settings.UsePermissions && !permission.UserHasPermission(oven.OwnerID.ToString(), permAllow))
{
return;
}
var data = oven.transform.GetOrAddComponent <FurnaceData>();
#region Charcoal Modifier
if (burnable.byproductItem != null)
{
oven.allowByproductCreation = false;
int charcoalAmount = 0;
float modifiedRate = Settings.CharcoalRate * Settings.WoodRate;
charcoalAmount += (int)(Settings.CharcoalRate * Settings.WoodRate);
modifiedRate -= charcoalAmount;
if (modifiedRate > 0 && modifiedRate <= 1f)
{
if (UnityEngine.Random.Range(0f, 1f) < modifiedRate)
{
charcoalAmount += 1;
}
}
if (charcoalAmount > 0)
{
TryAddItem(oven.inventory, burnable.byproductItem, Mathf.Min(charcoalAmount, fuel.amount));
}
}
#endregion
// Modify the amount of fuel to use
fuel.UseItem(Settings.WoodRate - 1);
}
void OnConsumeFuel(BaseOven oven, Item fuel, ItemModBurnable burnable)
{
if (!init)
{
return;
}
bool charcoal = false;
int mul = GetMultiplier(oven.OwnerID);
foreach (var item in oven.inventory.itemList.ToList())
{
if (!charcoal && item.info == charcoalDef)
{
charcoal = true;
item.amount += mul;
}
if (!cookableItems.ContainsKey(item.info))
{
continue;
}
int amountToCreate;
if (item.amount > mul)
{
item.MarkDirty();
item.amount -= mul;
amountToCreate = mul;
}
else
{
amountToCreate = item.amount;
item.RemoveFromContainer();
item.Remove();
}
var cookedDef = cookableItems[item.info].becomeOnCooked;
var cookedAmount = amountToCreate * cookableItems[item.info].amountOfBecome;
var cookedOvenItem =
oven.inventory.itemList.Where(p => p.info == cookedDef).OrderBy(p => p.amount).FirstOrDefault();
if (cookedOvenItem != null)
{
var amount = Math.Min(cookedOvenItem.MaxStackable() - cookedOvenItem.amount, cookedAmount);
cookedOvenItem.amount += amount;
if (cookedAmount - amount <= 0)
{
continue;
}
}
var cookedItem = ItemManager.Create(cookedDef, cookedAmount);
if (!cookedItem.MoveToContainer(oven.inventory))
{
cookedItem.Drop(oven.GetDropPosition(), oven.GetDropVelocity());
}
}
}
double GetBurntime(ItemDefinition item)
{
foreach (ItemMod mod in item.itemMods)
{
if (!(mod is ItemModBurnable))
{
continue;
}
ItemModBurnable burnable = mod as ItemModBurnable;
return(burnable.fuelAmount / 5);
}
return(0D);
}
private void OnConsumeFuel(BaseOven oven, Item fuel, ItemModBurnable burnable)
{
if (!isInitialized)
{
return;
}
LightController lightController = oven.GetComponent <LightController>();
if (lightController != null)
{
lightController.OnConsumeFuel(fuel);
}
}
/// <summary>
/// ON COOK FURNACE
/// ON COOK FIRE
/// ON FUEL LIGHT
/// </summary>
/// <param name="oven"></param>
/// <param name="fuel"></param>
/// <param name="burnable"></param>
void OnConsumeFuel(BaseOven oven, Item fuel, ItemModBurnable burnable)
{
if (oven.name.Contains("furnace"))
{
Interface.CallHook("OnCookFurnace", oven, fuel, burnable);
}
else if (oven.name.Contains("campfire"))
{
Interface.CallHook("OnCookFire", oven, fuel, burnable);
}
else if (oven.name.Contains("light") || oven.name.Contains("lantern"))
{
Interface.CallHook("OnFuelLight", oven, fuel, burnable);
}
}
Item FindBurnable(BaseOven oven)
{
if (oven.inventory == null)
{
return(null);
}
foreach (Item current in oven.inventory.itemList)
{
ItemModBurnable component = current.info.GetComponent <ItemModBurnable>();
if (component && (oven.fuelType == null || current.info == oven.fuelType))
{
return(current);
}
}
return(null);
}
private void OnConsumeFuel(BaseOven oven, Item fuel, ItemModBurnable burnable)
{
//Debug("Fuel used : " + oven.ShortPrefabName.ToString());
var allowedToRefull = new List <string>
{
"tunalight", "ceilinglight", "lantern",
};
if (!allowedToRefull.Contains(oven.panelName))
{
return;
}
//Debug("Refuilling");
fuel.amount += 1;
}
void OnConsumeFuel(BaseOven oven, Item fuel, ItemModBurnable burnable)
{
if (oven == null || oven is BaseFuelLightSource)
{
return;
}
// Check if permissions are enabled and player has permission
if (Settings.UsePermissions && !permission.UserHasPermission(oven.OwnerID.ToString(), permAllow)) return;
var data = oven.transform.GetOrAddComponent<FurnaceData>();
#region Charcoal Modifier
if (burnable.byproductItem != null)
{
oven.allowByproductCreation = false;
int charcoalAmount = 0;
float modifiedRate = Settings.CharcoalRate * Settings.WoodRate;
charcoalAmount += (int)(Settings.CharcoalRate * Settings.WoodRate);
modifiedRate -= charcoalAmount;
if (modifiedRate > 0 && modifiedRate <= 1f)
{
if (UnityEngine.Random.Range(0f, 1f) < modifiedRate)
{
charcoalAmount += 1;
}
}
if (charcoalAmount > 0)
{
TryAddItem(oven.inventory, burnable.byproductItem, Mathf.Min(charcoalAmount, fuel.amount));
}
}
#endregion
// Modify the amount of fuel to use
fuel.UseItem(Settings.WoodRate - 1);
}
void Unload()
{
if (expertModeEnabled)
{
// Loop through item definitions
var itemDefinitions = ItemManager.itemList;
foreach (var item in itemDefinitions)
{
// Skip any item definitions other than cooked meat
if (!item.shortname.Contains(".cooked"))
{
continue;
}
// Lower high temperature on item definition to prevent burning
var cookable = item.GetComponent <ItemModCookable>();
if (cookable != null)
{
cookable.highTemp = 250;
}
}
return;
}
foreach (var item in ItemManager.GetItemDefinitions())
{
ItemModBurnable component = item.GetComponent <ItemModBurnable>();
if (component && component.name == "wood.item")
{
component.byproductChance = 0.25f;
component.fuelAmount = 10f;
component.byproductAmount = 1;
}
if (item.shortname.Contains("cooked") || item.shortname.Contains("raw") || item.shortname.Contains("meat.boar") || item.shortname == ("bearmeat"))
{
var cookable = item.GetComponent <ItemModCookable>();
if (cookable != null)
{
cookable.lowTemp = 150;
cookable.highTemp = 250;
}
}
}
}
void OnConsumeFuel(BaseOven oven, Item fuel, ItemModBurnable burnable)
{
if (!isActivated || nfrInstalled || configData.ConsumeFuel || oven == null || fuel == null || !lights.Contains(oven))
{
return;
}
ConsumeTypes type = StringToType(oven?.ShortPrefabName ?? string.Empty);
if (type == ConsumeTypes.None)
{
return;
}
if (configData.LightTypes[type])
{
fuel.amount++;
}
}
void OnConsumeFuel(BaseOven oven, Item fuel, ItemModBurnable burnable)
{
ConsumeTypes type = StringToType(oven?.ShortPrefabName);
if (type == ConsumeTypes.None)
{
return;
}
if (IsActiveType(type))
{
if (usingPermissions && oven.OwnerID != 0U)
{
if (!HasPermission(oven.OwnerID.ToString(), type))
{
return;
}
}
++fuel.amount;
}
}
private void ConsumeFuel(Item fuel, ItemModBurnable burnable)
{
Interface.CallHook("OnConsumeFuel", this, fuel, burnable);
if (this.allowByproductCreation && burnable.byproductItem != null && UnityEngine.Random.Range(0f, 1f) > burnable.byproductChance)
{
Item item = ItemManager.Create(burnable.byproductItem, burnable.byproductAmount, (ulong)0);
if (!item.MoveToContainer(this.inventory, -1, true))
{
this.OvenFull();
item.Drop(this.inventory.dropPosition, this.inventory.dropVelocity, new Quaternion());
}
}
if (fuel.amount <= 1)
{
fuel.Remove(0f);
return;
}
fuel.amount--;
fuel.fuel = burnable.fuelAmount;
fuel.MarkDirty();
}
void OnConsumeFuel(BaseOven oven, Item fuel, ItemModBurnable burnable)
{
if (Settings.UsePermissions)
{
if (permission.UserHasPermission(oven.OwnerID.ToString(), PermAllowed) == false)
{
return;
}
}
if (oven.inventory.itemList.Any(x => x.info.GetComponent <ItemModCookable>()))
{
foreach (var item in oven.inventory.itemList)
{
if (item == fuel)
{
continue;
}
if (item.HasFlag(global::Item.Flag.OnFire))
{
item.SetFlag(global::Item.Flag.OnFire, false);
}
}
return;
}
foreach (var item in oven.inventory.itemList.Where(x => x.info.shortname == "wood" && x != fuel).ToList())
{
item.SetFlag(global::Item.Flag.OnFire, true);
var charcoalMod = item.info.GetComponent <ItemModBurnable>();
if (UnityEngine.Random.Range(0f, 1f) > Settings.CharcoalChance)
{
var charcoal = ItemManager.Create(charcoalMod.byproductItem, Settings.CharcoalPerWood);
if (!charcoal.MoveToContainer(oven.inventory))
{
oven.OvenFull();
item.Drop(oven.inventory.dropPosition, oven.inventory.dropVelocity);
}
}
item.UseItem(Settings.WoodSmeltedPerTick);
}
}
void Unload()
{
foreach (var item in ItemManager.GetItemDefinitions())
{
ItemModBurnable component = item.GetComponent <ItemModBurnable>();
if (component && component.name == "wood.item")
{
component.byproductChance = 0.25f;
component.fuelAmount = 10f;
component.byproductAmount = 1;
}
if (item.shortname.Contains("cooked") || item.shortname.Contains("raw") || item.shortname.Contains("meat.boar") || item.shortname == ("bearmeat"))
{
var cookable = item.GetComponent <ItemModCookable>();
if (cookable != null)
{
cookable.lowTemp = 150;
cookable.highTemp = 250;
}
}
}
}
void OnConsumeFuel(BaseOven oven, Item fuel, ItemModBurnable burnable)
{
int data = checkLight(oven.transform);
if (debug)
{
Puts(data.ToString());
}
if (data != 6)
{
if (data < 3)
{
fuel.amount += 1;
return;
}
lightFuel.Remove(oven.transform);
if (debug)
{
Puts($"-1 fuel from {oven.name} {oven.transform.position}!");
}
}
}
private void ConsumeFuel(Item fuel, ItemModBurnable burnable)
{
Interface.CallHook("OnConsumeFuel", (object)this, (object)fuel, (object)burnable);
if (this.allowByproductCreation && Object.op_Inequality((Object)burnable.byproductItem, (Object)null) && (double)Random.Range(0.0f, 1f) > (double)burnable.byproductChance)
{
Item obj = ItemManager.Create(burnable.byproductItem, burnable.byproductAmount, 0UL);
if (!obj.MoveToContainer(this.inventory, -1, true))
{
this.OvenFull();
obj.Drop(this.inventory.dropPosition, this.inventory.dropVelocity, (Quaternion)null);
}
}
if (fuel.amount <= 1)
{
fuel.Remove(0.0f);
}
else
{
--fuel.amount;
fuel.fuel = burnable.fuelAmount;
fuel.MarkDirty();
}
}
private void ConsumeFuel(Item fuel, ItemModBurnable burnable)
{
if (Furnace.allowByproductCreation && burnable.byproductItem != null && Random.Range(0f, 1f) > burnable.byproductChance)
{
var def = burnable.byproductItem;
var item = ItemManager.Create(def, (int)(burnable.byproductAmount * OutputMultiplier(def.shortname))); // It's fuel multiplier
if (!item.MoveToContainer(Furnace.inventory))
{
StopCooking();
item.Drop(Furnace.inventory.dropPosition, Furnace.inventory.dropVelocity);
}
}
if (fuel.amount <= 1)
{
fuel.Remove();
return;
}
fuel.amount -= _fuelUsageMultiplier;
fuel.fuel = burnable.fuelAmount;
fuel.MarkDirty();
}
// for jack o laterns
private void OnConsumeFuel(BaseOven oven, Item fuel, ItemModBurnable burnable)
{
if (oven == null || string.IsNullOrEmpty(oven.ShortPrefabName) ||
oven.OwnerID == null || oven.OwnerID == 0U || oven.OwnerID.ToString() == null)
{
return;
}
if (!permission.UserHasPermission(oven.OwnerID.ToString(), perm_freelights) ||
!ProcessShortPrefabName(oven.ShortPrefabName) ||
!IsLightPrefabName(oven.ShortPrefabName))
{
return;
}
else
{
fuel.amount += 1;
oven.StopCooking();
oven.allowByproductCreation = false;
oven.SetFlag(BaseEntity.Flags.On, true);
}
// catch all
return;
}
void OnConsumeFuel(BaseOven oven, Item fuel, ItemModBurnable burnable)
{
// Check if furnance is usable
if (oven == null)
{
return;
}
// Check if permissions are enabled and player has permission
if (usePermissions && !permission.UserHasPermission(oven.OwnerID.ToString(), permAllow))
{
return;
}
// Modify the amount of fuel to use
fuel.amount -= fuelUsageModifier - 1;
// Modify the amount of byproduct to produce
burnable.byproductAmount = 1 * (int)byproductModifier;
burnable.byproductChance = (100 - byproductPercent) / 100f;
// Loop through furance inventory slots
for (var i = 0; i < oven.inventorySlots; i++)
{
try
{
// Check for and ignore invalid items
var slotItem = oven.inventory.GetSlot(i);
if (slotItem == null || !slotItem.IsValid())
{
continue;
}
// Check for and ignore non-cookables
var cookable = slotItem.info.GetComponent <ItemModCookable>();
if (cookable == null)
{
continue;
}
// Skip already cooked food items
if (slotItem.info.shortname.EndsWith(".cooked"))
{
continue;
}
// The chance of consumption is going to result in a 1 or 0
var consumptionAmount = (int)Math.Ceiling(cookedModifier * (Random.Range(0f, 1f) <= cookedPercent ? 1 : 0));
// Check how many are actually in the furnace, before we try removing too many
var inFurnaceAmount = slotItem.amount;
if (inFurnaceAmount < consumptionAmount)
{
consumptionAmount = inFurnaceAmount;
}
// Set consumption to however many we can pull from this actual stack
consumptionAmount = TakeFromInventorySlot(oven.inventory, slotItem.info.itemid, consumptionAmount, i);
// If we took nothing, then... we can't create any
if (consumptionAmount <= 0)
{
continue;
}
// Create the item(s) that are now cooked
var cookedItem = ItemManager.Create(cookable.becomeOnCooked, cookable.amountOfBecome * consumptionAmount);
if (!cookedItem.MoveToContainer(oven.inventory))
{
cookedItem.Drop(oven.inventory.dropPosition, oven.inventory.dropVelocity);
}
}
catch (InvalidOperationException) { }
}
}
public ConsumeFuelEvent(BaseOven baseOven, Item fuel, ItemModBurnable burnable)
{
BaseOven = baseOven;
Item = new InvItem(fuel);
Burnable = burnable;
}
public void OnConsumeFuel(BaseOven oven, Item fuel, ItemModBurnable burnable)
{
var instanceId = RPGHelper.OvenId(oven);
if (!PlayersFurnaces.ContainsKey(instanceId))
return;
var steamId = Convert.ToUInt64(PlayersFurnaces[instanceId]);
var player = BasePlayer.FindByID(steamId) ?? BasePlayer.FindSleeping(steamId);
var rpgInfo = player == null ? RPGInfo(PlayersFurnaces[instanceId]) : RPGInfo(player);
if (rpgInfo == null)
return;
if (!rpgInfo.Skills.ContainsKey(HRK.Blacksmith))
return;
var skillPoints = rpgInfo.Skills[HRK.Blacksmith];
double random = Random(0, 1);
float skillChance = (float)skillPoints/7;
float maybeGiveAmount = (float)skillPoints/2;
int amountToGive = (int) Math.Ceiling(maybeGiveAmount);
if (random > skillChance)
return;
var itemList = oven.inventory.itemList;
var itensCanMelt = (from item in itemList let itemModCookable = item.info.GetComponent<ItemModCookable>() where itemModCookable != null select item).ToList();
foreach (var item in itensCanMelt)
{
var itemModCookable = item.info.GetComponent<ItemModCookable>();
oven.inventory.Take(null, item.info.itemid, amountToGive);
var itemToGive = ItemManager.Create(itemModCookable.becomeOnCooked, amountToGive);
if (!itemToGive.MoveToContainer(oven.inventory))
itemToGive.Drop(oven.inventory.dropPosition, oven.inventory.dropVelocity);
}
}
public static void ConsumeFuel(BaseOven bo, Item fuel, ItemModBurnable burn)
{
OnConsumeFuel.OnNext(new ConsumeFuelEvent(bo, fuel, burn));
}
private void OnConsumeFuel(BaseOven oven, Item fuel, ItemModBurnable burnable)
{
var byproductChance = burnable.byproductChance * CharcoalChanceModifier;
if (oven.allowByproductCreation && burnable.byproductItem != null && Random.Range(0.0f, 1f) <= byproductChance)
{
Item obj = ItemManager.Create(burnable.byproductItem, (int) Math.Round(burnable.byproductAmount * CharcoalProductionModifier));
if (!obj.MoveToContainer(oven.inventory))
obj.Drop(oven.inventory.dropPosition, oven.inventory.dropVelocity);
}
for (int i = 0; i < oven.inventorySlots; i++)
{
try
{
var slotItem = oven.inventory.GetSlot(i);
if (slotItem == null || !slotItem.IsValid())
continue;
var cookable = slotItem.info.GetComponent<ItemModCookable>();
if (cookable == null)
{
continue;
}
if (cookable.becomeOnCooked.category == ItemCategory.Food && slotItem.info.shortname.Trim().EndsWith(".cooked") && DontOvercookMeat)
{
continue;
}
// Some simple math here.
// The chance of consumption is going to result in a 1 or 0.
// Anything * 0 == 0
// Which basically means... don't smelt anything yet.
var consumptionAmount = (int) Math.Ceiling(ProductionModifier * (Random.Range(0f, 1f) <= ChancePerConsumption ? 1 : 0));
// Check how many are actually in the furnace, before we try removing too many. :)
var inFurnaceAmount = slotItem.amount;
if (inFurnaceAmount < consumptionAmount)
{
consumptionAmount = inFurnaceAmount;
}
// Set consumption to however many we can pull from this actual stack.
consumptionAmount = TakeFromInventorySlot(oven.inventory, slotItem.info.itemid, consumptionAmount, i);
// If we took nothing, then... we can't create any.
if (consumptionAmount <= 0)
{
continue;
}
// Create the item(s) that are now smelted.
var smeltedItem = ItemManager.Create(cookable.becomeOnCooked, cookable.amountOfBecome * consumptionAmount);
if (!smeltedItem.MoveToContainer(oven.inventory))
{
smeltedItem.Drop(oven.inventory.dropPosition, oven.inventory.dropVelocity);
}
}
catch (InvalidOperationException)
{
// Eat this. Modified collection. Blah blah.
}
}
}
public ConsumeFuelEvent(BaseOven bo, Item fuel, ItemModBurnable burn)
{
_baseOven = bo;
_item = new InvItem(fuel);
_burn = burn;
}
/// <summary>
/// Called from <c>BaseOven.ConsumeFuel(Item, ItemModBurnable)</c> .
/// </summary>
public static void On_ConsumeFuel(BaseOven bo, Item fuel, ItemModBurnable burn) => OnNext("On_ConsumeFuel", new ConsumeFuelEvent(bo, fuel, burn));
private void OnConsumeFuel(BaseOven oven, Item fuel, ItemModBurnable burnable)
{
HookCalled("OnConsumeFuel");
// TODO: Print fuel consumed
}
