environment.c

Go to the documentation of this file.

class Environment
{
    const float RAIN_LIMIT_LOW      = 0.05;
 
    const float WATER_LEVEL_HIGH    = 1.5;
    const float WATER_LEVEL_MID     = 1.2;
    const float WATER_LEVEL_LOW     = 0.5;
    const float WATER_LEVEL_NONE    = 0.15;
    
    protected float                 m_WetDryTick; //ticks passed since last clothing wetting or drying
    protected float                 m_ItemsWetnessMax; 
    protected float                 m_RoofCheckTimer; // keeps info about tick time
 
    //player
    protected PlayerBase            m_Player;
    protected float                 m_PlayerHeightPos; // y position of player above water level (meters)
    protected float                 m_PlayerSpeed; // 1-3 speed of player movement
    protected float                 m_PlayerTemperature; //34-44
    protected float                 m_PlayerHeat; //3-9 heatcomfort generated by entites movement
    protected float                 m_HeatComfort;  //delta that changes entitys temperature                
 
    //environment
    protected float                 m_Rain = 0; // 0-1 amount of rain 
    protected float                 m_Wind = 0; // strength of wind
    protected float                 m_Fog = 0; // 0-1 how foggy it is
    protected float                 m_DayOrNight = 0; // 0-1 day(1) or night(0)
    protected float                 m_Clouds = 0; // 0-1 how cloudy it is
    protected float                 m_EnvironmentTemperature = 0; //temperature of environment player is in
    protected float                 m_Time = 0;
    protected string                m_SurfaceType;
    
    //
    protected float                 m_WaterLevel;
    protected bool                  m_IsUnderRoof;
    private bool                    m_IsUnderRoofBuilding;
    protected bool                  m_IsInWater;
    protected bool                  m_IsTempSet;
    //
    protected float                 m_HeatSourceTemp;   
    protected float                 m_HeatBufferTimer;
    
    protected ref array<int>        m_SlotIdsComplete;
    protected ref array<int>        m_SlotIdsUpper;
    protected ref array<int>        m_SlotIdsBottom;
    protected ref array<int>        m_SlotIdsLower;
    
    protected ref array<int>        m_HeadParts;
    protected ref array<int>        m_BodyParts;
    protected ref array<int>        m_FeetParts;
    
    protected ref SimpleMovingAverage<float> m_WindAverageBuffer;
 
    protected bool m_HasTemperatureSources;
    protected float m_UTSAverageTemperature;
    protected ref array<UTemperatureSource> m_UTemperatureSources;
    protected ref SimpleMovingAverage<float> m_UTSAverageTemperatureBuffer;
    
    #ifdef DIAG_DEVELOPER
    bool m_Debug = false;
 
    bool m_DebugLogDryWet = false;
    #endif
        
    void Environment(PlayerBase pPlayer)
    {
        Init(pPlayer);
    }
    
    void Init(PlayerBase pPlayer)
    {
        m_Player                        = pPlayer;
        m_PlayerSpeed                   = 0.0;
        m_WetDryTick                    = 0.0;
        m_RoofCheckTimer                = 0.0;
        m_WaterLevel                    = 0.0;
        m_HeatComfort                   = 0.0;
        
        m_IsUnderRoof                   = false;
        m_IsInWater                     = false;
        m_SurfaceType                   = "cp_dirt";
 
        m_HeatBufferTimer               = 0.0;
        
        m_WindAverageBuffer             = new SimpleMovingAverage<float>(30, 0.5);
        
        m_UTSAverageTemperature         = 0.0;
        m_UTemperatureSources           = new array<UTemperatureSource>();
        m_UTSAverageTemperatureBuffer   = new SimpleMovingAverage<float>(10, 0);
 
        m_SlotIdsComplete       = new array<int>;       
        m_SlotIdsComplete       = {
            InventorySlots.HEADGEAR,
            InventorySlots.MASK,
            InventorySlots.EYEWEAR,
            InventorySlots.GLOVES,
            InventorySlots.ARMBAND,
            InventorySlots.BODY,
            InventorySlots.HIPS,
            InventorySlots.VEST,
            InventorySlots.BACK,
            InventorySlots.LEGS,
            InventorySlots.FEET
        };
        m_SlotIdsUpper          = new array<int>;
        m_SlotIdsUpper          = {
            InventorySlots.GLOVES,
            InventorySlots.ARMBAND,
            InventorySlots.BODY,
            InventorySlots.HIPS,
            InventorySlots.VEST,
            InventorySlots.BACK,
            InventorySlots.LEGS,
            InventorySlots.FEET
        };
        m_SlotIdsBottom         = new array<int>;
        m_SlotIdsBottom         = {
            InventorySlots.HIPS,
            InventorySlots.LEGS,
            InventorySlots.FEET
        };
        m_SlotIdsLower          = new array<int>;
        m_SlotIdsLower          = {
            InventorySlots.FEET,
        };
 
        m_HeadParts             = new array<int>;
        m_HeadParts             = {
            InventorySlots.HEADGEAR,
            InventorySlots.MASK,
        };
        
        m_BodyParts             = new array<int>;
        m_BodyParts             = {
            InventorySlots.GLOVES,
 
            InventorySlots.BODY,
            InventorySlots.BACK,
            InventorySlots.VEST,
        };
        
        m_FeetParts             = new array<int>;
        m_FeetParts             = {
            InventorySlots.LEGS,
            InventorySlots.FEET,
        };
    }
 
    
    // Calculates heatisolation of clothing, process its wetness, collects heat from heated items and calculates player's heat comfort
    void Update(float pDelta)
    {
        if (m_Player)
        {
            m_RoofCheckTimer += pDelta;
            if ( m_RoofCheckTimer >= GameConstants.ENVIRO_TICK_ROOF_RC_CHECK )
            {
                if ( !IsInsideBuilding() )
                    CheckUnderRoof();
                
                m_RoofCheckTimer = 0;
            }
 
            m_Time += pDelta;
            if ( m_Time >= GameConstants.ENVIRO_TICK_RATE )
            {
                m_Time = 0;
                m_WetDryTick++; // Sets whether it is time to add wetness to items and clothing
 
                CheckWaterContact(m_WaterLevel);
                CollectAndSetPlayerData();
                CollectAndSetEnvironmentData();
                GatherTemperatureSources();
 
                ProcessTemperatureSources();
                
                ProcessItemsHeat();
 
                if ( m_WetDryTick >= GameConstants.ENVIRO_TICKS_TO_WETNESS_CALCULATION )
                {
                    if ( IsWaterContact() )
                    {
                        ProcessWetnessByWaterLevel(m_WaterLevel);
                    }
                    else if ( IsRaining() && !IsInsideBuilding() && !IsUnderRoof() && !IsInsideVehicle() )
                    {
                        ProcessWetnessByRain();
                    }
                    else
                    {
                        ProcessItemsDryness();
                    }
 
                    if ( ( m_ItemsWetnessMax < GameConstants.STATE_WET ) && ( m_Player.GetStatWet().Get() == 1 ) )
                    {
                        m_Player.GetStatWet().Set( 0 );
                    }
                    else if ( ( m_ItemsWetnessMax >= GameConstants.STATE_WET ) && ( m_Player.GetStatWet().Get() == 0 ) )
                    {
                        m_Player.GetStatWet().Set( 1 );
                    }
 
                    m_WetDryTick = 0;
                    m_ItemsWetnessMax = 0; 
                }
            }
        }
    }
    
    bool IsTemperatureSet()
    {
        return m_IsTempSet;
    }
 
    // DEPRECATED
    void AddToEnvironmentTemperature(float pTemperature);
    
    protected float GetPlayerHeat()
    {
        float heat = Math.Max(m_PlayerSpeed * GameConstants.ENVIRO_DEFAULT_ENTITY_HEAT, GameConstants.ENVIRO_DEFAULT_ENTITY_HEAT);
        return heat;
    }
    
    bool IsUnderRoof()
    {
        return m_IsUnderRoof;
    }
    
    protected bool IsWaterContact()
    {
        return m_IsInWater;
    }
    
    bool IsInsideBuilding()
    {
        return m_Player && m_Player.IsSoundInsideBuilding();
    }
 
    protected bool IsInsideVehicle()
    {
        return m_Player && m_Player.IsInVehicle();
    }
    
    private bool IsUnderRoofBuilding()
    {
        return m_IsUnderRoofBuilding;
    }
    
    protected bool IsRaining()
    {
        return m_Rain > RAIN_LIMIT_LOW;
    }
    
    protected void CheckUnderRoof()
    {
        // if inside vehicle return immediatelly
        if (IsInsideVehicle())
        {
            m_IsUnderRoof = false;
            m_IsUnderRoofBuilding = false;
            return;
        }
        
        float hitFraction;
        vector hitPosition, hitNormal;
        vector from = m_Player.GetPosition();
        vector to = from + "0 25 0";
        Object hitObject;
        PhxInteractionLayers collisionLayerMask = PhxInteractionLayers.ITEM_LARGE|PhxInteractionLayers.BUILDING|PhxInteractionLayers.VEHICLE;
        
        m_IsUnderRoof = DayZPhysics.RayCastBullet(from, to, collisionLayerMask, null, hitObject, hitPosition, hitNormal, hitFraction);
 
        m_IsUnderRoofBuilding = hitObject && hitObject.IsInherited(House);
    }
    
    protected void CheckWaterContact(out float pWaterLevel)
    {
        m_IsInWater = false;
        if (m_Player.IsSwimming())
        {
            m_IsInWater = true;
            HumanMovementState hms = new HumanMovementState();
            m_Player.GetMovementState(hms);
            pWaterLevel = WATER_LEVEL_MID;
            if (hms.m_iMovement >= DayZPlayerConstants.MOVEMENTIDX_WALK)
                pWaterLevel = WATER_LEVEL_HIGH;
 
            return;
        }
        
        if (IsUnderRoofBuilding())
        {
            m_IsInWater = false;
            return;
        }
 
        string surfType;
        int liquidType;
 
        g_Game.SurfaceUnderObject(m_Player, surfType, liquidType);
        
        switch ( liquidType )
        {
            case 0: // sea
            case LIQUID_WATER:
            case LIQUID_RIVERWATER:
                pWaterLevel = m_Player.GetCurrentWaterLevel();
                m_IsInWater = true;
            break;
        }
 
        m_Player.SetInWater(m_IsInWater);
 
        m_SurfaceType = surfType;
    }
    
    // ENVIRONMENT
    // Returns amount of deg C air temperature should be lowered by, based on player's height above water level
    float GetTemperatureHeightCorrection()
    {
        float temperature_reduction = Math.Max(0, (m_PlayerHeightPos * GameConstants.ENVIRO_TEMPERATURE_HEIGHT_REDUCTION));
        return temperature_reduction;
    }
    
    float GetWindModifierPerSurface()
    {
        if (IsUnderRoofBuilding())
            return 0.0;
 
        return g_Game.ConfigGetFloat("CfgSurfaces " + m_SurfaceType + " windModifier");
    }
    
    float GetTemperature()
    {
        return m_EnvironmentTemperature;
    }
    
    // Calculates and return temperature of environment
    protected float GetEnvironmentTemperature()
    {
        float temperature;
        temperature = g_Game.GetMission().GetWorldData().GetBaseEnvTemperature();
        temperature += Math.AbsFloat(temperature * m_Clouds * GameConstants.ENVIRO_CLOUDS_TEMP_EFFECT);
        
        if (IsWaterContact())
        {
            temperature -= Math.AbsFloat(temperature * GameConstants.ENVIRO_WATER_TEMPERATURE_COEF);
        }
        
        if (IsInsideBuilding() || m_IsUnderRoofBuilding)
        {
            temperature += Math.AbsFloat(temperature * GameConstants.ENVIRO_TEMPERATURE_INSIDE_COEF);
        }
        else if (IsInsideVehicle())
        {
            temperature += Math.AbsFloat(temperature * GameConstants.ENVIRO_TEMPERATURE_INSIDE_VEHICLE_COEF);
        }
        else if (IsUnderRoof() && !m_IsUnderRoofBuilding)
        {
            temperature += Math.AbsFloat(temperature * GameConstants.ENVIRO_TEMPERATURE_UNDERROOF_COEF);
            temperature -= GameConstants.ENVIRO_TEMPERATURE_WIND_COEF * GetWindModifierPerSurface() * m_Wind;
        }
        else
        {
            temperature -= GameConstants.ENVIRO_TEMPERATURE_WIND_COEF * GetWindModifierPerSurface() * m_Wind;
            temperature -= Math.AbsFloat(temperature * m_Fog * GameConstants.ENVIRO_FOG_TEMP_EFFECT);
            temperature -= GetTemperatureHeightCorrection();
        }
        
        // incorporate temperature from temperature sources (buffer)
        if (Math.AbsFloat(m_UTSAverageTemperature) > 0.001)
        {
            temperature += m_UTSAverageTemperature;
        }
        
        return temperature;
    }   
        
    // Calculats wet/drying delta based on player's location and weather
    float GetWetDelta()
    {
        float wetDelta = 0;
        if ( IsWaterContact() )
        {
            if (m_WaterLevel >= WATER_LEVEL_HIGH)
            {
                wetDelta = 1;
            }
            else if (m_WaterLevel >= WATER_LEVEL_MID && m_WaterLevel < WATER_LEVEL_HIGH)
            {
                wetDelta = 0.66;
            }
            else if (m_WaterLevel >= WATER_LEVEL_LOW && m_WaterLevel < WATER_LEVEL_MID)
            {
                wetDelta = 0.66;
            }
            else if (m_WaterLevel >= WATER_LEVEL_NONE && m_WaterLevel < WATER_LEVEL_LOW)
            {
                wetDelta = 0.33;
            }
        }
        else if (IsRaining() && !IsInsideBuilding() && !IsUnderRoof() && !IsInsideVehicle())
        {
            wetDelta = GameConstants.ENVIRO_WET_INCREMENT * GameConstants.ENVIRO_TICKS_TO_WETNESS_CALCULATION * (m_Rain) * (1 + (GameConstants.ENVIRO_WIND_EFFECT * m_Wind));
        }
        else
        {
            float tempEffect = Math.Max(m_PlayerHeat + GetEnvironmentTemperature(), 1.0);
 
            float weatherEffect = ((1 - (m_Fog * GameConstants.ENVIRO_FOG_DRY_EFFECT))) * (1 - (m_Clouds * GameConstants.ENVIRO_CLOUD_DRY_EFFECT));
            if (weatherEffect <= 0)
            {
                weatherEffect = 1.0;
            }
            
            wetDelta = -(GameConstants.ENVIRO_DRY_INCREMENT * weatherEffect * tempEffect);
            if (!IsInsideBuilding())
            {
                wetDelta *= 1 + (GameConstants.ENVIRO_WIND_EFFECT * m_Wind);
            }
        }
 
        return wetDelta;
    }
 
    // EXPOSURE
    // Each tick updates current entity member variables
    protected void CollectAndSetPlayerData()
    {
        vector playerPos = m_Player.GetPosition();
        m_PlayerHeightPos = playerPos[1];
 
        HumanCommandMove hcm = m_Player.GetCommand_Move();
        if (hcm)
        {
            m_PlayerSpeed = hcm.GetCurrentMovementSpeed();
        }
 
        m_PlayerHeat = GetPlayerHeat();
    }
    
    // Each tick updates current environment member variables
    protected void CollectAndSetEnvironmentData()
    {
        Weather weather = g_Game.GetWeather();
        m_Rain          = weather.GetRain().GetActual();
        m_DayOrNight    = g_Game.GetWorld().GetSunOrMoon();
        m_Fog           = weather.GetFog().GetActual();
        m_Clouds        = weather.GetOvercast().GetActual();
        m_Wind          = m_WindAverageBuffer.Add(weather.GetWindSpeed() / weather.GetWindMaximumSpeed());
 
        SetEnvironmentTemperature();
    }
    
    void SetEnvironmentTemperature()
    {
        m_IsTempSet = true;
        m_EnvironmentTemperature = GetEnvironmentTemperature();
    }
 
    protected void ProcessWetnessByRain()
    {
        ProcessItemsWetness(m_SlotIdsComplete);
    }
 
    protected void ProcessWetnessByWaterLevel(float pWaterLevel)
    {
        // process attachments by water depth
        if (pWaterLevel >= WATER_LEVEL_HIGH)
        {
            ProcessItemsWetness(m_SlotIdsComplete);
        }
        else if (pWaterLevel >= WATER_LEVEL_MID && pWaterLevel < WATER_LEVEL_HIGH)
        {
            ProcessItemsWetness(m_SlotIdsUpper);
        }
        else if (pWaterLevel >= WATER_LEVEL_LOW && pWaterLevel < WATER_LEVEL_MID)
        {
            ProcessItemsWetness(m_SlotIdsBottom);
        }
        else if (pWaterLevel >= WATER_LEVEL_NONE && pWaterLevel < WATER_LEVEL_LOW)
        {
            ProcessItemsWetness(m_SlotIdsLower);
        }
    }
 
    // Wets or dry items once in given time
    protected void ProcessItemsWetness(array<int> pSlotIds)
    {
        EntityAI attachment;
        
        int playerAttachmentCount = m_Player.GetInventory().AttachmentCount();
        
        LogDryWetProcess(string.Format("Environment :: ProcessItemsWetness (update interval=%1s)", GameConstants.ENVIRO_TICK_RATE));
        for (int attIdx = 0; attIdx < playerAttachmentCount; ++attIdx)
        {
            attachment = m_Player.GetInventory().GetAttachmentFromIndex(attIdx);
            if (attachment.IsItemBase())
            {
                int attachmentSlotsCount = attachment.GetInventory().GetSlotIdCount();
                for (int attachmentSlotId = 0; attachmentSlotId < attachmentSlotsCount; ++attachmentSlotId)
                {
                    int attachmentSlot = attachment.GetInventory().GetSlotId(attachmentSlotId);
                    for (int i = 0; i < pSlotIds.Count(); ++i)
                    {
                        if (attachmentSlot == pSlotIds.Get(i))
                        {
                            ApplyWetnessToItem(ItemBase.Cast(attachment));
                            break;
                        }
                    }
                }
            }
        }
        
        if (m_Player.GetItemInHands())
            ApplyWetnessToItem(m_Player.GetItemInHands());
 
        LogDryWetProcess("==========");
 
    }
 
    protected void ProcessItemsDryness()
    {
        EntityAI attachment;
        ItemBase item;
        
        int attCount = m_Player.GetInventory().AttachmentCount();
        
        LogDryWetProcess(string.Format("Environment :: ProcessItemsDryness (update interval=%1s)", GameConstants.ENVIRO_TICK_RATE));
        EnvironmentDrynessData drynessData = new EnvironmentDrynessData();
        drynessData.m_UseTemperatureSources = m_HasTemperatureSources;
 
        if (m_HasTemperatureSources)
        {
            float distance = vector.Distance(m_UTemperatureSources[0].GetPosition(), m_Player.GetPosition());
            distance = Math.Max(distance, 0.1);
            drynessData.m_TemperatureSourceDistance = distance;
            LogDryWetProcess(string.Format("distance to heatsource: %1 m", distance));
        }
        
        for (int attIdx = 0; attIdx < attCount; attIdx++)
        {
            attachment = m_Player.GetInventory().GetAttachmentFromIndex(attIdx);
            if (attachment && attachment.IsItemBase())
            {
                item = ItemBase.Cast(attachment);
                if (item)
                    ApplyDrynessToItemEx(item, drynessData);
            }
        }
 
        if (m_Player.GetItemInHands())
        {
            ApplyDrynessToItemEx(m_Player.GetItemInHands(), drynessData);
        }
        
        LogDryWetProcess("==========");
    }
 
    protected void ApplyWetnessToItem(ItemBase pItem)
    {
        if (pItem)
        {
            ItemBase parentItem;
            bool isParentWet            = false;
            bool parentContainsLiquid   = false;
            InventoryLocation iLoc      = new InventoryLocation();
 
            if (pItem.GetInventory().GetCurrentInventoryLocation(iLoc))
            {
                EntityAI parent = iLoc.GetParent();
                if (parent)
                {
                    parentItem = ItemBase.Cast(parent);
                    if (parentItem)
                    {
                        if (parentItem.GetWet() >= GameConstants.STATE_SOAKING_WET)
                            isParentWet = true;
 
                        if ((parentItem.GetLiquidType() != 0) && (parentItem.GetQuantity() > 0))
                            parentContainsLiquid = true;
                    }
                    else
                        isParentWet = true;
                    
                    if ((pItem.GetWet() > m_ItemsWetnessMax) && (parent == m_Player))
                        m_ItemsWetnessMax = pItem.GetWet();
                }
            }
 
            if (isParentWet || parentContainsLiquid)
            {
                float soakingCoef = 0;
                if (parentContainsLiquid)
                {
                    soakingCoef = pItem.GetSoakingIncrement("parentWithLiquid");
                    LogDryWetProcess(string.Format("%1 (soak coef=%2/s, current wetness=%3) [parent contains liquid]", pItem.GetDisplayName(), soakingCoef / GameConstants.ENVIRO_TICK_RATE, pItem.GetWet()), parentItem != null);
                }
                else if (isParentWet && parentItem)
                {
                    if (pItem.GetWet() < parentItem.GetWet())
                    {
                        soakingCoef = pItem.GetSoakingIncrement("wetParent");
                        LogDryWetProcess(string.Format("%1 (soak coef=%2/s, current wetness=%3) [parent wet]", pItem.GetDisplayName(), soakingCoef / GameConstants.ENVIRO_TICK_RATE, pItem.GetWet()), parentItem != null);
                    }
                }
                else
                {
                    soakingCoef = GetWetDelta();
                    LogDryWetProcess(string.Format("%1 (soak coef=%2/s, current wetness=%3) [normal]", pItem.GetDisplayName(), soakingCoef / GameConstants.ENVIRO_TICK_RATE, pItem.GetWet()), parentItem != null);
                }
 
                pItem.AddWet(soakingCoef);
                pItem.AddTemperature(GameConstants.ENVIRO_TICK_RATE * GameConstants.TEMPERATURE_RATE_COOLING_PLAYER * pItem.GetSoakingIncrement("wetParent"));
                
                if (pItem.GetInventory().GetCargo())
                {
                    int inItemCount = pItem.GetInventory().GetCargo().GetItemCount();
                    for (int i = 0; i < inItemCount; i++)
                    {
                        ItemBase inItem;
                        if (Class.CastTo(inItem, pItem.GetInventory().GetCargo().GetItem(i)))
                            ApplyWetnessToItem(inItem);
                    }
                }
                
                int attCount = pItem.GetInventory().AttachmentCount();
                if (attCount > 0)
                {
                    for (int attIdx = 0; attIdx < attCount; attIdx++)
                    {
                        EntityAI attachment = pItem.GetInventory().GetAttachmentFromIndex(attIdx);
                        ItemBase itemAtt = ItemBase.Cast(attachment);
                        if (itemAtt)
                            ApplyWetnessToItem(itemAtt);
                    }
                }
            }
        }
    }
    
    protected void ApplyDrynessToItem(ItemBase pItem)
    {
        EnvironmentDrynessData drynessData = new EnvironmentDrynessData();
        ApplyDrynessToItemEx(pItem, drynessData);
    }
    
    protected void ApplyDrynessToItemEx(ItemBase pItem, EnvironmentDrynessData pDrynessData)
    {
        if (pItem)
        {
            float dryingIncrement = pItem.GetDryingIncrement("player");
            if (pDrynessData.m_UseTemperatureSources)
                dryingIncrement = pItem.GetDryingIncrement("playerHeatSource");
            
            ItemBase parentItem;
            bool isParentWet            = false;
            bool parentContainsLiquid   = false;
    
            InventoryLocation iLoc = new InventoryLocation();
            if (pItem.GetInventory().GetCurrentInventoryLocation(iLoc))
            {
                EntityAI parent = iLoc.GetParent();
                if (parent)
                {
                    parentItem = ItemBase.Cast(parent);
                    if (parentItem)
                    {
                        if (parentItem.GetWet() >= GameConstants.STATE_SOAKING_WET)
                            isParentWet = true;
    
                        if ((parentItem.GetLiquidType() != 0) && (parentItem.GetQuantity() > 0))
                            parentContainsLiquid = true;
                    }
                    
                    if ((pItem.GetWet() > m_ItemsWetnessMax) && (parent == m_Player))
                    {
                        m_ItemsWetnessMax = pItem.GetWet();
                    }
                }
            }
    
            float dryingCoef = 0;
            
            if (!isParentWet && !parentContainsLiquid)
            {
                
                dryingCoef = (-1 * GameConstants.ENVIRO_TICK_RATE * dryingIncrement) / pDrynessData.m_TemperatureSourceDistance;
                if (pItem.GetWet() >= GameConstants.STATE_DAMP)
                {
                    LogDryWetProcess(string.Format("%1 (dry coef=%2/s, current wetness=%3) [normal]", pItem.GetDisplayName(), dryingCoef / GameConstants.ENVIRO_TICK_RATE, pItem.GetWet()), parentItem != null);
                    pItem.AddWet(dryingCoef);           
                }
                
                if (pItem.GetInventory().GetCargo())
                {
                    int inItemCount = pItem.GetInventory().GetCargo().GetItemCount();
                    for (int i = 0; i < inItemCount; i++)
                    {
                        ItemBase inItem;
                        if (Class.CastTo(inItem, pItem.GetInventory().GetCargo().GetItem(i)))
                            ApplyDrynessToItemEx(inItem, pDrynessData);
                    }
                }
                
                int attCount = pItem.GetInventory().AttachmentCount();
                if (attCount > 0)
                {
                    for (int attIdx = 0; attIdx < attCount; attIdx++)
                    {
                        EntityAI attachment = pItem.GetInventory().GetAttachmentFromIndex(attIdx);
                        ItemBase itemAtt;
                        if (ItemBase.CastTo(itemAtt, attachment))
                            ApplyDrynessToItemEx(itemAtt, pDrynessData);
                    }
                }
                
                pItem.AddTemperature(GameConstants.ENVIRO_TICK_RATE * GameConstants.TEMPERATURE_RATE_COOLING_PLAYER);
            }
            
            if (parentContainsLiquid)
            {
                dryingCoef = (GameConstants.ENVIRO_TICK_RATE * pItem.GetSoakingIncrement("parentWithLiquid")) / pDrynessData.m_TemperatureSourceDistance;
                LogDryWetProcess(string.Format("%1 (dry coef=%2/s, current wetness=%3) [parent contains liquid]", pItem.GetDisplayName(), dryingCoef / GameConstants.ENVIRO_TICK_RATE, pItem.GetWet()), parentItem != null);
                pItem.AddWet(dryingCoef);
                pItem.AddTemperature(GameConstants.ENVIRO_TICK_RATE * GameConstants.TEMPERATURE_RATE_COOLING_PLAYER);
            }
    
            if (isParentWet)
            {
                if (pItem.GetWet() < parentItem.GetWet())
                {
                    dryingCoef = (GameConstants.ENVIRO_TICK_RATE * pItem.GetSoakingIncrement("wetParent")) / pDrynessData.m_TemperatureSourceDistance;
                    LogDryWetProcess(string.Format("%1 (dry coef=%2/s, current wetness=%3) [parent wet]", pItem.GetDisplayName(), dryingCoef / GameConstants.ENVIRO_TICK_RATE, pItem.GetWet()), parentItem != null);
                    pItem.AddWet(dryingCoef);
                }
    
                pItem.AddTemperature(GameConstants.ENVIRO_TICK_RATE * GameConstants.TEMPERATURE_RATE_COOLING_PLAYER * 3.5);
            }
        }
    }
 
    // HEAT COMFORT
    protected void ProcessItemsHeat()
    {
        float hcHead, hcBody, hcFeet;   
        float hHead, hBody, hFeet;      
        
        float heatComfortAvg;
        float heatAvg;
 
        BodyPartHeatProperties(m_HeadParts, GameConstants.ENVIRO_HEATCOMFORT_HEADPARTS_WEIGHT, hcHead, hHead);
        BodyPartHeatProperties(m_BodyParts, GameConstants.ENVIRO_HEATCOMFORT_BODYPARTS_WEIGHT, hcBody, hBody);
        BodyPartHeatProperties(m_FeetParts, GameConstants.ENVIRO_HEATCOMFORT_FEETPARTS_WEIGHT, hcFeet, hFeet);
 
        heatComfortAvg = (hcHead + hcBody + hcFeet) / 3;
        heatAvg = (hHead + hBody + hFeet) / 3;
        heatAvg = heatAvg * GameConstants.ENVIRO_ITEM_HEAT_TRANSFER_COEF;
        
        // heat buffer
        float applicableHB = 0.0;
        if (m_UTSAverageTemperature < 0.001)
        {
            applicableHB = m_Player.GetStatHeatBuffer().Get() / 30.0;
            if (applicableHB > 0.0)
            {
                if (m_HeatBufferTimer > 1.0)
                {
                    m_Player.GetStatHeatBuffer().Add(Math.Min(EnvTempToCoef(m_EnvironmentTemperature), -0.1) * GameConstants.ENVIRO_PLAYER_HEATBUFFER_DECREASE);
                }
                else
                {
                    m_HeatBufferTimer += GameConstants.ENVIRO_PLAYER_HEATBUFFER_TICK;
                }
            }
            else
            {
                m_HeatBufferTimer = 0.0;
            }           
        }
        else
        {
            applicableHB = m_Player.GetStatHeatBuffer().Get() / 30.0;
            if (m_HeatComfort > PlayerConstants.THRESHOLD_HEAT_COMFORT_MINUS_WARNING)
            {
                m_Player.GetStatHeatBuffer().Add(GameConstants.ENVIRO_PLAYER_HEATBUFFER_INCREASE);
                m_HeatBufferTimer = 0.0;
            }
            else
            {
                m_HeatBufferTimer = 0.0;
            }
        }
        
        m_HeatComfort = (heatComfortAvg + heatAvg + (GetPlayerHeat() / 100)) + EnvTempToCoef(m_EnvironmentTemperature);
        if ((m_HeatComfort + applicableHB) < (PlayerConstants.THRESHOLD_HEAT_COMFORT_PLUS_WARNING - 0.01))
        {
            m_HeatComfort += applicableHB;
        }
        else
        {
            if (m_HeatComfort <= (PlayerConstants.THRESHOLD_HEAT_COMFORT_PLUS_WARNING - 0.01))
            {
                m_HeatComfort = PlayerConstants.THRESHOLD_HEAT_COMFORT_PLUS_WARNING - 0.01;
            }
        }
 
        m_HeatComfort = Math.Clamp(m_HeatComfort, m_Player.GetStatHeatComfort().GetMin(), m_Player.GetStatHeatComfort().GetMax());
        
        m_Player.GetStatHeatComfort().Set(m_HeatComfort);
    }
    
    protected bool OverridenHeatComfort(out float value);
    
    protected float EnvTempToCoef(float pTemp)
    {
        if (pTemp >= GameConstants.ENVIRO_HIGH_TEMP_LIMIT)
        {
            return 1;
        }
        
        if (pTemp <= GameConstants.ENVIRO_LOW_TEMP_LIMIT)
        {
            return -1;
        }
 
        return (pTemp - GameConstants.ENVIRO_PLAYER_COMFORT_TEMP) / GameConstants.ENVIRO_TEMP_EFFECT_ON_PLAYER;
    }
    
    protected void BodyPartHeatProperties(array<int> pBodyPartIds, float pCoef, out float pHeatComfort, out float pHeat)
    {
        int attCount;
        
        EntityAI attachment;
        ItemBase item;
        
        pHeatComfort = -1;
        attCount = m_Player.GetInventory().AttachmentCount();
        
        for (int attIdx = 0; attIdx < attCount; attIdx++)
        {
            attachment = m_Player.GetInventory().GetAttachmentFromIndex(attIdx);
            if (attachment.IsClothing())
            {
                item = ItemBase.Cast(attachment);
                int attachmentSlot = attachment.GetInventory().GetSlotId(0);
 
                for (int i = 0; i < pBodyPartIds.Count(); i++)
                {
                    if (attachmentSlot == pBodyPartIds.Get(i))
                    {
                        float heatIsoMult = 1.0;
                        if (attachmentSlot == InventorySlots.VEST)
                        {
                            heatIsoMult = GameConstants.ENVIRO_HEATISOLATION_VEST_WEIGHT;
                        }
 
                        if (attachmentSlot == InventorySlots.BACK)
                        {
                            heatIsoMult = GameConstants.ENVIRO_HEATISOLATION_BACK_WEIGHT;
                        }
 
                        pHeatComfort += heatIsoMult * MiscGameplayFunctions.GetCurrentItemHeatIsolation(item);
                        
                        // go through any attachments and cargo (only current level, ignore nested containers - they isolate)
                        int inAttCount = item.GetInventory().AttachmentCount();
                        if (inAttCount > 0)
                        {
                            for (int inAttIdx = 0; inAttIdx < inAttCount; inAttIdx++)
                            {
                                EntityAI inAttachment = item.GetInventory().GetAttachmentFromIndex(inAttIdx);
                                ItemBase itemAtt = ItemBase.Cast(inAttachment);
                                if (itemAtt)
                                {
                                    pHeat += itemAtt.GetTemperature();
                                }
                            }
                        }
                        if (item.GetInventory().GetCargo())
                        {
                            int inItemCount = item.GetInventory().GetCargo().GetItemCount();
                            
                            for (int j = 0; j < inItemCount; j++)
                            {
                                ItemBase inItem;
                                if (Class.CastTo(inItem, item.GetInventory().GetCargo().GetItem(j)))
                                {
                                    pHeat += inItem.GetTemperature();
                                }
                            }
                        }
                    }
                }
            }
        }
 
        pHeatComfort = (pHeatComfort / pBodyPartIds.Count()) * pCoef;
        pHeat = (pHeat / pBodyPartIds.Count()) * pCoef;
    }
    
    protected void GatherTemperatureSources()
    {
        m_UTemperatureSources.Clear();
 
        array<Object> nearestObjects = new array<Object>;
        GetGame().GetObjectsAtPosition(m_Player.GetPosition(), GameConstants.ENVIRO_TEMP_SOURCES_LOOKUP_RADIUS, nearestObjects, null);
 
        foreach (Object nearestObject : nearestObjects)
        {
            EntityAI ent = EntityAI.Cast(nearestObject);
            if (ent && ent.IsUniversalTemperatureSource() && ent != m_Player)
            {
                if (vector.DistanceSq(m_Player.GetPosition(), ent.GetPosition()) > Math.SqrFloat(ent.GetUniversalTemperatureSource().GetMaxRange()))
                    continue;
 
                m_UTemperatureSources.Insert(ent.GetUniversalTemperatureSource());
            }
        }
 
        if (m_Player.GetItemInHands() && m_Player.GetItemInHands().IsUniversalTemperatureSource())
            m_UTemperatureSources.Insert(m_Player.GetItemInHands().GetUniversalTemperatureSource());
    }
    
    protected void ProcessTemperatureSources()
    {
        if (m_UTemperatureSources.Count() == 0)
        {
            m_HasTemperatureSources = false;
            m_UTSAverageTemperature = m_UTSAverageTemperatureBuffer.Add(0);
            return;
        }
 
        array<float> utsTemperatures = new array<float>();
        
        // get temperature from the source (based on distance), save it for min/max filtering
        foreach (UTemperatureSource tempSource : m_UTemperatureSources)
            utsTemperatures.Insert(CalcTemperatureFromTemperatureSource(tempSource));
 
        float min = MiscGameplayFunctions.GetMinValue(utsTemperatures);
        float max = MiscGameplayFunctions.GetMaxValue(utsTemperatures);
        
        if (max > 0 && min < 0)
        {
            m_UTSAverageTemperature = m_UTSAverageTemperatureBuffer.Add((max + min) * 0.5);
        }
        else
        {
            m_UTSAverageTemperature = m_UTSAverageTemperatureBuffer.Add(max);
        }
        
        m_HasTemperatureSources = true;
    }
    
    float GetUniversalSourcesTemperageAverage()
    {
        return m_UTSAverageTemperature;
    }
    
    float CalcTemperatureFromTemperatureSource(notnull UTemperatureSource uts)
    {
        float distance      = vector.Distance(m_Player.GetPosition(), uts.GetPosition());
        distance            = Math.Max(distance, 0.1);  //min distance cannot be 0 (division by zero)
        float temperature   = 0;
 
        //Debug.Log(string.Format("CalcTemperatureFromTemperatureSource::distance: %1", distance), "Environment");
        
        if (distance > uts.GetFullRange())
        {
            float distFactor = 1 - (distance / uts.GetMaxRange());
            distFactor = Math.Max(distFactor, 0.0); 
            temperature = uts.GetTemperature() * distFactor;
            //temperature = Math.Clamp(temperature, uts.GetTemperatureMin(), uts.GetTemperatureMax());
            //Debug.Log(string.Format("CalcTemperatureFromTemperatureSource::distFactor: %1", distFactor), "Environment");
            //Debug.Log(string.Format("CalcTemperatureFromTemperatureSource::temperatureXX: %1", temperature), "Environment");
        }
        else
        {
            temperature = uts.GetTemperature();
        }
 
        //Debug.Log(string.Format("CalcTemperatureFromTemperatureSource::temperature: %1", temperature), "Environment");
 
        return temperature;
    }
 
#ifdef DIAG_DEVELOPER
    EnvDebugData GetEnvDebugData()
    {
        EnvDebugData data = new EnvDebugData();
        data.Synch(this, m_Player);
        return data;
    }
    
    void ShowEnvDebugPlayerInfo(bool enabled)
    {
        EnvDebugData data = GetEnvDebugData();
        DisplayEnvDebugPlayerInfo(enabled, data);
    }
    
    static void DisplayEnvDebugPlayerInfo(bool enabled, EnvDebugData data)
    {
        int windowPosX = 10;
        int windowPosY = 200;
 
        Object obj;
 
        DbgUI.Begin("Player stats", windowPosX, windowPosY);
        if ( enabled )
        {
            DbgUI.Text(string.Format("Heat comfort: %1", data.m_PlayerData.m_HeatComfort));
            DbgUI.Text(string.Format("Inside: %1 (%2)", data.m_PlayerData.m_Inside, data.m_PlayerData.m_Surface));
            DbgUI.Text(string.Format("Under roof: %1 (%2)", data.m_PlayerData.m_UnderRoof, data.m_PlayerData.m_UnderRoofTimer));
            if ( data.m_PlayerData.m_WaterLevel > 0 )
            {
                DbgUI.Text(string.Format("Water Level: %1", data.m_PlayerData.m_WaterLevel));
            }
            
        }
        DbgUI.End();
        
        DbgUI.Begin("Weather stats:", windowPosX, windowPosY + 200);
        if ( enabled )
        {
            DbgUI.Text(string.Format("Env temperature (base): %1", data.m_MiscData.m_TemperatureBase));
            DbgUI.Text(string.Format("Env temperature (modfied): %1", data.m_MiscData.m_TemperatureModified));
            DbgUI.Text(string.Format("Wind: %1 (x%2)", data.m_WeatherData.m_Wind, data.m_WeatherData.m_WindModifier));
            DbgUI.Text(string.Format("Rain: %1", data.m_WeatherData.m_Rain));
            DbgUI.Text(string.Format("Day/Night (1/0): %1", data.m_MiscData.m_DayOrNight));
            DbgUI.Text(string.Format("Fog: %1", data.m_WeatherData.m_Fog));
            DbgUI.Text(string.Format("Clouds: %1", data.m_WeatherData.m_Clouds));
            DbgUI.Text(string.Format("Height: %1", data.m_MiscData.m_Height));
            DbgUI.Text(string.Format("Wet delta: %1", data.m_MiscData.m_WetDelta));
        }
        DbgUI.End();
    }
    
    void FillDebugWeatherData(EnvDebugWeatherData data)
    {
        data.m_Wind = m_Wind;
        data.m_WindModifier = GetWindModifierPerSurface();
        data.m_Rain = m_Rain;
        data.m_Fog = m_Fog;
        data.m_Clouds = m_Clouds;
    }
#endif
 
    string GetDebugMessage()
    {
        string message;     
        message += "Player stats";
        message += "\nHeat comfort: " + m_HeatComfort.ToString();
        message += "\nInside: " + IsInsideBuilding().ToString() + " (" + m_Player.GetSurfaceType() + ")";
        message += "\nUnder roof: " + m_IsUnderRoof.ToString() + " (" + GetNextRoofCheck() + ")";
        if (IsWaterContact() && m_WaterLevel > WATER_LEVEL_NONE)
        {
            message += "\nWater Level: " + m_WaterLevel;
        }
 
        message += "\n\nWeather stats";
        message += "\nEnv temperature (base): " + g_Game.GetMission().GetWorldData().GetBaseEnvTemperature().ToString();
        message += "\nEnv temperature (modified): " + m_EnvironmentTemperature.ToString();
        message += "\nWind: " + m_Wind.ToString() + " (x" + GetWindModifierPerSurface() + ")";
        message += "\nRain: " + m_Rain.ToString();
        message += "\nDay/Night (1/0): " + m_DayOrNight.ToString();
        message += "\nFog: " + m_Fog.ToString();
        message += "\nClouds: " + m_Clouds.ToString();
        message += "\nHeight: " + GetTemperatureHeightCorrection().ToString();
        message += "\nWet delta: " + GetWetDelta().ToString();
        
        return message;
    }
    
    int GetNextRoofCheck()
    {
        return (GameConstants.ENVIRO_TICK_ROOF_RC_CHECK - m_RoofCheckTimer) + 1;
    }
    
    float GetWaterLevel()
    {
        if (IsWaterContact() && m_WaterLevel > WATER_LEVEL_NONE)
        {
            return m_WaterLevel;
        }
        else
        {
            return 0;
        }
    }
    
    float GetDayOrNight()
    {
        return m_DayOrNight;
    }
    
    private void LogDryWetProcess(string message, bool indented = false)
    {
        #ifdef DIAG_DEVELOPER
        if (m_DebugLogDryWet)
        {
            string indentation = "";
            if (indented)
                indentation = "|--";
 
            Debug.Log(string.Format("%1 %2", indentation, message));
        }
        #endif
    }
}
 
class EnvironmentDrynessData
{
    bool m_UseTemperatureSources        = false;
    float m_TemperatureSourceDistance   = 1.0;
}
 
#ifdef DIAG_DEVELOPER
class EnvDebugPlayerData : Param
{
    float   m_HeatComfort;
    bool    m_Inside;
    string  m_Surface;
    bool    m_UnderRoof;
    int     m_UnderRoofTimer;
    float   m_WaterLevel;
    
    void Synch(Environment env, PlayerBase player)
    {
        m_HeatComfort = player.GetStatHeatComfort().Get();
        m_Inside = env.IsInsideBuilding();
        m_Surface = player.GetSurfaceType();
        m_UnderRoof = env.IsUnderRoof();
        m_UnderRoofTimer = env.GetNextRoofCheck();
        m_WaterLevel = env.GetWaterLevel();
    }
    
    override bool Serialize(Serializer ctx)
    {
        return (
        ctx.Write(m_HeatComfort) && ctx.Write(m_Inside) && ctx.Write(m_Surface) && ctx.Write(m_UnderRoof) && ctx.Write(m_UnderRoofTimer) && ctx.Write(m_WaterLevel));
    }
    
    override bool Deserializer(Serializer ctx)
    {
        return ctx.Read(m_HeatComfort) && ctx.Read(m_Inside) && ctx.Read(m_Surface) && ctx.Read(m_UnderRoof) && ctx.Read(m_UnderRoofTimer) && ctx.Read(m_WaterLevel);
    }
}
 
class EnvDebugMiscData : Param
{
    float   m_TemperatureBase;
    float   m_TemperatureModified;
    float   m_DayOrNight;
    float   m_Height;
    float   m_WetDelta;
    
    void Synch(Environment env)
    {
        m_TemperatureBase = g_Game.GetMission().GetWorldData().GetBaseEnvTemperature();
        m_TemperatureModified = env.GetTemperature();
        m_DayOrNight = env.GetDayOrNight();
        m_Height = env.GetTemperatureHeightCorrection();
        m_WetDelta = env.GetWetDelta();
    }
    
    override bool Serialize(Serializer ctx)
    {
        return ctx.Write(m_TemperatureBase) && ctx.Write(m_TemperatureModified) && ctx.Write(m_DayOrNight) && ctx.Write(m_Height) && ctx.Write(m_WetDelta);
    }
    
    override bool Deserializer(Serializer ctx)
    {
        return ctx.Read(m_TemperatureBase) && ctx.Read(m_TemperatureModified) && ctx.Read(m_DayOrNight) && ctx.Read(m_Height) && ctx.Read(m_WetDelta);
    }
}
 
class EnvDebugWeatherData : Param
{
    float   m_Wind;
    float   m_WindModifier;
    float   m_Rain;
    float   m_Fog;
    float   m_Clouds;
    
    void Synch(Environment env)
    {
        env.FillDebugWeatherData(this);
    }
    
    override bool Serialize(Serializer ctx)
    {
        return ctx.Write(m_Wind) && ctx.Write(m_WindModifier) && ctx.Write(m_Rain) && ctx.Write(m_Fog) && ctx.Write(m_Clouds);
    }
        
    override bool Deserializer(Serializer ctx)
    {
        return ctx.Read(m_Wind) && ctx.Read(m_WindModifier) && ctx.Read(m_Rain) && ctx.Read(m_Fog) && ctx.Read(m_Clouds);
    }
}
 
class EnvDebugData : Param
{
    ref EnvDebugPlayerData      m_PlayerData = new EnvDebugPlayerData();
    ref EnvDebugMiscData        m_MiscData = new EnvDebugMiscData();
    ref EnvDebugWeatherData     m_WeatherData = new EnvDebugWeatherData();
    
    void Synch(Environment env, PlayerBase player)
    {
        m_PlayerData.Synch(env, player);
        m_MiscData.Synch(env);
        m_WeatherData.Synch(env);
    }
    
    override bool Serialize(Serializer ctx)
    {
        return m_PlayerData.Serialize(ctx) && m_MiscData.Serialize(ctx) && m_WeatherData.Serialize(ctx);
    }
        
    override bool Deserializer(Serializer ctx)
    {
        return m_PlayerData.Deserializer(ctx) && m_MiscData.Deserializer(ctx) && m_WeatherData.Deserializer(ctx);
    }
}
#endif