Cooking.c File Reference

Go to the source code of this file.

Enumerations
enum	CookingMethodType {   NONE = 0 , BAKING = 1 , BOILING = 2 , DRYING = 3 ,   TIME = 4 , COUNT }

Functions
void	ProcessItemToCook (notnull ItemBase pItem, ItemBase cookingEquip, Param2< CookingMethodType, float > pCookingMethod, out Param2< bool, bool > pStateFlags)
int	CookWithEquipment (ItemBase cooking_equipment, float cooking_time_coef=1)
int	CookOnStick (Edible_Base item_to_cook, float cook_time_inc)
int	UpdateCookingState (Edible_Base item_to_cook, CookingMethodType cooking_method, ItemBase cooking_equipment, float cooking_time_coef)
int	UpdateCookingStateOnStick (Edible_Base item_to_cook, float cook_time_inc)
void	SmokeItem (Edible_Base item_to_cook, float cook_time_inc)
void	TerminateCookingSounds (ItemBase pItem)
ItemBase	GetItemTypeFromCargo (typename item_type, ItemBase cooking_equipment)
	Cooking data.
CookingMethodType	GetCookingMethod (ItemBase cooking_equipment)
	DEPREACTED.
Param2< CookingMethodType, float >	GetCookingMethodWithTimeOverride (ItemBase cooking_equipment)
Edible_Base	GetFoodOnStick (ItemBase stick_item)
float	GetTimeToCook (Edible_Base item_to_cook, CookingMethodType cooking_method)
float	GetMinTempToCook (Edible_Base item_to_cook, CookingMethodType cooking_method)
void	AddTemperatureToItem (ItemBase cooked_item, ItemBase cooking_equipment, float min_temperature)
void	DecreaseCookedItemQuantity (notnull Edible_Base pItem, float pAmount=0.0)

Variables
enum CookingMethodType	TIME_WITH_SUPPORT_MATERIAL_COEF = 1.0
static const float	TIME_WITHOUT_SUPPORT_MATERIAL_COEF = 2.0
	time modifier used when not using support material
static const float	COOKING_FOOD_TIME_INC_VALUE = 2
	time modifier used when using support material
static const float	COOKING_LARD_DECREASE_COEF = 25
	time increase when cooking a food
static const float	COOKING_FOOD_QUANTITY_DECREASE_AMOUNT_NONE = 25
	how many units from quantity of lard are remove at each stage
static const float	COOKING_FOOD_QUANTITY_DECREASE_AMOUNT_LARD = 0
	how many units from quantity of item are removed at each stage when support material is NOT used
static const float	DEFAULT_COOKING_TEMPERATURE = 150
	NOT USED.
static const float	FOOD_MAX_COOKING_TEMPERATURE = 150
static const float	PARAM_BURN_DAMAGE_COEF = 0.05
static const float	LIQUID_BOILING_POINT = 150
static const float	LIQUID_VAPOR_QUANTITY = 2
	COOKING_EQUIPMENT_POT = Pot
	COOKING_EQUIPMENT_FRYINGPAN = FryingPan
	COOKING_EQUIPMENT_CAULDRON = Cauldron
	COOKING_INGREDIENT_LARD = Lard

Enumeration Type Documentation

CookingMethodType

enum CookingMethodType

Enumerator
NONE
BAKING
BOILING
DRYING
TIME
COUNT

Definition at line 1 of file Cooking.c.

{
  NONE = 0, //no cooking method available
  BAKING = 1,
  BOILING = 2,
  DRYING = 3,
  TIME = 4,
 
  COUNT
}

Function Documentation

AddTemperatureToItem()

void AddTemperatureToItem ( ItemBase cooked_item, ItemBase cooking_equipment, float min_temperature )

protected

Definition at line 474 of file Cooking.c.

  {
    if (cooked_item.GetTemperatureMax() >= FireplaceBase.PARAM_ITEM_HEAT_MIN_TEMP)
    {
      float item_temperature = cooked_item.GetTemperature();
 
      //set actual cooking temperature
      float actual_cooking_temp = DEFAULT_COOKING_TEMPERATURE; //default
      if (cooking_equipment)
        actual_cooking_temp = cooking_equipment.GetTemperature();
 
      //add temperature
      if (actual_cooking_temp > item_temperature)
      {
        item_temperature = actual_cooking_temp * 0.5;
        item_temperature = Math.Clamp(item_temperature, min_temperature, FOOD_MAX_COOKING_TEMPERATURE);
 
        //set new temperature
        if (GetGame() && GetGame().IsServer())
          cooked_item.SetTemperature(item_temperature);
      }
    }
  }

References Math::Clamp(), DEFAULT_COOKING_TEMPERATURE, FOOD_MAX_COOKING_TEMPERATURE, and GetGame().

Referenced by ProcessItemToCook(), UpdateCookingState(), and UpdateCookingStateOnStick().

CookOnStick()

int CookOnStick	(	Edible_Base	item_to_cook,
		float	cook_time_inc )

Definition at line 137 of file Cooking.c.

  {
    if (item_to_cook && item_to_cook.CanBeCookedOnStick())
    {
      //update food
      return UpdateCookingStateOnStick(item_to_cook, cook_time_inc);
    }
 
    return 0;
  }

References UpdateCookingStateOnStick().

CookWithEquipment()

int CookWithEquipment	(	ItemBase	cooking_equipment,
		float	cooking_time_coef = 1 )

cooking time coef override

Definition at line 72 of file Cooking.c.

  {
    bool is_empty;
 
    //check cooking conditions
    if (cooking_equipment == null)
      return 0;
 
    if (cooking_equipment.IsRuined())
      return 0;
 
    //manage items in cooking equipment
    Param2<bool, bool> stateFlags = new Param2<bool, bool>(false, false); // 1st - done; 2nd - burned
    Param2<CookingMethodType, float> cookingMethodWithTime = GetCookingMethodWithTimeOverride(cooking_equipment);
 
    if (cooking_time_coef != 1)
      cookingMethodWithTime.param2 = cooking_time_coef;
 
    CargoBase cargo = cooking_equipment.GetInventory().GetCargo();
    if (cargo)
    {
      is_empty = cargo.GetItemCount() == 0;
 
      //process items
      for (int i = 0; i < cargo.GetItemCount(); i++)
        ProcessItemToCook(ItemBase.Cast(cargo.GetItem(i)), cooking_equipment, cookingMethodWithTime, stateFlags);
    }
    else
      ProcessItemToCook(cooking_equipment, cooking_equipment, cookingMethodWithTime, stateFlags);
 
    //manage cooking equipment
    Bottle_Base bottle_base = Bottle_Base.Cast(cooking_equipment);
    if (bottle_base)
    {
      float cookingEquipmentTemp = cooking_equipment.GetTemperature();
 
      //handle water boiling
      if (cookingEquipmentTemp >= LIQUID_BOILING_POINT)
      {
        //remove agents
        cooking_equipment.RemoveAllAgents();
 
        if (cooking_equipment.GetQuantity() > 0)
        {
          //vaporize liquid
          cooking_equipment.AddQuantity(-LIQUID_VAPOR_QUANTITY);
        }
      }
 
      //handle audio visuals
      bottle_base.RefreshAudioVisualsOnClient(cookingMethodWithTime.param1, stateFlags.param1, is_empty, stateFlags.param2);
    }
 
    FryingPan frying_pan = FryingPan.Cast(cooking_equipment);
    if (frying_pan && !bottle_base)
    {
      //handle audio visuals
      frying_pan.RefreshAudioVisualsOnClient(cookingMethodWithTime.param1, stateFlags.param1, is_empty, stateFlags.param2);
    }
 
    return 1;
  }

References GetCookingMethodWithTimeOverride(), LIQUID_BOILING_POINT, LIQUID_VAPOR_QUANTITY, and ProcessItemToCook().

DecreaseCookedItemQuantity()

void DecreaseCookedItemQuantity ( notnull Edible_Base pItem, float pAmount = 0.0 )

protected

Definition at line 498 of file Cooking.c.

  {
    if (GetGame().IsServer())
    {
      float quantity = pItem.GetQuantity() - pAmount;
      quantity = Math.Clamp(quantity, 0, pItem.GetQuantityMax());
      pItem.SetQuantity(quantity);
    }
  }

References Math::Clamp(), and GetGame().

Referenced by UpdateCookingState(), and UpdateCookingStateOnStick().

GetCookingMethod()

CookingMethodType GetCookingMethod ( ItemBase cooking_equipment )

protected

DEPREACTED.

Definition at line 384 of file Cooking.c.

  {
    if (cooking_equipment.Type() == COOKING_EQUIPMENT_POT || cooking_equipment.Type() == COOKING_EQUIPMENT_CAULDRON)
    {
      //has water, but not petrol dammit X)
      if (cooking_equipment.GetQuantity() > 0 && cooking_equipment.GetLiquidType() != LIQUID_GASOLINE)
        return CookingMethodType.BOILING;
 
      //has lard in cargo
      if (GetItemTypeFromCargo(COOKING_INGREDIENT_LARD, cooking_equipment))
        return CookingMethodType.BAKING;
      return CookingMethodType.DRYING;
    }
 
    if (cooking_equipment.Type() == COOKING_EQUIPMENT_FRYINGPAN)
    {
      if (GetItemTypeFromCargo(COOKING_INGREDIENT_LARD, cooking_equipment))
        return CookingMethodType.BAKING;
      return CookingMethodType.DRYING;
    }
 
    return CookingMethodType.NONE;
  }

References COOKING_EQUIPMENT_CAULDRON, COOKING_EQUIPMENT_FRYINGPAN, COOKING_EQUIPMENT_POT, COOKING_INGREDIENT_LARD, GetItemTypeFromCargo(), and LIQUID_GASOLINE.

GetCookingMethodWithTimeOverride()

Param2< CookingMethodType, float > GetCookingMethodWithTimeOverride ( ItemBase cooking_equipment )

protected

when cooking in gasoline, jump to drying state(will be burnt then)

Definition at line 408 of file Cooking.c.

  {
    Param2<CookingMethodType, float> val = new Param2<CookingMethodType, float>(CookingMethodType.NONE, TIME_WITH_SUPPORT_MATERIAL_COEF);
 
    switch (cooking_equipment.Type())
    {
    case COOKING_EQUIPMENT_POT:
    case COOKING_EQUIPMENT_CAULDRON:
    case COOKING_EQUIPMENT_FRYINGPAN:
      if (cooking_equipment.GetQuantity() > 0)
      {
        if (cooking_equipment.GetLiquidType() == LIQUID_GASOLINE)
        {
          val = new Param2<CookingMethodType, float>(CookingMethodType.DRYING, TIME_WITHOUT_SUPPORT_MATERIAL_COEF);
          break;
        }
 
        val = new Param2<CookingMethodType, float>(CookingMethodType.BOILING, TIME_WITH_SUPPORT_MATERIAL_COEF);
        break;
      }
 
      if (GetItemTypeFromCargo(COOKING_INGREDIENT_LARD, cooking_equipment))
      {
        //has lard in cargo, slower process
        val = new Param2<CookingMethodType, float>(CookingMethodType.BAKING, TIME_WITH_SUPPORT_MATERIAL_COEF);
        break;
      }
 
      if (cooking_equipment.GetInventory().GetCargo().GetItemCount() > 0)
      {
        val = new Param2<CookingMethodType, float>(CookingMethodType.BAKING, TIME_WITHOUT_SUPPORT_MATERIAL_COEF);
        break;
      }
 
      val = new Param2<CookingMethodType, float>(CookingMethodType.NONE, TIME_WITHOUT_SUPPORT_MATERIAL_COEF);
      break;
 
    default:
      val = new Param2<CookingMethodType, float>(CookingMethodType.BAKING, TIME_WITHOUT_SUPPORT_MATERIAL_COEF);
      break;
    }
 
    return val;
  }

References COOKING_EQUIPMENT_CAULDRON, COOKING_EQUIPMENT_FRYINGPAN, COOKING_EQUIPMENT_POT, COOKING_INGREDIENT_LARD, GetItemTypeFromCargo(), LIQUID_GASOLINE, TIME_WITH_SUPPORT_MATERIAL_COEF, and TIME_WITHOUT_SUPPORT_MATERIAL_COEF.

Referenced by CookWithEquipment().

GetFoodOnStick()

Edible_Base GetFoodOnStick ( ItemBase stick_item )

protected

Definition at line 454 of file Cooking.c.

  {
    Edible_Base food_on_stick = Edible_Base.Cast(stick_item.GetAttachmentByType(Edible_Base));
 
    return food_on_stick;
  }

GetItemTypeFromCargo()

ItemBase GetItemTypeFromCargo ( typename item_type , ItemBase cooking_equipment )

protected

Cooking data.

Definition at line 363 of file Cooking.c.

  {
    CargoBase cargo = cooking_equipment.GetInventory().GetCargo();
    if (cargo)
    {
      for (int i = 0; i < cargo.GetItemCount(); i++)
      {
        EntityAI entity = cargo.GetItem(i);
        if (entity.Type() == item_type)
        {
          ItemBase item = ItemBase.Cast(entity);
 
          return item;
        }
      }
    }
 
    return null;
  }

Referenced by GetCookingMethod(), GetCookingMethodWithTimeOverride(), and UpdateCookingState().

GetMinTempToCook()

float GetMinTempToCook ( Edible_Base item_to_cook, CookingMethodType cooking_method )

protected

Definition at line 467 of file Cooking.c.

  {
    FoodStageType food_stage_type = item_to_cook.GetNextFoodStageType(cooking_method);
    return FoodStage.GetCookingPropertyFromIndex(eCookingPropertyIndices.MIN_TEMP, food_stage_type, null, item_to_cook.GetType());
  }

GetTimeToCook()

float GetTimeToCook ( Edible_Base item_to_cook, CookingMethodType cooking_method )

protected

Definition at line 461 of file Cooking.c.

  {
    FoodStageType food_stage_type = item_to_cook.GetNextFoodStageType(cooking_method);
    return FoodStage.GetCookingPropertyFromIndex(eCookingPropertyIndices.COOK_TIME, food_stage_type, null, item_to_cook.GetType());
  }

ProcessItemToCook()

void ProcessItemToCook	(	notnull ItemBase	pItem,
		ItemBase	cookingEquip,
		Param2< CookingMethodType, float >	pCookingMethod,
		out Param2< bool, bool >	pStateFlags )

state flags are in order: is_done, is_burned

enable cooking SoundEvent

update food

check for done state from baking (exclude Lard from baked items)

check for burned state

Definition at line 34 of file Cooking.c.

  {
    Edible_Base item_to_cook = Edible_Base.Cast(pItem);
 
    pStateFlags = new Param2<bool, bool>(false, false);
 
    if (item_to_cook && item_to_cook.CanBeCooked())
    {
      item_to_cook.MakeSoundsOnClient(true, pCookingMethod.param1);
 
      UpdateCookingState(item_to_cook, pCookingMethod.param1, cookingEquip, pCookingMethod.param2);
 
      //check for done state for boiling and drying
      if (item_to_cook.IsFoodBoiled() || item_to_cook.IsFoodDried())
        pStateFlags.param1 = true;
      else if (item_to_cook.IsFoodBaked() && item_to_cook.Type() != Lard)
        pStateFlags.param1 = true;
      else if (item_to_cook.IsFoodBurned())
        pStateFlags.param2 = true;
    }
    else
    {
      //damage item
      pItem.DecreaseHealth("", "", PARAM_BURN_DAMAGE_COEF * 100);
 
      //add temperature to item
      AddTemperatureToItem(pItem, null, 0);
    }
  }

References AddTemperatureToItem(), PARAM_BURN_DAMAGE_COEF, and UpdateCookingState().

Referenced by CookWithEquipment().

SmokeItem()

void SmokeItem ( Edible_Base item_to_cook, float cook_time_inc )

protected

Definition at line 302 of file Cooking.c.

  {
    if (item_to_cook)
    {
      float new_cook_time = item_to_cook.GetCookingTime() + cook_time_inc;
      float drying_cook_time = FoodStage.GetCookingPropertyFromIndex(eCookingPropertyIndices.COOK_TIME, FoodStageType.DRIED, null, item_to_cook.GetType());
 
      switch (item_to_cook.GetFoodStageType())
      {
      case FoodStageType.RAW:
        item_to_cook.SetCookingTime(new_cook_time);
 
        if (item_to_cook.GetCookingTime() >= drying_cook_time)
        {
          item_to_cook.ChangeFoodStage(FoodStageType.DRIED);
          item_to_cook.RemoveAllAgentsExcept(eAgents.BRAIN);
          item_to_cook.SetCookingTime(0);
        }
        break;
      default:
        item_to_cook.SetCookingTime(new_cook_time);
 
        if (item_to_cook.GetCookingTime() >= drying_cook_time)
        {
          item_to_cook.ChangeFoodStage(FoodStageType.BURNED);
          item_to_cook.RemoveAllAgents();
          item_to_cook.SetCookingTime(0);
        }
        break;
      }
    }
  }

TerminateCookingSounds()

void TerminateCookingSounds ( ItemBase pItem )

protected

Definition at line 335 of file Cooking.c.

  {
    Edible_Base edible;
    if (pItem)
    {
      if (pItem.GetInventory()) // cookware
      {
        CargoBase cargo = pItem.GetInventory().GetCargo();
        if (cargo)
        {
          for (int i = 0; i < cargo.GetItemCount(); i++)
          {
            edible = Edible_Base.Cast(cargo.GetItem(i));
            if (edible)
              edible.MakeSoundsOnClient(false);
          }
        }
      }
      else
      {
        edible = Edible_Base.Cast(pItem);
        if (edible)
          edible.MakeSoundsOnClient(false);
      }
    }
  }

UpdateCookingState()

int UpdateCookingState ( Edible_Base item_to_cook, CookingMethodType cooking_method, ItemBase cooking_equipment, float cooking_time_coef )

protected

Change food stage

Remove all modifiers

any foodstage without lard

any foodstage without lard

Definition at line 149 of file Cooking.c.

  {
    //food properties
    float food_temperature = item_to_cook.GetTemperature();
 
    //{min_temperature, time_to_cook, max_temperature (optional)}
    //get next stage name - if next stage is not defined, next stage name will be empty "" and no cooking properties (food_min_temp, food_time_to_cook, food_max_temp) will be set
    FoodStageType new_stage_type = item_to_cook.GetNextFoodStageType(cooking_method);
 
    float food_min_temp = 0;
    float food_time_to_cook = 0;
    float food_max_temp = -1;
 
    //Set next stage cooking properties if next stage possible
    if (item_to_cook.CanChangeToNewStage(cooking_method)) // new_stage_type != NONE
    {
      array<float> next_stage_cooking_properties = new array<float>();
      next_stage_cooking_properties = FoodStage.GetAllCookingPropertiesForStage(new_stage_type, null, item_to_cook.GetType());
 
      food_min_temp = next_stage_cooking_properties.Get(eCookingPropertyIndices.MIN_TEMP);
      food_time_to_cook = next_stage_cooking_properties.Get(eCookingPropertyIndices.COOK_TIME);
      // The last element is optional and might not exist
      if (next_stage_cooking_properties.Count() > 2)
        food_max_temp = next_stage_cooking_properties.Get(eCookingPropertyIndices.MAX_TEMP);
    }
 
    //add temperature
    AddTemperatureToItem(item_to_cook, cooking_equipment, food_min_temp);
 
    //add cooking time if the food can be cooked by this method
    if (food_min_temp > 0 && food_temperature >= food_min_temp)
    {
      float new_cooking_time = item_to_cook.GetCookingTime() + COOKING_FOOD_TIME_INC_VALUE * cooking_time_coef;
      item_to_cook.SetCookingTime(new_cooking_time);
 
      //progress to next stage
      if (item_to_cook.GetCookingTime() >= food_time_to_cook)
      {
        //if max temp is defined check next food stage
        if (food_max_temp >= 0)
        {
          if (food_temperature > food_max_temp && item_to_cook.GetFoodStageType() != FoodStageType.BURNED)
            new_stage_type = FoodStageType.BURNED;
        }
 
        item_to_cook.ChangeFoodStage(new_stage_type);
        item_to_cook.RemoveAllAgentsExcept(eAgents.BRAIN);
 
        if (cooking_equipment)
        {
          if (cooking_method == CookingMethodType.BAKING)
          {
            ItemBase lard = GetItemTypeFromCargo(COOKING_INGREDIENT_LARD, cooking_equipment);
            if (lard)
            {
              //decrease lard quantity
              float lardQuantity = lard.GetQuantity() - COOKING_LARD_DECREASE_COEF;
              lardQuantity = Math.Clamp(lardQuantity, 0, lard.GetQuantityMax());
              lard.SetQuantity(lardQuantity);
            }
            else
            {
              DecreaseCookedItemQuantity(item_to_cook, COOKING_FOOD_QUANTITY_DECREASE_AMOUNT_NONE);
            }
          }
        }
        else
        {
          DecreaseCookedItemQuantity(item_to_cook, COOKING_FOOD_QUANTITY_DECREASE_AMOUNT_NONE);
        }
 
        //reset cooking time
        item_to_cook.SetCookingTime(0);
 
        return 1;
      }
    }
 
    return 0;
  }

References AddTemperatureToItem(), Math::Clamp(), COOKING_FOOD_QUANTITY_DECREASE_AMOUNT_NONE, COOKING_FOOD_TIME_INC_VALUE, COOKING_INGREDIENT_LARD, COOKING_LARD_DECREASE_COEF, DecreaseCookedItemQuantity(), and GetItemTypeFromCargo().

Referenced by ProcessItemToCook().

UpdateCookingStateOnStick()

int UpdateCookingStateOnStick ( Edible_Base item_to_cook, float cook_time_inc )

protected

Definition at line 235 of file Cooking.c.

  {
    //food properties
    float food_temperature = item_to_cook.GetTemperature();
 
    //{min_temperature, time_to_cook, max_temperature (optional)}
    //get next stage name - if next stage is not defined, next stage name will be empty "" and no cooking properties (food_min_temp, food_time_to_cook, food_max_temp) will be set
    FoodStageType new_stage_type = item_to_cook.GetNextFoodStageType(CookingMethodType.BAKING);
    float food_min_temp = 0;
    float food_time_to_cook = 0;
    float food_max_temp = -1;
    bool is_done = false; // baked
    bool is_burned = false; // burned
 
    //Set next stage cooking properties if next stage possible
    if (item_to_cook.CanChangeToNewStage(CookingMethodType.BAKING))
    {
      array<float> next_stage_cooking_properties = new array<float>;
      next_stage_cooking_properties = FoodStage.GetAllCookingPropertiesForStage(new_stage_type, null, item_to_cook.GetType());
 
      food_min_temp = next_stage_cooking_properties.Get(eCookingPropertyIndices.MIN_TEMP);
      food_time_to_cook = next_stage_cooking_properties.Get(eCookingPropertyIndices.COOK_TIME);
      // The last element is optional and might not exist
      if (next_stage_cooking_properties.Count() > 2)
        food_max_temp = next_stage_cooking_properties.Get(eCookingPropertyIndices.MAX_TEMP);
    }
 
 
    // refresh audio
    if (item_to_cook.GetInventory().IsAttachment())
    {
      item_to_cook.MakeSoundsOnClient(true, CookingMethodType.BAKING);
      //add temperature
      AddTemperatureToItem(item_to_cook, null, food_min_temp);
    }
 
    //add cooking time if the food can be cooked by this method
    if (food_min_temp > 0 && food_temperature >= food_min_temp)
    {
      float new_cooking_time = item_to_cook.GetCookingTime() + cook_time_inc;
      item_to_cook.SetCookingTime(new_cooking_time);
 
      //progress to next stage
      if (item_to_cook.GetCookingTime() >= food_time_to_cook)
      {
        //if max temp is defined check next food stage
        if (food_max_temp >= 0)
        {
          if (food_temperature > food_max_temp && item_to_cook.GetFoodStageType() != FoodStageType.BURNED)
            new_stage_type = FoodStageType.BURNED;
        }
 
        //change food stage
        item_to_cook.ChangeFoodStage(new_stage_type);
        item_to_cook.RemoveAllAgentsExcept(eAgents.BRAIN);
 
        DecreaseCookedItemQuantity(item_to_cook, COOKING_FOOD_QUANTITY_DECREASE_AMOUNT_NONE);
 
        //reset cooking time
        item_to_cook.SetCookingTime(0);
        return 1;
      }
    }
 
    return 0;
  }

References AddTemperatureToItem(), COOKING_FOOD_QUANTITY_DECREASE_AMOUNT_NONE, and DecreaseCookedItemQuantity().

Referenced by CookOnStick().

Variable Documentation

COOKING_EQUIPMENT_CAULDRON

COOKING_EQUIPMENT_CAULDRON = Cauldron

Definition at line 31 of file Cooking.c.

Referenced by GetCookingMethod(), and GetCookingMethodWithTimeOverride().

COOKING_EQUIPMENT_FRYINGPAN

COOKING_EQUIPMENT_FRYINGPAN = FryingPan

Definition at line 30 of file Cooking.c.

Referenced by GetCookingMethod(), and GetCookingMethodWithTimeOverride().

COOKING_EQUIPMENT_POT

COOKING_EQUIPMENT_POT = Pot

Definition at line 29 of file Cooking.c.

Referenced by GetCookingMethod(), and GetCookingMethodWithTimeOverride().

COOKING_FOOD_QUANTITY_DECREASE_AMOUNT_LARD

const float COOKING_FOOD_QUANTITY_DECREASE_AMOUNT_LARD = 0

static

how many units from quantity of item are removed at each stage when support material is NOT used

Definition at line 20 of file Cooking.c.

COOKING_FOOD_QUANTITY_DECREASE_AMOUNT_NONE

const float COOKING_FOOD_QUANTITY_DECREASE_AMOUNT_NONE = 25

static

how many units from quantity of lard are remove at each stage

Definition at line 19 of file Cooking.c.

Referenced by UpdateCookingState(), and UpdateCookingStateOnStick().

COOKING_FOOD_TIME_INC_VALUE

const float COOKING_FOOD_TIME_INC_VALUE = 2

static

time modifier used when using support material

Definition at line 17 of file Cooking.c.

Referenced by UpdateCookingState().

COOKING_INGREDIENT_LARD

COOKING_INGREDIENT_LARD = Lard

Definition at line 32 of file Cooking.c.

Referenced by GetCookingMethod(), GetCookingMethodWithTimeOverride(), and UpdateCookingState().

COOKING_LARD_DECREASE_COEF

const float COOKING_LARD_DECREASE_COEF = 25

static

time increase when cooking a food

Definition at line 18 of file Cooking.c.

Referenced by UpdateCookingState().

DEFAULT_COOKING_TEMPERATURE

const float DEFAULT_COOKING_TEMPERATURE = 150

static

NOT USED.

Definition at line 22 of file Cooking.c.

Referenced by AddTemperatureToItem().

FOOD_MAX_COOKING_TEMPERATURE

const float FOOD_MAX_COOKING_TEMPERATURE = 150

static

Definition at line 23 of file Cooking.c.

Referenced by AddTemperatureToItem().

LIQUID_BOILING_POINT

const float LIQUID_BOILING_POINT = 150

static

Definition at line 26 of file Cooking.c.

Referenced by CookWithEquipment().

LIQUID_VAPOR_QUANTITY

const float LIQUID_VAPOR_QUANTITY = 2

static

Definition at line 27 of file Cooking.c.

Referenced by CookWithEquipment().

PARAM_BURN_DAMAGE_COEF

const float PARAM_BURN_DAMAGE_COEF = 0.05

static

Definition at line 24 of file Cooking.c.

Referenced by AddDamageToItemByFire(), AddDamageToItemByFireEx(), and ProcessItemToCook().

TIME_WITH_SUPPORT_MATERIAL_COEF

enum CookingMethodType TIME_WITH_SUPPORT_MATERIAL_COEF = 1.0

Referenced by GetCookingMethodWithTimeOverride().

TIME_WITHOUT_SUPPORT_MATERIAL_COEF

const float TIME_WITHOUT_SUPPORT_MATERIAL_COEF = 2.0

static

time modifier used when not using support material

Definition at line 15 of file Cooking.c.

Referenced by GetCookingMethodWithTimeOverride().