Защищенные члены
float	GetPlayerHeat ()
	Returns heat player generated based on player's movement speed (for now)

bool	IsUnderRoof ()

bool	IsWaterContact ()

bool	IsInsideBuilding ()

bool	IsInsideVehicle ()

bool	IsRaining ()

bool	IsSnowing ()

bool	DetermineHeatcomfortBehavior ()

void	CheckUnderRoof ()
	Checks whether Player is sheltered.

void	CheckWaterContact (out float pWaterLevel)

float	GetWindModifierPerSurface ()

float	GetTemperature ()

float	GetTargetHeatComfort ()

float	GetEnvironmentTemperature ()

float	GetWetDelta ()

void	CollectAndSetPlayerData ()

void	CollectAndSetEnvironmentData ()

void	SetEnvironmentTemperature ()

void	SetAreaGenericColdness ()
	Determines whether player is in cold area which restricts use of some actions (digging)

float	WindEffectTemperatureValue (float temperatureInput)

void	ProcessWetnessByWaterLevel (float pWaterLevel)
	process attachments by water depth

void	ProcessItemsWetness (array< int > pSlotIds)

void	ProcessItemsDryness ()

void	ApplyWetnessToItem (ItemBase pItem)

void	ApplyDrynessToItem (ItemBase pItem)

void	ApplyDrynessToItemEx (ItemBase pItem, EnvironmentDrynessData pDrynessData)

void	ProcessHeatComfort ()
	Calculates and process player's heatcomfort related to body parts.

void	SetTargetHeatComfort (float value)

void	SetHeatcomfortDirectly ()

void	ProcessHeatBuffer (float heatComfortCloths)

float	GetApplicableHeatbuffer ()

void	ProcessItemsTemperature (array< int > pBodyPartIds)
	go through all items in player's possession cool/warm them to neutral temperature

void	ProcessItemsInHandsTemperature ()

void	ProcessItemHierarchyRecursive (ItemBase item, float heatPermeabilityCoef=1.0)

void	SetProcessedItemTemperature (ItemBase item, float heatPermeabilityCoef=1.0)

float	EnvTempToCoef (float pTemp)

void	BodyPartHeatProperties (int pBodyPartId, float pCoef, out float pHeatComfort, out float pHeat)
	returns enhanced heat comfort for given body part

float	NakedBodyPartHeatComfortPenalty (int pBodyPartSlotId, float pCoef)

void	GatherTemperatureSources ()

void	SetItemHeatingCoef (float val)

void	ProcessTemperatureSources ()

void	OnTemperatureSourcesEnter ()

void	OnTemperatureSourcesLeft ()

void	SetEnvironmentSnapshotData ()

float	GetUniversalSourcesTemperageAverage ()

float	CalcTemperatureFromTemperatureSource (notnull UTemperatureSource uts)

string	GetDebugMessage ()
	debug

int	GetNextRoofCheck ()

float	GetWaterLevel ()

void	Init (PlayerBase pPlayer)

bool	OverridenHeatComfort (out float value)

void	AddToEnvironmentTemperature (float pTemperature)

void	ProcessItemsHeat ()

void	ProcessWetnessByRain ()

float	GetTemperatureHeightCorrection ()

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

float	GetDayOrNight ()

Защищенные данные
const float	SNOWFALL_LIMIT_LOW = 0.5

const float	SNOWFALL_WIND_COMBINED_THRESHOLD = 1.3

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

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_TargetHeatComfort
	player's heatcomfort (buffered, stored in player stats)

float	m_Rain = 0
	target value of heatcomfort (non-buffered)

float	m_Snowfall = 0

float	m_Wind = 0

float	m_Fog = 0

float	m_DayOrNight = 0

float	m_Clouds = 0

float	m_EnvironmentTemperature

float	m_Time = 0

string	m_SurfaceType

int	m_LiquidType

float	m_ItemTemperatureCoef

float	m_WaterLevel

bool	m_IsUnderRoof

bool	m_IsInWater

bool	m_IsTempSet

float	m_HeatBufferTimer

ref array< int >	m_SlotIdsComplete
	reused as state toggle

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 WorldData	m_WorldData

bool	m_HasTemperatureSources

float	m_UTSAverageTemperature

ref array< UTemperatureSource >	m_UTemperatureSources

ref SimpleMovingAverage< float >	m_UTSAverageTemperatureBuffer

ref SimpleMovingAverage< float >	m_AverageHeatComfortBuffer

int	m_HeatComfortBehaviorCategory

ref EnvironmentSnapshotData	m_EnvironmentSnapshot

float	m_HeatSourceTemp
	DEPRECATED.

ref SimpleMovingAverage< float >	m_WindAverageBuffer

Закрытые данные
const float	RAIN_LIMIT_LOW = 0.05

bool	m_IsUnderRoofBuilding

bool	m_Initialized
	used for calculations before the data modification

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

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

◆ Environment()

void Environment ( PlayerBase pPlayer )

inlineprivate

    {
        m_Player = pPlayer;
    }

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

Методы

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

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

Используется в 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);
 
                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.

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

◆ BodyPartHeatProperties() [1/2]

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)

    {
        pHeatComfort = 0;
        pHeat = 0;
        
        if (pBodyPartIds.Count() > 0)
        {
            LogItemHeat(string.Format("BodyPartHeatProperties (%1)", EnumTools.EnumToString(InventorySlots, pBodyPartIds[0])));
    
            int attCount = m_Player.GetInventory().AttachmentCount();
            for (int attIdx = 0; attIdx < attCount; ++attIdx)
            {
                EntityAI attachment = m_Player.GetInventory().GetAttachmentFromIndex(attIdx);
                if (attachment.IsClothing())
                {
                    ItemBase item = ItemBase.Cast(attachment);
                    int attachmentSlot = attachment.GetInventory().GetSlotId(0);
    
                    for (int i = 0; i < pBodyPartIds.Count(); ++i)
                    {
                        if (attachmentSlot == pBodyPartIds[i])
                        {
                            float heatIsoMult = 1.0;
                            if (attachmentSlot == InventorySlots.BACK)
                                heatIsoMult = GameConstants.ENVIRO_HEATISOLATION_BACK_WEIGHT;
                            else if (attachmentSlot == InventorySlots.VEST)
                                heatIsoMult = GameConstants.ENVIRO_HEATISOLATION_VEST_WEIGHT;
    
                            pHeatComfort += heatIsoMult * MiscGameplayFunctions.GetCurrentItemHeatIsolation(item);
                            
                            float itemHeatcomfort = 0;
                            float itemTemperature = 0;
                            
                            // go through any attachments and cargo (only current level, ignore nested containers - they isolate)
                            int inventoryAttCount = item.GetInventory().AttachmentCount();
                            if (inventoryAttCount > 0)
                            {
                                LogItemHeat(string.Format("attachments:"), false);
                                for (int inAttIdx = 0; inAttIdx < inventoryAttCount; ++inAttIdx)
                                {
                                    EntityAI inAttachment = item.GetInventory().GetAttachmentFromIndex(inAttIdx);
                                    ItemBase attachmentItem = ItemBase.Cast(inAttachment);
                                    if (attachmentItem && attachmentItem.CanHaveTemperature())
                                    {
                                        itemTemperature = attachmentItem.GetTemperature();
                                        if (itemTemperature < GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_LOWER_LIMIT || itemTemperature > GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_UPPER_LIMIT)
                                        {
                                            itemHeatcomfort = NormalizedTemperature(itemTemperature) * attachmentItem.GetQuantityNormalizedScripted() * attachmentItem.GetTemperaturePerQuantityWeight();
                                            LogItemHeat(string.Format("%1: temperature=%2 heat=%3", attachmentItem, itemTemperature, pHeat), true);
                                            pHeat += itemHeatcomfort;
                                        }
                                    }
                                }
                            }
                            if (item.GetInventory().GetCargo())
                            {
                                int inventoryItemCount = item.GetInventory().GetCargo().GetItemCount();
                                
                                if (inventoryItemCount > 0)
                                {
                                    LogItemHeat(string.Format("cargo:"), false);
                                    for (int j = 0; j < inventoryItemCount; ++j)
                                    {
                                        ItemBase inventoryItem = ItemBase.Cast(item.GetInventory().GetCargo().GetItem(j));
                                        if (inventoryItem && inventoryItem.CanHaveTemperature())
                                        {
                                            itemTemperature = inventoryItem.GetTemperature();
                                            if (itemTemperature < GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_LOWER_LIMIT || itemTemperature > GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_UPPER_LIMIT)
                                            {
                                                itemHeatcomfort = NormalizedTemperature(itemTemperature) * inventoryItem.GetQuantityNormalizedScripted() * inventoryItem.GetTemperaturePerQuantityWeight();
                                                LogItemHeat(string.Format("%1: temperature=%2 heat=%3", inventoryItem, itemTemperature, itemHeatcomfort), true);
                                                pHeat += itemHeatcomfort;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
 
            pHeatComfort += (pHeatComfort / pBodyPartIds.Count()) * pCoef;
            
            LogItemHeat(string.Format("overall heat from items=%1 (coef applied)", pHeat));
            LogItemHeat("");
        }
    }

Перекрестные ссылки EnumTools::EnumToString(), GameConstants::ENVIRO_HEATISOLATION_BACK_WEIGHT, GameConstants::ENVIRO_HEATISOLATION_VEST_WEIGHT, GameConstants::ITEM_TEMPERATURE_NEUTRAL_ZONE_UPPER_LIMIT, LogItemHeat(), m_Player и NormalizedTemperature().

◆ BodyPartHeatProperties() [2/2]

void BodyPartHeatProperties	(	int	pBodyPartId,
		float	pCoef,
		out float	pHeatComfort,
		out float	pHeat )

inlineprotected

returns enhanced heat comfort for given body part

    {
        pHeatComfort = 0;
        pHeat = 0;
 
        int attCount = m_Player.GetInventory().AttachmentCount();
        for (int attIdx = 0; attIdx < attCount; ++attIdx)
        {
            EntityAI attachment = m_Player.GetInventory().GetAttachmentFromIndex(attIdx);
            if (attachment.IsClothing())
            {
                ItemBase item = ItemBase.Cast(attachment);
                int attachmentSlot = attachment.GetInventory().GetSlotId(0);
 
                if (attachmentSlot == pBodyPartId)
                {
                    LogItemHeat(string.Format("BodyPartHeatProperties (%1)", EnumTools.EnumToString(InventorySlots, pBodyPartId)));
 
                    float itemHeatcomfort = 0;
                    float itemTemperature = 0;
                    
                    // go through any attachments and cargo (only current level, ignore nested containers - they isolate)
                    int inventoryAttCount = item.GetInventory().AttachmentCount();
                    if (inventoryAttCount > 0)
                    {
                        LogItemHeat(string.Format("attachments:"), false);
                        for (int inAttIdx = 0; inAttIdx < inventoryAttCount; ++inAttIdx)
                        {
                            EntityAI inAttachment = item.GetInventory().GetAttachmentFromIndex(inAttIdx);
                            ItemBase attachmentItem = ItemBase.Cast(inAttachment);
                            if (attachmentItem && attachmentItem.CanHaveTemperature())
                            {
                                itemTemperature = attachmentItem.GetTemperature();
                                if (itemTemperature < GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_LOWER_LIMIT || itemTemperature > GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_UPPER_LIMIT)
                                {
                                    itemHeatcomfort = NormalizedTemperature(itemTemperature) * attachmentItem.GetQuantityNormalizedScripted() * attachmentItem.GetTemperaturePerQuantityWeight();
                                    LogItemHeat(string.Format("%1: temperature=%2 heat=%3", attachmentItem, itemTemperature, pHeat), true);
                                    pHeat += itemHeatcomfort;
                                }
                            }
                        }
                    }
                    if (item.GetInventory().GetCargo())
                    {
                        int inventoryItemCount = item.GetInventory().GetCargo().GetItemCount();
                        
                        if (inventoryItemCount > 0)
                        {
                            LogItemHeat(string.Format("cargo:"), false);
                            for (int j = 0; j < inventoryItemCount; ++j)
                            {
                                ItemBase inventoryItem = ItemBase.Cast(item.GetInventory().GetCargo().GetItem(j));
                                if (inventoryItem && inventoryItem.CanHaveTemperature())
                                {
                                    itemTemperature = inventoryItem.GetTemperature();
                                    if (itemTemperature < GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_LOWER_LIMIT || itemTemperature > GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_UPPER_LIMIT)
                                    {
                                        itemHeatcomfort = NormalizedTemperature(itemTemperature) * inventoryItem.GetQuantityNormalizedScripted() * inventoryItem.GetTemperaturePerQuantityWeight();
                                        LogItemHeat(string.Format("%1: temperature=%2 heat=%3", inventoryItem, itemTemperature, itemHeatcomfort), true);
                                        pHeat += itemHeatcomfort;
                                    }
                                }
                            }
                        }
                    }
                    
                    pHeatComfort = MiscGameplayFunctions.GetCurrentItemHeatIsolation(item) * pCoef;
                    
                    LogItemHeat(string.Format("overall heat from items=%1 (coef applied)", pHeat));
                    LogItemHeat("");
 
                    break;
                }
            }
        }
    }

Перекрестные ссылки EnumTools::EnumToString(), GameConstants::ITEM_TEMPERATURE_NEUTRAL_ZONE_UPPER_LIMIT, LogItemHeat(), m_Player и NormalizedTemperature().

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

◆ CalcTemperatureFromTemperatureSource()

float CalcTemperatureFromTemperatureSource ( notnull UTemperatureSource uts )

inlineprotected

heat transfer through air to player (env temperature)

    {
        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;
 
        if (distance > uts.GetFullRange())
        {
            float distFactor = Math.InverseLerp(uts.GetMaxRange(), uts.GetFullRange(), distance);
            temperature = uts.GetTemperatureCap() * distFactor;
        }
        else
        {
            temperature = uts.GetTemperatureCap();
        }
 
        return temperature;
    }

Перекрестные ссылки vector::Distance(), Math::InverseLerp(), 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

    {
        
        string surfType;
        int liquidType;
 
        m_IsInWater = false;
        if (m_Player.IsSwimming())
        {
            g_Game.SurfaceUnderObjectByBoneCorrectedLiquid(m_Player, SurfaceAnimationBone.RightFrontLimb, surfType, liquidType);
            m_SurfaceType = surfType;
            m_LiquidType = liquidType;
            
            m_IsInWater = true;
            m_Player.SetInWater(m_IsInWater);
            
            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 impact;
        g_Game.SurfaceUnderObjectExCorrectedLiquid(m_Player, surfType, impact, liquidType);
        
        switch (liquidType)
        {
            case LIQUID_SALTWATER:
            case LIQUID_WATER:
            case LIQUID_RIVERWATER:
            case LIQUID_FRESHWATER:
            case LIQUID_STILLWATER:
            case LIQUID_HOTWATER:
                pWaterLevel = m_Player.GetCurrentWaterLevel();
                m_IsInWater = true;
            break;
        }
 
        m_Player.SetInWater(m_IsInWater);
 
        m_SurfaceType = surfType;
        m_LiquidType = liquidType;
 
    }

Перекрестные ссылки g_Game, IsUnderRoofBuilding(), LIQUID_FRESHWATER, LIQUID_HOTWATER, LIQUID_RIVERWATER, LIQUID_SALTWATER, LIQUID_STILLWATER, LIQUID_WATER, m_IsInWater, m_LiquidType, 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_Snowfall      = weather.GetSnowfall().GetActual();
        m_DayOrNight    = g_Game.GetMission().GetWorldData().GetDaytime();
        m_Fog           = weather.GetFog().GetActual();
        m_Clouds        = weather.GetOvercast().GetActual();
        m_Wind          = g_Game.GetWeather().GetWindMagnitude().GetActual();
 
        SetEnvironmentTemperature();
        SetAreaGenericColdness();
    }

Перекрестные ссылки g_Game, m_Clouds, m_DayOrNight, m_Fog, m_Rain, m_Snowfall, m_Wind, SetAreaGenericColdness() и 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().

◆ DetermineHeatcomfortBehavior()

bool DetermineHeatcomfortBehavior ( )

inlineprotected

    {
        if (IsInsideVehicle())
        {
            CarScript car = CarScript.Cast(m_Player.GetParent());
            if (car && car.EngineIsOn())
            {
                m_HeatComfortBehaviorCategory = EEnvironmentHeatcomfortBehaviorCategory.CAR_ENGINE_ON;
                return true;
            }
        }
        
        m_HeatComfortBehaviorCategory = EEnvironmentHeatcomfortBehaviorCategory.DEFAULT;
        
        return false;
    }

Перекрестные ссылки IsInsideVehicle(), m_HeatComfortBehaviorCategory и m_Player.

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

◆ EnvTempToCoef()

float EnvTempToCoef ( float pTemp )

inlineprotected

    {
        return (pTemp - GameConstants.ENVIRO_PLAYER_COMFORT_TEMP) / GameConstants.ENVIRO_TEMP_EFFECT_ON_PLAYER;
    }

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

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

◆ GatherTemperatureSources()

void GatherTemperatureSources ( )

inlineprotected

next temp source is too far

skip - this TS is not affecting player entities

    {
        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;
                
                if (ent.GetUniversalTemperatureSource().GetLambda().AffectsPlayer())
                    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().

◆ GetApplicableHeatbuffer()

float GetApplicableHeatbuffer ( )

inlineprotected

    {
        float applicableHeatbuffer = Math.Round((m_Player.GetStatHeatBuffer().Get() / m_Player.GetStatHeatBuffer().GetMax()) * 1000) * 0.001;
        return applicableHeatbuffer;
    }

Перекрестные ссылки m_Player и Math::Round().

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

◆ GetDayOrNight()

float GetDayOrNight ( )

inlineprotected

    {
        return m_DayOrNight;
    }

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

◆ GetDebugMessage()

string GetDebugMessage ( )

inlineprotected

debug

    {
        string message;
        message += "Player stats";
        message += "\nHeat comfort(target): " + GetTargetHeatComfort().ToString();
        message += "\nHeat comfort(dynamic): " + m_HeatComfort.ToString();
        
        int liquidType;
        string impact, surfaceType;
        g_Game.SurfaceUnderObjectExCorrectedLiquid(m_Player, surfaceType, impact, liquidType);
        
        message += "\nInside: " + IsInsideBuilding().ToString();
        message += "\nSurface: " + surfaceType;
        message += "\nLiquid: " + liquidType;
        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): " + m_WorldData.GetBaseEnvTemperature().ToString();
        message += "\nEnv temperature (height corrected): " + m_WorldData.GetBaseEnvTemperatureAtObject(m_Player);
        message += "\nEnv temperature (modified): " + m_EnvironmentTemperature.ToString();
        message += "\nWind: " + m_Wind.ToString() + " (x" + GetWindModifierPerSurface() + ")";
        message += "\nRain: " + m_Rain.ToString();
        message += "\nSnow: " + m_Snowfall.ToString();
        message += "\nDatetime: " + WorldDataDaytime.ToString(m_DayOrNight);
        message += "\nFog: " + m_Fog.ToString();
        message += "\nClouds: " + m_Clouds.ToString();
        message += "\nWet delta: " + GetWetDelta().ToString();
        
        return message;
    }

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

◆ GetEnvironmentTemperature()

float GetEnvironmentTemperature ( )

inlineprotected

    {
        float temperature;
        temperature = m_WorldData.GetBaseEnvTemperatureAtObject(m_Player);
        temperature += m_Clouds * m_WorldData.m_CloudsTemperatureEffectModifier;
        
        if (IsWaterContact())
        {
            float waterBodyTemperature = m_WorldData.GetLiquidTypeEnviroTemperature(m_LiquidType);
            temperature = waterBodyTemperature - m_WorldData.m_WaterContactTemperatureModifier;
            
            return temperature;
        }
        
        if (IsInsideBuilding() || m_IsUnderRoofBuilding)
        {
            temperature += m_WorldData.m_TemperatureInsideBuildingsModifier;
        }
        else if (IsInsideVehicle())
        {
            temperature += Math.AbsFloat(temperature * GameConstants.ENVIRO_TEMPERATURE_INSIDE_VEHICLE_COEF);
            return temperature;
        }
        else if (IsUnderRoof() && !m_IsUnderRoofBuilding)
        {
            temperature += m_Fog * GameConstants.ENVIRO_FOG_TEMP_EFFECT;
            temperature += WindEffectTemperatureValue(temperature) * GetWindModifierPerSurface() * GameConstants.ENVIRO_TEMPERATURE_UNDERROOF_COEF;
        }
        else
        {
            temperature += m_Fog * GameConstants.ENVIRO_FOG_TEMP_EFFECT;
            temperature += WindEffectTemperatureValue(temperature) * GetWindModifierPerSurface();
        }
 
        // incorporate temperature from temperature sources (buffer)
        if (Math.AbsFloat(m_UTSAverageTemperature) > 0.0)
            temperature = m_UTSAverageTemperature;
        
        return temperature;
    }

Перекрестные ссылки Math::AbsFloat(), GameConstants::ENVIRO_FOG_TEMP_EFFECT, GameConstants::ENVIRO_TEMPERATURE_INSIDE_VEHICLE_COEF, GameConstants::ENVIRO_TEMPERATURE_UNDERROOF_COEF, GetWindModifierPerSurface(), IsInsideBuilding(), IsInsideVehicle(), IsUnderRoof(), IsWaterContact(), m_Clouds, m_Fog, m_IsUnderRoofBuilding, m_LiquidType, m_Player, m_UTSAverageTemperature, m_WorldData и WindEffectTemperatureValue().

Используется в 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 = m_PlayerSpeed * GameConstants.ENVIRO_DEFAULT_ENTITY_HEAT;
        return heat;
    }

Перекрестные ссылки GameConstants::ENVIRO_DEFAULT_ENTITY_HEAT и m_PlayerSpeed.

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

◆ GetTargetHeatComfort()

float GetTargetHeatComfort ( )

inlineprotected

    {
        return m_TargetHeatComfort;
    }

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

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

◆ GetTemperature()

float GetTemperature ( )

inlineprotected

    {
        return m_EnvironmentTemperature;
    }

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

◆ GetTemperatureHeightCorrection()

float GetTemperatureHeightCorrection ( )

inlineprotected

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

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

◆ GetUniversalSourcesTemperageAverage()

float GetUniversalSourcesTemperageAverage ( )

inlineprotected

    {
        return m_UTSAverageTemperature;
    }

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

◆ GetWaterLevel()

float GetWaterLevel ( )

inlineprotected

    {
        if (IsWaterContact() && m_WaterLevel > WATER_LEVEL_NONE)
        {
            return m_WaterLevel;
        }
 
        return 0.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 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 (!IsInsideBuilding() && !IsUnderRoof() && !IsInsideVehicle())
        {
            if (IsRaining())
                wetDelta = GameConstants.ENVIRO_WET_INCREMENT * GameConstants.ENVIRO_TICKS_TO_WETNESS_CALCULATION * (m_Rain) * (1 + (GameConstants.ENVIRO_WIND_EFFECT * m_Wind));
 
            if (IsSnowing() && MiscGameplayFunctions.GetCombinedSnowfallWindValue() > SNOWFALL_WIND_COMBINED_THRESHOLD)
                wetDelta = GameConstants.ENVIRO_WET_INCREMENT * GameConstants.ENVIRO_TICKS_TO_WETNESS_CALCULATION * (m_Snowfall - SNOWFALL_LIMIT_LOW) * GameConstants.ENVIRO_SNOW_WET_COEF * (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_SNOW_WET_COEF, GameConstants::ENVIRO_TICKS_TO_WETNESS_CALCULATION, GameConstants::ENVIRO_WET_INCREMENT, GameConstants::ENVIRO_WIND_EFFECT, GetEnvironmentTemperature(), IsInsideBuilding(), IsInsideVehicle(), IsRaining(), IsSnowing(), IsUnderRoof(), IsWaterContact(), m_Clouds, m_Fog, m_PlayerHeat, m_Rain, m_Snowfall, m_WaterLevel, m_Wind, Math::Max(), SNOWFALL_LIMIT_LOW, SNOWFALL_WIND_COMBINED_THRESHOLD, 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() [1/2]

void Init ( )

inlineprivate

whole body slots

upper body part slots

bottom body part slots

lower body part slots

heat comfort related slots

    {
        m_PlayerSpeed                   = 0.0;
        m_WetDryTick                    = 0.0;
        m_RoofCheckTimer                = 0.0;
        m_WaterLevel                    = 0.0;
        m_HeatComfort                   = m_Player.GetStatHeatComfort().Get();
        m_WorldData                     = g_Game.GetMission().GetWorldData();
        m_EnvironmentTemperature        = m_WorldData.GetBaseEnvTemperatureAtObject(m_Player);
        
        m_IsUnderRoof                   = false;
        m_IsInWater                     = false;
        m_SurfaceType                   = "cp_dirt";
 
        m_HeatBufferTimer               = 0.0;
        
        m_UTSAverageTemperature         = 0.0;
        m_UTemperatureSources           = new array<UTemperatureSource>();
        m_UTSAverageTemperatureBuffer   = new SimpleMovingAverage<float>(10, 0.0);
        m_AverageHeatComfortBuffer      = new SimpleMovingAverage<float>(20, m_HeatComfort);
        
        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.HIPS,
            InventorySlots.BODY,
            InventorySlots.BACK,
            InventorySlots.VEST,
            InventorySlots.MELEE,
            InventorySlots.SHOULDER
        };
        
        m_FeetParts             = new array<int>();
        m_FeetParts             = {
            InventorySlots.LEGS,
            InventorySlots.FEET,
        };
        
        m_HeatComfortBehaviorCategory = EEnvironmentHeatcomfortBehaviorCategory.DEFAULT;
        
        SetEnvironmentSnapshotData();
        
        m_Initialized = true;
    }

Перекрестные ссылки g_Game, m_AverageHeatComfortBuffer, m_BodyParts, m_EnvironmentTemperature, m_FeetParts, m_HeadParts, m_HeatBufferTimer, m_HeatComfort, m_HeatComfortBehaviorCategory, m_Initialized, 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_WorldData и SetEnvironmentSnapshotData().

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

◆ Init() [2/2]

void Init ( PlayerBase pPlayer )

inlineprotected

    {
        Init();
    }

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

◆ IsInsideBuilding()

bool IsInsideBuilding ( )

inlineprotected

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

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

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

◆ IsInsideVehicle()

bool IsInsideVehicle ( )

inlineprotected

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

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

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

◆ IsNeutralTemperature()

bool IsNeutralTemperature	(	float	temperature,
		float	lowerLimit = GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_LOWER_LIMIT,
		float	upperLimit = GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_UPPER_LIMIT )

inlineprivate

    {
        if (temperature >= lowerLimit && temperature <= upperLimit)
            return true;
 
        return false;
    }

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

◆ IsRaining()

bool IsRaining ( )

inlineprotected

    {
        return m_Rain > RAIN_LIMIT_LOW;
    }

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

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

◆ IsSnowing()

bool IsSnowing ( )

inlineprotected

    {
        return m_Snowfall > SNOWFALL_LIMIT_LOW;
    }

Перекрестные ссылки m_Snowfall и SNOWFALL_LIMIT_LOW.

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

◆ IsTemperatureSet()

bool IsTemperatureSet ( )

inlineprivate

    {
        return m_IsTempSet;
    }

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

◆ IsUnderRoof()

bool IsUnderRoof ( )

inlineprotected

    {
        return m_IsUnderRoof;
    }

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

Используется в GetEnvironmentTemperature(), GetWetDelta(), NakedBodyPartHeatComfortPenalty() и 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(), NakedBodyPartHeatComfortPenalty() и 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().

◆ LogItemHeat()

void LogItemHeat	(	string	message,
		bool	indented = false )

inlineprivate

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

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

Используется в BodyPartHeatProperties(), BodyPartHeatProperties() и ProcessHeatComfort().

◆ NakedBodyPartHeatComfortPenalty()

float NakedBodyPartHeatComfortPenalty	(	int	pBodyPartSlotId,
		float	pCoef )

inlineprotected

    {
        float penalty = 0.0;
        
        if (!IsInsideBuilding() && !IsUnderRoof() && !IsInsideVehicle() && !IsWaterContact())
        {
            if (m_Rain > GameConstants.ENVIRO_NAKED_BODY_PENALTY_RAIN_MIN_VALUE || m_Snowfall > GameConstants.ENVIRO_NAKED_BODY_PENALTY_SNOWFALL_MIN_VALUE)
            {
                penalty += GameConstants.ENVIRO_ISOLATION_WETFACTOR_DRENCHED;
                penalty *= pCoef;
            }
        }
        
        return penalty;
    }

Перекрестные ссылки GameConstants::ENVIRO_ISOLATION_WETFACTOR_DRENCHED, GameConstants::ENVIRO_NAKED_BODY_PENALTY_RAIN_MIN_VALUE, GameConstants::ENVIRO_NAKED_BODY_PENALTY_SNOWFALL_MIN_VALUE, IsInsideBuilding(), IsInsideVehicle(), IsUnderRoof(), IsWaterContact(), m_Rain и m_Snowfall.

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

◆ NormalizedTemperature()

float NormalizedTemperature	(	float	temperature,
		float	lowerLimit = GameConstants.ENVIRO_LOW_TEMP_LIMIT,
		float	upperLimit = GameConstants.ENVIRO_HIGH_TEMP_LIMIT )

inlineprivate

    {
        if (temperature >= GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_LOWER_LIMIT && temperature <= GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_UPPER_LIMIT)
            return 0.0;
 
        if (temperature < GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_LOWER_LIMIT)
            return Math.Clamp(Math.InverseLerp(lowerLimit, GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_LOWER_LIMIT, temperature), -1.0, -0.1);
        
        if (temperature > GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_UPPER_LIMIT)
            return Math.Clamp(Math.InverseLerp(GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_UPPER_LIMIT, upperLimit, temperature), 0.1, 1.0);
        
        // neutral zone
        return 0.0;
    }

Перекрестные ссылки Math::Clamp(), Math::InverseLerp(), GameConstants::ITEM_TEMPERATURE_NEUTRAL_ZONE_LOWER_LIMIT и GameConstants::ITEM_TEMPERATURE_NEUTRAL_ZONE_UPPER_LIMIT.

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

◆ OnTemperatureSourcesEnter()

void OnTemperatureSourcesEnter ( )

protected

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

◆ OnTemperatureSourcesLeft()

void OnTemperatureSourcesLeft ( )

protected

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

◆ OverridenHeatComfort()

bool OverridenHeatComfort ( out float value )

protected

◆ ProcessHeatBuffer()

void ProcessHeatBuffer ( float heatComfortCloths )

inlineprotected

dynamic HB cap based on actual heatcomfort (from cloths)

    {
        if (m_HeatComfortBehaviorCategory == EEnvironmentHeatcomfortBehaviorCategory.DEFAULT)
        {
            float applicableHeatbuffer = GetApplicableHeatbuffer();
            float originalTargetHeatcomfortMultiplier = 1.0;
            
            float heatBufferCap = Math.InverseLerp(0.0, GameConstants.ENVIRO_HEATCOMFORT_WEIGHT_SUMMARY, heatComfortCloths);
            float heatBufferMax = GameConstants.ENVIRO_PLAYER_HEATBUFFER_CAPACITY_MIN + heatBufferCap * (1 - GameConstants.ENVIRO_PLAYER_HEATBUFFER_CAPACITY_MIN);
            m_Player.SetHeatBufferDynamicMax(heatBufferMax);
            
            float increaseRate = 0.0;
            float decreaseRate = 0.0;
 
            if (m_EnvironmentSnapshot)
            {
                increaseRate = GameConstants.ENVIRO_PLAYER_HEATBUFFER_INCREASE / (heatBufferMax * (( -GameConstants.ENVIRO_PLAYER_HEATBUFFER_TEMP_AFFECT * m_EnvironmentSnapshot.m_TargetHeatComfort ) + 1 ));
                decreaseRate = GameConstants.ENVIRO_PLAYER_HEATBUFFER_DECREASE / (heatBufferMax * (( GameConstants.ENVIRO_PLAYER_HEATBUFFER_TEMP_AFFECT * m_EnvironmentSnapshot.m_TargetHeatComfort ) + 1 ));
                
                if (m_IsInWater)
                    decreaseRate *= GameConstants.ENVIRO_PLAYER_HEATBUFFER_WATEREFFECT * m_WaterLevel;
            }
 
            if (!m_HasTemperatureSources)
            {
                if (m_Player.GetModifiersManager().IsModifierActive(eModifiers.MDF_HEATBUFFER))
                {
                    if (m_HeatBufferTimer >= 1.0)
                        m_Player.GetStatHeatBuffer().Add(-decreaseRate);
                    else
                        m_HeatBufferTimer = 1.0;
                }
                else
                {
                    m_HeatBufferTimer = 0.0;
                    if (applicableHeatbuffer > 0.0)
                        m_Player.GetStatHeatBuffer().Add(-decreaseRate);
                    else if (applicableHeatbuffer != 0.0 && !m_Player.GetModifiersManager().IsModifierActive(eModifiers.MDF_HEATBUFFER))
                        m_Player.GetStatHeatBuffer().Set(0.0);
                }           
            }
            else
            {
                if (m_HeatComfort > PlayerConstants.THRESHOLD_HEAT_COMFORT_MINUS_WARNING && m_UTSAverageTemperature > 0) // m_UTSAverageTemperature can be negative
                {
                    if (applicableHeatbuffer < heatBufferMax)
                        m_Player.GetStatHeatBuffer().Add(increaseRate);
                }
                else if (applicableHeatbuffer > 0.0)
                    m_Player.GetStatHeatBuffer().Add(-decreaseRate);
                else if (applicableHeatbuffer != 0.0 && !m_Player.GetModifiersManager().IsModifierActive(eModifiers.MDF_HEATBUFFER))
                        m_Player.GetStatHeatBuffer().Set(0.0);
    
                m_HeatBufferTimer = 0.0;
            }
        }
    }

Перекрестные ссылки GameConstants::ENVIRO_HEATCOMFORT_WEIGHT_SUMMARY, GameConstants::ENVIRO_PLAYER_HEATBUFFER_CAPACITY_MIN, GameConstants::ENVIRO_PLAYER_HEATBUFFER_DECREASE, GameConstants::ENVIRO_PLAYER_HEATBUFFER_INCREASE, GameConstants::ENVIRO_PLAYER_HEATBUFFER_TEMP_AFFECT, GameConstants::ENVIRO_PLAYER_HEATBUFFER_WATEREFFECT, GetApplicableHeatbuffer(), Math::InverseLerp(), m_EnvironmentSnapshot, m_HasTemperatureSources, m_HeatBufferTimer, m_HeatComfort, m_HeatComfortBehaviorCategory, m_IsInWater, m_Player, m_UTSAverageTemperature, m_WaterLevel и PlayerConstants::THRESHOLD_HEAT_COMFORT_MINUS_WARNING.

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

◆ ProcessHeatComfort()

void ProcessHeatComfort ( )

inlineprotected

Calculates and process player's heatcomfort related to body parts.

Heat Comfort Penalty

heatcomfort body parts penalties

    {
        float hcPenaltyTotal 
        
        // NEW body parts => splitted
        float hcBodyPartTotal, hcBodyPart;
        float hBodyPartTotal, hBodyPart;
        
        float heatComfortSum = 0.0;
        float heatItems = 0.0;
        
        LogItemHeat("====================");
        BodyPartHeatProperties(InventorySlots.HEADGEAR, GameConstants.ENVIRO_HEATCOMFORT_HEADGEAR_WEIGHT, hcBodyPart, hBodyPart);
        hcBodyPartTotal += hcBodyPart; hBodyPartTotal += hBodyPart;
        BodyPartHeatProperties(InventorySlots.MASK, GameConstants.ENVIRO_HEATCOMFORT_MASK_WEIGHT, hcBodyPart, hBodyPart);
        hcBodyPartTotal += hcBodyPart; hBodyPartTotal += hBodyPart;
        BodyPartHeatProperties(InventorySlots.VEST, GameConstants.ENVIRO_HEATCOMFORT_VEST_WEIGHT, hcBodyPart, hBodyPart);
        hcBodyPartTotal += hcBodyPart; hBodyPartTotal += hBodyPart;
        BodyPartHeatProperties(InventorySlots.BODY, GameConstants.ENVIRO_HEATCOMFORT_BODY_WEIGHT, hcBodyPart, hBodyPart);
        hcBodyPartTotal += hcBodyPart; hBodyPartTotal += hBodyPart;
        BodyPartHeatProperties(InventorySlots.BACK, GameConstants.ENVIRO_HEATCOMFORT_BACK_WEIGHT, hcBodyPart, hBodyPart);
        hcBodyPartTotal += hcBodyPart; hBodyPartTotal += hBodyPart;
        BodyPartHeatProperties(InventorySlots.GLOVES, GameConstants.ENVIRO_HEATCOMFORT_GLOVES_WEIGHT, hcBodyPart, hBodyPart);
        hcBodyPartTotal += hcBodyPart; hBodyPartTotal += hBodyPart;
        BodyPartHeatProperties(InventorySlots.LEGS, GameConstants.ENVIRO_HEATCOMFORT_LEGS_WEIGHT, hcBodyPart, hBodyPart);
        hcBodyPartTotal += hcBodyPart; hBodyPartTotal += hBodyPart;
        BodyPartHeatProperties(InventorySlots.FEET, GameConstants.ENVIRO_HEATCOMFORT_FEET_WEIGHT, hcBodyPart, hBodyPart);
        hcBodyPartTotal += hcBodyPart; hBodyPartTotal += hBodyPart;
        BodyPartHeatProperties(InventorySlots.HIPS, GameConstants.ENVIRO_HEATCOMFORT_HIPS_WEIGHT, hcBodyPart, hBodyPart);
        hcBodyPartTotal += hcBodyPart; hBodyPartTotal += hBodyPart;
        
        hcPenaltyTotal += NakedBodyPartHeatComfortPenalty(InventorySlots.HEADGEAR, GameConstants.ENVIRO_HEATCOMFORT_HEADGEAR_WEIGHT);
        hcPenaltyTotal += NakedBodyPartHeatComfortPenalty(InventorySlots.MASK, GameConstants.ENVIRO_HEATCOMFORT_MASK_WEIGHT);
        hcPenaltyTotal += NakedBodyPartHeatComfortPenalty(InventorySlots.BODY, GameConstants.ENVIRO_HEATCOMFORT_BODY_WEIGHT);
        hcPenaltyTotal += NakedBodyPartHeatComfortPenalty(InventorySlots.GLOVES, GameConstants.ENVIRO_HEATCOMFORT_GLOVES_WEIGHT);
        hcPenaltyTotal += NakedBodyPartHeatComfortPenalty(InventorySlots.LEGS, GameConstants.ENVIRO_HEATCOMFORT_LEGS_WEIGHT);
        hcPenaltyTotal += NakedBodyPartHeatComfortPenalty(InventorySlots.FEET, GameConstants.ENVIRO_HEATCOMFORT_FEET_WEIGHT);
 
        heatItems = hBodyPartTotal;
        heatComfortSum = hcBodyPartTotal;
        heatComfortSum += hcPenaltyTotal; 
        
        {
            float stomachContentTemperature = m_Player.GetStomach().GetStomachTemperature();
            if (!IsNeutralTemperature(stomachContentTemperature))
            {
                stomachContentTemperature = m_Player.GetStomach().GetStomachTemperature() * GameConstants.ENVIRO_STOMACH_WEIGHT;
                stomachContentTemperature = Math.Clamp(stomachContentTemperature, -GameConstants.ENVIRO_STOMACH_WEIGHT, GameConstants.ENVIRO_STOMACH_WEIGHT);
                
                heatComfortSum += stomachContentTemperature;
            }
        }
 
        float targetHeatComfort = (heatComfortSum + heatItems + (GetPlayerHeat() / 100)) + EnvTempToCoef(m_EnvironmentTemperature);
 
        SetEnvironmentSnapshotData();
        ProcessHeatBuffer(hcBodyPartTotal);
 
        if (m_Player.GetModifiersManager().IsModifierActive(eModifiers.MDF_HEATBUFFER))
            targetHeatComfort = Math.Clamp(targetHeatComfort, 0.0, m_Player.GetStatHeatComfort().GetMax());
        else
            targetHeatComfort = Math.Clamp(targetHeatComfort, m_Player.GetStatHeatComfort().GetMin(), m_Player.GetStatHeatComfort().GetMax());
 
        targetHeatComfort = Math.Round(targetHeatComfort * 100) * 0.01;
        
        float dynamicHeatComfort;
        
        {
            float direction = 1.0;
            if (targetHeatComfort < 0.0)
                direction = -1.0;
            
            if (Math.AbsFloat(targetHeatComfort - m_HeatComfort) <= GameConstants.ENVIRO_HEATCOMFORT_MAX_STEP_SIZE)
                dynamicHeatComfort = m_AverageHeatComfortBuffer.Add(targetHeatComfort);
            else
                dynamicHeatComfort = m_AverageHeatComfortBuffer.Add((Math.AbsFloat(targetHeatComfort) - GameConstants.ENVIRO_HEATCOMFORT_MAX_STEP_SIZE) * direction);
        }
        
        dynamicHeatComfort = Math.Round(dynamicHeatComfort * 100) * 0.01;
 
        m_HeatComfort = dynamicHeatComfort;
 
        SetTargetHeatComfort(targetHeatComfort);
        m_Player.GetStatHeatComfort().Set(m_HeatComfort);
    }

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

◆ ProcessItemHierarchyRecursive()

void ProcessItemHierarchyRecursive	(	ItemBase	item,
		float	heatPermeabilityCoef = 1.0 )

inlineprotected

    {
        float heatPermCoef = heatPermeabilityCoef;
        
        // go through any attachments and cargo, recursive
        int inventoryAttCount = item.GetInventory().AttachmentCount();
        if (inventoryAttCount > 0)
        {
            ItemBase attachmentItem;
            for (int inAttIdx = 0; inAttIdx < inventoryAttCount; ++inAttIdx)
            {
                if (Class.CastTo(attachmentItem,item.GetInventory().GetAttachmentFromIndex(inAttIdx)))
                {
                    heatPermCoef = heatPermeabilityCoef;
                    heatPermCoef *= attachmentItem.GetHeatPermeabilityCoef();
                    
                    if (attachmentItem.CanHaveTemperature() && !attachmentItem.IsSelfAdjustingTemperature())
                    {
                        SetProcessedItemTemperature(attachmentItem,heatPermCoef);
                    }
                    
                    ProcessItemHierarchyRecursive(attachmentItem,heatPermCoef);
                }
            }
        }
        
        if (item.GetInventory().GetCargo())
        {
            int inventoryItemCount = item.GetInventory().GetCargo().GetItemCount();
            if (inventoryItemCount > 0)
            {
                ItemBase inventoryItem;
                for (int j = 0; j < inventoryItemCount; ++j)
                {
                    if (Class.CastTo(inventoryItem,item.GetInventory().GetCargo().GetItem(j)))
                    {
                        heatPermCoef = heatPermeabilityCoef;
                        heatPermCoef *= inventoryItem.GetHeatPermeabilityCoef();
                        
                        if (inventoryItem.CanHaveTemperature() && !inventoryItem.IsSelfAdjustingTemperature())
                        {
                            SetProcessedItemTemperature(inventoryItem,heatPermCoef);
                        }
                        
                        ProcessItemHierarchyRecursive(inventoryItem,heatPermCoef);
                    }
                }
            }
        }
    }

Перекрестные ссылки Class::CastTo(), ProcessItemHierarchyRecursive() и SetProcessedItemTemperature().

Используется в ProcessItemHierarchyRecursive(), ProcessItemsInHandsTemperature() и ProcessItemsTemperature().

◆ 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

    {
        // for backward combatibility only
        ProcessHeatComfort();
    }

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

◆ ProcessItemsInHandsTemperature()

void ProcessItemsInHandsTemperature ( )

inlineprotected

    {
        ItemBase item = m_Player.GetItemInHands();
        if (item)
        {
            float heatPermCoef = item.GetHeatPermeabilityCoef();
            //first handle the item itself, if necessary
            if (item.CanHaveTemperature() && !item.IsSelfAdjustingTemperature())
                SetProcessedItemTemperature(item,heatPermCoef);
            
            ProcessItemHierarchyRecursive(item,heatPermCoef);
        }
    }

Перекрестные ссылки m_Player, ProcessItemHierarchyRecursive() и SetProcessedItemTemperature().

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

◆ ProcessItemsTemperature()

void ProcessItemsTemperature ( array< int > pBodyPartIds )

inlineprotected

go through all items in player's possession cool/warm them to neutral temperature

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

    {
        EntityAI attachment;
        ItemBase item;
        
        int attCount = m_Player.GetInventory().AttachmentCount();
        for (int attIdx = 0; attIdx < attCount; ++attIdx)
        {
            attachment = m_Player.GetInventory().GetAttachmentFromIndex(attIdx);
            item = ItemBase.Cast(attachment);
            int attachmentSlot = attachment.GetInventory().GetSlotId(0);
            
            for (int i = 0; i < pBodyPartIds.Count(); ++i)
            {
                if (attachmentSlot == pBodyPartIds[i])
                {
                    float heatPermCoef = item.GetHeatPermeabilityCoef();
                    //first handle the item itself, if necessary
                    if (item.CanHaveTemperature() && !item.IsSelfAdjustingTemperature())
                        SetProcessedItemTemperature(item,heatPermCoef);
                    
                    ProcessItemHierarchyRecursive(item,heatPermCoef);
                }
            }
        }
    }

Перекрестные ссылки m_Player, ProcessItemHierarchyRecursive() и SetProcessedItemTemperature().

Используется в 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() и Update().

◆ ProcessTemperatureSources()

void ProcessTemperatureSources ( )

inlineprotected

adds average of 2 most significat sources to buffer

    {
        int UTScount = m_UTemperatureSources.Count();
        if (UTScount == 0)
        {
            m_HasTemperatureSources = false;
            OnTemperatureSourcesLeft();
            m_UTSAverageTemperatureBuffer.Add(0.0);
            m_UTSAverageTemperature = 0.0;
            SetItemHeatingCoef(GameConstants.TEMP_COEF_INVENTORY);
 
            return;
        }
 
        array<float> utsTemperatures = new array<float>();
        
        // get temperature from the source (based on distance), save it for min/max filtering
        float itemCoefAverage = 0.0;
        foreach (UTemperatureSource tempSource : m_UTemperatureSources)
        {
            utsTemperatures.Insert(CalcTemperatureFromTemperatureSource(tempSource));
            itemCoefAverage += tempSource.GetTemperatureItemCoef();
        }
        itemCoefAverage /= UTScount;
        SetItemHeatingCoef(itemCoefAverage);
        
        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);
        }
 
        if (m_HasTemperatureSources == false)
            OnTemperatureSourcesEnter();
 
        m_HasTemperatureSources = true;
    }

Перекрестные ссылки CalcTemperatureFromTemperatureSource(), m_HasTemperatureSources, m_UTemperatureSources, m_UTSAverageTemperature, m_UTSAverageTemperatureBuffer, OnTemperatureSourcesEnter(), OnTemperatureSourcesLeft(), SetItemHeatingCoef() и GameConstants::TEMP_COEF_INVENTORY.

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

◆ ProcessWetnessByRain()

void ProcessWetnessByRain ( )

inlineprotected

    {
        ProcessItemsWetness(m_SlotIdsComplete);
    }

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

◆ ProcessWetnessByWaterLevel()

void ProcessWetnessByWaterLevel ( float pWaterLevel )

inlineprotected

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().

◆ SetAreaGenericColdness()

void SetAreaGenericColdness ( )

inlineprotected

Determines whether player is in cold area which restricts use of some actions (digging)

    {           
        float heigthCorrectedTemp = m_WorldData.GetBaseEnvTemperatureAtObject(m_Player);
        m_Player.SetInColdArea(heigthCorrectedTemp <= GameConstants.COLD_AREA_TEMPERATURE_THRESHOLD);
    }

Перекрестные ссылки GameConstants::COLD_AREA_TEMPERATURE_THRESHOLD, m_Player и m_WorldData.

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

◆ SetEnvironmentSnapshotData()

void SetEnvironmentSnapshotData ( )

inlineprotected

    {
        EnvironmentSnapshotData data = new EnvironmentSnapshotData();
        data.m_TargetHeatComfort = m_TargetHeatComfort;
        
        m_EnvironmentSnapshot = data;
    }

Перекрестные ссылки m_EnvironmentSnapshot и m_TargetHeatComfort.

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

◆ SetEnvironmentTemperature()

void SetEnvironmentTemperature ( )

inlineprotected

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

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

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

◆ SetHeatcomfortDirectly()

void SetHeatcomfortDirectly ( )

inlineprotected

    {
        if (m_HeatComfortBehaviorCategory == EEnvironmentHeatcomfortBehaviorCategory.CAR_ENGINE_ON)
        {
            float targetHeatComfort = 0.0;
            float dynamicHeatComfort = m_AverageHeatComfortBuffer.Add(targetHeatComfort);
            
            m_HeatComfort = dynamicHeatComfort;
 
            SetTargetHeatComfort(0.0);
            m_Player.GetStatHeatComfort().Set(dynamicHeatComfort);
        }
    }

Перекрестные ссылки m_AverageHeatComfortBuffer, m_HeatComfort, m_HeatComfortBehaviorCategory, m_Player и SetTargetHeatComfort().

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

◆ SetItemHeatingCoef()

void SetItemHeatingCoef ( float val )

inlineprotected

    {
        m_ItemTemperatureCoef = val;
    }

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

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

◆ SetProcessedItemTemperature()

void SetProcessedItemTemperature	(	ItemBase	item,
		float	heatPermeabilityCoef = 1.0 )

inlineprotected

    {
        if (item.GetTemperature() != GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_MIDDLE)
            item.SetTemperatureEx(new TemperatureDataInterpolated(GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_MIDDLE,ETemperatureAccessTypes.ACCESS_INVENTORY,GameConstants.ENVIRO_TICK_RATE,m_ItemTemperatureCoef,heatPermeabilityCoef));
    }

Перекрестные ссылки GameConstants::ENVIRO_TICK_RATE, GameConstants::ITEM_TEMPERATURE_NEUTRAL_ZONE_MIDDLE и m_ItemTemperatureCoef.

Используется в ProcessItemHierarchyRecursive(), ProcessItemsInHandsTemperature() и ProcessItemsTemperature().

◆ SetTargetHeatComfort()

void SetTargetHeatComfort ( float value )

inlineprotected

    {
        m_TargetHeatComfort = value;
    }

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

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

◆ Update()

void Update ( float pDelta )

inlineprivate

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

Updates data

Process temperatures

heat comfort calculation

Process item wetness/dryness

setting of wetness/dryiness of player

reset item wetness counter;

    {
        if (m_Player && m_Initialized)
        {
            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();
                
                ProcessItemsTemperature(m_HeadParts);
                ProcessItemsTemperature(m_BodyParts);
                ProcessItemsTemperature(m_FeetParts);
                ProcessItemsInHandsTemperature();
 
                if (DetermineHeatcomfortBehavior())
                    SetHeatcomfortDirectly();
                else
                    ProcessHeatComfort();
 
                if (m_WetDryTick >= GameConstants.ENVIRO_TICKS_TO_WETNESS_CALCULATION)
                {
                    if (IsWaterContact())
                    {
                        ProcessWetnessByWaterLevel(m_WaterLevel);
                    }
                    else if ((IsRaining() || (IsSnowing() && MiscGameplayFunctions.GetCombinedSnowfallWindValue() > SNOWFALL_WIND_COMBINED_THRESHOLD)) && !IsInsideBuilding() && !IsUnderRoof() && !IsInsideVehicle())
                    {
                        ProcessItemsWetness(m_SlotIdsComplete);
                    }
                    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(), DetermineHeatcomfortBehavior(), GameConstants::ENVIRO_TICK_RATE, GameConstants::ENVIRO_TICK_ROOF_RC_CHECK, GameConstants::ENVIRO_TICKS_TO_WETNESS_CALCULATION, GatherTemperatureSources(), IsInsideBuilding(), IsInsideVehicle(), IsRaining(), IsSnowing(), IsUnderRoof(), IsWaterContact(), m_BodyParts, m_FeetParts, m_HeadParts, m_Initialized, m_ItemsWetnessMax, m_Player, m_RoofCheckTimer, m_SlotIdsComplete, m_Time, m_WaterLevel, m_WetDryTick, ProcessHeatComfort(), ProcessItemsDryness(), ProcessItemsInHandsTemperature(), ProcessItemsTemperature(), ProcessItemsWetness(), ProcessTemperatureSources(), ProcessWetnessByWaterLevel(), SetHeatcomfortDirectly(), SNOWFALL_WIND_COMBINED_THRESHOLD и GameConstants::STATE_WET.

◆ WindEffectTemperatureValue()

float WindEffectTemperatureValue ( float temperatureInput )

inlineprotected

    {
        float output = 0.0;
 
        output = (temperatureInput - GameConstants.ENVIRO_WIND_CHILL_LIMIT) / (GameConstants.ENVIRO_WIND_EFFECT_SLOPE - GameConstants.ENVIRO_WIND_CHILL_LIMIT);
        output = output * m_Wind * m_WorldData.GetWindCoef();
        
        return -output;
    }

Перекрестные ссылки GameConstants::ENVIRO_WIND_CHILL_LIMIT, GameConstants::ENVIRO_WIND_EFFECT_SLOPE, m_Wind и m_WorldData.

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

Поля

◆ m_AverageHeatComfortBuffer

ref SimpleMovingAverage<float> m_AverageHeatComfortBuffer

protected

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

◆ m_BodyParts

ref array<int> m_BodyParts

protected

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

◆ m_Clouds

float m_Clouds = 0

protected

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

◆ m_DayOrNight

float m_DayOrNight = 0

protected

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

◆ m_EnvironmentSnapshot

ref EnvironmentSnapshotData m_EnvironmentSnapshot

protected

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

◆ m_EnvironmentTemperature

float m_EnvironmentTemperature

protected

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

◆ m_FeetParts

ref array<int> m_FeetParts

protected

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

◆ m_Fog

float m_Fog = 0

protected

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

◆ m_HasTemperatureSources

bool m_HasTemperatureSources

protected

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

◆ m_HeadParts

ref array<int> m_HeadParts

protected

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

◆ m_HeatBufferTimer

float m_HeatBufferTimer

protected

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

◆ m_HeatComfort

float m_HeatComfort

protected

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

◆ m_HeatComfortBehaviorCategory

int m_HeatComfortBehaviorCategory

protected

Используется в DetermineHeatcomfortBehavior(), Init(), ProcessHeatBuffer() и SetHeatcomfortDirectly().

◆ m_HeatSourceTemp

float m_HeatSourceTemp

protected

DEPRECATED.

◆ m_Initialized

bool m_Initialized

private

used for calculations before the data modification

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

◆ m_IsInWater

bool m_IsInWater

protected

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

◆ 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_ItemTemperatureCoef

float m_ItemTemperatureCoef

protected

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

◆ m_LiquidType

int m_LiquidType

protected

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

◆ m_Player

◆ 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

target value of heatcomfort (non-buffered)

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

◆ 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

reused as state toggle

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

◆ m_SlotIdsLower

ref array<int> m_SlotIdsLower

protected

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

◆ m_SlotIdsUpper

ref array<int> m_SlotIdsUpper

protected

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

◆ m_Snowfall

float m_Snowfall = 0

protected

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

◆ m_SurfaceType

string m_SurfaceType

protected

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

◆ m_TargetHeatComfort

float m_TargetHeatComfort

protected

player's heatcomfort (buffered, stored in player stats)

Используется в GetTargetHeatComfort(), SetEnvironmentSnapshotData() и SetTargetHeatComfort().

◆ 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(), ProcessHeatBuffer() и ProcessTemperatureSources().

◆ m_UTSAverageTemperatureBuffer

ref SimpleMovingAverage<float> m_UTSAverageTemperatureBuffer

protected

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

◆ m_WaterLevel

float m_WaterLevel

protected

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

◆ m_WetDryTick

float m_WetDryTick

protected

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

◆ m_Wind

float m_Wind = 0

protected

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

◆ m_WindAverageBuffer

ref SimpleMovingAverage<float> m_WindAverageBuffer

protected

◆ m_WorldData

ref WorldData m_WorldData

protected

Используется в GetDebugMessage(), GetEnvironmentTemperature(), GetTemperatureHeightCorrection(), Init(), SetAreaGenericColdness() и WindEffectTemperatureValue().

◆ RAIN_LIMIT_LOW

const float RAIN_LIMIT_LOW = 0.05

private

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

◆ SNOWFALL_LIMIT_LOW

const float SNOWFALL_LIMIT_LOW = 0.5

protected

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

◆ SNOWFALL_WIND_COMBINED_THRESHOLD

const float SNOWFALL_WIND_COMBINED_THRESHOLD = 1.3

protected

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

◆ WATER_LEVEL_HIGH

const float WATER_LEVEL_HIGH = 1.5

protected

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

◆ WATER_LEVEL_LOW

const float WATER_LEVEL_LOW = 0.5

protected

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

◆ WATER_LEVEL_MID

const float WATER_LEVEL_MID = 1.2

protected

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

◆ WATER_LEVEL_NONE

const float WATER_LEVEL_NONE = 0.15

protected

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

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

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

Закрытые члены
void	Environment (PlayerBase pPlayer)

void	Init ()

void	Update (float pDelta)

bool	IsTemperatureSet ()

bool	IsUnderRoofBuilding ()

bool	IsNeutralTemperature (float temperature, float lowerLimit=GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_LOWER_LIMIT, float upperLimit=GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_UPPER_LIMIT)

float	NormalizedTemperature (float temperature, float lowerLimit=GameConstants.ENVIRO_LOW_TEMP_LIMIT, float upperLimit=GameConstants.ENVIRO_HIGH_TEMP_LIMIT)

void	LogDryWetProcess (string message, bool indented=false)

void	LogItemHeat (string message, bool indented=false)

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

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

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

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

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

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

◆ Environment()

Методы

◆ AddToEnvironmentTemperature()

◆ ApplyDrynessToItem()

◆ ApplyDrynessToItemEx()

◆ ApplyWetnessToItem()

◆ BodyPartHeatProperties() [1/2]

◆ BodyPartHeatProperties() [2/2]

◆ CalcTemperatureFromTemperatureSource()

◆ CheckUnderRoof()

◆ CheckWaterContact()

◆ CollectAndSetEnvironmentData()

◆ CollectAndSetPlayerData()

◆ DetermineHeatcomfortBehavior()

◆ EnvTempToCoef()

◆ GatherTemperatureSources()

◆ GetApplicableHeatbuffer()

◆ GetDayOrNight()

◆ GetDebugMessage()

◆ GetEnvironmentTemperature()

◆ GetNextRoofCheck()

◆ GetPlayerHeat()

◆ GetTargetHeatComfort()

◆ GetTemperature()

◆ GetTemperatureHeightCorrection()

◆ GetUniversalSourcesTemperageAverage()

◆ GetWaterLevel()

◆ GetWetDelta()

◆ GetWindModifierPerSurface()

◆ Init() [1/2]

◆ Init() [2/2]

◆ IsInsideBuilding()

◆ IsInsideVehicle()

◆ IsNeutralTemperature()

◆ IsRaining()

◆ IsSnowing()

◆ IsTemperatureSet()

◆ IsUnderRoof()

◆ IsUnderRoofBuilding()

◆ IsWaterContact()

◆ LogDryWetProcess()

◆ LogItemHeat()

◆ NakedBodyPartHeatComfortPenalty()

◆ NormalizedTemperature()

◆ OnTemperatureSourcesEnter()

◆ OnTemperatureSourcesLeft()

◆ OverridenHeatComfort()

◆ ProcessHeatBuffer()

◆ ProcessHeatComfort()

◆ ProcessItemHierarchyRecursive()

◆ ProcessItemsDryness()

◆ ProcessItemsHeat()

◆ ProcessItemsInHandsTemperature()

◆ ProcessItemsTemperature()

◆ ProcessItemsWetness()

◆ ProcessTemperatureSources()

◆ ProcessWetnessByRain()

◆ ProcessWetnessByWaterLevel()

◆ SetAreaGenericColdness()

◆ SetEnvironmentSnapshotData()

◆ SetEnvironmentTemperature()

◆ SetHeatcomfortDirectly()

◆ SetItemHeatingCoef()

◆ SetProcessedItemTemperature()

◆ SetTargetHeatComfort()

◆ Update()

◆ WindEffectTemperatureValue()

Поля

◆ m_AverageHeatComfortBuffer

◆ m_BodyParts

◆ m_Clouds

◆ m_DayOrNight

◆ m_EnvironmentSnapshot

◆ m_EnvironmentTemperature