internal static void Postfix(CookingPotItem __instance)
{
if (!__instance.AttachedFireIsBurning() && WaterUtils.IsCookingItem(__instance))
{
__instance.PickUpCookedItem();
}
}
internal void ApplyToCookingPot()
{
CookingPotItem cookingPot = this.GetComponent <CookingPotItem>();
if (cookingPot == null)
{
MelonLoader.MelonLogger.LogError("CookingPotWaterSaveData applied to a non-cookingpotitem!");
}
else
{
cookingPot.m_CookingState = this.cookingState;
cookingPot.m_LitersSnowBeingMelted = this.litersSnowBeingMelted;
cookingPot.m_LitersWaterBeingBoiled = this.litersWaterBeingBoiled;
cookingPot.m_MinutesUntilCooked = this.minutesUntilCooked;
cookingPot.m_MinutesUntilRuined = this.minutesUntilRuined;
if (cookingState == CookingPotItem.CookingState.Cooking)
{
cookingPot.m_GrubMeshRenderer.sharedMaterials = cookingPot.m_BoilWaterPotMaterialsList;
}
else if (cookingState == CookingPotItem.CookingState.Ready)
{
cookingPot.m_GrubMeshRenderer.sharedMaterials = cookingPot.m_BoilWaterReadyMaterialsList;
}
}
}
internal static void Prefix(CookingPotItem __instance, ref CookingPotItem.CookingState cookingState) // circumvent the transformation to "ruined" after a long time period.
{
if (cookingState == CookingPotItem.CookingState.Cooking && !__instance.AttachedFireIsBurning() && WaterUtils.GetWaterAmount(__instance) > 0)
{
cookingState = __instance.GetCookingState();
}
}
internal static void Prefix(CookingPotItem __instance, ref CookingPotItem.CookingState cookingState)
{
if (cookingState == CookingPotItem.CookingState.Cooking && !__instance.AttachedFireIsBurning() && WaterUtils.GetWaterAmount(__instance) > 0)
{
cookingState = __instance.GetCookingState();
}
}
public static void Postfix(CookingPotItem __instance, ref bool __result)
{
if (Settings.options.embersSystem && Settings.options.embersSystemNoCooking && __result && __instance.m_FireBeingUsed?.m_EmberTimer > 0)
{
__result = false;
}
}
internal static bool Prefix(CookingPotItem __instance)
{
if (__instance.GetCookingState() == CookingPotItem.CookingState.Cooking)
{
return(true);
}
float waterAmount = WaterUtils.GetWaterAmount(__instance);
if (waterAmount <= 0)
{
return(true);
}
bool potable = __instance.GetCookingState() == CookingPotItem.CookingState.Ready;
GearItem gearItem = __instance.GetComponent <GearItem>();
WaterSupply waterSupply = gearItem.m_WaterSupply;
if (waterSupply == null)
{
waterSupply = gearItem.gameObject.AddComponent <WaterSupply>();
gearItem.m_WaterSupply = waterSupply;
}
waterSupply.m_VolumeInLiters = waterAmount;
waterSupply.m_WaterQuality = potable ? LiquidQuality.Potable : LiquidQuality.NonPotable;
waterSupply.m_TimeToDrinkSeconds = GameManager.GetInventoryComponent().GetPotableWaterSupply().m_WaterSupply.m_TimeToDrinkSeconds;
waterSupply.m_DrinkingAudio = GameManager.GetInventoryComponent().GetPotableWaterSupply().m_WaterSupply.m_DrinkingAudio;
GameManager.GetPlayerManagerComponent().UseInventoryItem(gearItem);
return(false);
}
internal static void Postfix(Panel_Cooking __instance)
{
GearItem cookedItem = __instance.GetSelectedFood();
if (cookedItem == null || cookedItem.m_Cookable == null)
{
return;
}
CookingPotItem cookingPotItem = __instance.m_CookingPotInteractedWith;
if (cookingPotItem == null)
{
return;
}
if (cookedItem.m_Cookable.m_PotableWaterRequiredLiters <= 0)
{
return;
}
float litersRequired = cookedItem.m_Cookable.m_PotableWaterRequiredLiters;
float additionalMinutes = litersRequired * __instance.m_MinutesToMeltSnowPerLiter * cookingPotItem.GetTotalCookMultiplier();
__instance.m_Label_CookedItemCookTime.text = GetCookingTime(cookedItem.m_Cookable.m_CookTimeMinutes * cookingPotItem.GetTotalCookMultiplier()) + " (+" + GetCookingTime(additionalMinutes) + " " + Localization.Get("GAMEPLAY_ButtonMelt") + ")";
}
private static void Prefix(GearItem __instance)
{
CookingPotItem cookingPot = __instance.m_CookingPotItem;
if (cookingPot != null)
{
ModComponentUtils.ComponentUtils.GetOrCreateComponent <CookingPotWaterSaveData>(__instance).GetFromCookingPot();
}
}
internal static bool IsCookingItem(CookingPotItem cookingPotItem)
{
if (!cookingPotItem.IsCookingSomething())
{
return(false);
}
return(Traverse.Create(cookingPotItem).Field("m_GearItemBeingCooked").GetValue() != null);
}
internal static void Postfix(CookingPotItem __instance)
{
TrackExitPlaceMesh.isExecuting = false;
// This is used to instantly pick up food from pot/ cans, when using right-click (It is bugged otherwise).
// It is not allowed for meat -> !__instance.IsDummyPot().
if (!__instance.AttachedFireIsBurning() && WaterUtils.IsCookingItem(__instance) && !__instance.IsDummyPot())
{
__instance.PickUpCookedItem();
}
}
internal void Initialize()
{
if (this.cookingPotItem != null)
{
return;
}
this.cookingPotItem = this.GetComponent <CookingPotItem>();
this.originalState = this.cookingPotItem.GetCookingState();
this.nextState = originalState - 1;
}
internal static void Postfix(CookingPotItem __instance)
{
if (__instance.AttachedFireIsBurning())
{
return;
}
if (__instance.m_ParticlesSnowMelting.activeInHierarchy && WaterUtils.IsCooledDown(__instance))
{
Utils.SetActive(__instance.m_ParticlesSnowMelting, false);
}
}
private static void ConfigureCookingPot(ModComponent modComponent)
{
ModCookingPotComponent modCookingPotComponent = modComponent as ModCookingPotComponent;
if (modCookingPotComponent == null)
{
return;
}
CookingPotItem cookingPotItem = ModUtils.GetOrCreateComponent <CookingPotItem>(modComponent);
cookingPotItem.m_WaterCapacityLiters = modCookingPotComponent.Capacity;
cookingPotItem.m_CanCookGrub = modCookingPotComponent.CanCookGrub;
cookingPotItem.m_CanCookLiquid = modCookingPotComponent.CanCookLiquid;
cookingPotItem.m_CanCookMeat = modCookingPotComponent.CanCookMeat;
cookingPotItem.m_CanOnlyWarmUpFood = false;
CookingPotItem template = ModUtils.GetItem <CookingPotItem>(modCookingPotComponent.Template, modComponent.name);
cookingPotItem.m_BoilingTimeMultiplier = template.m_BoilingTimeMultiplier;
cookingPotItem.m_BoilWaterPotMaterialsList = template.m_BoilWaterPotMaterialsList;
cookingPotItem.m_BoilWaterReadyMaterialsList = template.m_BoilWaterReadyMaterialsList;
cookingPotItem.m_ConditionPercentDamageFromBoilingDry = template.m_ConditionPercentDamageFromBoilingDry;
cookingPotItem.m_ConditionPercentDamageFromBurningFood = template.m_ConditionPercentDamageFromBurningFood;
cookingPotItem.m_CookedCalorieMultiplier = template.m_CookedCalorieMultiplier;
cookingPotItem.m_CookingTimeMultiplier = template.m_CookingTimeMultiplier;
cookingPotItem.m_GrubMeshType = template.m_GrubMeshType;
cookingPotItem.m_LampOilMultiplier = template.m_LampOilMultiplier;
cookingPotItem.m_MeltSnowMaterialsList = template.m_MeltSnowMaterialsList;
cookingPotItem.m_NearFireWarmUpCookingTimeMultiplier = template.m_NearFireWarmUpCookingTimeMultiplier;
cookingPotItem.m_NearFireWarmUpReadyTimeMultiplier = template.m_NearFireWarmUpReadyTimeMultiplier;
cookingPotItem.m_ParticlesItemCooking = template.m_ParticlesItemCooking;
cookingPotItem.m_ParticlesItemReady = template.m_ParticlesItemReady;
cookingPotItem.m_ParticlesItemRuined = template.m_ParticlesItemRuined;
cookingPotItem.m_ParticlesSnowMelting = template.m_ParticlesSnowMelting;
cookingPotItem.m_ParticlesWaterBoiling = template.m_ParticlesWaterBoiling;
cookingPotItem.m_ParticlesWaterReady = template.m_ParticlesWaterReady;
cookingPotItem.m_ParticlesWaterRuined = template.m_ParticlesWaterRuined;
cookingPotItem.m_ReadyTimeMultiplier = template.m_ReadyTimeMultiplier;
cookingPotItem.m_RuinedFoodMaterialsList = template.m_RuinedFoodMaterialsList;
cookingPotItem.m_SnowMesh = modCookingPotComponent.SnowMesh;
cookingPotItem.m_WaterMesh = modCookingPotComponent.WaterMesh;
GameObject grubMesh = UnityEngine.Object.Instantiate(template.m_GrubMeshFilter.gameObject, cookingPotItem.transform);
cookingPotItem.m_GrubMeshFilter = grubMesh.GetComponent <MeshFilter>();
cookingPotItem.m_GrubMeshRenderer = grubMesh.GetComponent <MeshRenderer>();
PlaceableItem placeableItem = ModUtils.GetOrCreateComponent <PlaceableItem>(modComponent);
placeableItem.m_Range = template.GetComponent <PlaceableItem>()?.m_Range ?? 3;
}
internal static void Postfix(CookingPotItem __instance)
{
//Implementation.Log("CookingPotItem -- UpdateMeltingSnow");
if (__instance.AttachedFireIsBurning())
{
return;
}
else if (__instance.m_LitersSnowBeingMelted > 0)
{
if (__instance.m_ParticlesSnowMelting.activeInHierarchy && WaterUtils.IsCooledDown(__instance))
{
Utils.SetActive(__instance.m_ParticlesSnowMelting, false);
}
}
}
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 void GetFromCookingPot()
{
CookingPotItem cookingPot = this.GetComponent <CookingPotItem>();
if (cookingPot == null)
{
MelonLoader.MelonLogger.LogError("CookingPotWaterSaveData trying to get data from a non-cookingpotitem!");
}
else
{
this.cookingState = cookingPot.m_CookingState;
this.litersSnowBeingMelted = cookingPot.m_LitersSnowBeingMelted;
this.litersWaterBeingBoiled = cookingPot.m_LitersWaterBeingBoiled;
this.minutesUntilCooked = cookingPot.m_MinutesUntilCooked;
this.minutesUntilRuined = cookingPot.m_MinutesUntilRuined;
}
}
public static void Execute()
{
Panel_Cooking panel_Cooking = InterfaceManager.m_Panel_Cooking;
GearItem cookedItem = panel_Cooking.GetSelectedFood();
CookingPotItem cookingPotItem = panel_Cooking.m_CookingPotInteractedWith;
GearItem result = cookedItem.Drop(1, false, true);
CookingModifier cookingModifier = ComponentUtils.GetOrCreateComponent <CookingModifier>(result);
cookingModifier.additionalMinutes = result.m_Cookable.m_PotableWaterRequiredLiters * panel_Cooking.m_MinutesToMeltSnowPerLiter;
cookingModifier.Apply();
GameAudioManager.Play3DSound(result.m_Cookable.m_PutInPotAudio, cookingPotItem.gameObject);
cookingPotItem.StartCooking(result);
panel_Cooking.ExitCookingInterface();
}
internal static void Postfix(CookingPotItem __instance)
{
if (__instance.AttachedFireIsBurning())
{
return;
}
if ((__instance.m_ParticlesWaterBoiling.activeInHierarchy || __instance.m_ParticlesWaterReady.activeInHierarchy) && WaterUtils.IsCooledDown(__instance))
{
Utils.SetActive(__instance.m_ParticlesWaterReady, false);
Utils.SetActive(__instance.m_ParticlesWaterBoiling, false);
if (__instance.GetCookingState() == CookingPotItem.CookingState.Ready)
{
ModUtils.GetOrCreateComponent <OverrideCookingState>(__instance).ForceReady = true;
WaterUtils.SetElapsedCookingTimeForWater(__instance, WaterUtils.GetWaterAmount(__instance));
}
}
}
private static void CheckFoodItem(SkillsManager skillsManager, SkillType skillType, int numPoints,
SkillsManager.PointAssignmentMode mode, CookingPotItem pot)
{
GearItem itemBeingCooked = Traverse.Create(pot).Field("m_GearItemBeingCooked").GetValue <GearItem>();
if (itemBeingCooked && itemBeingCooked.IsWornOut())
{
return; // No skill points for cooking ruined items
}
else if (itemBeingCooked && itemBeingCooked.m_FoodItem)
{
FoodItem food = itemBeingCooked.m_FoodItem;
if (food.m_IsMeat && food.m_IsRawMeat && food.m_CaloriesRemaining < MIN_SIZE * food.m_CaloriesTotal)
{
return; // No skill points if the piece of meat being cooked is too small
}
}
skillsManager.IncrementPointsAndNotify(skillType, numPoints, mode);
}
public override void Deserialize(string data)
{
ForceReady = false;
bool.TryParse(data, out ForceReady);
if (!ForceReady)
{
return;
}
CookingPotItem cookingPotItem = this.GetComponent <CookingPotItem>();
if (cookingPotItem == null)
{
return;
}
Traverse.Create(cookingPotItem).Method("SetCookingState", new System.Type[] { typeof(CookingPotItem.CookingState) }).GetValue(CookingPotItem.CookingState.Ready);
cookingPotItem.m_GrubMeshRenderer.sharedMaterials = cookingPotItem.m_BoilWaterReadyMaterialsList;
}
internal static bool Prefix(CookingPotItem __instance)
{
float waterAmount = __instance.m_LitersWaterBeingBoiled;
if (Water.IsNone(waterAmount)) //only applies with water
{
return(true);
}
float waterVolumeToDrink = GameManager.GetPlayerManagerComponent().CalculateWaterVolumeToDrink(waterAmount);
if (Water.IsNone(waterVolumeToDrink)) // Not thirsty.
{
HUDMessage.AddMessage(Localization.Get("GAMEPLAY_Youarenotthirsty"));
GameAudioManager.PlayGUIError();
return(false);
}
bool is_ready = __instance.GetCookingState() == CookingPotItem.CookingState.Ready;
bool is_not_ready_and_no_fire = __instance.GetCookingState() == CookingPotItem.CookingState.Cooking && !__instance.AttachedFireIsBurning();
if (is_ready || is_not_ready_and_no_fire) //patch applies if ready or if still cooking but no fire.
{
DrinkFromPot.cookingPot = __instance;
DrinkFromPot.OnDrink();
if (Water.IsNone(__instance.m_LitersWaterBeingBoiled))
{
return(true);
}
else
{
GameManager.GetPlayerManagerComponent().ExitInspectGearMode(false);
return(false);
}
}
return(true);
}
internal static void Postfix(CookingPotItem __instance)
{
Water.AdjustWaterToWaterSupply();
}
internal static void SetWaterAmount(CookingPotItem cookingPotItem, float value)
{
System.Reflection.FieldInfo fieldInfo = AccessTools.Field(typeof(CookingPotItem), "m_LitersWaterBeingBoiled");
fieldInfo.SetValue(cookingPotItem, value);
}
internal static void Postfix(CookingPotItem __instance)
{
ModUtils.GetOrCreateComponent <OverrideCookingState>(__instance).ForceReady = false;
}
void Update()
{
if (fire.GetFireState() == FireState.Off)
{
"AutoCook.Update: fire isn't lit, aborting".logDbg();
Destroy(this);
return;
}
CookingPotItem pot = null;
if (gearPlacePoint.m_PlacedGear)
{
if (!gearPlacePoint.m_PlacedGear.name.Contains("CookingPot")) // GEAR_CookingPot or GEAR_CookingPotDummy
{
"AutoCook.Update: gear in place point isn't a cooking pot, aborting".logDbg();
Destroy(this);
return;
}
pot = gearPlacePoint.m_PlacedGear.GetComponent <CookingPotItem>();
if (pot.m_LitersSnowBeingMelted > 0f || pot.m_LitersWaterBeingBoiled > 0f) // if we started with water in pot
{
if (pot.m_CookingState == CookingPotItem.CookingState.Cooking || pot.m_LitersWaterBeingBoiled == 0f)
{
return;
}
"AutoCook.Update: picking up boiled water".logDbg();
pot.PickUpCookedItem();
}
if (pot.m_GearItemBeingCooked)
{
if (pot.GetCookingState() == CookingPotItem.CookingState.Cooking)
{
return;
}
$"AutoCook.Update: picking up cooked item {pot.m_GearItemBeingCooked.name}".logDbg();
pot.PickUpCookedItem();
}
}
var item = getRawFood(!cookMeatToo);
if (!item)
{
return;
}
$"AutoCook.Update: start cooking {item.name}".logDbg();
item.m_Cookable.m_DoNotCookWhenDropped = true;
if (pot)
{
pot.StartCooking(item);
}
else
{
gearPlacePoint.DropAndPlaceItem(item);
}
item.m_Cookable.m_DoNotCookWhenDropped = false;
}
internal static void SetElapsedCookingTimeForWater(CookingPotItem cookingPotItem, float waterLiters)
{
float hours = waterLiters * InterfaceManager.m_Panel_Cooking.m_MinutesToBoilWaterPerLiter * cookingPotItem.GetTotalBoilMultiplier() / 60f;
SetElapsedCookingTime(cookingPotItem, hours);
}
internal static void Postfix(CookingPotItem __instance)
{
Water.AdjustWaterToWaterSupply();
ModUtils.GetOrCreateComponent <OverrideCookingState>(__instance).ForceReady = false;
}
internal static void SetElapsedCookingTime(CookingPotItem cookingPotItem, float hours)
{
Traverse.Create(cookingPotItem).Field("m_CookingElapsedHours").SetValue(hours);
}
internal static bool IsCooledDown(CookingPotItem cookingPotItem)
{
return(Traverse.Create(cookingPotItem).Field("m_GracePeriodElapsedHours").GetValue <float>() * 60.0 > (double)InterfaceManager.m_Panel_Cooking.m_MinutesGraceTimeInterruptedCooking);
}
internal static float GetWaterAmount(CookingPotItem cookingPotItem)
{
System.Reflection.FieldInfo fieldInfo = AccessTools.Field(typeof(CookingPotItem), "m_LitersWaterBeingBoiled");
return((float)fieldInfo.GetValue(cookingPotItem));
}
