Класс ComponentEnergyManager

Граф наследования:ComponentEnergyManager:

Защищенные члены
void	ComponentEnergyManager ()
void	~ComponentEnergyManager ()
override void	Event_OnInit ()
void	DebugUpdate ()
Shape	DrawArrow (vector from, vector to, float size=0.5, int color=0xFFFFFFFF, float flags=0)
EntityAI	GetThisEntityAI ()
override void	Event_OnAwake ()
override int	GetCompType ()
void	OnDeviceDestroyed ()
void	RefreshDebug ()
bool	GetDebugPlugs ()
void	SetDebugPlugs (bool newVal)
void	SwitchOn ()
	Energy manager: Switches ON the device so it starts doing its work if it has enough energy.
void	SwitchOff ()
	Energy manager: Switches OFF the device.
void	SetPassiveState (bool state=true)
	Energy manager: Changes the status of this device. When it's passive (true), the main timer and OnWork events are not used.
void	UnplugDevice (EntityAI device_to_unplug)
	Energy manager: Unplugs the given device from this one.
void	UnplugThis ()
	Energy manager: Unplugs this device from its power source.
void	UnplugAllDevices ()
	Energy manager: Unplugs everything directly connected to this device.
void	RestorePlugState (bool state)
void	SetEnergy (float new_energy)
	Energy manager: Sets stored energy for this device. It ignores the min/max limit!
void	SetEnergy0To1 (float energy01)
	Energy manager: Sets stored energy for this device between 0 and MAX based on relative input value between 0 and 1.
void	UpdateSelections ()
	Energy manager: Shows/Hides all selections this system works with. Call this if something is wrong with selections (like during Init and Restore event in config)
void	UpdatePlugState ()
	Energy manager: Unplugs this device when it's necesarry.
void	GetCompatiblePlugTypes (out TIntArray IDs)
void	StoreEnergySourceIDs (int b1, int b2, int b3, int b4)
void	SetEnergyMaxPristine (float new_limit)
	Energy manager: Changes the maximum amount of energy this device can store (when pristine).
void	SetCordLength (float new_length)
	Energy manager: Changes the length of the virtual power cord.
void	SetPlugType (int new_type)
void	SetAttachmentAction (int new_action_type)
void	SetEnergyUsage (float new_usage)
	Energy manager: Changes the energy usage per second.
void	ResetEnergyUsage ()
	Energy manager: Resets energy usage to default (config) value.
void	SetCordTextureFile (string new_path)
void	SetEnergySourceClient (EntityAI source)
void	SetDeviceBySocketID (int id, EntityAI plugged_device)
	Energy manager: Stores the device which is plugged into the given socket ID.
void	SetElectricityIconVisibility (bool make_visible)
	Energy manager: Sets visibility of the electricity icon (bolt).
void	UpdateCanWork ()
void	HandleMoveInsideCargo (EntityAI container)
void	SetUpdateInterval (float value)
	Energy manager: Sets the interval of the OnWork(...) calls. Changing this value does not change the rate of energy consumption.
bool	GetRestorePlugState ()
bool	PlugThisInto (EntityAI energy_source, int socket_id=-1)
	Energy manager: Attempts to plug this device into the energy_source. Returns true if the action was successfull, or false if not (due to plug incompatibility or no free socket on the receiver). The ID of the power socket is chosen automatically unless optional parameter socket_id is used (starting from 0). If the given ID is not free then a free socket is found.
bool	CanSwitchOn ()
	Energy manager: Checks if the device can be switched ON.
bool	CanWork (float test_energy=-1)
	Energy manager: Checks whenever this device can do work or not.
bool	CheckWetness ()
	Energy manager: Checks if this device is being stopped from working by its wetness level. Returns true when its wetness is not blocking it, false when its to owet to work.
bool	CanSwitchOff ()
	Energy manager: Checks if the device can be switched OFF.
bool	GetPreviousSwitchState ()
bool	IsSwitchedOn ()
	Energy manager: Returns state of the switch. Whenever the device is working or not does not matter. Use IsWorking() to account for that as well.
bool	IsCordFolded ()
	Energy manager: Returns true if the cord of this device is folded. Returns false if it's plugged.
bool	IsPassive ()
	Energy manager: Returns true if this device is set to be passive. False if otherwise.
bool	IsPlugged ()
	Energy manager: Returns true if this device is plugged into some other device (even if they are OFF or ruined). Otherwise it returns false.
bool	ConsumeEnergy (float amount)
	Energy manager: Consumes the given amount of energy. If there is not enough of stored energy in this device, then it tries to take it from its power source, if any exists. Returns true if the requested amount of energy was consumed. Otherwise it returns false.
bool	IsWorking ()
	Energy manager: Returns true if this device is working right now.
bool	HasEnoughStoredEnergy ()
	Energy manager: Returns true if this device has enough of stored energy for its own use.
bool	HasFreeSocket (int socket_id=-1)
	Energy manager: Returns true if this device has any free socket to receive a plug. If optional parameter socket_id is provided then only that socket ID is checked.
bool	IsPlugCompatible (int plug_ID)
	Energy manager: Checks if the given plug is compatible with this device's socket. Used by CanReceivePlugFrom() method.
bool	CanReceivePlugFrom (EntityAI device_to_plug)
	Energy manager: Returns true if this device can receive power plug of the other device.
bool	CanBePluggedInto (EntityAI potential_energy_provider)
	Energy manager: Returns true if this device can be plugged into the given energy source. Otherwise returns false.
bool	HasElectricityIcon ()
	Energy manager: Returns true if the electricity icon (bolt) is supposed to be visible for this device. False if not.
bool	HasConversionOfEnergyToQuantity ()
	Energy manager: Returns true if this item automatically converts its energy to quantity.
bool	IsEnergySourceAtReach (vector from_position, float add_tolerance=0, vector override_source_position="-1 -1 -1")
	Energy manager: Returns true if this device's virtual power cord can reach its energy source at the given position, depending on its cordLength config parameter. Otherwise returns false.
bool	HasVisibleSocketsInInventory ()
bool	IsSelectionAPlug (string selection_to_test)
	Energy manager: Returns true if this selection is a plug that's plugged into this device. Otherwise returns false.
int	GetSocketsCount ()
	Energy manager: Returns the count of power sockets (whenever used or not)
int	GetPlugType ()
	Energy manager: Returns plug type. Check \DZ\data\basicDefines.hpp OR \Scripts\Classes\Component_constants.h files for types of plugs.
int	GetAttachmentAction ()
int	GetEnergySourceStorageIDb1 ()
int	GetEnergySourceStorageIDb2 ()
int	GetEnergySourceStorageIDb3 ()
int	GetEnergySourceStorageIDb4 ()
int	GetEnergySourceNetworkIDLow ()
int	GetEnergySourceNetworkIDHigh ()
int	GetPluggedDevicesCount ()
	Energy manager: Returns the number of devices plugged into this one.
int	GetEnergy0To100 ()
	Energy manager: Returns % of stored energy this device has as integer (from 0 to 100)
float	GetEnergy0To1 ()
	Energy manager: Returns % of stored energy this device has as float (from 0.0 to 1.0)
float	GetUpdateInterval ()
	Energy manager: Returns the update interval of this device.
float	GetWetnessExposure ()
	Returns wetness exposure value defined in config.
float	GetEnergyUsage ()
	Energy manager: Returns the number of energy this device needs to run itself (See its config >> energyUsagePerSecond)
float	GetEnergy ()
	Energy manager: Returns the amount of stored energy this device has.
float	AddEnergy (float added_energy)
	Energy manager: Adds energy to this device and clamps it within its min/max storage limits. Returns the amount of energy that was clamped. Negative value is supported, but you should still use ConsumeEnergy(...) for propper substraction of energy.
float	GetEnergyMax ()
	Energy manager: Returns the maximum amount of energy this device can curently store. If parameter 'reduceMaxEnergyByDamageCoef' is used in the config of this device then the returned value will be reduced by damage.
float	GetEnergyMaxPristine ()
	Energy manager: Returns the maximum amount of energy this device can store. It's damage is NOT taken into account.
float	GetEnergyAtSpawn ()
float	GetCordLength ()
	Energy manager: Returns the length of the virtual power cord.
EntityAI	GetEnergySource ()
	Energy manager: Returns the energy source this device is plugged into.
EntityAI	GetDeviceBySocketID (int id)
	Energy manager: Returns the device which is plugged into the given socket ID.
EntityAI	GetPlugOwner (string plug_selection_name)
	Energy manager: Returns the device to which the given plug selection belongs to.
EntityAI	GetPluggedDevice ()
	Energy manager: Returns a device which is plugged into this one. If there are more devices to choose from then it returns the first one that is found.
string	GetCordTextureFile ()
	Energy manager: Returns path to the cord texture file.
array< EntityAI >	GetPluggedDevices ()
	Energy manager: Returns an array of devices which are plugged into this one.
array< EntityAI >	GetPoweredDevices ()
	Energy manager: Returns an array of devices which are plugged into this one and are turned on.
void	OnWork (float consumed_energy)
void	OnIsPlugged (EntityAI source_device)
void	OnIsUnplugged (EntityAI last_energy_source)
void	OnOwnSocketTaken (EntityAI device)
void	OnOwnSocketReleased (EntityAI device)
void	OnAttachmentAdded (EntityAI elec_device)
void	OnAttachmentRemoved (EntityAI elec_device)
void	StartUpdates ()
void	OnEnergyConsumed ()
	Energy manager: Called when energy was consumed on this device.
void	OnEnergyAdded ()
	Energy manager: Called when energy was added on this device.
void	StopUpdates ()
void	InteractBranch (EntityAI originalCaller, Man player=null, int system=0)
void	OnInteractBranch (EntityAI originalCaller, Man player, int system)
	Called when the player is interacting with an item containing this energy component, or when interacting with an item this device is connected to.
void	WakeUpWholeBranch (EntityAI original_caller)
void	PlugCordIntoSocket (EntityAI device_to_plug, int socket_id=-1)
void	UpdateSocketSelections (int socket_id, EntityAI device_to_plug)
void	SetEnergySource (EntityAI source)
bool	PlugInDevice (EntityAI device_to_plug, int socket_id=-1)
void	SetPlugOwner (string selection_name, EntityAI device)
void	UnplugCordFromSocket (int socket_to_unplug_ID)
void	SetPowered (bool state)
bool	FindAndConsumeEnergy (EntityAI original_caller, float amount, bool ignore_switch_state=false)
int	GetMySocketID ()
void	SetMySocketID (int slot_ID)
void	Synch ()
void	ClearLastUpdateTime ()
void	RememberLastUpdateTime ()
float	GetCurrentUpdateTime ()
void	DeviceUpdate ()

Защищенные данные
const float	DEFAULT_UPDATE_INTERVAL = 15
Shape	m_DebugPlugArrow
bool	m_IsSwichedOn
bool	m_IsSwichedOnPreviousState
bool	m_IsPassiveDevice
bool	m_IsWorking
bool	m_CanWork
bool	m_CanStopWork
bool	m_RestorePlugState
bool	m_AutoSwitchOff
bool	m_ShowSocketsInInventory
bool	m_HasElectricityIcon
bool	m_AutoSwitchOffWhenInCargo
bool	m_IsPlugged
bool	m_ConvertEnergyToQuantity
int	m_MySocketID = -1
int	m_PlugType
int	m_EnergySourceStorageIDb1
int	m_EnergySourceStorageIDb2
int	m_EnergySourceStorageIDb3
int	m_EnergySourceStorageIDb4
int	m_AttachmentActionType
int	m_EnergySourceNetworkIDLow = -1
int	m_EnergySourceNetworkIDHigh = -1
float	m_EnergyUsage
float	m_Energy
float	m_EnergyAtSpawn
float	m_EnergyStorageMax
float	m_ReduceMaxEnergyByDamageCoef
float	m_SocketsCount
float	m_CordLength
float	m_LastUpdateTime
float	m_WetnessExposure
float	m_UpdateInterval
string	m_CordTextureFile
ref TIntArray	m_CompatiblePlugTypes
EntityAI	m_EnergySource
ref array< EntityAI >	m_PluggedDevices
ref map< string, EntityAI >	m_DeviceByPlugSelection
ref Timer	m_UpdateTimer
ref Timer	m_UpdateQuantityTimer
ref Timer	m_DebugUpdate
const int	MAX_SOCKETS_COUNT = 4
EntityAI	m_Sockets [MAX_SOCKETS_COUNT]

Статические защищенные данные
static bool	m_DebugPlugs = false
static const string	SOCKET_ = "socket_"
static const string	_PLUGGED = "_plugged"
static const string	_AVAILABLE = "_available"
static const string	SEL_CORD_PLUGGED = "cord_plugged"
static const string	SEL_CORD_FOLDED = "cord_folded"

Дополнительные унаследованные члены
Закрытые члены унаследованные от Component
void	Event_OnFrame (IEntity other, float timeSlice)
Shape	DebugBBoxDraw ()
void	DebugBBoxSetColor (int color)
void	DebugBBoxDelete ()
Shape	DebugDirectionDraw (float distance=1)
void	DebugDirectionSetColor (int color)
void	DebugDirectionDelete ()
void	SetParentEntityAI (EntityAI e)
void	Event_OnAwake ()
void	Event_OnInit ()
void	LogThis (string msg, string fnc_name="n/a")
void	LogThisWarning (string msg, string fnc_name="n/a")
void	LogThisError (string msg, string fnc_name="n/a")
string	GetCompName ()
int	GetCompType ()
void	Event_OnItemAttached (EntityAI item, string slot_name)
void	Event_OnItemDetached (EntityAI item, string slot_name)
override Shape	DebugBBoxDraw ()
override void	DebugBBoxSetColor (int color)
override void	DebugBBoxDelete ()
override Shape	DebugDirectionDraw (float distance=1)
override void	DebugDirectionDelete ()
void	OnDrawing ()
Закрытые статические члены унаследованные от Component
static void	Init ()
static string	GetNameByType (int comp_type)
static bool	IsTypeExist (int comp_type)
static void	LogErrorBadCompType (int comp_type, string fnc_name)
static void	LogWarningAlredyExist (int comp_type, string fnc_name)
Закрытые данные унаследованные от Component
EntityAI	m_ThisEntityAI
Shape	m_DebugShapeBBox
Shape	m_DebugShapeDirection
float	m_DebugShapeDirectionDist

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

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

ComponentEnergyManager()

void ComponentEnergyManager ( )

inlineprotected

    {
        // Disable debug arrows on public release, so that they don't use their timers.
        #ifndef DEVELOPER
        m_DebugPlugs = false;
        #endif
    }

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

~ComponentEnergyManager()

void ~ComponentEnergyManager ( )

inlineprotected

    {
        if (m_DebugPlugArrow)
        {
            m_DebugPlugArrow.Destroy();
            m_DebugPlugArrow = NULL; 
        }
    }

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

Методы

AddEnergy()

float AddEnergy ( float added_energy )

inlineprotected

Energy manager: Adds energy to this device and clamps it within its min/max storage limits. Returns the amount of energy that was clamped. Negative value is supported, but you should still use ConsumeEnergy(...) for propper substraction of energy.

    {
        if (added_energy != 0)
        {
            //Print("AddEnergy ---------> " + added_energy + " " + this + " " +m_ThisEntityAI.ClassName());
            #ifdef DIAG_DEVELOPER
            if (FeatureTimeAccel.GetFeatureTimeAccelEnabled(ETimeAccelCategories.ENERGY_CONSUMPTION) && added_energy < 0)
            {
                float timeAccel = FeatureTimeAccel.GetFeatureTimeAccelValue();
                added_energy *= timeAccel;
            }
            #endif
            
            bool energy_was_added = (added_energy > 0);
            
            float energy_to_clamp = GetEnergy() + added_energy;
            float clamped_energy = Math.Clamp( energy_to_clamp, 0, GetEnergyMax() );
            SetEnergy(clamped_energy);
            StartUpdates();
            
            if (energy_was_added)
                OnEnergyAdded();
            else
                OnEnergyConsumed();
            
            return energy_to_clamp - clamped_energy;
        }
        
        return 0;
    }

Перекрестные ссылки Math::Clamp(), GetEnergy(), GetEnergyMax(), OnEnergyAdded(), OnEnergyConsumed(), SetEnergy() и StartUpdates().

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

CanBePluggedInto()

bool CanBePluggedInto ( EntityAI potential_energy_provider )

inlineprotected

Energy manager: Returns true if this device can be plugged into the given energy source. Otherwise returns false.

    {
        return potential_energy_provider.GetCompEM().CanReceivePlugFrom( m_ThisEntityAI );
    }

Перекрестные ссылки Component::m_ThisEntityAI.

CanReceivePlugFrom()

bool CanReceivePlugFrom ( EntityAI device_to_plug )

inlineprotected

Energy manager: Returns true if this device can receive power plug of the other device.

    {
        // The following conditions are broken down for the sake of easier reading/debugging.
        
        if ( HasFreeSocket()  &&  device_to_plug != m_ThisEntityAI)
        {
            if ( device_to_plug.GetCompEM().GetEnergySource() != m_ThisEntityAI)
            {   
                if ( IsPlugCompatible(device_to_plug.GetCompEM().GetPlugType()) )
                {
                    if ( device_to_plug.GetCompEM().IsEnergySourceAtReach( device_to_plug.GetPosition(), 0, m_ThisEntityAI.GetPosition() ) )
                    {
                        return true;
                    }
                }
            }
        }
        
        return false;
    }

Перекрестные ссылки HasFreeSocket(), IsPlugCompatible() и Component::m_ThisEntityAI.

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

CanSwitchOff()

bool CanSwitchOff ( )

inlineprotected

Energy manager: Checks if the device can be switched OFF.

    {
        if ( IsPassive() )
        {
            return false;
        }
        
        return IsSwitchedOn();
    }

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

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

CanSwitchOn()

bool CanSwitchOn ( )

inlineprotected

Energy manager: Checks if the device can be switched ON.

    {
        if ( !IsSwitchedOn() )
        {
            return true;
        }
        
        return false;
    }

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

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

CanWork()

bool CanWork ( float test_energy = -1 )

inlineprotected

Energy manager: Checks whenever this device can do work or not.

Аргументы

test_energy

float optional parameter will overwite the default energy consumption value of this device.

Возвращает

bool Returns true if this device will work when it's switched on. Otherwise it returns false.

    {
        if ( GetGame().IsMultiplayer()  &&  GetGame().IsClient() )
        {
            return m_CanWork;
        }
        
        if (m_ThisEntityAI && m_ThisEntityAI.IsRuined())
        {
            return false;
        }
        
        // Check if the power source(s) (which can be serially connected) can provide needed energy.
        float       energy_usage    = test_energy;
        float       gathered_energy = GetEnergy();
        EntityAI    energy_source   = GetEnergySource();
        
        if (energy_usage == -1)
        {
            energy_usage = GetEnergyUsage();
        }
        
        if ( !CheckWetness() )
        {
            return false;
        }
        
        if (gathered_energy <= 0 && energy_usage <= 0) //empty power source
        {
            return false;
        }
        
        int cycle_limit = 500; // Sanity check to definitely avoid infinite cycles
        
        while ( gathered_energy < energy_usage ) // Look for energy source if we don't have enough stored energy
        {
            // Safetycheck!
            if (cycle_limit > 0)
            {
                cycle_limit--;
            }
            else
            {
                DPrint("Energy Manager ERROR: The 'cycle_limit' safety break had to be activated to prevent possible game freeze. Dumping debug information...");
                //Print(m_ThisEntityAI);
                //Print(this);
                //Print(energy_source);
                
                if (energy_source.GetCompEM())
                {
                    //Print(energy_source.GetCompEM());
                }
                
                //Print(gathered_energy);
                //Print(energy_usage);
                
                //Print(m_ThisEntityAI.GetPosition());
                
                if (energy_source)
                {
                    //Print(energy_source.GetPosition());
                }
                
                //Print("End of the 'cycle_limit' safety break ^ ");
                
                return false;
            }
            // ^ Safetycheck!
            
            if ( energy_source  &&  energy_source != m_ThisEntityAI  &&  !energy_source.IsRuined()  &&  energy_source.GetCompEM()  &&  energy_source.GetCompEM().IsSwitchedOn()  &&  energy_source.GetCompEM().CheckWetness() )
            {
                gathered_energy = gathered_energy + energy_source.GetCompEM().GetEnergy();
                energy_source = energy_source.GetCompEM().GetEnergySource();
            }
            else
            {
                // No power source, no energy.
                return false;
            }
        }
        
        // Enough energy was found
        return true;
    }

Перекрестные ссылки CheckWetness(), DPrint(), GetEnergy(), GetEnergySource(), GetEnergyUsage(), GetGame(), m_CanWork и Component::m_ThisEntityAI.

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

CheckWetness()

bool CheckWetness ( )

inlineprotected

Energy manager: Checks if this device is being stopped from working by its wetness level. Returns true when its wetness is not blocking it, false when its to owet to work.

    {
        return (m_ThisEntityAI.GetWet() <= 1-m_WetnessExposure);
    }

Перекрестные ссылки Component::m_ThisEntityAI и m_WetnessExposure.

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

ClearLastUpdateTime()

void ClearLastUpdateTime ( )

inlineprotected

    {
        m_LastUpdateTime = 0;
    }

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

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

ConsumeEnergy()

bool ConsumeEnergy ( float amount )

inlineprotected

Energy manager: Consumes the given amount of energy. If there is not enough of stored energy in this device, then it tries to take it from its power source, if any exists. Returns true if the requested amount of energy was consumed. Otherwise it returns false.

    {
        return FindAndConsumeEnergy(m_ThisEntityAI, amount, true);
    }

Перекрестные ссылки FindAndConsumeEnergy() и Component::m_ThisEntityAI.

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

DebugUpdate()

void DebugUpdate ( )

inlineprotected

    {
        if ( GetDebugPlugs() )
        {
            if ( GetGame().IsMultiplayer()  &&  GetGame().IsServer() )
            {
                if (m_DebugUpdate)
                    m_DebugUpdate.Stop();
                
                return;
            }
        
            if (m_DebugPlugArrow)
            {
                m_DebugPlugArrow.Destroy();
                m_DebugPlugArrow = NULL; 
            }
            
            if ( GetEnergySource() )
            {
                vector from = GetEnergySource().GetPosition() + "0 0.1 0";
                vector to = m_ThisEntityAI.GetPosition() + "0 0.1 0";
                
                //No need to draw an arrow in this situation as it would not be visible
                if ( vector.DistanceSq(from, to) == 0 )
                    return;
                
                if ( m_ThisEntityAI.GetType() == "BarbedWire" ) // Special case for debugging of electric fences. Temporal code until offsets in fences are fixed.
                {
                    EntityAI BBB = m_ThisEntityAI.GetHierarchyParent();
                    
                    if ( BBB  &&  BBB.GetType() == "Fence" )
                    {
                        to = to + "0 -1.3 0";
                    }
                }
                
                m_DebugPlugArrow = DrawArrow( from, to );
            }
        }
    }

Перекрестные ссылки vector::DistanceSq(), DrawArrow(), GetDebugPlugs(), GetEnergySource(), GetGame(), m_DebugPlugArrow, m_DebugUpdate и Component::m_ThisEntityAI.

DeviceUpdate()

void DeviceUpdate ( )

inlineprotected

    {
        /*
        vector pos = m_ThisEntityAI.GetPosition();
        string debug_message = "Object " + m_ThisEntityAI.GetType() + "  |  Energy: " + GetEnergy() + "  |  IsAtReach: " + (IsEnergySourceAtReach(pos)).ToString();
        Print(debug_message);
        */
        
        if ( !m_IsPassiveDevice )
        {
            // 'm_ThisEntityAI' and 'this' must be checked because this method is caled from a timer
            if ( m_ThisEntityAI  &&  this  &&  IsSwitchedOn()  &&  !m_ThisEntityAI.IsRuined()  &&  CheckWetness()  &&  m_CanWork  &&  !GetGame().IsMissionMainMenu() )
            {
                bool was_powered = IsWorking();
                float consumed_energy_coef;
                // Make sure to use only as much % of energy as needed since this function can be called at random.
                
                if ( m_LastUpdateTime == 0 )
                {
                    RememberLastUpdateTime();
                    consumed_energy_coef = 1.0;
                }
                else
                {
                    float updatetime = GetCurrentUpdateTime();
                    float time = updatetime - m_LastUpdateTime;
                    consumed_energy_coef = time / 1000;
                }
                
                if (consumed_energy_coef > 0) // Prevents calling of OnWork events when no energy is consumed
                {
                    m_LastUpdateTime = GetCurrentUpdateTime();
                    float consume_energy = GetEnergyUsage() * consumed_energy_coef;
                    bool has_consumed_enough = true;
                    
                    if (GetGame().IsServer() || !GetGame().IsMultiplayer()) // single player or server side multiplayer
                        has_consumed_enough = ConsumeEnergy( consume_energy );
                    
                    SetPowered( has_consumed_enough );
                    
                    if ( has_consumed_enough )
                    {
                        if ( !was_powered )
                        {
                            m_CanStopWork = true;
                            WakeUpWholeBranch(m_ThisEntityAI);
                            GetGame().GameScript.CallFunction(m_ThisEntityAI, "OnWorkStart", NULL, 0);
                            UpdateCanWork();
                        }
                        
                        OnWork( consume_energy );
                    }
                    else
                    {
                        if ( was_powered )
                        {
                            if (m_CanStopWork)
                            {
                                m_CanStopWork = false;
                                ClearLastUpdateTime();
                                GetGame().GameScript.CallFunction(m_ThisEntityAI, "OnWorkStop", NULL, 0); // This event is called only once when the device STOPS being powered
                                UpdateCanWork();
                                
                                if (m_AutoSwitchOff)
                                {
                                    SwitchOff(); 
                                }
                            }
                        }
                        
                        StopUpdates();
                    }
                }
                else
                {
                    ClearLastUpdateTime();
                }
            }
            else if (this && m_ThisEntityAI)
            {
                SetPowered( false );
                StopUpdates();
                
                if (m_CanStopWork)
                {
                    m_CanStopWork = false;
                    ClearLastUpdateTime();
                    GetGame().GameScript.CallFunction(m_ThisEntityAI, "OnWorkStop", NULL, 0); // This event is called only once when the device STOPS being powered
                    UpdateCanWork();
                    
                    if (m_AutoSwitchOff)
                    {
                        SwitchOff(); 
                    }
                }
            }
        }
    }

Перекрестные ссылки CheckWetness(), ClearLastUpdateTime(), ConsumeEnergy(), GetCurrentUpdateTime(), GetEnergyUsage(), GetGame(), IsSwitchedOn(), IsWorking(), m_AutoSwitchOff, m_CanStopWork, m_CanWork, m_IsPassiveDevice, m_LastUpdateTime, Component::m_ThisEntityAI, OnWork(), RememberLastUpdateTime(), SetPowered(), StopUpdates(), SwitchOff(), UpdateCanWork() и WakeUpWholeBranch().

Используется в Entity::OnVariablesSynchronized(), SetPassiveState(), SwitchOff() и SwitchOn().

DrawArrow()

Shape DrawArrow ( vector from, vector to, float size = 0.5, int color = 0xFFFFFFFF, float flags = 0 )

inlineprotected

    {
        vector dir = to - from;
        dir.Normalize();
        vector dir1 = dir * size;
        size = size * 0.5;
    
        vector dir2 = dir.Perpend() * size;
    
        vector pts[5];
        pts[0] = from;
        pts[1] = to;
        pts[2] = to - dir1 - dir2;
        pts[3] = to - dir1 + dir2;
        pts[4] = to;
        
        return Shape.CreateLines(color, flags, pts, 5);
    }

Перекрестные ссылки vector::Normalize(), vector::Perpend() и Shape.

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

Event_OnAwake()

override void Event_OnAwake ( )

inlineprotected

    {
        string cfg_item = "CfgVehicles " + m_ThisEntityAI.GetType();
        string cfg_energy_manager = cfg_item + " EnergyManager ";
        
        // Read all config parameters
        m_EnergyUsage                   = GetGame().ConfigGetFloat(cfg_energy_manager + "energyUsagePerSecond");
        bool switch_on                  = GetGame().ConfigGetFloat(cfg_energy_manager + "switchOnAtSpawn");
        m_AutoSwitchOff                 = GetGame().ConfigGetFloat(cfg_energy_manager + "autoSwitchOff");
        m_HasElectricityIcon            = GetGame().ConfigGetFloat(cfg_energy_manager + "hasIcon");
        m_AutoSwitchOffWhenInCargo      = GetGame().ConfigGetFloat(cfg_energy_manager + "autoSwitchOffWhenInCargo");
        
        m_EnergyAtSpawn                 = GetGame().ConfigGetFloat(cfg_energy_manager + "energyAtSpawn");
        m_Energy = m_EnergyAtSpawn;
        m_EnergyStorageMax              = GetGame().ConfigGetFloat(cfg_energy_manager + "energyStorageMax");
        m_ReduceMaxEnergyByDamageCoef   = GetGame().ConfigGetFloat(cfg_energy_manager + "reduceMaxEnergyByDamageCoef");
        m_SocketsCount                  = GetGame().ConfigGetFloat(cfg_energy_manager + "powerSocketsCount");
        
        m_IsPassiveDevice               = GetGame().ConfigGetFloat(cfg_energy_manager + "isPassiveDevice");
        m_CordLength                    = GetGame().ConfigGetFloat(cfg_energy_manager + "cordLength");
        m_PlugType                      = GetGame().ConfigGetFloat(cfg_energy_manager + "plugType");
        
        m_AttachmentActionType          = GetGame().ConfigGetFloat(cfg_energy_manager + "attachmentAction");
        m_WetnessExposure               = GetGame().ConfigGetFloat(cfg_energy_manager + "wetnessExposure");
        
        float update_interval           = GetGame().ConfigGetFloat(cfg_energy_manager + "updateInterval");
        
        m_ConvertEnergyToQuantity       = GetGame().ConfigGetFloat(cfg_energy_manager + "convertEnergyToQuantity");
        
        
        // Check if energy->quantity converion is configured properly
        float cfg_max_quantity = GetGame().ConfigGetFloat (cfg_item + " varQuantityMax");
        
        if (m_ConvertEnergyToQuantity  &&  cfg_max_quantity <= 0)
        {
            string error = "Error! Item " + m_ThisEntityAI.GetType() + " has invalid configuration of the energy->quantity conversion feature. To fix this, add 'varQuantityMax' parameter with value higher than 0 to the item's config. Then make sure to re-build the PBO containing this item!";
            Error(error);
            m_ConvertEnergyToQuantity = false;
        }
        else
        {
            if (m_ConvertEnergyToQuantity)
            {
                if (!m_UpdateQuantityTimer)
                    m_UpdateQuantityTimer = new Timer( CALL_CATEGORY_SYSTEM );
                
                m_UpdateQuantityTimer.Run( 0.3 , this, "OnEnergyAdded", NULL, false);
            }
        }
        
        // Set update interval
        if ( update_interval <= 0 )
            update_interval = DEFAULT_UPDATE_INTERVAL;
        
        SetUpdateInterval( update_interval );
        
        // If energyAtSpawn is present, then use its value for energyStorageMax if that cfg param is not present (for convenience's sake)
        string cfg_check_energy_limit = cfg_energy_manager + "energyStorageMax";
        
        if ( !GetGame().ConfigIsExisting (cfg_check_energy_limit)  &&  m_Energy > 0 )
        {
            m_EnergyStorageMax = m_Energy;
        }
        
        // Fill m_CompatiblePlugTypes
        string cfg_check_plug_types = cfg_energy_manager + "compatiblePlugTypes";
        
        if ( GetGame().ConfigIsExisting (cfg_check_plug_types) )
        {
            m_CompatiblePlugTypes = new TIntArray;
            GetGame().ConfigGetIntArray(cfg_check_plug_types, m_CompatiblePlugTypes);   
        }
        
        if (GetSocketsCount() > 0)
            m_PluggedDevices = new array<EntityAI>;
        
        if ( m_CordLength < 0 )
        {
            m_CordLength = 0;
            string error_message_cord = "Warning! " + m_ThisEntityAI.GetType() + ": config parameter 'cordLength' is less than 0! Cord length should not be negative!";
            DPrint(error_message_cord);
        }
        
        if (GetSocketsCount() > 0)
        {
            m_DeviceByPlugSelection = new map<string,EntityAI>;
            // Prepare the m_DeviceByPlugSelection
            string cfg_animation_sources = "cfgVehicles " + m_ThisEntityAI.GetType() + " " + "AnimationSources ";
            int animation_sources_count = GetGame().ConfigGetChildrenCount(cfg_animation_sources);
            
            for (int i_selection = 0; i_selection < animation_sources_count; i_selection++)
            {
                // TO DO: This could be optimized so not all selections on item are considered as plug/socket selections.
                string selection;
                GetGame().ConfigGetChildName(cfg_animation_sources, i_selection, selection);
                m_DeviceByPlugSelection.Set(selection, NULL);
            }
        }
        
        
        
        // Prepare sockets
        if ( m_SocketsCount > MAX_SOCKETS_COUNT )
        {
            m_SocketsCount = MAX_SOCKETS_COUNT;
            string error_message_sockets = "Error! " + m_ThisEntityAI.GetType() + ": config parameter 'powerSocketsCount' is higher than the current limit (" + MAX_SOCKETS_COUNT.ToString() + ")! Raise the limit (constant MAX_SOCKETS_COUNT) or decrease the powerSocketsCount parameter for this device!";
            DPrint(error_message_sockets);
        }
        
        m_Sockets[MAX_SOCKETS_COUNT]; // Handles selections for plugs in the sockets. Feel free to change the limit if needed.
        
        GetGame().ConfigGetText(cfg_energy_manager + "cordTextureFile", m_CordTextureFile); 
        
        if ( switch_on )
        {
            SwitchOn();
        }
        
        for ( int i = 0; i <= GetSocketsCount(); ++i )
        {
            m_ThisEntityAI.HideSelection ( SOCKET_ + i.ToString() + _PLUGGED );
        }
        
        // Show/hide inventory sockets
        m_ShowSocketsInInventory = false;
        if ( GetSocketsCount() > 0  &&  IsPlugCompatible(PLUG_COMMON_APPLIANCE)  &&  m_ThisEntityAI.GetType() != "MetalWire" ) // metal wire filter is hopefully temporal.
        {
            m_ShowSocketsInInventory = true;
        }
        
        m_CanWork = HasEnoughStoredEnergy();
        
        m_ThisEntityAI.HideSelection( SEL_CORD_PLUGGED );
        
        
        #ifdef DIAG_DEVELOPER
        GetGame().m_EnergyManagerArray.Insert( this );
        #endif
    }

Перекрестные ссылки _PLUGGED, CALL_CATEGORY_SYSTEM, DEFAULT_UPDATE_INTERVAL, DPrint(), Error(), GetGame(), GetSocketsCount(), HasEnoughStoredEnergy(), IsPlugCompatible(), m_AttachmentActionType, m_AutoSwitchOff, m_AutoSwitchOffWhenInCargo, m_CanWork, m_CompatiblePlugTypes, m_ConvertEnergyToQuantity, m_CordLength, m_CordTextureFile, m_DeviceByPlugSelection, m_Energy, m_EnergyAtSpawn, m_EnergyStorageMax, m_EnergyUsage, m_HasElectricityIcon, m_IsPassiveDevice, m_PluggedDevices, m_PlugType, m_ReduceMaxEnergyByDamageCoef, m_ShowSocketsInInventory, m_Sockets, m_SocketsCount, Component::m_ThisEntityAI, m_UpdateQuantityTimer, m_WetnessExposure, MAX_SOCKETS_COUNT, PLUG_COMMON_APPLIANCE, SEL_CORD_PLUGGED, SetUpdateInterval(), SOCKET_ и SwitchOn().

Event_OnInit()

override void Event_OnInit ( )

inlineprotected

    {
        m_ThisEntityAI.m_EM = this;
        GetGame().GameScript.CallFunction(m_ThisEntityAI, "OnInitEnergy", NULL, 0);
    }

Перекрестные ссылки GetGame() и Component::m_ThisEntityAI.

FindAndConsumeEnergy()

bool FindAndConsumeEnergy ( EntityAI original_caller, float amount, bool ignore_switch_state = false )

inlineprotected

    {
        if ( (ignore_switch_state  ||  IsSwitchedOn())  &&  !m_ThisEntityAI.IsRuined() )
        {
            float available_energy = AddEnergy(-amount);
            
            if ( available_energy < 0  &&  IsPlugged() )
            {
                // This devices does not has enough of stored energy, therefore it will take it from its power source (which can be a chain of cable reels)
                EntityAI next_power_source = GetEnergySource();
                
                if (next_power_source  &&  next_power_source != original_caller) // Prevents infinite loop if the power source is the original caller itself
                {
                    return next_power_source.GetCompEM().FindAndConsumeEnergy( original_caller, -available_energy );
                }
            }
            
            if ( available_energy >= 0)
            {
                return true;
            }
            
            return false;
        }
        else
        {
            return false;
        }
    }

Перекрестные ссылки AddEnergy(), GetEnergySource(), IsPlugged(), IsSwitchedOn() и Component::m_ThisEntityAI.

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

GetAttachmentAction()

int GetAttachmentAction ( )

inlineprotected

    {
        return m_AttachmentActionType;
    }

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

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

GetCompatiblePlugTypes()

void GetCompatiblePlugTypes ( out TIntArray IDs )

inlineprotected

    {
        IDs = m_CompatiblePlugTypes;
    }

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

GetCompType()

override int GetCompType ( )

inlineprotected

    {
        return COMP_TYPE_ENERGY_MANAGER;
    }

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

GetCordLength()

float GetCordLength ( )

inlineprotected

Energy manager: Returns the length of the virtual power cord.

    {
        return m_CordLength;
    }

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

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

GetCordTextureFile()

string GetCordTextureFile ( )

inlineprotected

Energy manager: Returns path to the cord texture file.

    {
        return m_CordTextureFile;
    }

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

GetCurrentUpdateTime()

float GetCurrentUpdateTime ( )

inlineprotected

    {
        return GetGame().GetTime();
    }

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

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

GetDebugPlugs()

bool GetDebugPlugs ( )

inlineprotected

    {
        return m_DebugPlugs;
    }

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

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

GetDeviceBySocketID()

EntityAI GetDeviceBySocketID ( int id )

inlineprotected

Energy manager: Returns the device which is plugged into the given socket ID.

    {
        return m_Sockets[id];
    }

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

Используется в HasFreeSocket(), PlugCordIntoSocket(), UnplugCordFromSocket() и UpdateSelections().

GetEnergy()

float GetEnergy ( )

inlineprotected

Energy manager: Returns the amount of stored energy this device has.

    {
        return m_Energy;
    }

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

Используется в AddEnergy(), CanWork(), HasEnoughStoredEnergy() и Entity::OnStoreSave().

GetEnergy0To1()

float GetEnergy0To1 ( )

inlineprotected

Energy manager: Returns % of stored energy this device has as float (from 0.0 to 1.0)

    {
        if ( m_EnergyStorageMax > 0 )
        {
            return m_Energy / m_EnergyStorageMax;
        }
        
        return 0;
    }

Перекрестные ссылки m_Energy и m_EnergyStorageMax.

GetEnergy0To100()

int GetEnergy0To100 ( )

inlineprotected

Energy manager: Returns % of stored energy this device has as integer (from 0 to 100)

    {
        if ( m_EnergyStorageMax > 0 )
        {
            int coef = Math.Round( m_Energy / m_EnergyStorageMax * 100 );
            return coef;
        }
        
        return 0;
    }

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

GetEnergyAtSpawn()

float GetEnergyAtSpawn ( )

inlineprotected

    {
        return m_EnergyAtSpawn;
    }

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

GetEnergyMax()

float GetEnergyMax ( )

inlineprotected

Energy manager: Returns the maximum amount of energy this device can curently store. If parameter 'reduceMaxEnergyByDamageCoef' is used in the config of this device then the returned value will be reduced by damage.

    {
        float max_health = 0;
        
        if ( m_ThisEntityAI.HasDamageSystem() )
            max_health = m_ThisEntityAI.GetMaxHealth("","");
        //else if ( m_ReduceMaxEnergyByDamageCoef != 0 )
        //  Error("[ERROR] ReduceMaxEnergyByDamageCoef is setup but " + m_ThisEntityAI.GetType() + " does not have a Damage System");
        
        if ( max_health == 0 || m_ReduceMaxEnergyByDamageCoef == 0 )
            return GetEnergyMaxPristine();
        
        float health = 100;
        
        if (GetGame().IsServer() || !GetGame().IsMultiplayer()) // TO DO: Remove this IF when method GetHealth can be called on client!
            health = m_ThisEntityAI.GetHealth("","");
        
        float damage_coef = 1 - (health / max_health);
        
        return GetEnergyMaxPristine() * (1 - ( damage_coef * m_ReduceMaxEnergyByDamageCoef ) );
    }

Перекрестные ссылки GetEnergyMaxPristine(), GetGame(), m_ReduceMaxEnergyByDamageCoef и Component::m_ThisEntityAI.

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

GetEnergyMaxPristine()

float GetEnergyMaxPristine ( )

inlineprotected

Energy manager: Returns the maximum amount of energy this device can store. It's damage is NOT taken into account.

    {
        return m_EnergyStorageMax;
    }

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

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

GetEnergySource()

EntityAI GetEnergySource ( )

inlineprotected

Energy manager: Returns the energy source this device is plugged into.

    {
        return m_EnergySource;
    }

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

Используется в CanWork(), DebugUpdate(), FindAndConsumeEnergy(), IsEnergySourceAtReach(), OnAttachmentRemoved(), Entity::OnStoreSave(), UnplugThis() и UpdateSelections().

GetEnergySourceNetworkIDHigh()

int GetEnergySourceNetworkIDHigh ( )

inlineprotected

    {
        return m_EnergySourceNetworkIDHigh;
    }

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

Используется в Entity::OnVariablesSynchronized().

GetEnergySourceNetworkIDLow()

int GetEnergySourceNetworkIDLow ( )

inlineprotected

    {
        return m_EnergySourceNetworkIDLow;
    }

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

Используется в Entity::OnVariablesSynchronized().

GetEnergySourceStorageIDb1()

int GetEnergySourceStorageIDb1 ( )

inlineprotected

    {
        return m_EnergySourceStorageIDb1;
    }

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

Используется в Entity::EEOnAfterLoad().

GetEnergySourceStorageIDb2()

int GetEnergySourceStorageIDb2 ( )

inlineprotected

    {
        return m_EnergySourceStorageIDb2;
    }

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

Используется в Entity::EEOnAfterLoad().

GetEnergySourceStorageIDb3()

int GetEnergySourceStorageIDb3 ( )

inlineprotected

    {
        return m_EnergySourceStorageIDb3;
    }

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

Используется в Entity::EEOnAfterLoad().

GetEnergySourceStorageIDb4()

int GetEnergySourceStorageIDb4 ( )

inlineprotected

    {
        return m_EnergySourceStorageIDb4;
    }

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

Используется в Entity::EEOnAfterLoad().

GetEnergyUsage()

float GetEnergyUsage ( )

inlineprotected

Energy manager: Returns the number of energy this device needs to run itself (See its config >> energyUsagePerSecond)

    {
        return m_EnergyUsage;
    }

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

Используется в CanWork(), DeviceUpdate(), HasEnoughStoredEnergy() и SetEnergy().

GetMySocketID()

int GetMySocketID ( )

inlineprotected

    {
        return m_MySocketID;
    }

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

GetPluggedDevice()

EntityAI GetPluggedDevice ( )

inlineprotected

Energy manager: Returns a device which is plugged into this one. If there are more devices to choose from then it returns the first one that is found.

    {
        if ( GetPluggedDevicesCount() > 0 )
        {
            return GetPluggedDevices().Get(0);
        }
        
        return NULL;
    }

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

GetPluggedDevices()

array< EntityAI > GetPluggedDevices ( )

inlineprotected

Energy manager: Returns an array of devices which are plugged into this one.

    {
        return m_PluggedDevices;
    }

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

Используется в GetPluggedDevice(), GetPluggedDevicesCount(), GetPoweredDevices(), InteractBranch(), IsSelectionAPlug(), PlugInDevice(), UnplugAllDevices(), UnplugDevice() и WakeUpWholeBranch().

GetPluggedDevicesCount()

int GetPluggedDevicesCount ( )

inlineprotected

Energy manager: Returns the number of devices plugged into this one.

    {
        if ( GetPluggedDevices() )
        {
            return GetPluggedDevices().Count();
        }
        
        return 0;
    }

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

Используется в GetPluggedDevice(), GetPoweredDevices(), HasFreeSocket(), UnplugAllDevices() и UnplugDevice().

GetPlugOwner()

EntityAI GetPlugOwner ( string plug_selection_name )

inlineprotected

Energy manager: Returns the device to which the given plug selection belongs to.

    {
        if ( m_DeviceByPlugSelection.Contains(plug_selection_name) )
        {
            return m_DeviceByPlugSelection.Get(plug_selection_name);
        }
        
        return NULL;
    }

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

GetPlugType()

int GetPlugType ( )

inlineprotected

Energy manager: Returns plug type. Check \DZ\data\basicDefines.hpp OR \Scripts\Classes\Component_constants.h files for types of plugs.

    {
        return m_PlugType;
    }

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

GetPoweredDevices()

array< EntityAI > GetPoweredDevices ( )

inlineprotected

Energy manager: Returns an array of devices which are plugged into this one and are turned on.

    {
        array<EntityAI> return_array = new array<EntityAI>;
        int plugged_devices_c = GetPluggedDevicesCount();
        for ( int i = 0; i < plugged_devices_c; ++i )
        {
            EntityAI device = GetPluggedDevices().Get(i);
            if ( IsSwitchedOn() )
            {
                return_array.Insert(device);
            }
        }
        
        return return_array;
    }

Перекрестные ссылки GetPluggedDevices(), GetPluggedDevicesCount() и IsSwitchedOn().

GetPreviousSwitchState()

bool GetPreviousSwitchState ( )

inlineprotected

    {
        return m_IsSwichedOnPreviousState;
    }

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

Используется в Entity::OnVariablesSynchronized().

GetRestorePlugState()

bool GetRestorePlugState ( )

inlineprotected

    {
        return m_RestorePlugState;
    }

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

Используется в Entity::EEOnAfterLoad().

GetSocketsCount()

int GetSocketsCount ( )

inlineprotected

Energy manager: Returns the count of power sockets (whenever used or not)

    {
        return m_SocketsCount;
    }

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

Используется в Event_OnAwake(), HasFreeSocket(), InteractBranch(), IsSelectionAPlug(), PlugCordIntoSocket(), UpdateSelections() и WakeUpWholeBranch().

GetThisEntityAI()

EntityAI GetThisEntityAI ( )

inlineprotected

    {
        return m_ThisEntityAI;
    }

Перекрестные ссылки Component::m_ThisEntityAI.

GetUpdateInterval()

float GetUpdateInterval ( )

inlineprotected

Energy manager: Returns the update interval of this device.

    {
        #ifdef DIAG_DEVELOPER
        if (FeatureTimeAccel.GetFeatureTimeAccelEnabled(ETimeAccelCategories.ENERGY_CONSUMPTION) || (FeatureTimeAccel.GetFeatureTimeAccelEnabled(ETimeAccelCategories.ENERGY_RECHARGE)))
        {
            return 1;//when modifying time accel, we might want to see things happen when they should, instead of waiting for the next tick
        }
        #endif
        return m_UpdateInterval;
    }

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

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

GetWetnessExposure()

float GetWetnessExposure ( )

inlineprotected

Returns wetness exposure value defined in config.

    {
        return m_WetnessExposure;
    }

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

HandleMoveInsideCargo()

void HandleMoveInsideCargo ( EntityAI container )

inlineprotected

    {
        if ( m_AutoSwitchOffWhenInCargo )
        {
            if (IsSwitchedOn())
            {
                SwitchOff();
            }
        }
    }

Перекрестные ссылки IsSwitchedOn(), m_AutoSwitchOffWhenInCargo и SwitchOff().

Используется в Entity::OnMovedInsideCargo().

HasConversionOfEnergyToQuantity()

bool HasConversionOfEnergyToQuantity ( )

inlineprotected

Energy manager: Returns true if this item automatically converts its energy to quantity.

    {
        return m_ConvertEnergyToQuantity;
    }

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

HasElectricityIcon()

bool HasElectricityIcon ( )

inlineprotected

Energy manager: Returns true if the electricity icon (bolt) is supposed to be visible for this device. False if not.

    {
        return m_HasElectricityIcon;
    }

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

HasEnoughStoredEnergy()

bool HasEnoughStoredEnergy ( )

inlineprotected

Energy manager: Returns true if this device has enough of stored energy for its own use.

    {
        if ( GetEnergy() > GetEnergyUsage() )
        {
            return true;
        }
        
        return false;
    }

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

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

HasFreeSocket()

bool HasFreeSocket ( int socket_id = -1 )

inlineprotected

Energy manager: Returns true if this device has any free socket to receive a plug. If optional parameter socket_id is provided then only that socket ID is checked.

    {
        if (socket_id == -1)
        {
            int plugged_devices = GetPluggedDevicesCount();
            int plugged_devices_limit = GetSocketsCount();
            
            if ( plugged_devices < plugged_devices_limit )
            {
                return true;
            }
            
            return false;
        }
        else
        {
            EntityAI device = GetDeviceBySocketID(socket_id);
            
            if (device)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
    }

Перекрестные ссылки GetDeviceBySocketID(), GetPluggedDevicesCount() и GetSocketsCount().

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

HasVisibleSocketsInInventory()

bool HasVisibleSocketsInInventory ( )

inlineprotected

    {
        return m_ShowSocketsInInventory;
    }

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

InteractBranch()

void InteractBranch ( EntityAI originalCaller, Man player = null, int system = 0 )

inlineprotected

Gets called originally when the player is interacting with an item containing this energy component, then recursively following the branches of connection from the original item to the peripheries External calling of this function is not automatic for all item interactions and may need to be implemented on case by case bases Avoid using for gameplay logic, use 'OnInteractBranch' instead

    {
        OnInteractBranch(originalCaller, player, system);
        if ( GetSocketsCount() > 0 )
        {
            array<EntityAI> devices = GetPluggedDevices();
            
            foreach ( EntityAI device : devices)
            {
                if ( device != originalCaller ) // originalCaller check here prevents infinite loops
                {
                    device.GetCompEM().InteractBranch( originalCaller, player, system );
                }
            }
        }
    }

Перекрестные ссылки GetPluggedDevices(), GetSocketsCount() и OnInteractBranch().

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

IsCordFolded()

bool IsCordFolded ( )

inlineprotected

Energy manager: Returns true if the cord of this device is folded. Returns false if it's plugged.

    {
        if ( IsPlugged() )
            return false;
        
        return true;
    }

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

IsEnergySourceAtReach()

bool IsEnergySourceAtReach ( vector from_position, float add_tolerance = 0, vector override_source_position = "-1 -1 -1" )

inlineprotected

Energy manager: Returns true if this device's virtual power cord can reach its energy source at the given position, depending on its cordLength config parameter. Otherwise returns false.

Аргументы

from_position	vector position from where the measurement will be taken
add_tolerance	float parameter will add to the cord's length in meters (optional)

Возвращает

bool True if the power source will be at reach for the plug, or if config param cordLength is absent or 0. False if not, or is not plugged, or this device lacks Energy Manager component.

vector position_player = GetGame().GetPlayer().GetPosition();
 
if ( my_device.GetCompEM().IsEnergySourceAtReach( position_player )  )
{
    Print("Power source is at reach!");
}else{
    Print("Power source is NOT at reach!");
}

    {
        if ( !IsPlugged()  &&  override_source_position == "-1 -1 -1" )
        {
            return false;
        }
        
        if ( GetCordLength() == 0 ) // 0 is an exception, which means infinitely long cable.
        {
            return true;
        }
        
        vector source_pos;
        float distance;
        
        if ( override_source_position == "-1 -1 -1" )
        {
            EntityAI energy_source = GetEnergySource();
            
            if (!energy_source)
                return false;
            
            source_pos = energy_source.GetPosition();
            distance = vector.Distance( from_position, source_pos );
        }
        else
        {
            source_pos = override_source_position;
            distance = vector.Distance( from_position, source_pos );
        }
        
        if (distance > GetCordLength() + add_tolerance)
        {
            return false;
        }
        else
        {
            return true;
        }
    }

Перекрестные ссылки vector::Distance(), GetCordLength(), GetEnergySource() и IsPlugged().

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

IsPassive()

bool IsPassive ( )

inlineprotected

Energy manager: Returns true if this device is set to be passive. False if otherwise.

    {
        return m_IsPassiveDevice;
    }

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

Используется в CanSwitchOff() и Entity::OnStoreSave().

IsPlugCompatible()

bool IsPlugCompatible ( int plug_ID )

inlineprotected

Energy manager: Checks if the given plug is compatible with this device's socket. Used by CanReceivePlugFrom() method.

    {
        if ( plug_ID == PLUG_UNDEFINED )
        {
            return true; // When plugType is undefined in config then make it compatible.
        }
        
        if ( m_CompatiblePlugTypes )
        {
            for ( int i = 0; i < m_CompatiblePlugTypes.Count(); i++ )
            {
                int plug_ID_to_Check = m_CompatiblePlugTypes.Get(i);
                
                if ( plug_ID_to_Check == plug_ID )
                {
                    return true;
                }
            }
        }
        else
        {
            // Since the config parameter compatiblePlugTypes is not present, then accept all plugs for simplicity's sake
            return true;
        }
        
        return false;
    }

Перекрестные ссылки m_CompatiblePlugTypes и PLUG_UNDEFINED.

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

IsPlugged()

bool IsPlugged ( )

inlineprotected

Energy manager: Returns true if this device is plugged into some other device (even if they are OFF or ruined). Otherwise it returns false.

    {
        return m_IsPlugged;
    }

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

Используется в FindAndConsumeEnergy(), IsCordFolded(), IsEnergySourceAtReach() и Entity::OnStoreSave().

IsSelectionAPlug()

bool IsSelectionAPlug ( string selection_to_test )

inlineprotected

Energy manager: Returns true if this selection is a plug that's plugged into this device. Otherwise returns false.

    {
        if ( GetPluggedDevices() )
        {
            int socket_count = GetSocketsCount();
            
            for ( int i = socket_count; i >= 0; --i )
            {
                string real_selection = SOCKET_ + i.ToString() +_PLUGGED;
                
                if ( selection_to_test == real_selection)
                {
                    return true;
                }
            }
        }
        
        return false;
    }

Перекрестные ссылки _PLUGGED, GetPluggedDevices(), GetSocketsCount() и SOCKET_.

IsSwitchedOn()

bool IsSwitchedOn ( )

inlineprotected

Energy manager: Returns state of the switch. Whenever the device is working or not does not matter. Use IsWorking() to account for that as well.

    {
        return m_IsSwichedOn;
    }

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

Используется в CanSwitchOff(), CanSwitchOn(), DeviceUpdate(), FindAndConsumeEnergy(), GetPoweredDevices(), HandleMoveInsideCargo(), Entity::OnStoreSave() и Entity::OnVariablesSynchronized().

IsWorking()

bool IsWorking ( )

inlineprotected

Energy manager: Returns true if this device is working right now.

    {
        return m_IsWorking;
    }

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

Используется в DeviceUpdate(), Entity::IsIgnited() и SwitchOff().

OnAttachmentAdded()

void OnAttachmentAdded ( EntityAI elec_device )

inlineprotected

    {
        int attachment_action_type = GetAttachmentAction();
        
        if ( attachment_action_type == PLUG_THIS_INTO_ATTACHMENT )
        {
            if ( elec_device.GetCompEM().CanReceivePlugFrom( m_ThisEntityAI ) )
            {
                PlugThisInto(elec_device);
            }
        }
        else if ( attachment_action_type == PLUG_ATTACHMENTS_INTO_THIS )
        {
            elec_device.GetCompEM().PlugThisInto(m_ThisEntityAI);
        }
    }

Перекрестные ссылки GetAttachmentAction(), Component::m_ThisEntityAI, PLUG_ATTACHMENTS_INTO_THIS, PLUG_THIS_INTO_ATTACHMENT и PlugThisInto().

Используется в Entity::EEItemAttached().

OnAttachmentRemoved()

void OnAttachmentRemoved ( EntityAI elec_device )

inlineprotected

    {
        int attachment_action_type = GetAttachmentAction();
        
        if ( attachment_action_type == PLUG_THIS_INTO_ATTACHMENT )
        {
            if ( elec_device == GetEnergySource() )
            {
                UnplugThis();
            }
        }
        else if ( attachment_action_type == PLUG_ATTACHMENTS_INTO_THIS )
        {
            elec_device.GetCompEM().UnplugThis();
        }
    }

Перекрестные ссылки GetAttachmentAction(), GetEnergySource(), PLUG_ATTACHMENTS_INTO_THIS, PLUG_THIS_INTO_ATTACHMENT и UnplugThis().

Используется в Entity::EEItemDetached().

OnDeviceDestroyed()

void OnDeviceDestroyed ( )

inlineprotected

    {
        bool was_working = m_ThisEntityAI.GetCompEM().IsWorking();
        
        SwitchOff();
        UnplugAllDevices();
        UnplugThis();
        SetPowered( false );
        
        if ( was_working )
            m_ThisEntityAI.OnWorkStop();
        ;
    }

Перекрестные ссылки Component::m_ThisEntityAI, SetPowered(), SwitchOff(), UnplugAllDevices() и UnplugThis().

Используется в Entity::EEDelete().

OnEnergyAdded()

void OnEnergyAdded ( )

inlineprotected

Energy manager: Called when energy was added on this device.

    {
        if (m_UpdateQuantityTimer)
        {
            m_UpdateQuantityTimer.Stop();
            m_UpdateQuantityTimer = NULL;
        }
        
        m_ThisEntityAI.OnEnergyAdded();
    }

Перекрестные ссылки Component::m_ThisEntityAI и m_UpdateQuantityTimer.

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

OnEnergyConsumed()

void OnEnergyConsumed ( )

inlineprotected

Energy manager: Called when energy was consumed on this device.

    {
        m_ThisEntityAI.OnEnergyConsumed();
    }

Перекрестные ссылки Component::m_ThisEntityAI.

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

OnInteractBranch()

void OnInteractBranch ( EntityAI originalCaller, Man player, int system )

inlineprotected

Called when the player is interacting with an item containing this energy component, or when interacting with an item this device is connected to.

    {
        m_ThisEntityAI.IncreaseLifetime();
    
    }

Перекрестные ссылки Component::m_ThisEntityAI.

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

OnIsPlugged()

void OnIsPlugged ( EntityAI source_device )

inlineprotected

    {
        if (m_DebugPlugs)
        {
            if (!m_DebugUpdate)
                m_DebugUpdate = new Timer( CALL_CATEGORY_SYSTEM );
            
            if (!m_DebugUpdate.IsRunning())
                m_DebugUpdate.Run(0.01, this, "DebugUpdate", NULL, true);
        }
        
        UpdateCanWork();
        m_ThisEntityAI.OnIsPlugged(source_device);
    }

Перекрестные ссылки CALL_CATEGORY_SYSTEM, m_DebugPlugs, m_DebugUpdate, Component::m_ThisEntityAI и UpdateCanWork().

OnIsUnplugged()

void OnIsUnplugged ( EntityAI last_energy_source )

inlineprotected

    {
        UpdateCanWork();
        m_ThisEntityAI.OnIsUnplugged( last_energy_source );
    }

Перекрестные ссылки Component::m_ThisEntityAI и UpdateCanWork().

OnOwnSocketReleased()

void OnOwnSocketReleased ( EntityAI device )

inlineprotected

    {
        //play sound
        if ( device.GetCompEM().GetPlugType() == PLUG_COMMON_APPLIANCE && m_ThisEntityAI.IsInitialized() )
        {
            EffectSound sound_unplug;
            m_ThisEntityAI.PlaySoundSet( sound_unplug, "cablereel_unplug_SoundSet", 0, 0 );
        }
                
        m_ThisEntityAI.OnOwnSocketReleased( device );
    }

Перекрестные ссылки Component::m_ThisEntityAI и PLUG_COMMON_APPLIANCE.

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

OnOwnSocketTaken()

void OnOwnSocketTaken ( EntityAI device )

inlineprotected

    {
        //play sound
        if ( device.GetCompEM().GetPlugType() == PLUG_COMMON_APPLIANCE && m_ThisEntityAI.IsInitialized() )
        {
            EffectSound sound_plug;
            m_ThisEntityAI.PlaySoundSet( sound_plug, "cablereel_plugin_SoundSet", 0, 0 );
        }
        
        m_ThisEntityAI.OnOwnSocketTaken(device);
    }

Перекрестные ссылки Component::m_ThisEntityAI и PLUG_COMMON_APPLIANCE.

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

OnWork()

void OnWork ( float consumed_energy )

inlineprotected

    {
        m_ThisEntityAI.OnWork(consumed_energy);
    }

Перекрестные ссылки Component::m_ThisEntityAI.

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

PlugCordIntoSocket()

void PlugCordIntoSocket ( EntityAI device_to_plug, int socket_id = -1 )

inlineprotected

    {
        if (socket_id >= 0)
        {
            EntityAI plug_owner_by_socket = GetDeviceBySocketID(socket_id);
            
            if (!plug_owner_by_socket)
            {
                UpdateSocketSelections(socket_id, device_to_plug);
                return;
            }
        }
 
        int slots_c = GetSocketsCount();
        
        for ( int i = 0; i < slots_c; ++i )
        {
            EntityAI plug_owner = GetDeviceBySocketID(i);
            
            if ( !plug_owner ) // Check if this socket is available
            {
                UpdateSocketSelections(i, device_to_plug);
                break;
            }
        }
    }

Перекрестные ссылки GetDeviceBySocketID(), GetSocketsCount() и UpdateSocketSelections().

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

PlugInDevice()

bool PlugInDevice ( EntityAI device_to_plug, int socket_id = -1 )

inlineprotected

    {
        if (CanReceivePlugFrom(device_to_plug))
        {
            device_to_plug.IncreaseLifetime();
            InteractBranch(m_ThisEntityAI);
            if (device_to_plug.GetCompEM().IsPlugged())
                device_to_plug.GetCompEM().UnplugThis();
            
            GetPluggedDevices().Insert(device_to_plug);
            device_to_plug.GetCompEM().SetEnergySource(m_ThisEntityAI);
            
            PlugCordIntoSocket(device_to_plug, socket_id); // Visualisation
            OnOwnSocketTaken(device_to_plug);
            
            device_to_plug.GetCompEM().OnIsPlugged(m_ThisEntityAI);
            WakeUpWholeBranch( m_ThisEntityAI );
            
            if (GetGame().IsServer() || !GetGame().IsMultiplayer())
            {
                device_to_plug.HideSelection(SEL_CORD_FOLDED);
                device_to_plug.ShowSelection(SEL_CORD_PLUGGED);
            }
            
            return true;
        }
        
        return false;
    }

Перекрестные ссылки CanReceivePlugFrom(), GetGame(), GetPluggedDevices(), InteractBranch(), Component::m_ThisEntityAI, OnOwnSocketTaken(), PlugCordIntoSocket(), SEL_CORD_FOLDED, SEL_CORD_PLUGGED и WakeUpWholeBranch().

PlugThisInto()

bool PlugThisInto ( EntityAI energy_source, int socket_id = -1 )

inlineprotected

Energy manager: Attempts to plug this device into the energy_source. Returns true if the action was successfull, or false if not (due to plug incompatibility or no free socket on the receiver). The ID of the power socket is chosen automatically unless optional parameter socket_id is used (starting from 0). If the given ID is not free then a free socket is found.

    {
        return energy_source.GetCompEM().PlugInDevice(m_ThisEntityAI, socket_id);
    }

Перекрестные ссылки Component::m_ThisEntityAI.

Используется в Entity::EEOnAfterLoad(), OnAttachmentAdded() и Entity::OnVariablesSynchronized().

RefreshDebug()

void RefreshDebug ( )

inlineprotected

    {
        if ( m_DebugPlugs )
        {
            if ( !m_DebugUpdate )
                m_DebugUpdate = new Timer( CALL_CATEGORY_SYSTEM );
            
            if ( !m_DebugUpdate.IsRunning() )
                m_DebugUpdate.Run(0.01, this, "DebugUpdate", NULL, true);
        }
        else
        {
            if ( m_DebugPlugArrow )
            {
                m_DebugPlugArrow.Destroy();
                m_DebugPlugArrow = NULL; 
            }
        }
    }

Перекрестные ссылки CALL_CATEGORY_SYSTEM, m_DebugPlugArrow, m_DebugPlugs и m_DebugUpdate.

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

RememberLastUpdateTime()

void RememberLastUpdateTime ( )

inlineprotected

    {
        m_LastUpdateTime = GetCurrentUpdateTime();
    }

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

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

ResetEnergyUsage()

void ResetEnergyUsage ( )

inlineprotected

Energy manager: Resets energy usage to default (config) value.

    {
        string cfg_energy_usage = "CfgVehicles " + m_ThisEntityAI.GetType() + " EnergyManager ";
        m_EnergyUsage = GetGame().ConfigGetFloat (cfg_energy_usage + "energyUsagePerSecond");
    }

Перекрестные ссылки GetGame(), m_EnergyUsage и Component::m_ThisEntityAI.

RestorePlugState()

void RestorePlugState ( bool state )

inlineprotected

    {
        m_RestorePlugState = state;
    }

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

Используется в Entity::OnStoreLoad().

SetAttachmentAction()

void SetAttachmentAction ( int new_action_type )

inlineprotected

    {
        m_AttachmentActionType = new_action_type;
    }

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

SetCordLength()

void SetCordLength ( float new_length )

inlineprotected

Energy manager: Changes the length of the virtual power cord.

    {
        m_CordLength = new_length;
    }

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

SetCordTextureFile()

void SetCordTextureFile ( string new_path )

inlineprotected

    {
        m_CordTextureFile = new_path;
    }

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

SetDebugPlugs()

void SetDebugPlugs ( bool newVal )

inlineprotected

    {
        m_DebugPlugs = newVal;
        RefreshDebug();
    }

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

SetDeviceBySocketID()

void SetDeviceBySocketID ( int id, EntityAI plugged_device )

inlineprotected

Energy manager: Stores the device which is plugged into the given socket ID.

    {
        m_Sockets[id] = plugged_device;
    }

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

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

SetElectricityIconVisibility()

void SetElectricityIconVisibility ( bool make_visible )

inlineprotected

Energy manager: Sets visibility of the electricity icon (bolt).

    {
        m_HasElectricityIcon = make_visible;
    }

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

SetEnergy()

void SetEnergy ( float new_energy )

inlineprotected

Energy manager: Sets stored energy for this device. It ignores the min/max limit!

    {
        if (GetGame().IsServer() || !GetGame().IsMultiplayer()) // Client can't change energy value.
        {
            m_ThisEntityAI.SetWeightDirty();
            float old_energy = m_Energy;
            m_Energy = new_energy;
            
            if ( old_energy - GetEnergyUsage() <= 0 || (old_energy != new_energy && Math.Min(old_energy,new_energy) <= 0) )
            {
                UpdateCanWork();
            }
        }
    }

Перекрестные ссылки GetEnergyUsage(), GetGame(), m_Energy, Component::m_ThisEntityAI, Math::Min() и UpdateCanWork().

Используется в AddEnergy(), Entity::OnStoreLoad() и SetEnergy0To1().

SetEnergy0To1()

void SetEnergy0To1 ( float energy01 )

inlineprotected

Energy manager: Sets stored energy for this device between 0 and MAX based on relative input value between 0 and 1.

    {
        SetEnergy( Math.Lerp(0, GetEnergyMax(),energy01));
    }

Перекрестные ссылки GetEnergyMax(), Math::Lerp() и SetEnergy().

SetEnergyMaxPristine()

void SetEnergyMaxPristine ( float new_limit )

inlineprotected

Energy manager: Changes the maximum amount of energy this device can store (when pristine).

    {
        m_EnergyStorageMax = new_limit;
    }

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

SetEnergySource()

void SetEnergySource ( EntityAI source )

inlineprotected

    {   
        m_EnergySource = source;
        
        if (source)
        {
            m_IsPlugged = true;
            StartUpdates();
        }
        else
        {
            m_IsPlugged = false;
            m_EnergySourceNetworkIDLow = -1;
            m_EnergySourceNetworkIDHigh = -1;
        }
        
        if (m_EnergySource)
            m_EnergySource.GetNetworkID(m_EnergySourceNetworkIDLow, m_EnergySourceNetworkIDHigh);
        
        Synch();
    }

Перекрестные ссылки m_EnergySource, m_EnergySourceNetworkIDHigh, m_EnergySourceNetworkIDLow, m_IsPlugged, StartUpdates() и Synch().

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

SetEnergySourceClient()

void SetEnergySourceClient ( EntityAI source )

inlineprotected

    {   
        SetEnergySource(source);
    }

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

SetEnergyUsage()

void SetEnergyUsage ( float new_usage )

inlineprotected

Energy manager: Changes the energy usage per second.

    {
        m_EnergyUsage = new_usage;
    }

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

SetMySocketID()

void SetMySocketID ( int slot_ID )

inlineprotected

    {
        m_MySocketID = slot_ID;
    }

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

SetPassiveState()

void SetPassiveState ( bool state = true )

inlineprotected

Energy manager: Changes the status of this device. When it's passive (true), the main timer and OnWork events are not used.

    {
        m_IsPassiveDevice = state;
        if ( !m_IsPassiveDevice )
        {
            DeviceUpdate();
        }
    }

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

Используется в Entity::OnStoreLoad().

SetPlugOwner()

void SetPlugOwner ( string selection_name, EntityAI device )

inlineprotected

    {
        if ( m_DeviceByPlugSelection.Contains(selection_name) )
        {
            m_DeviceByPlugSelection.Set(selection_name, device);
        }
    }

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

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

SetPlugType()

void SetPlugType ( int new_type )

inlineprotected

    {
        m_PlugType = new_type;
    }

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

SetPowered()

void SetPowered ( bool state )

inlineprotected

    {
        m_IsWorking = state;
    }

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

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

SetUpdateInterval()

void SetUpdateInterval ( float value )

inlineprotected

Energy manager: Sets the interval of the OnWork(...) calls. Changing this value does not change the rate of energy consumption.

    {
        m_UpdateInterval = value;
    }

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

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

StartUpdates()

void StartUpdates ( )

inlineprotected

    {
        if (!m_IsPassiveDevice)
        {
            if (!m_UpdateTimer)
                m_UpdateTimer = new Timer(CALL_CATEGORY_SYSTEM);
            
            if (!m_UpdateTimer.IsRunning()) // Makes sure the timer is NOT running already
            {
                m_UpdateTimer.Run(GetUpdateInterval(), this, "DeviceUpdate", null, true);
            }
        }
    }

Перекрестные ссылки CALL_CATEGORY_SYSTEM, GetUpdateInterval(), m_IsPassiveDevice и m_UpdateTimer.

Используется в AddEnergy(), Entity::OnVariablesSynchronized(), SetEnergySource() и SwitchOn().

StopUpdates()

void StopUpdates ( )

inlineprotected

    {
        if (m_UpdateTimer)
        {
            m_UpdateTimer.Stop();
            m_UpdateTimer = NULL; // Delete timer from memory
        }
    }

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

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

StoreEnergySourceIDs()

void StoreEnergySourceIDs ( int b1, int b2, int b3, int b4 )

inlineprotected

    {
        m_EnergySourceStorageIDb1 = b1;
        m_EnergySourceStorageIDb2 = b2;
        m_EnergySourceStorageIDb3 = b3;
        m_EnergySourceStorageIDb4 = b4;
    }

Перекрестные ссылки m_EnergySourceStorageIDb1, m_EnergySourceStorageIDb2, m_EnergySourceStorageIDb3 и m_EnergySourceStorageIDb4.

Используется в Entity::OnStoreLoad().

SwitchOff()

void SwitchOff ( )

inlineprotected

Energy manager: Switches OFF the device.

    {
        m_IsSwichedOnPreviousState = m_IsSwichedOn;
        
        if (GetGame().IsServer() || !GetGame().IsMultiplayer())
        {
            if ( CanSwitchOff() )
            {
                m_IsSwichedOn = false;
                Synch();
                
                if ( IsWorking() )
                {
                    StopUpdates();
                    DeviceUpdate();
                }
                
                // 'Wakes up' all connected devices
                WakeUpWholeBranch( m_ThisEntityAI );
 
                UpdateCanWork();
                                
                // Call event
                GetGame().GameScript.CallFunction(m_ThisEntityAI, "OnSwitchOff", NULL, 0);
            }
        }
        
        if ( !GetGame().IsServer()  &&  GetGame().IsMultiplayer() )
        {
            m_IsSwichedOn = false;
            GetGame().GameScript.CallFunction(m_ThisEntityAI, "OnSwitchOff", NULL, 0);
        }
    }

Перекрестные ссылки CanSwitchOff(), DeviceUpdate(), GetGame(), IsWorking(), m_IsSwichedOn, m_IsSwichedOnPreviousState, Component::m_ThisEntityAI, StopUpdates(), Synch(), UpdateCanWork() и WakeUpWholeBranch().

Используется в DeviceUpdate(), HandleMoveInsideCargo(), OnDeviceDestroyed() и Entity::OnVariablesSynchronized().

SwitchOn()

void SwitchOn ( )

inlineprotected

Energy manager: Switches ON the device so it starts doing its work if it has enough energy.

    {
        m_IsSwichedOnPreviousState = m_IsSwichedOn;
        
        if (GetGame().IsServer() || !GetGame().IsMultiplayer())
        {
            if ( CanSwitchOn() )
            {
                m_IsSwichedOn = true;
                Synch();
                
                DeviceUpdate(); // 'Wake up' this device now
                StartUpdates();
                
                // 'Wakes up' all connected devices
                WakeUpWholeBranch( m_ThisEntityAI );
                
                UpdateCanWork();
                
                // Call event
                GetGame().GameScript.CallFunction(m_ThisEntityAI, "OnSwitchOn", NULL, 0);
            }
        }
        
        if ( !GetGame().IsServer()  &&  GetGame().IsMultiplayer()/*  &&  CanSwitchOn() */) // I want the CanSwitchOn() check, but when it's here, the OnSwitchOn() event is never called on client-side due to engine's synchronization system changing the m_IsSwichedOn to true without any specific event beign called. (Yes there is OnVariablesSynchronized() but that is called also when m_CanWork is synchronized, so I need to write a method of knowing when was this specific value changed.)
        {
            GetGame().GameScript.CallFunction(m_ThisEntityAI, "OnSwitchOn", NULL, 0);
        }
    }

Перекрестные ссылки CanSwitchOn(), DeviceUpdate(), GetGame(), m_IsSwichedOn, m_IsSwichedOnPreviousState, Component::m_ThisEntityAI, StartUpdates(), Synch(), UpdateCanWork() и WakeUpWholeBranch().

Используется в Event_OnAwake(), Entity::OnStoreLoad() и Entity::OnVariablesSynchronized().

Synch()

void Synch ( )

inlineprotected

    {
        m_ThisEntityAI.SetSynchDirty();
    }

Перекрестные ссылки Component::m_ThisEntityAI.

Используется в SetEnergySource(), SwitchOff(), SwitchOn() и UpdateCanWork().

UnplugAllDevices()

void UnplugAllDevices ( )

inlineprotected

Energy manager: Unplugs everything directly connected to this device.

    {
        if ( GetPluggedDevices() ) // This check is necesarry in case this function is called before initialization
        {
            int indexStart  = GetPluggedDevicesCount() - 1;
            for (int i = indexStart; i >= 0; --i)
            {
                UnplugDevice(GetPluggedDevices().Get(i));
            }
        }
    }

Перекрестные ссылки Get(), GetPluggedDevices(), GetPluggedDevicesCount() и UnplugDevice().

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

UnplugCordFromSocket()

void UnplugCordFromSocket ( int socket_to_unplug_ID )

inlineprotected

    {
        EntityAI plug_owner = GetDeviceBySocketID(socket_to_unplug_ID);
        
        if ( plug_owner )
        {
            SetDeviceBySocketID(socket_to_unplug_ID, NULL);
            string unplugged_selection = SOCKET_ + (socket_to_unplug_ID+1).ToString() + _AVAILABLE;
            m_ThisEntityAI.ShowSelection ( unplugged_selection );
            
            string plugged_selection = SOCKET_ + (socket_to_unplug_ID+1).ToString() + _PLUGGED;
            m_ThisEntityAI.HideSelection ( plugged_selection );
            SetPlugOwner( plugged_selection, NULL );
            plug_owner.GetCompEM().SetMySocketID(-1);
        }
    }

Перекрестные ссылки _AVAILABLE, _PLUGGED, GetDeviceBySocketID(), Component::m_ThisEntityAI, SetDeviceBySocketID(), SetPlugOwner(), SOCKET_ и ToString().

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

UnplugDevice()

void UnplugDevice ( EntityAI device_to_unplug )

inlineprotected

Energy manager: Unplugs the given device from this one.

    {
        if ( GetGame() )
        {
            int indexStart  = GetPluggedDevicesCount() - 1;
            bool deviceFound = false;
            
            for (int i = indexStart; i >= 0; --i)
            {
                EntityAI plugged_device = GetPluggedDevices().Get(i);
                
                if (plugged_device == device_to_unplug)
                {
                    GetPluggedDevices().Remove(i);
                    deviceFound = true;
                    break;
                }
            }
            
            if (deviceFound)
            {
                int socket_ID = device_to_unplug.GetCompEM().GetMySocketID();
                UnplugCordFromSocket(socket_ID);
                device_to_unplug.GetCompEM().SetEnergySource(null);
                device_to_unplug.GetCompEM().DeviceUpdate();
                device_to_unplug.GetCompEM().StartUpdates();
                device_to_unplug.GetCompEM().WakeUpWholeBranch(m_ThisEntityAI);
                
                if (m_DebugPlugs && m_DebugPlugArrow)
                {
                    m_DebugPlugArrow.Destroy();
                    m_DebugPlugArrow = null;
                }
                
                OnOwnSocketReleased(device_to_unplug);
                device_to_unplug.GetCompEM().OnIsUnplugged(m_ThisEntityAI);
                device_to_unplug.ShowSelection(SEL_CORD_FOLDED);
                device_to_unplug.HideSelection(SEL_CORD_PLUGGED);
            }
        }
    }

Перекрестные ссылки GetGame(), GetPluggedDevices(), GetPluggedDevicesCount(), m_DebugPlugArrow, m_DebugPlugs, Component::m_ThisEntityAI, OnOwnSocketReleased(), SEL_CORD_FOLDED, SEL_CORD_PLUGGED и UnplugCordFromSocket().

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

UnplugThis()

void UnplugThis ( )

inlineprotected

Energy manager: Unplugs this device from its power source.

    {
        if (GetGame())
        {
            if (GetEnergySource())
            {
                GetEnergySource().GetCompEM().UnplugDevice(m_ThisEntityAI);
            }
        }
    }

Перекрестные ссылки GetEnergySource(), GetGame() и Component::m_ThisEntityAI.

Используется в OnAttachmentRemoved(), OnDeviceDestroyed(), Entity::OnVariablesSynchronized() и UpdatePlugState().

UpdateCanWork()

void UpdateCanWork ( )

inlineprotected

    {
        if (GetGame().IsServer() || !GetGame().IsMultiplayer())
        {
            bool current_state = CanWork();
            
            if (current_state != m_CanWork)
            {
                m_CanWork = current_state;
                Synch();
                
                if ( m_ThisEntityAI && m_ThisEntityAI.GetHierarchyParent() && m_ThisEntityAI.GetHierarchyParent().GetCompEM() )
                {
                    m_ThisEntityAI.GetHierarchyParent().GetCompEM().UpdateCanWork();
                }
            }
        }
    }

Перекрестные ссылки CanWork(), GetGame(), m_CanWork, Component::m_ThisEntityAI и Synch().

Используется в DeviceUpdate(), OnIsPlugged(), OnIsUnplugged(), SetEnergy(), SwitchOff() и SwitchOn().

UpdatePlugState()

void UpdatePlugState ( )

inlineprotected

Energy manager: Unplugs this device when it's necesarry.

    {
        if (m_ThisEntityAI.GetCompEM().GetEnergySource())
        {
            EntityAI player = m_ThisEntityAI.GetHierarchyRootPlayer();
            // Check if the item is held in hands during advanced placement
            if (player)
            {
                // Measure distance from the player
                vector playerPosition = player.GetPosition();
                if (!IsEnergySourceAtReach(playerPosition, 5))
                    UnplugThis();
            }
            else
            {
                // Measure distance from the device
                vector itemPosition = m_ThisEntityAI.GetPosition();
                
                if (m_ThisEntityAI.GetHierarchyParent())
                    itemPosition = m_ThisEntityAI.GetHierarchyParent().GetPosition();
                
                if (!IsEnergySourceAtReach(itemPosition))
                    UnplugThis();
            }
        }
    }

Перекрестные ссылки IsEnergySourceAtReach(), Component::m_ThisEntityAI и UnplugThis().

UpdateSelections()

void UpdateSelections ( )

inlineprotected

Energy manager: Shows/Hides all selections this system works with. Call this if something is wrong with selections (like during Init and Restore event in config)

    {
        // Lets update sockets, if there are any
        int slots_c = GetSocketsCount();
        
        for ( int i = 0; i < slots_c; ++i )
        {
            EntityAI plug_owner = GetDeviceBySocketID(i);
            
            if ( plug_owner )
            {
                string plugged_selection = SOCKET_ + (i+1).ToString() + _PLUGGED;
                string available_selection = SOCKET_ + (i+1).ToString() + _AVAILABLE;
                m_ThisEntityAI.ShowSelection ( plugged_selection );
                m_ThisEntityAI.HideSelection ( available_selection );
                string texture_path = plug_owner.GetCompEM().GetCordTextureFile();
                int selection_index = m_ThisEntityAI.GetHiddenSelectionIndex( plugged_selection );
                m_ThisEntityAI.SetObjectTexture(selection_index, texture_path );
            }
            else
            {
                m_ThisEntityAI.ShowSelection ( SOCKET_ + (i+1).ToString() + _AVAILABLE );
                m_ThisEntityAI.HideSelection ( SOCKET_ + (i+1).ToString() + _PLUGGED );
            }
        }
        
        // Now lets update the cord/plug state
        if ( GetEnergySource() )
        {
            m_ThisEntityAI.ShowSelection ( SEL_CORD_PLUGGED );
            m_ThisEntityAI.HideSelection ( SEL_CORD_FOLDED );
        }
        else
        {
            m_ThisEntityAI.ShowSelection ( SEL_CORD_FOLDED );
            m_ThisEntityAI.HideSelection ( SEL_CORD_PLUGGED );
        }
    }

Перекрестные ссылки _AVAILABLE, _PLUGGED, GetDeviceBySocketID(), GetEnergySource(), GetSocketsCount(), Component::m_ThisEntityAI, SEL_CORD_FOLDED, SEL_CORD_PLUGGED, SOCKET_ и ToString().

UpdateSocketSelections()

void UpdateSocketSelections ( int socket_id, EntityAI device_to_plug )

inlineprotected

    {
        SetDeviceBySocketID(socket_id, device_to_plug);
        
        string plugged_selection = SOCKET_ + (socket_id+1).ToString() + _PLUGGED;
        SetPlugOwner( plugged_selection, device_to_plug );
        m_ThisEntityAI.ShowSelection ( plugged_selection );
        
        string unplugged_selection = SOCKET_ + (socket_id+1).ToString() + _AVAILABLE;
        m_ThisEntityAI.HideSelection ( unplugged_selection );
        string texture_path = device_to_plug.GetCompEM().GetCordTextureFile();
        int selection_index = m_ThisEntityAI.GetHiddenSelectionIndex( plugged_selection );
        m_ThisEntityAI.SetObjectTexture( selection_index, texture_path );
        device_to_plug.GetCompEM().SetMySocketID(socket_id);
    }

Перекрестные ссылки _AVAILABLE, _PLUGGED, Component::m_ThisEntityAI, SetDeviceBySocketID(), SetPlugOwner(), SOCKET_ и ToString().

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

WakeUpWholeBranch()

void WakeUpWholeBranch ( EntityAI original_caller )

inlineprotected

    {
        if ( GetSocketsCount() > 0 )
        {
            array<EntityAI> plugged_devices = GetPluggedDevices();
            int plugged_devices_c = plugged_devices.Count();
            
            for ( int i = 0; i < plugged_devices_c; ++i )
            {
                EntityAI device = plugged_devices.Get(i);
                if ( device != original_caller ) // original_caller check here prevents infinite loops
                {
                    device.GetCompEM().UpdateCanWork();
                    device.GetCompEM().DeviceUpdate();
                    device.GetCompEM().StartUpdates();
                    device.GetCompEM().WakeUpWholeBranch( original_caller );
                }
            }
        }
    }

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

Используется в DeviceUpdate(), PlugInDevice(), SwitchOff() и SwitchOn().

Поля

_AVAILABLE

const string _AVAILABLE = "_available"

staticprotected

Используется в UnplugCordFromSocket(), UpdateSelections() и UpdateSocketSelections().

_PLUGGED

const string _PLUGGED = "_plugged"

staticprotected

Используется в Event_OnAwake(), IsSelectionAPlug(), UnplugCordFromSocket(), UpdateSelections() и UpdateSocketSelections().

DEFAULT_UPDATE_INTERVAL

const float DEFAULT_UPDATE_INTERVAL = 15

protected

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

m_AttachmentActionType

int m_AttachmentActionType

protected

Используется в Event_OnAwake(), GetAttachmentAction() и SetAttachmentAction().

m_AutoSwitchOff

bool m_AutoSwitchOff

protected

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

m_AutoSwitchOffWhenInCargo

bool m_AutoSwitchOffWhenInCargo

protected

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

m_CanStopWork

bool m_CanStopWork

protected

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

m_CanWork

bool m_CanWork

protected

Используется в CanWork(), DeviceUpdate(), Event_OnAwake() и UpdateCanWork().

m_CompatiblePlugTypes

ref TIntArray m_CompatiblePlugTypes

protected

Используется в Event_OnAwake(), GetCompatiblePlugTypes() и IsPlugCompatible().

m_ConvertEnergyToQuantity

bool m_ConvertEnergyToQuantity

protected

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

m_CordLength

float m_CordLength

protected

Используется в Event_OnAwake(), GetCordLength() и SetCordLength().

m_CordTextureFile

string m_CordTextureFile

protected

Используется в Event_OnAwake(), GetCordTextureFile() и SetCordTextureFile().

m_DebugPlugArrow

Shape m_DebugPlugArrow

protected

Используется в DebugUpdate(), RefreshDebug(), UnplugDevice() и ~ComponentEnergyManager().

m_DebugPlugs

bool m_DebugPlugs = false

staticprotected

Используется в ComponentEnergyManager(), GetDebugPlugs(), OnIsPlugged(), RefreshDebug(), SetDebugPlugs() и UnplugDevice().

m_DebugUpdate

ref Timer m_DebugUpdate

protected

Используется в DebugUpdate(), OnIsPlugged() и RefreshDebug().

m_DeviceByPlugSelection

ref map<string,EntityAI> m_DeviceByPlugSelection

protected

Используется в Event_OnAwake(), GetPlugOwner() и SetPlugOwner().

m_Energy

float m_Energy

protected

Используется в Event_OnAwake(), GetEnergy(), GetEnergy0To1(), GetEnergy0To100() и SetEnergy().

m_EnergyAtSpawn

float m_EnergyAtSpawn

protected

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

m_EnergySource

EntityAI m_EnergySource

protected

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

m_EnergySourceNetworkIDHigh

int m_EnergySourceNetworkIDHigh = -1

protected

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

m_EnergySourceNetworkIDLow

int m_EnergySourceNetworkIDLow = -1

protected

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

m_EnergySourceStorageIDb1

int m_EnergySourceStorageIDb1

protected

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

m_EnergySourceStorageIDb2

int m_EnergySourceStorageIDb2

protected

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

m_EnergySourceStorageIDb3

int m_EnergySourceStorageIDb3

protected

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

m_EnergySourceStorageIDb4

int m_EnergySourceStorageIDb4

protected

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

m_EnergyStorageMax

float m_EnergyStorageMax

protected

Используется в Event_OnAwake(), GetEnergy0To1(), GetEnergy0To100(), GetEnergyMaxPristine() и SetEnergyMaxPristine().

m_EnergyUsage

float m_EnergyUsage

protected

Используется в Event_OnAwake(), GetEnergyUsage(), ResetEnergyUsage() и SetEnergyUsage().

m_HasElectricityIcon

bool m_HasElectricityIcon

protected

Используется в Event_OnAwake(), HasElectricityIcon() и SetElectricityIconVisibility().

m_IsPassiveDevice

bool m_IsPassiveDevice

protected

Используется в DeviceUpdate(), Event_OnAwake(), IsPassive(), SetPassiveState() и StartUpdates().

m_IsPlugged

bool m_IsPlugged

protected

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

m_IsSwichedOn

bool m_IsSwichedOn

protected

Используется в IsSwitchedOn(), SwitchOff() и SwitchOn().

m_IsSwichedOnPreviousState

bool m_IsSwichedOnPreviousState

protected

Используется в GetPreviousSwitchState(), SwitchOff() и SwitchOn().

m_IsWorking

bool m_IsWorking

protected

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

m_LastUpdateTime

float m_LastUpdateTime

protected

Используется в ClearLastUpdateTime(), DeviceUpdate() и RememberLastUpdateTime().

m_MySocketID

int m_MySocketID = -1

protected

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

m_PluggedDevices

ref array<EntityAI> m_PluggedDevices

protected

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

m_PlugType

int m_PlugType

protected

Используется в Event_OnAwake(), GetPlugType() и SetPlugType().

m_ReduceMaxEnergyByDamageCoef

float m_ReduceMaxEnergyByDamageCoef

protected

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

m_RestorePlugState

bool m_RestorePlugState

protected

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

m_ShowSocketsInInventory

bool m_ShowSocketsInInventory

protected

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

m_Sockets

EntityAI m_Sockets[MAX_SOCKETS_COUNT]

protected

Используется в Event_OnAwake(), GetDeviceBySocketID() и SetDeviceBySocketID().

m_SocketsCount

float m_SocketsCount

protected

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

m_UpdateInterval

float m_UpdateInterval

protected

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

m_UpdateQuantityTimer

ref Timer m_UpdateQuantityTimer

protected

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

m_UpdateTimer

ref Timer m_UpdateTimer

protected

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

m_WetnessExposure

float m_WetnessExposure

protected

Используется в CheckWetness(), Event_OnAwake() и GetWetnessExposure().

MAX_SOCKETS_COUNT

const int MAX_SOCKETS_COUNT = 4

protected

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

SEL_CORD_FOLDED

const string SEL_CORD_FOLDED = "cord_folded"

staticprotected

Используется в PlugInDevice(), UnplugDevice() и UpdateSelections().

SEL_CORD_PLUGGED

const string SEL_CORD_PLUGGED = "cord_plugged"

staticprotected

Используется в ActionUnplugThisByCord::ActionCondition(), Event_OnAwake(), PlugInDevice(), UnplugDevice() и UpdateSelections().

SOCKET_

const string SOCKET_ = "socket_"

staticprotected

Используется в Event_OnAwake(), IsSelectionAPlug(), UnplugCordFromSocket(), UpdateSelections() и UpdateSocketSelections().

---

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

• D:/Ishodniki/scripts/3_Game/tools/Component/ComponentEnergyManager.c