Защищенные члены
void	Environment (PlayerBase pPlayer)

void	Init (PlayerBase pPlayer)

void	Update (float pDelta)

bool	IsTemperatureSet ()

void	AddToEnvironmentTemperature (float pTemperature)

float	GetPlayerHeat ()
	Returns heat player generated based on player's movement speed (for now)

bool	IsUnderRoof ()

bool	IsWaterContact ()

bool	IsInsideBuilding ()

bool	IsInsideVehicle ()

bool	IsRaining ()

void	CheckUnderRoof ()
	Checks whether Player is sheltered.

void	CheckWaterContact (out float pWaterLevel)

float	GetTemperatureHeightCorrection ()

float	GetWindModifierPerSurface ()

float	GetTemperature ()

float	GetEnvironmentTemperature ()

float	GetWetDelta ()

void	CollectAndSetPlayerData ()

void	CollectAndSetEnvironmentData ()

void	SetEnvironmentTemperature ()

void	ProcessWetnessByRain ()

void	ProcessWetnessByWaterLevel (float pWaterLevel)

void	ProcessItemsWetness (array< int > pSlotIds)

void	ProcessItemsDryness ()

void	ApplyWetnessToItem (ItemBase pItem)

void	ApplyDrynessToItem (ItemBase pItem)

void	ApplyDrynessToItemEx (ItemBase pItem, EnvironmentDrynessData pDrynessData)

void	ProcessItemsHeat ()
	Calculates and process temperature of items.

bool	OverridenHeatComfort (out float value)
	DEPRECATED.

float	EnvTempToCoef (float pTemp)

void	BodyPartHeatProperties (array< int > pBodyPartIds, float pCoef, out float pHeatComfort, out float pHeat)
	returns weighted avg heat comfort for bodypart

void	GatherTemperatureSources ()

void	ProcessTemperatureSources ()

float	GetUniversalSourcesTemperageAverage ()

float	CalcTemperatureFromTemperatureSource (notnull UTemperatureSource uts)

string	GetDebugMessage ()
	debug

int	GetNextRoofCheck ()

float	GetWaterLevel ()

float	GetDayOrNight ()

Защищенные данные
float	m_WetDryTick

float	m_ItemsWetnessMax

float	m_RoofCheckTimer
	keeps wetness of most wet item in player's possesion

PlayerBase	m_Player

float	m_PlayerHeightPos

float	m_PlayerSpeed

float	m_PlayerTemperature

float	m_PlayerHeat

float	m_HeatComfort

float	m_Rain = 0

float	m_Wind = 0

float	m_Fog = 0

float	m_DayOrNight = 0

float	m_Clouds = 0

float	m_EnvironmentTemperature = 0

float	m_Time = 0

string	m_SurfaceType

float	m_WaterLevel

bool	m_IsUnderRoof

bool	m_IsInWater

bool	m_IsTempSet

float	m_HeatSourceTemp

float	m_HeatBufferTimer
	DEPRECATED.

ref array< int >	m_SlotIdsComplete

ref array< int >	m_SlotIdsUpper

ref array< int >	m_SlotIdsBottom

ref array< int >	m_SlotIdsLower

ref array< int >	m_HeadParts

ref array< int >	m_BodyParts

ref array< int >	m_FeetParts

ref SimpleMovingAverage< float >	m_WindAverageBuffer

bool	m_HasTemperatureSources

float	m_UTSAverageTemperature

ref array< UTemperatureSource >	m_UTemperatureSources

ref SimpleMovingAverage< float >	m_UTSAverageTemperatureBuffer

Закрытые члены
bool	IsUnderRoofBuilding ()

void	LogDryWetProcess (string message, bool indented=false)

Закрытые данные
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

bool	m_IsUnderRoofBuilding

Подробное описание

Конструктор(ы)

◆ Environment()

void Environment ( PlayerBase pPlayer )

inlineprotected

    {
        Init(pPlayer);
    }

Перекрестные ссылки Init().

Методы

◆ AddToEnvironmentTemperature()

void AddToEnvironmentTemperature ( float pTemperature )

protected

◆ ApplyDrynessToItem()

void ApplyDrynessToItem ( ItemBase pItem )

inlineprotected

    {
        EnvironmentDrynessData drynessData = new EnvironmentDrynessData();
        ApplyDrynessToItemEx(pItem, drynessData);
    }

Перекрестные ссылки ApplyDrynessToItemEx().

◆ ApplyDrynessToItemEx()

void ApplyDrynessToItemEx	(	ItemBase	pItem,
		EnvironmentDrynessData	pDrynessData )

inlineprotected

adds wetness to item inside parent item containing liquid

adds wetness to item inside wet parent item

    {
        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);
            }
        }
    }

Перекрестные ссылки ApplyDrynessToItemEx(), Class::CastTo(), GameConstants::ENVIRO_TICK_RATE, LogDryWetProcess(), m_ItemsWetnessMax, m_Player, GameConstants::STATE_DAMP, GameConstants::STATE_SOAKING_WET и GameConstants::TEMPERATURE_RATE_COOLING_PLAYER.

Используется в ApplyDrynessToItem(), ApplyDrynessToItemEx() и ProcessItemsDryness().

◆ ApplyWetnessToItem()

void ApplyWetnessToItem ( ItemBase pItem )

inlineprotected

    {
        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);
                    }
                }
            }
        }
    }

Перекрестные ссылки ApplyWetnessToItem(), Class::CastTo(), GameConstants::ENVIRO_TICK_RATE, GetWetDelta(), LogDryWetProcess(), m_ItemsWetnessMax, m_Player, GameConstants::STATE_SOAKING_WET и GameConstants::TEMPERATURE_RATE_COOLING_PLAYER.

Используется в ApplyWetnessToItem() и ProcessItemsWetness().

◆ BodyPartHeatProperties()

void BodyPartHeatProperties	(	array< int >	pBodyPartIds,
		float	pCoef,
		out float	pHeatComfort,
		out float	pHeat )

inlineprotected

returns weighted avg heat comfort for bodypart

go through all body parts we've defined for that zone (ex.: head, body, feet)

    {
        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;
    }

Перекрестные ссылки Class::CastTo(), GameConstants::ENVIRO_HEATISOLATION_BACK_WEIGHT, GameConstants::ENVIRO_HEATISOLATION_VEST_WEIGHT и m_Player.

Используется в ProcessItemsHeat().

◆ CalcTemperatureFromTemperatureSource()

float CalcTemperatureFromTemperatureSource ( notnull UTemperatureSource uts )

inlineprotected

heat transfer through air to player (env temperature)

dist factor minimum should be at 0

    {
        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;
    }

Перекрестные ссылки vector::Distance(), m_Player и Math::Max().

Используется в ProcessTemperatureSources().

◆ CheckUnderRoof()

void CheckUnderRoof ( )

inlineprotected

Checks whether Player is sheltered.

    {
        // 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);
    }

Перекрестные ссылки IsInsideVehicle(), m_IsUnderRoof, m_IsUnderRoofBuilding, m_Player и DayZPhysics::RayCastBullet().

Используется в Update().

◆ CheckWaterContact()

void CheckWaterContact ( out float pWaterLevel )

inlineprotected

no valid surface under character

sync info about water contact to player

update active surface

    {
        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;
    }

Перекрестные ссылки g_Game, IsUnderRoofBuilding(), LIQUID_RIVERWATER, LIQUID_WATER, m_IsInWater, m_Player, m_SurfaceType, WATER_LEVEL_HIGH и WATER_LEVEL_MID.

Используется в Update().

◆ CollectAndSetEnvironmentData()

void CollectAndSetEnvironmentData ( )

inlineprotected

    {
        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();
    }

Перекрестные ссылки g_Game, m_Clouds, m_DayOrNight, m_Fog, m_Rain, m_Wind, m_WindAverageBuffer и SetEnvironmentTemperature().

Используется в Update().

◆ CollectAndSetPlayerData()

void CollectAndSetPlayerData ( )

inlineprotected

    {
        vector playerPos = m_Player.GetPosition();
        m_PlayerHeightPos = playerPos[1];
 
        HumanCommandMove hcm = m_Player.GetCommand_Move();
        if (hcm)
        {
            m_PlayerSpeed = hcm.GetCurrentMovementSpeed();
        }
 
        m_PlayerHeat = GetPlayerHeat();
    }

Перекрестные ссылки GetPlayerHeat(), m_Player, m_PlayerHeat, m_PlayerHeightPos и m_PlayerSpeed.

Используется в Update().

◆ EnvTempToCoef()

float EnvTempToCoef ( float pTemp )

inlineprotected

    {
        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;
    }

Перекрестные ссылки GameConstants::ENVIRO_HIGH_TEMP_LIMIT, GameConstants::ENVIRO_LOW_TEMP_LIMIT, GameConstants::ENVIRO_PLAYER_COMFORT_TEMP и GameConstants::ENVIRO_TEMP_EFFECT_ON_PLAYER.

Используется в ProcessItemsHeat().

◆ GatherTemperatureSources()

void GatherTemperatureSources ( )

inlineprotected

next temp source is too far

    {
        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());
    }

Перекрестные ссылки vector::DistanceSq(), GameConstants::ENVIRO_TEMP_SOURCES_LOOKUP_RADIUS, GetGame(), m_Player, m_UTemperatureSources и Math::SqrFloat().

Используется в Update().

◆ GetDayOrNight()

float GetDayOrNight ( )

inlineprotected

    {
        return m_DayOrNight;
    }

Перекрестные ссылки m_DayOrNight.

◆ GetDebugMessage()

string GetDebugMessage ( )

inlineprotected

debug

    {
        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;
    }

Перекрестные ссылки g_Game, GetNextRoofCheck(), GetTemperatureHeightCorrection(), GetWetDelta(), GetWindModifierPerSurface(), IsInsideBuilding(), IsWaterContact(), m_Clouds, m_DayOrNight, m_EnvironmentTemperature, m_Fog, m_HeatComfort, m_IsUnderRoof, m_Player, m_Rain, m_WaterLevel, m_Wind, bool::ToString(), float::ToString() и WATER_LEVEL_NONE.

◆ GetEnvironmentTemperature()

float GetEnvironmentTemperature ( )

inlineprotected

    {
        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;
    }   

Перекрестные ссылки Math::AbsFloat(), GameConstants::ENVIRO_CLOUDS_TEMP_EFFECT, GameConstants::ENVIRO_FOG_TEMP_EFFECT, GameConstants::ENVIRO_TEMPERATURE_INSIDE_COEF, GameConstants::ENVIRO_TEMPERATURE_INSIDE_VEHICLE_COEF, GameConstants::ENVIRO_TEMPERATURE_UNDERROOF_COEF, GameConstants::ENVIRO_TEMPERATURE_WIND_COEF, GameConstants::ENVIRO_WATER_TEMPERATURE_COEF, g_Game, GetTemperatureHeightCorrection(), GetWindModifierPerSurface(), IsInsideBuilding(), IsInsideVehicle(), IsUnderRoof(), IsWaterContact(), m_Clouds, m_Fog, m_IsUnderRoofBuilding, m_UTSAverageTemperature и m_Wind.

Используется в GetWetDelta() и SetEnvironmentTemperature().

◆ GetNextRoofCheck()

int GetNextRoofCheck ( )

inlineprotected

    {
        return (GameConstants.ENVIRO_TICK_ROOF_RC_CHECK - m_RoofCheckTimer) + 1;
    }

Перекрестные ссылки GameConstants::ENVIRO_TICK_ROOF_RC_CHECK и m_RoofCheckTimer.

Используется в GetDebugMessage().

◆ GetPlayerHeat()

float GetPlayerHeat ( )

inlineprotected

Returns heat player generated based on player's movement speed (for now)

    {
        float heat = Math.Max(m_PlayerSpeed * GameConstants.ENVIRO_DEFAULT_ENTITY_HEAT, GameConstants.ENVIRO_DEFAULT_ENTITY_HEAT);
        return heat;
    }

Перекрестные ссылки GameConstants::ENVIRO_DEFAULT_ENTITY_HEAT, m_PlayerSpeed и Math::Max().

Используется в CollectAndSetPlayerData() и ProcessItemsHeat().

◆ GetTemperature()

float GetTemperature ( )

inlineprotected

    {
        return m_EnvironmentTemperature;
    }

Перекрестные ссылки m_EnvironmentTemperature.

◆ GetTemperatureHeightCorrection()

float GetTemperatureHeightCorrection ( )

inlineprotected

    {
        float temperature_reduction = Math.Max(0, (m_PlayerHeightPos * GameConstants.ENVIRO_TEMPERATURE_HEIGHT_REDUCTION));
        return temperature_reduction;
    }

Перекрестные ссылки GameConstants::ENVIRO_TEMPERATURE_HEIGHT_REDUCTION, m_PlayerHeightPos и Math::Max().

Используется в GetDebugMessage() и GetEnvironmentTemperature().

◆ GetUniversalSourcesTemperageAverage()

float GetUniversalSourcesTemperageAverage ( )

inlineprotected

    {
        return m_UTSAverageTemperature;
    }

Перекрестные ссылки m_UTSAverageTemperature.

◆ GetWaterLevel()

float GetWaterLevel ( )

inlineprotected

    {
        if (IsWaterContact() && m_WaterLevel > WATER_LEVEL_NONE)
        {
            return m_WaterLevel;
        }
        else
        {
            return 0;
        }
    }

Перекрестные ссылки IsWaterContact(), m_WaterLevel и WATER_LEVEL_NONE.

◆ GetWetDelta()

float GetWetDelta ( )

inlineprotected

player is getting wet by movement/swimming in water (+differentiate wetDelta by water level)

player is getting wet from rain

player is drying

    {
        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;
    }

Перекрестные ссылки GameConstants::ENVIRO_CLOUD_DRY_EFFECT, GameConstants::ENVIRO_DRY_INCREMENT, GameConstants::ENVIRO_FOG_DRY_EFFECT, GameConstants::ENVIRO_TICKS_TO_WETNESS_CALCULATION, GameConstants::ENVIRO_WET_INCREMENT, GameConstants::ENVIRO_WIND_EFFECT, GetEnvironmentTemperature(), IsInsideBuilding(), IsInsideVehicle(), IsRaining(), IsUnderRoof(), IsWaterContact(), m_Clouds, m_Fog, m_PlayerHeat, m_Rain, m_WaterLevel, m_Wind, Math::Max(), WATER_LEVEL_HIGH, WATER_LEVEL_LOW, WATER_LEVEL_MID и WATER_LEVEL_NONE.

Используется в ApplyWetnessToItem() и GetDebugMessage().

◆ GetWindModifierPerSurface()

float GetWindModifierPerSurface ( )

inlineprotected

    {
        if (IsUnderRoofBuilding())
            return 0.0;
 
        return g_Game.ConfigGetFloat("CfgSurfaces " + m_SurfaceType + " windModifier");
    }

Перекрестные ссылки g_Game, IsUnderRoofBuilding() и m_SurfaceType.

Используется в GetDebugMessage() и GetEnvironmentTemperature().

◆ Init()

void Init ( PlayerBase pPlayer )

inlineprotected

whole body slots

upper body part slots

bottom body part slots

lower body part slots

heat comfort related slots

    {
        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,
        };
    }

Перекрестные ссылки m_BodyParts, m_FeetParts, m_HeadParts, m_HeatBufferTimer, m_HeatComfort, m_IsInWater, m_IsUnderRoof, m_Player, m_PlayerSpeed, m_RoofCheckTimer, m_SlotIdsBottom, m_SlotIdsComplete, m_SlotIdsLower, m_SlotIdsUpper, m_SurfaceType, m_UTemperatureSources, m_UTSAverageTemperature, m_UTSAverageTemperatureBuffer, m_WaterLevel, m_WetDryTick и m_WindAverageBuffer.

◆ IsInsideBuilding()

bool IsInsideBuilding ( )

inlineprotected

    {
        return m_Player && m_Player.IsSoundInsideBuilding();
    }

Перекрестные ссылки m_Player.

Используется в GetDebugMessage(), GetEnvironmentTemperature(), GetWetDelta() и Update().

◆ IsInsideVehicle()

bool IsInsideVehicle ( )

inlineprotected

    {
        return m_Player && m_Player.IsInVehicle();
    }

Перекрестные ссылки m_Player.

Используется в CheckUnderRoof(), GetEnvironmentTemperature(), GetWetDelta() и Update().

◆ IsRaining()

bool IsRaining ( )

inlineprotected

    {
        return m_Rain > RAIN_LIMIT_LOW;
    }

Перекрестные ссылки m_Rain и RAIN_LIMIT_LOW.

Используется в GetWetDelta() и Update().

◆ IsTemperatureSet()

bool IsTemperatureSet ( )

inlineprotected

    {
        return m_IsTempSet;
    }

Перекрестные ссылки m_IsTempSet.

◆ IsUnderRoof()

bool IsUnderRoof ( )

inlineprotected

    {
        return m_IsUnderRoof;
    }

Перекрестные ссылки m_IsUnderRoof.

Используется в GetEnvironmentTemperature(), GetWetDelta() и Update().

◆ IsUnderRoofBuilding()

bool IsUnderRoofBuilding ( )

inlineprivate

    {
        return m_IsUnderRoofBuilding;
    }

Перекрестные ссылки m_IsUnderRoofBuilding.

Используется в CheckWaterContact() и GetWindModifierPerSurface().

◆ IsWaterContact()

bool IsWaterContact ( )

inlineprotected

    {
        return m_IsInWater;
    }

Перекрестные ссылки m_IsInWater.

Используется в GetDebugMessage(), GetEnvironmentTemperature(), GetWaterLevel(), GetWetDelta() и Update().

◆ LogDryWetProcess()

void LogDryWetProcess	(	string	message,
		bool	indented = false )

inlineprivate

    {
        #ifdef DIAG_DEVELOPER
        if (m_DebugLogDryWet)
        {
            string indentation = "";
            if (indented)
                indentation = "|--";
 
            Debug.Log(string.Format("%1 %2", indentation, message));
        }
        #endif
    }

Перекрестные ссылки Debug::Log().

Используется в ApplyDrynessToItemEx(), ApplyWetnessToItem(), ProcessItemsDryness() и ProcessItemsWetness().

◆ OverridenHeatComfort()

bool OverridenHeatComfort ( out float value )

protected

DEPRECATED.

◆ ProcessItemsDryness()

void ProcessItemsDryness ( )

inlineprotected

    {
        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("==========");
    }

Перекрестные ссылки ApplyDrynessToItemEx(), vector::Distance(), GameConstants::ENVIRO_TICK_RATE, GetPosition, LogDryWetProcess(), m_HasTemperatureSources, m_Player, m_UTemperatureSources и Math::Max().

Используется в Update().

◆ ProcessItemsHeat()

void ProcessItemsHeat ( )

inlineprotected

Calculates and process temperature of items.

Heat Comfort

Heat (from items);

    {
        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);
    }

Перекрестные ссылки BodyPartHeatProperties(), Math::Clamp(), GameConstants::ENVIRO_HEATCOMFORT_BODYPARTS_WEIGHT, GameConstants::ENVIRO_HEATCOMFORT_FEETPARTS_WEIGHT, GameConstants::ENVIRO_HEATCOMFORT_HEADPARTS_WEIGHT, GameConstants::ENVIRO_ITEM_HEAT_TRANSFER_COEF, GameConstants::ENVIRO_PLAYER_HEATBUFFER_DECREASE, GameConstants::ENVIRO_PLAYER_HEATBUFFER_INCREASE, GameConstants::ENVIRO_PLAYER_HEATBUFFER_TICK, EnvTempToCoef(), GetPlayerHeat(), m_BodyParts, m_EnvironmentTemperature, m_FeetParts, m_HeadParts, m_HeatBufferTimer, m_HeatComfort, m_Player, m_UTSAverageTemperature, Math::Min(), PlayerConstants::THRESHOLD_HEAT_COMFORT_MINUS_WARNING и PlayerConstants::THRESHOLD_HEAT_COMFORT_PLUS_WARNING.

Используется в Update().

◆ ProcessItemsWetness()

void ProcessItemsWetness ( array< int > pSlotIds )

inlineprotected

    {
        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("==========");
 
    }

Перекрестные ссылки ApplyWetnessToItem(), GameConstants::ENVIRO_TICK_RATE, LogDryWetProcess() и m_Player.

Используется в ProcessWetnessByRain() и ProcessWetnessByWaterLevel().

◆ ProcessTemperatureSources()

void ProcessTemperatureSources ( )

inlineprotected

adds average of 2 most significat sources to buffer

    {
        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;
    }

Перекрестные ссылки CalcTemperatureFromTemperatureSource(), m_HasTemperatureSources, m_UTemperatureSources, m_UTSAverageTemperature и m_UTSAverageTemperatureBuffer.

Используется в Update().

◆ ProcessWetnessByRain()

void ProcessWetnessByRain ( )

inlineprotected

    {
        ProcessItemsWetness(m_SlotIdsComplete);
    }

Перекрестные ссылки m_SlotIdsComplete и ProcessItemsWetness().

Используется в Update().

◆ ProcessWetnessByWaterLevel()

void ProcessWetnessByWaterLevel ( float pWaterLevel )

inlineprotected

complete

upper part

bottom part

feet

    {
        // 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);
        }
    }

Перекрестные ссылки m_SlotIdsBottom, m_SlotIdsComplete, m_SlotIdsLower, m_SlotIdsUpper, ProcessItemsWetness(), WATER_LEVEL_HIGH, WATER_LEVEL_LOW, WATER_LEVEL_MID и WATER_LEVEL_NONE.

Используется в Update().

◆ SetEnvironmentTemperature()

void SetEnvironmentTemperature ( )

inlineprotected

    {
        m_IsTempSet = true;
        m_EnvironmentTemperature = GetEnvironmentTemperature();
    }

Перекрестные ссылки GetEnvironmentTemperature(), m_EnvironmentTemperature и m_IsTempSet.

Используется в CollectAndSetEnvironmentData().

◆ Update()

void Update ( float pDelta )

inlineprotected

check if player is under roof (only if the Building check is false)

Updates data

Process temperature

Process item wetness/dryness

setting of wetness/dryiness of player

reset item wetness counter;

    {
        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; 
                }
            }
        }
    }

Перекрестные ссылки CheckUnderRoof(), CheckWaterContact(), CollectAndSetEnvironmentData(), CollectAndSetPlayerData(), GameConstants::ENVIRO_TICK_RATE, GameConstants::ENVIRO_TICK_ROOF_RC_CHECK, GameConstants::ENVIRO_TICKS_TO_WETNESS_CALCULATION, GatherTemperatureSources(), IsInsideBuilding(), IsInsideVehicle(), IsRaining(), IsUnderRoof(), IsWaterContact(), m_ItemsWetnessMax, m_Player, m_RoofCheckTimer, m_Time, m_WaterLevel, m_WetDryTick, ProcessItemsDryness(), ProcessItemsHeat(), ProcessTemperatureSources(), ProcessWetnessByRain(), ProcessWetnessByWaterLevel() и GameConstants::STATE_WET.

Поля

◆ m_BodyParts

ref array<int> m_BodyParts

protected

Используется в Init() и ProcessItemsHeat().

◆ m_Clouds

float m_Clouds = 0

protected

Используется в CollectAndSetEnvironmentData(), GetDebugMessage(), GetEnvironmentTemperature() и GetWetDelta().

◆ m_DayOrNight

float m_DayOrNight = 0

protected

Используется в CollectAndSetEnvironmentData(), GetDayOrNight() и GetDebugMessage().

◆ m_EnvironmentTemperature

float m_EnvironmentTemperature = 0

protected

Используется в GetDebugMessage(), GetTemperature(), ProcessItemsHeat() и SetEnvironmentTemperature().

◆ m_FeetParts

ref array<int> m_FeetParts

protected

Используется в Init() и ProcessItemsHeat().

◆ m_Fog

float m_Fog = 0

protected

Используется в CollectAndSetEnvironmentData(), GetDebugMessage(), GetEnvironmentTemperature() и GetWetDelta().

◆ m_HasTemperatureSources

bool m_HasTemperatureSources

protected

Используется в ProcessItemsDryness() и ProcessTemperatureSources().

◆ m_HeadParts

ref array<int> m_HeadParts

protected

Используется в Init() и ProcessItemsHeat().

◆ m_HeatBufferTimer

float m_HeatBufferTimer

protected

DEPRECATED.

Используется в Init() и ProcessItemsHeat().

◆ m_HeatComfort

float m_HeatComfort

protected

Используется в GetDebugMessage(), Init() и ProcessItemsHeat().

◆ m_HeatSourceTemp

float m_HeatSourceTemp

protected

◆ m_IsInWater

bool m_IsInWater

protected

Используется в CheckWaterContact(), Init() и IsWaterContact().

◆ m_IsTempSet

bool m_IsTempSet

protected

Используется в IsTemperatureSet() и SetEnvironmentTemperature().

◆ m_IsUnderRoof

bool m_IsUnderRoof

protected

Используется в CheckUnderRoof(), GetDebugMessage(), Init() и IsUnderRoof().

◆ m_IsUnderRoofBuilding

bool m_IsUnderRoofBuilding

private

Используется в CheckUnderRoof(), GetEnvironmentTemperature() и IsUnderRoofBuilding().

◆ m_ItemsWetnessMax

float m_ItemsWetnessMax

protected

Используется в ApplyDrynessToItemEx(), ApplyWetnessToItem() и Update().

◆ m_Player

PlayerBase m_Player

protected

Используется в ApplyDrynessToItemEx(), ApplyWetnessToItem(), BodyPartHeatProperties(), CalcTemperatureFromTemperatureSource(), CheckUnderRoof(), CheckWaterContact(), CollectAndSetPlayerData(), GatherTemperatureSources(), GetDebugMessage(), Init(), IsInsideBuilding(), IsInsideVehicle(), ProcessItemsDryness(), ProcessItemsHeat(), ProcessItemsWetness() и Update().

◆ m_PlayerHeat

float m_PlayerHeat

protected

Используется в CollectAndSetPlayerData() и GetWetDelta().

◆ m_PlayerHeightPos

float m_PlayerHeightPos

protected

Используется в CollectAndSetPlayerData() и GetTemperatureHeightCorrection().

◆ m_PlayerSpeed

float m_PlayerSpeed

protected

Используется в CollectAndSetPlayerData(), GetPlayerHeat() и Init().

◆ m_PlayerTemperature

float m_PlayerTemperature

protected

◆ m_Rain

float m_Rain = 0

protected

Используется в CollectAndSetEnvironmentData(), GetDebugMessage(), GetWetDelta() и IsRaining().

◆ m_RoofCheckTimer

float m_RoofCheckTimer

protected

keeps wetness of most wet item in player's possesion

Используется в GetNextRoofCheck(), Init() и Update().

◆ m_SlotIdsBottom

ref array<int> m_SlotIdsBottom

protected

Используется в Init() и ProcessWetnessByWaterLevel().

◆ m_SlotIdsComplete

ref array<int> m_SlotIdsComplete

protected

Используется в Init(), ProcessWetnessByRain() и ProcessWetnessByWaterLevel().

◆ m_SlotIdsLower

ref array<int> m_SlotIdsLower

protected

Используется в Init() и ProcessWetnessByWaterLevel().

◆ m_SlotIdsUpper

ref array<int> m_SlotIdsUpper

protected

Используется в Init() и ProcessWetnessByWaterLevel().

◆ m_SurfaceType

string m_SurfaceType

protected

Используется в CheckWaterContact(), GetWindModifierPerSurface() и Init().

◆ m_Time

float m_Time = 0

protected

Используется в Update().

◆ m_UTemperatureSources

ref array<UTemperatureSource> m_UTemperatureSources

protected

Используется в GatherTemperatureSources(), Init(), ProcessItemsDryness() и ProcessTemperatureSources().

◆ m_UTSAverageTemperature

float m_UTSAverageTemperature

protected

Используется в GetEnvironmentTemperature(), GetUniversalSourcesTemperageAverage(), Init(), ProcessItemsHeat() и ProcessTemperatureSources().

◆ m_UTSAverageTemperatureBuffer

ref SimpleMovingAverage<float> m_UTSAverageTemperatureBuffer

protected

Используется в Init() и ProcessTemperatureSources().

◆ m_WaterLevel

float m_WaterLevel

protected

Используется в GetDebugMessage(), GetWaterLevel(), GetWetDelta(), Init() и Update().

◆ m_WetDryTick

float m_WetDryTick

protected

Используется в Init() и Update().

◆ m_Wind

float m_Wind = 0

protected

Используется в CollectAndSetEnvironmentData(), GetDebugMessage(), GetEnvironmentTemperature() и GetWetDelta().

◆ m_WindAverageBuffer

ref SimpleMovingAverage<float> m_WindAverageBuffer

protected

Используется в CollectAndSetEnvironmentData() и Init().

◆ RAIN_LIMIT_LOW

const float RAIN_LIMIT_LOW = 0.05

private

Используется в IsRaining().

◆ WATER_LEVEL_HIGH

const float WATER_LEVEL_HIGH = 1.5

private

Используется в CheckWaterContact(), GetWetDelta() и ProcessWetnessByWaterLevel().

◆ WATER_LEVEL_LOW

const float WATER_LEVEL_LOW = 0.5

private

Используется в GetWetDelta() и ProcessWetnessByWaterLevel().

◆ WATER_LEVEL_MID

const float WATER_LEVEL_MID = 1.2

private

Используется в CheckWaterContact(), GetWetDelta() и ProcessWetnessByWaterLevel().

◆ WATER_LEVEL_NONE

const float WATER_LEVEL_NONE = 0.15

private

Используется в GetDebugMessage(), GetWaterLevel(), GetWetDelta() и ProcessWetnessByWaterLevel().

Объявления и описания членов класса находятся в файле:

D:/Ishodniki/scripts/4_World/Classes/Environment/Environment.c

Защищенные члены

Защищенные данные

Закрытые члены

Закрытые данные

Подробное описание

Конструктор(ы)

◆ Environment()

Методы

◆ AddToEnvironmentTemperature()

◆ ApplyDrynessToItem()

◆ ApplyDrynessToItemEx()

◆ ApplyWetnessToItem()

◆ BodyPartHeatProperties()

◆ CalcTemperatureFromTemperatureSource()

◆ CheckUnderRoof()

◆ CheckWaterContact()

◆ CollectAndSetEnvironmentData()

◆ CollectAndSetPlayerData()

◆ EnvTempToCoef()

◆ GatherTemperatureSources()

◆ GetDayOrNight()

◆ GetDebugMessage()

◆ GetEnvironmentTemperature()

◆ GetNextRoofCheck()

◆ GetPlayerHeat()

◆ GetTemperature()

◆ GetTemperatureHeightCorrection()

◆ GetUniversalSourcesTemperageAverage()

◆ GetWaterLevel()

◆ GetWetDelta()

◆ GetWindModifierPerSurface()

◆ Init()

◆ IsInsideBuilding()

◆ IsInsideVehicle()

◆ IsRaining()

◆ IsTemperatureSet()

◆ IsUnderRoof()

◆ IsUnderRoofBuilding()

◆ IsWaterContact()

◆ LogDryWetProcess()

◆ OverridenHeatComfort()

◆ ProcessItemsDryness()

◆ ProcessItemsHeat()

◆ ProcessItemsWetness()

◆ ProcessTemperatureSources()

◆ ProcessWetnessByRain()

◆ ProcessWetnessByWaterLevel()

◆ SetEnvironmentTemperature()

◆ Update()

Поля

◆ m_BodyParts

◆ m_Clouds

◆ m_DayOrNight

◆ m_EnvironmentTemperature

◆ m_FeetParts

◆ m_Fog

◆ m_HasTemperatureSources

◆ m_HeadParts

◆ m_HeatBufferTimer

◆ m_HeatComfort

◆ m_HeatSourceTemp

◆ m_IsInWater

◆ m_IsTempSet

◆ m_IsUnderRoof

◆ m_IsUnderRoofBuilding

◆ m_ItemsWetnessMax

◆ m_Player

◆ m_PlayerHeat

◆ m_PlayerHeightPos

◆ m_PlayerSpeed

◆ m_PlayerTemperature

◆ m_Rain

◆ m_RoofCheckTimer

◆ m_SlotIdsBottom

◆ m_SlotIdsComplete

◆ m_SlotIdsLower

◆ m_SlotIdsUpper

◆ m_SurfaceType

◆ m_Time

◆ m_UTemperatureSources