FREE DualFuelPumpjack : 3.1.2 3.1.2

using HarmonyLib;
using Newtonsoft.Json;
using Oxide.Core;
using System;
using System.Collections.Generic;
using System.Reflection;
using UnityEngine;

namespace Oxide.Plugins
{
    [Info("DualFuelPumpjack", "ZTL/FastBurst", "3.1.2")]
    [Description("Lets players use Low Grade Fuel for quarries/pumpjacks as a valid fuel source alongside Diesel.")]
    public class DualFuelPumpjack : RustPlugin
    {
        #region Vars
        private Harmony _harmony;
        public static DualFuelPumpjack _instance;

        private const string HarmonyId = "com.fastburst.dualfuelpumpjack";

        private const int DieselItemId = -946488912;
        private const int LowGradeItemId = -839770442;

        private const uint FuelStoragePumpID = 4260630588;
        private const uint OutputHopperPumpID = 70163214;
        private const uint FuelStorageQuarryID = 362963830;
        private const uint OutputHopperQuarryID = 875142383;
        #endregion

        #region Startup & Functions
        private void Init()
        {
            _instance = this;

            _harmony = new Harmony(HarmonyId);
            _harmony.PatchAll(Assembly.GetExecutingAssembly());
            Puts("DualFuelPumpjack Harmony patches applied.");
        }

        private void Unload()
        {
            _harmony?.UnpatchAll(HarmonyId);
            _harmony = null;
            _instance = null;
            Puts("DualFuelPumpjack Harmony patches removed.");
        }

        private void OnItemAddedToContainer(ItemContainer container, Item item)
        {
            if (item == null || container == null)
                return;

            var owner = container.entityOwner;
            if (owner == null)
                return;

            bool isQuarryOrPumpjack = owner is MiningQuarry || owner.ShortPrefabName.Contains("quarry") || owner.ShortPrefabName.Contains("pumpjack");

            if (!isQuarryOrPumpjack)
                return;
        }

        private ItemContainer.CanAcceptResult? CanAcceptItem(ItemContainer container, Item item, int targetSlot)
        {
            if (container == null || item == null)
                return null;

            var cupboard = container.entityOwner as BuildingPrivlidge;
            if (cupboard == null)
                return null;

            if (configData.AllowedItemShortnames.Contains(item.info.shortname))
            {
                return ItemContainer.CanAcceptResult.CanAccept;
            }

            return null;
        }
        #endregion

        #region Config
        private ConfigData configData;

        private class ConfigData
        {
            [JsonProperty(PropertyName = "Diesel Work Multiplier")]
            public float DieselMultiplier { get; set; }
            [JsonProperty(PropertyName = "Low Grade Work Multiplier")]
            public float LowGradeMultiplier { get; set; }
            [JsonProperty(PropertyName = "Fuel Consumption Per Tick")]
            public int FuelConsumption { get; set; }
            [JsonProperty(PropertyName = "Allowed Fuel Types")]
            public List<string> AllowedItemShortnames { get; set; }

            public VersionNumber Version { get; set; }
        }


        private ConfigData GetBaseConfig()
        {
            return new ConfigData
            {
                DieselMultiplier = 1.0f,        // Vanilla strength
                LowGradeMultiplier = 0.25f,     // 25% as strong as Diesel
                FuelConsumption = 1,            // Burns 1 fuel per tick
                AllowedItemShortnames = new List<string>
                {
                    "diesel_barrel",
                    "lowgradefuel"
                },
                Version = Version
            };
        }


        protected override void LoadConfig()
        {
            base.LoadConfig();

            try
            {
                configData = Config.ReadObject<ConfigData>();
            }
            catch
            {

            }

            if (configData == null)
            {
                LoadDefaultConfig();
            }

            if (configData.Version < Version)
                UpdateConfigValues();

            Config.WriteObject(configData, true);
        }

        protected override void LoadDefaultConfig()
        {
            configData = GetBaseConfig();
        }

        protected override void SaveConfig() => Config.WriteObject(configData, true);

        private void UpdateConfigValues()
        {
            PrintWarning("Config update detected! Updating config values...");

            ConfigData baseConfig = GetBaseConfig();

            if (configData.Version < new Core.VersionNumber(3, 1, 1))
            {
                configData = baseConfig;
                PrintWarning("Config has been reset to default!");
            }

            configData.Version = Version;
            PrintWarning("Config update completed!");
        }
        #endregion


        #region Harmony Patches
        [HarmonyPatch(typeof(MiningQuarry), nameof(MiningQuarry.CanAcceptItem))]
        public static class Patch_MiningQuarry_CanAcceptItem
        {
            static bool Prefix(Item item, ref bool __result)
            {
                if (item == null)
                    return true;

                var allowed = _instance.configData.AllowedItemShortnames;

                if (allowed.Contains(item.info.shortname))
                {
                    __result = true;
                    return false;
                }

                return true;
            }
        }

        [HarmonyPatch(typeof(MiningQuarry), nameof(MiningQuarry.ServerInit))]
        public static class Patch_MiningQuarry_ServerInit
        {
            static void Postfix(MiningQuarry __instance)
            {
                if (!__instance.isServer)
                    return;

                var fuelStorage = __instance.fuelStoragePrefab.instance.GetComponent<StorageContainer>();
                var inv = fuelStorage.inventory;

                // Pull allowed fuel types from config
                var allowed = _instance.configData.AllowedItemShortnames;

                // Fix: inv.canAcceptItem expects (BasePlayer, Item, int), so wrap with a lambda that ignores BasePlayer
                inv.canAcceptItem = (player, item, slot) =>
                {
                    if (item == null)
                        return false;

                    // Accept only items listed in config
                    return allowed.Contains(item.info.shortname);
                };
            }
        }

        [HarmonyPatch(typeof(MiningQuarry), nameof(MiningQuarry.FuelCheck))]
        public static class Patch_MiningQuarry_FuelCheck
        {
            static bool Prefix(MiningQuarry __instance, ref bool __result)
            {
                var cfg = _instance.configData;

                if (__instance.pendingWork > 0f)
                {
                    __result = true;
                    return false;
                }

                var fuelInv = __instance.fuelStoragePrefab.instance.GetComponent<StorageContainer>().inventory;

                float workAdded = 0f;

                foreach (string fuelShortname in cfg.AllowedItemShortnames)
                {
                    Item fuelItem = fuelInv.FindItemByItemName(fuelShortname);
                    if (fuelItem == null || fuelItem.amount < cfg.FuelConsumption)
                        continue;

                    float multiplier = 1f;

                    if (fuelShortname == "diesel_barrel")
                        multiplier = cfg.DieselMultiplier;

                    else if (fuelShortname == "lowgradefuel")
                        multiplier = cfg.LowGradeMultiplier;

                    object hookResult = Interface.CallHook("OnQuarryConsumeFuel", __instance, fuelItem);
                    if (hookResult is Item)
                        fuelItem = (Item)hookResult;

                    if (fuelItem == null || fuelItem.amount < cfg.FuelConsumption)
                        continue;

                    workAdded += (__instance.workPerFuel * multiplier);
                    fuelItem.UseItem(cfg.FuelConsumption);
                }

                if (workAdded > 0f)
                {
                    __instance.pendingWork += workAdded;
                    __result = true;
                    return false;
                }

                __result = false;
                return false;
            }
        }
        #endregion
    }
}