cooking.c

Go to the documentation of this file.

enum CookingMethodType
{
    NONE        = 0,        //no cooking method available
    BAKING      = 1,
    BOILING     = 2,
    DRYING      = 3,
    TIME        = 4,
    
    COUNT
}
 
class Cooking
{
    static const float TIME_WITH_SUPPORT_MATERIAL_COEF              = 1.0;  
    static const float TIME_WITHOUT_SUPPORT_MATERIAL_COEF           = 2.0;  
 
    static const float COOKING_FOOD_TIME_INC_VALUE                  = 2;    
    static const float COOKING_LARD_DECREASE_COEF                   = 25;   
    static const float COOKING_FOOD_QUANTITY_DECREASE_AMOUNT_NONE   = 25;   
    static const float COOKING_FOOD_QUANTITY_DECREASE_AMOUNT_LARD   = 0;    
 
    static const float DEFAULT_COOKING_TEMPERATURE                  = 150;  //default temperature for cooking (e.g. cooking on stick)
    static const float FOOD_MAX_COOKING_TEMPERATURE                 = 150;  //
    static const float PARAM_BURN_DAMAGE_COEF                       = 0.05; //value for calculating damage on items located in fireplace CargoGrid
 
    static const float LIQUID_BOILING_POINT                         = 150;  //boiling point for liquids
    static const float LIQUID_VAPOR_QUANTITY                        = 2;    //vapor quantity
 
    typename COOKING_EQUIPMENT_POT                      = Pot;
    typename COOKING_EQUIPMENT_FRYINGPAN                = FryingPan;
    typename COOKING_EQUIPMENT_CAULDRON                 = Cauldron;
    typename COOKING_INGREDIENT_LARD                    = Lard;
    
    void ProcessItemToCook(notnull ItemBase pItem, ItemBase cookingEquip, Param2<CookingMethodType, float> pCookingMethod, out Param2<bool, bool> pStateFlags)
    {
        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);
        }
    }
 
    //COOKING PROCESS
    //--- Cooking with equipment (pot)
    //Returns 1 if the item changed its cooking stage, 0 if not
    int CookWithEquipment(ItemBase cooking_equipment, float cooking_time_coef = 1)
    {
        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;
    }
    
    //Returns 1 if the item changed its cooking stage, 0 if not
    int CookOnStick( Edible_Base item_to_cook, float cook_time_inc )
    {
        if ( item_to_cook && item_to_cook.CanBeCookedOnStick() )
        {
            //update food
            return UpdateCookingStateOnStick( item_to_cook, cook_time_inc );
        }
        
        return 0;
    }
    
    //Returns 1 if the item changed its cooking stage, 0 if not
    protected int UpdateCookingState(Edible_Base item_to_cook, CookingMethodType cooking_method, ItemBase cooking_equipment, float cooking_time_coef)
    {
        //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;
    }
    
    //Returns 1 if the item changed its cooking stage, 0 if not
    protected int UpdateCookingStateOnStick( Edible_Base item_to_cook, float cook_time_inc )
    {
        //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;
    }
    
    void SmokeItem(Edible_Base item_to_cook, float cook_time_inc)
    {
        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;
            }
        }
    }
    
    void TerminateCookingSounds(ItemBase pItem)
    {
        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);
                }
            }
        }
    }
    
    protected ItemBase GetItemTypeFromCargo( typename item_type, ItemBase cooking_equipment )
    {
        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;
    }
 
    protected CookingMethodType GetCookingMethod(ItemBase cooking_equipment)
    {
        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;
    }
    
    protected Param2<CookingMethodType, float> GetCookingMethodWithTimeOverride(ItemBase cooking_equipment)
    {
        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;
    }
    
    Edible_Base GetFoodOnStick( ItemBase stick_item )
    {
        Edible_Base food_on_stick = Edible_Base.Cast( stick_item.GetAttachmentByType( Edible_Base ) );
 
        return food_on_stick;
    }
    
    float GetTimeToCook( Edible_Base item_to_cook, CookingMethodType cooking_method )
    {
        FoodStageType food_stage_type = item_to_cook.GetNextFoodStageType( cooking_method );
        return FoodStage.GetCookingPropertyFromIndex( eCookingPropertyIndices.COOK_TIME, food_stage_type, null, item_to_cook.GetType());
    }
 
    float GetMinTempToCook( Edible_Base item_to_cook, CookingMethodType cooking_method )
    {
        FoodStageType food_stage_type = item_to_cook.GetNextFoodStageType( cooking_method );
        return FoodStage.GetCookingPropertyFromIndex( eCookingPropertyIndices.MIN_TEMP, food_stage_type, null, item_to_cook.GetType());
    }
    
    //add temperature to item
    protected void AddTemperatureToItem( ItemBase cooked_item, ItemBase cooking_equipment, float min_temperature )
    {
        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 );
                }
            }
        }
    }
    
    protected void DecreaseCookedItemQuantity(notnull Edible_Base pItem, float pAmount = 0.0)
    {
        if (GetGame().IsServer())
        {
            float quantity = pItem.GetQuantity() - pAmount;
            quantity = Math.Clamp(quantity, 0, pItem.GetQuantityMax());
            pItem.SetQuantity(quantity);
        }
    }
}