C#:
// Plugin formatted by redBDGR's Plugin Formatting Tool
using Oxide.Core;
using Oxide.Game.Rust.Cui;
using System;
using System.Collections;
using System.Collections.Generic;
using Oxide.Core.Configuration;
using UnityEngine;
namespace Oxide.Plugins {
[Info("PowerSmelt", "redBDGR", "1.0.11")]
[Description("Advanced smelting customisation")]
class PowerSmelt : RustPlugin {
private bool Changed;
public static PowerSmelt plugin;
private const string permissionNameADMIN = "powersmelt.admin";
private const string permissionNameDISCONNECT = "powersmelt.disconnect";
private const string permissionNameUSE = "powersmelt.use";
private Coroutine ovenInit;
private bool needPermissionToUse = false;
private bool useAdvancedConfig = false;
private bool useItemSmeltingIcons = true;
private bool useFinishedSmeltingAlerts = true;
private bool useOutOfFuelAlerts = true;
private bool useInventoryFullAlerts = true;
private bool searchForFuelInCupboard = false;
private float byproductMultiplier = 1f;
private float byproductPercent = 0.5f;
private float furnaceSpeedMultiplier = 1f;
private bool burnMeat = true;
private bool cookInFurnaces = false;
private Dictionary<string, object> productMultipliers = new Dictionary<string, object>();
private Dictionary<ItemDefinition, ItemDefinition> becomeRevert = new Dictionary<ItemDefinition, ItemDefinition>();
private Dictionary<string, FurnaceData> furnaceStats = new Dictionary<string, FurnaceData>();
private Dictionary<string, CuiElementContainer> uiDic = new Dictionary<string, CuiElementContainer>();
private Dictionary<string, ItemRevertData> revertDic = new Dictionary<string, ItemRevertData>();
private List<string> alertIgnoreList = new List<string>();
public class FurnaceData {
public bool produceByproduct = true;
public int byproductAmount = 1;
public float byproductChance = 0.5f;
public int fuelNeededPerTick = 1;
public float fuelBurnSpeedMultiplier = 1f;
public int extraFuelNeededPerItemSmelting = 0;
public bool useWoodAsFuel = true;
public bool useLowGradeAsFuel = false;
public float furnaceTemperature;
public bool dropProduceOnGroundWhenFull = false;
public bool dropByproductOnGroundWhenFull = false;
public float timeForOvenToGetToCookingTemp = 3f;
public DefaultOvenType ovenType;
public Dictionary<string, ItemSmeltData> itemSmeltData = new Dictionary<string, ItemSmeltData>();
}
public enum DefaultOvenType {
Campfire, Furnace, OilRefinery
}
public class ItemSmeltData {
public float amountOfProductToProduce = 1;
public int rawResourceCostPerRefine = 1;
public string itemToBecome = "";
public float timeToRefine = 5f;
public float chance = 1;
}
public class ItemRevertData {
public int amountOfBecome;
public float cookTime;
public ItemRevertData(int _amountOfBecome, float _cookTime) {
amountOfBecome = _amountOfBecome;
cookTime = _cookTime;
}
}
private DynamicConfigFile furnaceData;
private StoredData storedData;
private class StoredData {
public Dictionary<string, FurnaceData> furnaceStats = new Dictionary<string, FurnaceData>();
}
private void SaveData() {
storedData.furnaceStats = furnaceStats;
furnaceData.WriteObject(storedData);
}
private void LoadData() {
try {
storedData = furnaceData.ReadObject<StoredData>();
furnaceStats = storedData.furnaceStats;
if (furnaceStats == null) GenerateDefaultData();
else if (furnaceStats.Count == 0) GenerateDefaultData();
}
catch {
Puts("Failed to load data, creating new file");
storedData = new StoredData();
}
}
private void GenerateDefaultData() {
furnaceStats = new Dictionary<string, FurnaceData>() {
{
"bbq.deployed", new FurnaceData {
furnaceTemperature = 200, ovenType = DefaultOvenType.Campfire
}
}
, {
"bbq.static", new FurnaceData {
furnaceTemperature = 200, ovenType = DefaultOvenType.Campfire
}
}
, {
"campfire", new FurnaceData {
furnaceTemperature = 200, ovenType = DefaultOvenType.Campfire
}
}
, {
"campfire_static", new FurnaceData {
furnaceTemperature = 200, ovenType = DefaultOvenType.Campfire
}
}
, {
"fireplace.deployed", new FurnaceData {
furnaceTemperature = 200, ovenType = DefaultOvenType.Campfire
}
}
, {
"furnace", new FurnaceData {
furnaceTemperature = 1000, ovenType = DefaultOvenType.Furnace
}
}
, {
"furnace.large", new FurnaceData {
furnaceTemperature = 1000, ovenType = DefaultOvenType.Furnace
}
}
, {
"furnace_static", new FurnaceData {
furnaceTemperature = 1000, ovenType = DefaultOvenType.Furnace
}
}
, {
"hobobarrel_static", new FurnaceData {
furnaceTemperature = 200, ovenType = DefaultOvenType.Campfire
}
}
, {
"refinery_small_deployed", new FurnaceData {
furnaceTemperature = 1500, ovenType = DefaultOvenType.OilRefinery
}
}
, {
"skull_fire_pit", new FurnaceData {
furnaceTemperature = 200, ovenType = DefaultOvenType.Campfire
}
}
, {
"small_refinery_static", new FurnaceData {
furnaceTemperature = 1500, ovenType = DefaultOvenType.OilRefinery
}
}
, {
"cursedcauldron.deployed", new FurnaceData {
furnaceTemperature = 200, ovenType = DefaultOvenType.Campfire
}
}
,
}
;
foreach (var entry in furnaceStats) {
switch (entry.Value.ovenType) {
case DefaultOvenType.Campfire : foreach (ItemDefinition def in ItemManager.GetItemDefinitions()) {
ItemModCookable cookable = def?.GetComponent<ItemModCookable>();
if (!cookable) continue;
if (cookable.lowTemp <= 200) entry.Value.itemSmeltData.Add(def.shortname, new ItemSmeltData());
}
break;
case DefaultOvenType.Furnace : foreach (ItemDefinition def in ItemManager.GetItemDefinitions()) {
ItemModCookable cookable = def?.GetComponent<ItemModCookable>();
if (!cookable) continue;
if (cookable.lowTemp > 200 && cookable.lowTemp <= 1000) entry.Value.itemSmeltData.Add(def.shortname, new ItemSmeltData());
}
break;
case DefaultOvenType.OilRefinery : foreach (ItemDefinition def in ItemManager.GetItemDefinitions()) {
ItemModCookable cookable = def?.GetComponent<ItemModCookable>();
if (!cookable) continue;
if (cookable.lowTemp > 1000 && cookable.lowTemp <= 1500) entry.Value.itemSmeltData.Add(def.shortname, new ItemSmeltData());
}
break;
}
LoadDefaultNums(entry.Key);
}
SaveData();
Load();
}
private void LoadDefaultNums(string ovenName) {
foreach (var entry in furnaceStats[ovenName].itemSmeltData) {
ItemDefinition def = ItemManager.FindItemDefinition(entry.Key);
if (!def) {
Puts($"Could not find ItemDefinition for {entry.Key}");
continue;
}
ItemModCookable cookable = def.GetComponent<ItemModCookable>();
if (!cookable) {
Puts($"Could not find ItemModCookable for {entry.Key}");
continue;
}
entry.Value.amountOfProductToProduce = cookable.amountOfBecome;
entry.Value.itemToBecome = cookable.becomeOnCooked.shortname;
entry.Value.rawResourceCostPerRefine = 1;
entry.Value.timeToRefine = cookable.cookTime;
}
}
protected override void LoadDefaultConfig() {
Config.Clear();
LoadVariables();
}
private void LoadVariables() {
needPermissionToUse = Convert.ToBoolean(GetConfig("General Settings", "Need Permission For Custom Rates", false));
useAdvancedConfig = Convert.ToBoolean(GetConfig("General Settings", "Use Advanced Configuration", false));
useItemSmeltingIcons = Convert.ToBoolean(GetConfig("Advanced Settings", "Use Item Smelting Icons", true));
useFinishedSmeltingAlerts = Convert.ToBoolean(GetConfig("Advanced Settings", "Use Finished Smelting Alerts", true));
useOutOfFuelAlerts = Convert.ToBoolean(GetConfig("Advanced Settings", "Use Out Of Fuel Alerts", true));
useInventoryFullAlerts = Convert.ToBoolean(GetConfig("Advanced Settings", "Use Inventory Full Alerts", true));
searchForFuelInCupboard = Convert.ToBoolean(GetConfig("Advanced Settings", "Ovens Will Search For Fuel In Toolcupboard", false));
byproductPercent = FlipPercentile(Convert.ToSingle(GetConfig("Simple Settings", "Byproduct Percent", 0.5f)));
byproductMultiplier = Convert.ToSingle(GetConfig("Simple Settings", "Byproduct Multiplier", 1f));
furnaceSpeedMultiplier = Convert.ToSingle(GetConfig("Simple Settings", "Furnace Speed Multiplier", 1f));
productMultipliers = (Dictionary<string, object>)GetConfig("Simple Settings", "Product Multipliers", GetDefaultProductMultipliers());
burnMeat = Convert.ToBoolean(GetConfig("Simple Settings", "Burn Meat", true));
cookInFurnaces = Convert.ToBoolean(GetConfig("Simple Settings", "Cook In Meat Furnaces", false));
if (!Changed) return;
SaveConfig();
Changed = false;
}
private static Dictionary<string, object> GetDefaultProductMultipliers() {
Dictionary<string, object> x = new Dictionary<string, object>();
foreach(ItemDefinition def in ItemManager.GetItemDefinitions()) {
ItemModCookable cookable = def.GetComponent<ItemModCookable>();
if (cookable) x.Add(def.shortname, 1);
}
return x;
}
private void Init() {
plugin = this;
LoadVariables();
permission.RegisterPermission(permissionNameADMIN, this);
permission.RegisterPermission(permissionNameDISCONNECT, this);
permission.RegisterPermission(permissionNameUSE, this);
if (!useAdvancedConfig) {
Unsubscribe(nameof(OnEntitySpawned));
Unsubscribe(nameof(OnItemAddedToContainer));
Unsubscribe(nameof(OnItemRemovedFromContainer));
}
else {
furnaceData = Interface.Oxide.DataFileSystem.GetFile("PowerSmelt");
LoadData();
}
lang.RegisterMessages(new Dictionary<string, string> {
["No Permission"]
= "You are not allowed to use this command!", ["(Furnace Alert) Finished Smelting"] = "{0} has finished smelting {1}", ["(Furnace Alert) Out of Fuel"] = "{0} has run out of fuel", ["(Furnace Alert) Inventory Full"] = "{0}'s Inventory is full", ["(Furnace Alert) Alerts Enabled"] = "You have enabled furnace alerts", ["(Furnace Alert) Alerts Disabled"] = "You have disabled furnace alerts",
}
, this);
}
private void OnServerInitialized() {
if (useAdvancedConfig) {
Puts($"Starting oven initialization for {UnityEngine.Object.FindObjectsOfType<BaseOven>().Length} ovens");
ovenInit = ServerMgr.Instance.StartCoroutine(InitOvens());
}
else {
foreach(ItemDefinition def in ItemManager.GetItemDefinitions()) {
ItemModCookable cookable = def.GetComponent<ItemModCookable>();
if (cookable) {
if (burnMeat == false) if (def.shortname.Contains(".cooked")) cookable.highTemp = 150;
if (cookInFurnaces == true) if (def.shortname.Contains("raw") || def.shortname == "meat.boar" || def.shortname == "bearmeat") {
cookable.lowTemp = 800;
cookable.highTemp = 1200;
}
float defaultCookTime = 5;
int defaultAmountToBecome = 1;
object amountToBecome;
if (productMultipliers.TryGetValue(def.shortname, out amountToBecome)) {
defaultAmountToBecome = cookable.amountOfBecome;
cookable.amountOfBecome = cookable.amountOfBecome * Convert.ToInt32(amountToBecome);
}
revertDic.Add(def.shortname, new ItemRevertData(defaultAmountToBecome, defaultCookTime));
}
ItemModBurnable burnable = def.GetComponent<ItemModBurnable>();
if (burnable) {
burnable.byproductAmount = 1;
burnable.byproductChance = 0.5f;
burnable.byproductAmount = burnable.byproductAmount * Convert.ToInt32(byproductMultiplier);
burnable.byproductChance = byproductPercent;
}
}
foreach (BaseOven oven in UnityEngine.Object.FindObjectsOfType<BaseOven>()) {
if (oven.GetComponent<BaseFuelLightSource>()) continue;
if (!oven.HasFlag(BaseEntity.Flags.On)) continue;
BasePlayer player = BasePlayer.Find(oven.OwnerID.ToString());
if (needPermissionToUse) if (player) if (!permission.UserHasPermission(player.UserIDString, permissionNameUSE)) continue;
oven.CancelInvoke(oven.Cook);
oven.inventory.temperature = GetCookingTemperature(oven.temperature);
oven.UpdateAttachmentTemperature();
oven.InvokeRepeating(oven.Cook, 0.5f / furnaceSpeedMultiplier, 0.5f / furnaceSpeedMultiplier);
}
}
}
private void Unload() {
if (useAdvancedConfig) {
if (ovenInit != null) {
ServerMgr.Instance.StopCoroutine(ovenInit);
ovenInit = null;
Puts("Halting oven initialization");
}
UI.KillAllUI("PowerSmeltUI");
foreach (SmeltManager manager in UnityEngine.Object.FindObjectsOfType<SmeltManager>()) UnityEngine.Object.Destroy(manager);
}
else {
foreach (var def in ItemManager.GetItemDefinitions()) {
ItemModBurnable burnable = def.GetComponent<ItemModBurnable>();
if (burnable && def.shortname == "wood.item") {
burnable.fuelAmount = 10f;
burnable.byproductAmount = 1;
burnable.byproductChance = 0.25f;
}
ItemModCookable cookable = def.GetComponent<ItemModCookable>();
if (def.shortname.Contains("cooked") || def.shortname.Contains("raw") || def.shortname.Contains("meat.boar") || def.shortname == ("bearmeat")) {
if (cookable == null) continue;
cookable.highTemp = 250;
cookable.lowTemp = 150;
}
ItemRevertData data;
if (revertDic.TryGetValue(def.shortname, out data)) {
cookable.amountOfBecome = data.amountOfBecome;
cookable.cookTime = data.cookTime;
}
}
}
}
private void OnEntitySpawned(BaseNetworkable entity) {
if (!useAdvancedConfig) return;
BaseOven oven = entity.GetComponent<BaseOven>();
if (!oven) return;
if (oven.GetComponent<BaseFuelLightSource>()) return;
if (oven.GetComponent<SmeltManager>()) return;
oven.gameObject.AddComponent<SmeltManager>();
}
private object OnOvenToggle(BaseOven oven, BasePlayer player) {
if (oven == null || oven.GetComponent<BaseFuelLightSource>()) return null;
if (player != null) {
if (oven.needsBuildingPrivilegeToUse && !player.CanBuild()) return null;
if (needPermissionToUse) if (!permission.UserHasPermission(player.UserIDString, permissionNameUSE)) return null;
}
if (!useAdvancedConfig) {
if (oven.HasFlag(BaseEntity.Flags.On)) return null;
if (FindBurnable(oven) == null) return false;
oven.inventory.temperature = GetCookingTemperature(oven.temperature);
oven.UpdateAttachmentTemperature();
oven.CancelInvoke(oven.Cook);
oven.InvokeRepeating(oven.Cook, 0.5f / furnaceSpeedMultiplier, 0.5f / furnaceSpeedMultiplier);
oven.SetFlag(BaseEntity.Flags.On, true);
return false;
}
else {
if (!furnaceStats.ContainsKey(oven.ShortPrefabName)) return null;
SmeltManager manager = oven.GetComponent<SmeltManager>();
if (!manager) manager = oven.gameObject.AddComponent<SmeltManager>();
else {
if (oven.HasFlag(BaseEntity.Flags.On)) manager.StopCooking();
else manager.StartCooking();
}
if (player) manager.smeltPlayer = player;
return false;
}
}
private void OnItemAddedToContainer(ItemContainer container, Item item) {
if (item == null || container == null) return;
if (container.entityOwner == null) return;
SmeltManager manager = container.entityOwner.GetComponent<SmeltManager>();
if (!manager) return;
BaseOven oven = container.entityOwner.GetComponent<BaseOven>();
if (!oven) return;
if (!oven.HasFlag(BaseEntity.Flags.On)) return;
ItemSmeltData data = null;
if (manager.ItemIsCookable(item, ref data)) {
manager.StartCoroutine(manager.StartRefiningItem(item, data));
}
}
private void OnItemRemovedFromContainer(ItemContainer container, Item item) {
SmeltManager manager = container.entityOwner?.GetComponent<SmeltManager>();
if (!manager) return;
Coroutine routine;
if (manager.refineQue.TryGetValue(item, out routine)) {
manager.StopCoroutine(routine);
manager.refineQue.Remove(item);
item.SetFlag(global : : Item.Flag.Cooking, false);
}
}
private class SmeltManager : FacepunchBehaviour {
public BaseOven oven;
public FurnaceData furnaceData;
private BuildingPrivlidge cupboard;
private Item currentBurnable;
public Dictionary<Item, Coroutine> refineQue = new Dictionary<Item, Coroutine>();
public BasePlayer smeltPlayer;
private ItemDefinition woodDef = ItemManager.FindItemDefinition("wood");
private ItemDefinition lgfDef = ItemManager.FindItemDefinition("lowgradefuel");
private float ovenSpeed;
private bool itemSmeltingIcons = plugin.useItemSmeltingIcons;
private string englishName = "";
private enum AlertType {
FinishedSmelting, OutOfFuel, InventoryFull
}
private void Awake() {
oven = GetComponent<BaseOven>();
furnaceData = plugin.GetFurnaceData(oven);
if (furnaceData == null) {
Destroy(this);
return;
}
ovenSpeed = 0.5f / furnaceData.fuelBurnSpeedMultiplier;
englishName = GetEnglishName();
if (oven.HasFlag(BaseEntity.Flags.On)) {
StartCooking();
}
if (plugin.searchForFuelInCupboard) {
cupboard = GetComponent<DecayEntity>()?.GetBuildingPrivilege();
}
}
private void OnDestroy() {
if (oven) {
if (oven.HasFlag(BaseEntity.Flags.On)) {
StopCooking();
oven.StopCooking();
}
}
}
/* private void Update() { if (UnityEngine.Time.time >= startTime + 10f) { foreach (var entry in refineQue) Debug.Log(entry); startTime = UnityEngine.Time.time; } Debug.Log(oven?.inventory.temperature); } */
private void FuelTick() {
Item item = FindBurnable();
if (item == null) {
StopCooking();
SendAlertMessage(smeltPlayer ? smeltPlayer : BasePlayer.Find(oven.OwnerID.ToString()), AlertType.OutOfFuel);
return;
}
/* BaseEntity slot = oven.GetSlot(BaseEntity.Slot.FireMod); Used for vanilla item refine if (slot) { slot.SendMessage("Cook", 0.5f, SendMessageOptions.DontRequireReceiver); } */
ItemModBurnable component = item.info.GetComponent<ItemModBurnable>();
item.fuel = item.fuel - 0.5f * (furnaceData.furnaceTemperature / 200f);
if (item.fuel <= 0f) ConsumeFuel(item, component);
}
private IEnumerator StartRefiningCycles() {
yield return new WaitForSeconds(0.5f);
for (int i = 0; i < oven.inventory.capacity; i++) {
Item item1 = oven.inventory.GetSlot(i);
if (item1 == null) continue;
ItemSmeltData data = null;
if (ItemIsCookable(item1, ref data)) if (!refineQue.ContainsKey(item1)) refineQue.Add(item1, StartCoroutine(RefineItem(item1, data.timeToRefine)));
yield return new WaitForSeconds(0.1f);
}
}
public IEnumerator StartRefiningItem(Item item, ItemSmeltData data) {
if (!refineQue.ContainsKey(item)) refineQue.Add(item, StartCoroutine(RefineItem(item, data.timeToRefine)));
yield break;
}
private IEnumerator RefineItem(Item item, float timeToRefine) {
if (itemSmeltingIcons) {
item.SetFlag(global : : Item.Flag.Cooking, true);
item.MarkDirty();
}
yield return new WaitForSeconds(timeToRefine);
bool createNewRefineQue = false;
bool endStack = false;
if (item != null) {
if (item.GetRootContainer() == oven.inventory) {
if (oven.HasFlag(BaseEntity.Flags.On)) {
ItemSmeltData data;
if (furnaceData.itemSmeltData.TryGetValue(item.info.shortname, out data)) {
float x = data.amountOfProductToProduce;
float rawCost = Convert.ToSingle(data.rawResourceCostPerRefine);
float rawAmount = Convert.ToSingle(item.amount);
float amountOfProduct = Convert.ToSingle(x);
if (rawCost < 0) amountOfProduct = Mathf.RoundToInt(item.amount * x);
else if (amountOfProduct < 0) amountOfProduct = 1;
if (!TryTakeItems(item, Convert.ToInt32(rawCost))) {
if (rawCost > 0) amountOfProduct = amountOfProduct * (rawAmount / rawCost);
endStack = true;
}
if (data.chance != 1f) {
if (UnityEngine.Random.Range(0f, 1f) > data.chance) createNewRefineQue = true;
}
else {
ItemDefinition newDef = ItemManager.FindItemDefinition(data.itemToBecome);
if (newDef != null) {
Item item2 = ItemManager.CreateByItemID(newDef.itemid, Mathf.RoundToInt(amountOfProduct));
if (!item2.MoveToContainer(oven.inventory)) {
if (furnaceData.dropByproductOnGroundWhenFull) item2.Drop(oven.inventory.dropPosition, oven.inventory.dropVelocity);
else {
SendAlertMessage(smeltPlayer ? smeltPlayer : BasePlayer.Find(oven.OwnerID.ToString()), AlertType.InventoryFull);
StopCooking();
item2.Drop(oven.inventory.dropPosition, oven.inventory.dropVelocity);
}
}
createNewRefineQue = true;
}
}
}
if (data.rawResourceCostPerRefine < 0) createNewRefineQue = false;
}
}
}
if (createNewRefineQue == true && endStack == false) {
Coroutine routine;
if (refineQue.TryGetValue(item, out routine)) routine = StartCoroutine(RefineItem(item, timeToRefine));
else refineQue.Add(item, StartCoroutine(RefineItem(item, timeToRefine)));
}
}
public void StartCooking() {
Item fuel = FindBurnable();
if (fuel == null) return;
fuel.SetFlag(global : : Item.Flag.OnFire, true);
fuel.MarkDirty();
oven.inventory.temperature = furnaceData.furnaceTemperature;
oven.UpdateAttachmentTemperature();
oven.CancelInvoke(oven.Cook);
oven.InvokeRepeating(FuelTick, 0.5f, ovenSpeed);
StartCoroutine(StartRefiningCycles());
oven.SetFlag(BaseEntity.Flags.On, true);
oven.SetFlag(BaseEntity.Flags.Reserved5, true);
}
public void StopCooking() {
if (oven.inventory == null) return;
oven.inventory.temperature = 15f;
oven.UpdateAttachmentTemperature();
oven.CancelInvoke(FuelTick);
foreach (KeyValuePair<Item, Coroutine> entry in refineQue) StopCoroutine(entry.Value);
refineQue.Clear();
oven.SetFlag(BaseEntity.Flags.On, false);
foreach (Item item in oven.inventory.itemList) {
if (item.HasFlag(global : : Item.Flag.Cooking)) {
item.SetFlag(global : : Item.Flag.Cooking, false);
item.MarkDirty();
}
if (!item.HasFlag(global : : Item.Flag.OnFire)) {
continue;
}
item.SetFlag(global : : Item.Flag.OnFire, false);
item.MarkDirty();
}
}
private Item FindBurnable() {
if (oven == null) return null;
if (oven.inventory == null) return null;
if (currentBurnable != null) if (currentBurnable.GetRootContainer() == oven.inventory) if (currentBurnable.amount >= furnaceData.fuelNeededPerTick + furnaceData.extraFuelNeededPerItemSmelting * refineQue.Count) return currentBurnable;
if (cupboard != null) {
Item cupboardFuel = TryGetCupboardFuel();
if (cupboardFuel != null) return currentBurnable;
}
List<Item>.Enumerator enumerator = oven.inventory.itemList.GetEnumerator();
try {
while (enumerator.MoveNext()) {
Item current = enumerator.Current;
if (current == null) continue;
if (!current.info.GetComponent<ItemModBurnable>()) continue;
if (furnaceData.useLowGradeAsFuel && furnaceData.useWoodAsFuel) {
if (current.info == lgfDef || current.info == woodDef) {
int x = refineQue.Count;
if (x == 0) {
if (current.amount < furnaceData.fuelNeededPerTick) continue;
}
else if (current.amount < furnaceData.fuelNeededPerTick + furnaceData.extraFuelNeededPerItemSmelting * x) continue;
}
else continue;
}
else if (furnaceData.useWoodAsFuel) {
if (current.info == woodDef) {
int x = refineQue.Count;
if (x == 0) {
if (current.amount < furnaceData.fuelNeededPerTick) continue;
}
else if (current.amount < furnaceData.fuelNeededPerTick + furnaceData.extraFuelNeededPerItemSmelting * x) continue;
}
else continue;
}
else if (furnaceData.useLowGradeAsFuel) {
if (current.info == lgfDef) {
int x = refineQue.Count;
if (x == 0) {
if (current.amount < furnaceData.fuelNeededPerTick) continue;
}
else if (current.amount < furnaceData.fuelNeededPerTick + furnaceData.extraFuelNeededPerItemSmelting * x) continue;
}
else continue;
}
else return null;
currentBurnable = current;
return current;
}
return null;
}
finally {
((IDisposable)enumerator).Dispose();
}
}
private Item TryGetCupboardFuel() {
List<Item>.Enumerator enumerator = cupboard.inventory.itemList.GetEnumerator();
try {
while (enumerator.MoveNext()) {
Item current = enumerator.Current;
if (current == null) continue;
if (!current.info.GetComponent<ItemModBurnable>()) continue;
if (furnaceData.useLowGradeAsFuel && furnaceData.useWoodAsFuel) {
if (current.info == lgfDef || current.info == woodDef) {
int x = refineQue.Count;
if (x == 0) {
if (current.amount < furnaceData.fuelNeededPerTick) continue;
}
else if (current.amount < furnaceData.fuelNeededPerTick + furnaceData.extraFuelNeededPerItemSmelting * x) continue;
}
else continue;
}
else if (furnaceData.useWoodAsFuel) {
if (current.info == woodDef) {
int x = refineQue.Count;
if (x == 0) {
if (current.amount < furnaceData.fuelNeededPerTick) continue;
}
else if (current.amount < furnaceData.fuelNeededPerTick + furnaceData.extraFuelNeededPerItemSmelting * x) continue;
}
else continue;
}
else if (furnaceData.useLowGradeAsFuel) {
if (current.info == lgfDef) {
int x = refineQue.Count;
if (x == 0) {
if (current.amount < furnaceData.fuelNeededPerTick) continue;
}
else if (current.amount < furnaceData.fuelNeededPerTick + furnaceData.extraFuelNeededPerItemSmelting * x) continue;
}
else continue;
}
currentBurnable = current;
return current;
}
return null;
}
finally {
((IDisposable)enumerator).Dispose();
}
}
private void ConsumeFuel(Item fuel, ItemModBurnable burnable) {
if (furnaceData.produceByproduct && burnable.byproductItem != null && UnityEngine.Random.Range(0f, 1f) <= furnaceData.byproductChance) {
Item item = ItemManager.Create(burnable.byproductItem, Mathf.RoundToInt(furnaceData.byproductAmount));
if (!item.MoveToContainer(oven.inventory)) {
if (furnaceData.dropByproductOnGroundWhenFull) item.Drop(oven.inventory.dropPosition, oven.inventory.dropVelocity);
else {
SendAlertMessage(smeltPlayer ? smeltPlayer : BasePlayer.Find(oven.OwnerID.ToString()), AlertType.InventoryFull);
StopCooking();
item.Drop(oven.inventory.dropPosition, oven.inventory.dropVelocity);
}
}
}
int fuelNeeded = furnaceData.fuelNeededPerTick + furnaceData.extraFuelNeededPerItemSmelting;
if (fuel.amount <= fuelNeeded) {
fuel.Remove();
fuel.RemoveFromContainer();
return;
}
fuel.amount = fuel.amount - fuelNeeded;
fuel.fuel = burnable.fuelAmount;
fuel.MarkDirty();
}
private bool TryTakeItems(Item item, int amount) {
if (item.amount <= amount || amount < 0) {
SendAlertMessage(smeltPlayer ? smeltPlayer : BasePlayer.Find(oven.OwnerID.ToString()), AlertType.FinishedSmelting, item);
item.Remove();
return false;
}
else if (item.amount > amount) {
item.amount = item.amount - amount;
item.MarkDirty();
return true;
}
return false;
}
public bool ItemIsCookable(Item item, ref ItemSmeltData data) {
if (item == null) return false;
if (item.HasFlag(global : : Item.Flag.OnFire)) return false;
if (item == currentBurnable) return false;
if (furnaceData.itemSmeltData == null) return false;
if (!furnaceData.itemSmeltData.TryGetValue(item.info.shortname, out data)) return false;
ItemDefinition newDef = ItemManager.FindItemDefinition(data.itemToBecome);
if (newDef == null) return false;
return true;
}
private string GetEnglishName() {
switch (oven.ShortPrefabName) {
case "bbq.deployed" : return "BBQ";
case "bbq.static" : return "BBQ";
case "campfire" : return "Campfire";
case "campfire_static" : return "Campfire";
case "fireplace.deployed" : return "Fireplace";
case "furnace" : return "Furnace";
case "furnace.large" : return "Large Furnace";
case "furnace_static" : return "Furnace";
case "hobobarrel_static" : return "Hobo Barrel";
case "refinery_small_deployed" : return "Small Refinery";
case "skull_fire_pit" : return "Skull Fire Pit";
case "small_refinery_static" : return "Small Refinery";
}
return "Smelter";
}
private void SendAlertMessage(BasePlayer player, AlertType type, Item item = null) {
if (!player) return;
if (type == AlertType.FinishedSmelting && item != null) {
if (plugin.useFinishedSmeltingAlerts) player.ChatMessage(string.Format(plugin.msg("(Furnace Alert) Finished Smelting", player.UserIDString), englishName, item.info.displayName.english));
}
else if (type == AlertType.OutOfFuel) {
if (plugin.useOutOfFuelAlerts) player.ChatMessage(string.Format(plugin.msg("(Furnace Alert) Out of Fuel", player.UserIDString), englishName));
}
else if (type == AlertType.InventoryFull) {
if (plugin.useInventoryFullAlerts) player.ChatMessage(string.Format(plugin.msg("(Furnace Alert) Inventory Full", player.UserIDString), englishName));
}
}
}
[ChatCommand("powersmelt")]
private void CustomSmeltCMD(BasePlayer player, string command, string[] args) {
if (!permission.UserHasPermission(player.UserIDString, permissionNameADMIN)) {
player.ChatMessage(msg("No Permission", player.UserIDString));
return;
}
if (!useAdvancedConfig) {
player.ChatMessage("This command is unavailable as the advanced configuration is disabled");
return;
}
if (args.Length == 1) {
switch (args[0]) {
case "lookingat" : RaycastHit hit;
if (!UnityEngine.Physics.Raycast(player.eyes.HeadRay(), out hit)) {
player.ChatMessage("No valid entity was found");
return;
}
BaseEntity entity = hit.GetEntity();
if (!entity) {
player.ChatMessage("No valid entity was found");
return;
}
if (!entity.GetComponent<SmeltManager>()) {
player.ChatMessage("No valid entity was found");
return;
}
player.SendConsoleCommand("powersmelt.openovenoptionsui", entity.ShortPrefabName);
break;
case "apply" : SaveData();
LoadData();
ServerMgr.Instance.StartCoroutine(UpdateOvens());
player.ChatMessage($"Updating all furnaces...This will take approximately {(UnityEngine.Object.FindObjectsOfType<SmeltManager>().Length * 0.01f).ToString().Substring(0, 4)} seconds");
break;
case "update" : player.ChatMessage($"Updating all new furnaces...This may take a while");
ServerMgr.Instance.StartCoroutine(UpdateFurnaceData(player));
break;
}
return;
}
CreateOvenTypeUI(player);
}
private IEnumerator UpdateFurnaceData(BasePlayer player = null) {
foreach (BaseOven oven in UnityEngine.Object.FindObjectsOfType<BaseOven>()) {
yield return new WaitForSeconds(0.05f);
if (oven.GetComponent<BaseFuelLightSource>()) continue;
if (furnaceStats.ContainsKey(oven.ShortPrefabName)) continue;
switch (oven.temperature) {
case BaseOven.TemperatureType.Cooking : furnaceStats.Add(oven.ShortPrefabName, new FurnaceData() {
furnaceTemperature = 200, ovenType = DefaultOvenType.Campfire
}
);
break;
case BaseOven.TemperatureType.Smelting : furnaceStats.Add(oven.ShortPrefabName, new FurnaceData() {
furnaceTemperature = 1000, ovenType = DefaultOvenType.Furnace
}
);
break;
case BaseOven.TemperatureType.Fractioning : furnaceStats.Add(oven.ShortPrefabName, new FurnaceData() {
furnaceTemperature = 1500, ovenType = DefaultOvenType.OilRefinery
}
);
break;
}
FurnaceData data;
if (!furnaceStats.TryGetValue(oven.ShortPrefabName, out data)) {
continue;
}
switch (data.ovenType) {
case DefaultOvenType.Campfire : foreach (ItemDefinition def in ItemManager.GetItemDefinitions()) {
yield return new WaitForSeconds(0.01f);
ItemModCookable cookable = def?.GetComponent<ItemModCookable>();
if (!cookable) continue;
if (cookable.lowTemp <= 200) data.itemSmeltData.Add(def.shortname, new ItemSmeltData());
}
break;
case DefaultOvenType.Furnace : foreach (ItemDefinition def in ItemManager.GetItemDefinitions()) {
yield return new WaitForSeconds(0.01f);
ItemModCookable cookable = def?.GetComponent<ItemModCookable>();
if (!cookable) continue;
if (cookable.lowTemp > 200 && cookable.lowTemp <= 1000) data.itemSmeltData.Add(def.shortname, new ItemSmeltData());
}
break;
case DefaultOvenType.OilRefinery : foreach (ItemDefinition def in ItemManager.GetItemDefinitions()) {
yield return new WaitForSeconds(0.01f);
ItemModCookable cookable = def?.GetComponent<ItemModCookable>();
if (!cookable) continue;
if (cookable.lowTemp > 1000 && cookable.lowTemp <= 1500) data.itemSmeltData.Add(def.shortname, new ItemSmeltData());
}
break;
}
}
if (player) player.ChatMessage("Furnace data has been updated");
else Puts("Furnace data has been update");
SaveData();
}
[ChatCommand("furnacealerts")]
private void FurnaceAlertsCMD(BasePlayer player, string command, string[] args) {
if (alertIgnoreList.Contains(player.UserIDString)) {
alertIgnoreList.Remove(player.UserIDString);
player.ChatMessage(msg("(Furnace Alert) Alerts Disabled", player.UserIDString));
}
else {
alertIgnoreList.Add(player.UserIDString);
player.ChatMessage(msg("(Furnace Alert) Alerts Enabled", player.UserIDString));
}
}
[ConsoleCommand("powersmelt.closeui")]
private void CloseUICMD(ConsoleSystem.Arg arg) {
if (arg.Connection == null) return;
BasePlayer player = arg.Player();
if (player == null) return;
DestroyUI(player);
}
[ConsoleCommand("powersmelt.backtomenu")]
private void BackToMenuCMD(ConsoleSystem.Arg arg) {
if (arg.Connection == null) return;
BasePlayer player = arg.Player();
if (player == null) return;
CreateOvenTypeUI(player);
}
[ConsoleCommand("powersmelt.openovenoptionsui")]
private void OpenOvenOptionsUICMD(ConsoleSystem.Arg arg) {
if (arg.Connection == null) return;
BasePlayer player = arg.Player();
if (player == null) return;
if (!permission.UserHasPermission(player.UserIDString, permissionNameADMIN)) return;
if (arg.Args.Length != 1) return;
CreateOvenOptionsUI(player, arg.Args[0]);
}
[ConsoleCommand("powersmelt.updatefurnacedata")]
private void UpdateFuranceDataCMD(ConsoleSystem.Arg arg) {
if (arg.Connection == null) return;
BasePlayer player = arg.Player();
if (player == null) return;
if (!permission.UserHasPermission(player.UserIDString, permissionNameADMIN)) return;
Puts($"Updating all new furnaces...This may take a while");
ServerMgr.Instance.StartCoroutine(UpdateFurnaceData(player));
}
[ConsoleCommand("powersmelt.updateconfigoption")]
private void UpdateDataCMD(ConsoleSystem.Arg arg) {
BasePlayer player = arg.Player();
if (arg.Connection != null) {
if (player == null) return;
if (!permission.UserHasPermission(player.UserIDString, permissionNameADMIN)) return;
// ... [Code preview truncated due to length. Full source in attached file] ...