Ejemplo n.º 1
0
        internal static float GetScentIntensity(ModComponent modComponent)
        {
            Scent scent = ModUtils.GetComponent <Scent>(modComponent);

            if (scent == null)
            {
                return(0f);
            }

            switch (scent.m_ScentCategory)
            {
            case ScentRangeCategory.COOKED_MEAT:
                return(5f);

            case ScentRangeCategory.COOKED_FISH:
                return(5f);

            case ScentRangeCategory.GUTS:
                return(20f);

            case ScentRangeCategory.QUARTER:
                return(50f);

            case ScentRangeCategory.RAW_MEAT:
                return(15f);

            case ScentRangeCategory.RAW_FISH:
                return(15f);

            default:
                return(0f);
            }
        }
Ejemplo n.º 2
0
        internal static void Configure(ModComponent modComponent)
        {
            ModScentComponent modScentComponent = ModUtils.GetComponent <ModScentComponent>(modComponent);

            if (modScentComponent == null)
            {
                return;
            }

            Scent scent = ModUtils.GetOrCreateComponent <Scent>(modScentComponent);

            scent.m_ScentCategory = ModUtils.TranslateEnumValue <ScentRangeCategory, ScentCategory>(modScentComponent.scentCategory);
        }
        internal static void Configure(ModComponent modComponent)
        {
            ModCookableComponent modCookableComponent = modComponent as ModCookableComponent;

            if (modCookableComponent == null || !modCookableComponent.Cooking)
            {
                return;
            }

            Cookable cookable = ModUtils.GetOrCreateComponent <Cookable>(modCookableComponent);

            cookable.m_CookableType               = ModUtils.TranslateEnumValue <Cookable.CookableType, CookableType>(modCookableComponent.type);
            cookable.m_CookTimeMinutes            = modCookableComponent.CookingMinutes;
            cookable.m_ReadyTimeMinutes           = modCookableComponent.BurntMinutes;
            cookable.m_NumUnitsRequired           = modCookableComponent.CookingUnitsRequired;
            cookable.m_PotableWaterRequiredLiters = modCookableComponent.CookingWaterRequired;
            cookable.m_WarmUpNearFireRange        = 1.5f;

            cookable.m_CookAudio     = ModUtils.DefaultIfEmpty(modCookableComponent.CookingAudio, GetDefaultCookAudio(modCookableComponent));
            cookable.m_PutInPotAudio = ModUtils.DefaultIfEmpty(modCookableComponent.StartCookingAudio, GetDefaultStartCookingAudio(modCookableComponent));

            Cookable template = ModUtils.GetComponent <Cookable>(Resources.Load <GameObject>("GEAR_PinnacleCanPeaches"));

            cookable.m_MeshPotStyle       = template?.m_MeshPotStyle;
            cookable.m_MeshCanStyle       = template?.m_MeshCanStyle;
            cookable.m_LiquidMeshRenderer = template?.m_LiquidMeshRenderer;

            // either just heat or convert, but not both
            if (modCookableComponent.CookingResult == null)
            {
                // no conversion, just heating
                FoodItem foodItem = ModUtils.GetComponent <FoodItem>(modCookableComponent);
                if (foodItem != null)
                {
                    foodItem.m_HeatedWhenCooked = true;
                }
            }
            else
            {
                // no heating, but instead convert the item when cooking completes
                GearItem cookedGearItem = modCookableComponent.CookingResult.GetComponent <GearItem>();
                if (cookedGearItem == null)
                {
                    // not mapped yet, do it now
                    Mapper.Map(modCookableComponent.CookingResult);
                    cookedGearItem = modCookableComponent.CookingResult.GetComponent <GearItem>();
                }

                cookable.m_CookedPrefab = cookedGearItem ?? throw new ArgumentException("CookingResult does not map to GearItem for prefab " + modCookableComponent.name);
            }
        }
        internal static void Postfix(Panel_Cooking __instance)
        {
            List <GearItem> foodList = Traverse.Create(__instance).Field("m_FoodList").GetValue <List <GearItem> >();

            if (foodList == null)
            {
                return;
            }

            foreach (GearItem eachGearItem in foodList)
            {
                CookingModifier cookingModifier = ModUtils.GetComponent <CookingModifier>(eachGearItem);
                cookingModifier?.Revert();
            }
        }
        internal static void Postfix(GearItem placedGearNew)
        {
            if (placedGearNew == null || placedGearNew.m_CookingPotItem == null || !placedGearNew.m_CookingPotItem.AttachedFireIsBurning())
            {
                return;
            }

            CookingPotItem       cookingPotItem       = placedGearNew.m_CookingPotItem;
            OverrideCookingState overrideCookingState = ModUtils.GetComponent <OverrideCookingState>(cookingPotItem);

            if (overrideCookingState?.ForceReady ?? false)
            {
                WaterUtils.SetElapsedCookingTimeForWater(cookingPotItem, WaterUtils.GetWaterAmount(cookingPotItem));
            }
        }
        internal static void Configure(ModComponent modComponent)
        {
            ModEvolveComponent modEvolveComponent = ModUtils.GetComponent <ModEvolveComponent>(modComponent);

            if (modEvolveComponent == null)
            {
                return;
            }

            EvolveItem evolveItem = ModUtils.GetOrCreateComponent <EvolveItem>(modEvolveComponent);

            evolveItem.m_ForceNoAutoEvolve    = false;
            evolveItem.m_GearItemToBecome     = GetTargetItem(modEvolveComponent.TargetItemName, modEvolveComponent.name);
            evolveItem.m_RequireIndoors       = modEvolveComponent.IndoorsOnly;
            evolveItem.m_StartEvolvePercent   = 0;
            evolveItem.m_TimeToEvolveGameDays = Mathf.Clamp(modEvolveComponent.EvolveHours / 24f, 0.01f, 1000);
        }
        public static void Configure(ModComponent modComponent)
        {
            ModSharpenableComponent modSharpenableComponent = ModUtils.GetComponent <ModSharpenableComponent>(modComponent);

            if (modSharpenableComponent == null)
            {
                return;
            }

            Sharpenable sharpenable = ModUtils.GetOrCreateComponent <Sharpenable>(modSharpenableComponent);

            sharpenable.m_ConditionIncreaseMax = modSharpenableComponent.ConditionMax;
            sharpenable.m_ConditionIncreaseMin = modSharpenableComponent.ConditionMin;
            sharpenable.m_DurationMinutesMax   = modSharpenableComponent.MinutesMax;
            sharpenable.m_DurationMinutesMin   = modSharpenableComponent.MinutesMin;

            sharpenable.m_SharpenToolChoices    = ModUtils.GetItems <ToolsItem>(modSharpenableComponent.Tools, modComponent.name + ": Tools");
            sharpenable.m_RequiresToolToSharpen = sharpenable.m_SharpenToolChoices.Count() > 0;
        }
Ejemplo n.º 8
0
        internal static void Configure(ModComponent modComponent)
        {
            ModFireStarterComponent modFireStarterComponent = ModUtils.GetComponent <ModFireStarterComponent>(modComponent);

            if (modFireStarterComponent == null)
            {
                return;
            }

            FireStarterItem fireStarterItem = ModUtils.GetOrCreateComponent <FireStarterItem>(modFireStarterComponent);

            fireStarterItem.m_SecondsToIgniteTinder = modFireStarterComponent.SecondsToIgniteTinder;
            fireStarterItem.m_SecondsToIgniteTorch  = modFireStarterComponent.SecondsToIgniteTorch;

            fireStarterItem.m_FireStartSkillModifier = modFireStarterComponent.SuccessModifier;

            fireStarterItem.m_ConditionDegradeOnUse = Mapper.GetDecayPerStep(modFireStarterComponent.NumberOfUses, modComponent.MaxHP);
            fireStarterItem.m_ConsumeOnUse          = modFireStarterComponent.DestroyedOnUse;
            fireStarterItem.m_RequiresSunLight      = modFireStarterComponent.RequiresSunLight;
            fireStarterItem.m_OnUseSoundEvent       = modFireStarterComponent.OnUseSoundEvent;
        }
Ejemplo n.º 9
0
        internal static void Configure(ModComponent modComponent)
        {
            ModFirstAidComponent modFirstAidComponent = ModUtils.GetComponent <ModFirstAidComponent>(modComponent);

            if (modFirstAidComponent == null)
            {
                return;
            }

            FirstAidItem firstAidItem = ModUtils.GetOrCreateComponent <FirstAidItem>(modFirstAidComponent);

            // not used
            firstAidItem.m_AppliesSutures    = false;
            firstAidItem.m_StabalizesSprains = false;

            switch (modFirstAidComponent.FirstAidType)
            {
            case FirstAidType.Antibiotics:
                firstAidItem.m_ProvidesAntibiotics = true;
                break;

            case FirstAidType.Bandage:
                firstAidItem.m_AppliesBandage = true;
                break;

            case FirstAidType.Disinfectant:
                firstAidItem.m_AppliesBandage = true;
                break;

            case FirstAidType.PainKiller:
                firstAidItem.m_KillsPain = true;
                break;
            }

            firstAidItem.m_HPIncrease       = modFirstAidComponent.InstantHealing;
            firstAidItem.m_TimeToUseSeconds = modFirstAidComponent.TimeToUseSeconds;
            firstAidItem.m_UnitsPerUse      = modFirstAidComponent.UnitsPerUse;
            firstAidItem.m_UseAudio         = modFirstAidComponent.UseAudio;
        }
Ejemplo n.º 10
0
        internal static void Configure(ModComponent modComponent)
        {
            ModHarvestableComponent modHarvestableComponent = ModUtils.GetComponent <ModHarvestableComponent>(modComponent);

            if (modHarvestableComponent == null)
            {
                return;
            }

            Harvest harvest = ModUtils.GetOrCreateComponent <Harvest>(modHarvestableComponent);

            harvest.m_Audio           = modHarvestableComponent.Audio;
            harvest.m_DurationMinutes = modHarvestableComponent.Minutes;

            if (modHarvestableComponent.YieldNames.Length != modHarvestableComponent.YieldCounts.Length)
            {
                throw new ArgumentException("YieldNames and YieldCounts do not have the same length on gear item '" + modHarvestableComponent.name + "'.");
            }

            harvest.m_YieldGear      = ModUtils.GetItems <GearItem>(modHarvestableComponent.YieldNames, modHarvestableComponent.name);
            harvest.m_YieldGearUnits = modHarvestableComponent.YieldCounts;
        }