ComponentEnergyManager.c

См. документацию.

//-----------------------------
// ENERGY MANAGER
//-----------------------------
/*
Author: Boris Vacula
 
Documentation can be found at DayZ Confluence >> Camping & Squatting >> Electricity >> Energy Manager functionalities
 
This system controls storage, spending and sharing of energy between instances.
 
Every EntityAI object which uses this API gains these functions:
    -It can store some amout of energy
    -It can use this amount of energy for any kind of functionality
    -It can share this energy with other devices plugged into it
    -It will have an ON/OFF switch
*/
 
class ComponentEnergyManager : Component
{
    protected const  float DEFAULT_UPDATE_INTERVAL = 15;
    protected static bool           m_DebugPlugs = false; //true; // Use this to toggle visualisation of plug connections
    protected       Shape          m_DebugPlugArrow;
    
    protected       bool            m_IsSwichedOn;
    protected       bool            m_IsSwichedOnPreviousState; // Necesarry due to synchronization of m_IsSwichedOn
    protected       bool            m_IsPassiveDevice;
    protected       bool            m_IsWorking;
    protected       bool            m_CanWork;
    protected       bool            m_CanStopWork;
    protected       bool            m_RestorePlugState; // After server restart, this value reports if this device was plugged into something or not at the end of last session.
    protected       bool            m_AutoSwitchOff;
    protected       bool            m_ShowSocketsInInventory;
    protected       bool            m_HasElectricityIcon; // Electricity icon over the item in inventory
    protected       bool            m_AutoSwitchOffWhenInCargo;
    protected       bool            m_IsPlugged; // Synchronized variable
    protected       bool            m_ConvertEnergyToQuantity;
    
    protected       int             m_MySocketID = -1;
    protected       int             m_PlugType;
    protected       int             m_EnergySourceStorageIDb1; // Storage persistence ID
    protected       int             m_EnergySourceStorageIDb2; // Storage persistence ID
    protected       int             m_EnergySourceStorageIDb3; // Storage persistence ID
    protected       int             m_EnergySourceStorageIDb4; // Storage persistence ID
    protected       int             m_AttachmentActionType;
    protected       int             m_EnergySourceNetworkIDLow = -1;  // Network ID
    protected       int             m_EnergySourceNetworkIDHigh = -1; // Network ID
    
    protected       float           m_EnergyUsage;
    protected       float           m_Energy;
    protected       float           m_EnergyAtSpawn;
    protected       float           m_EnergyStorageMax;
    protected       float           m_ReduceMaxEnergyByDamageCoef;
    protected       float           m_SocketsCount;
    protected       float           m_CordLength;
    protected       float           m_LastUpdateTime;
    protected       float           m_WetnessExposure;
    protected       float           m_UpdateInterval; // Interval of OnWork(...) calls and device updates.
    
    protected       string          m_CordTextureFile;
    
    // Concatenated strings for p3d selections
    protected static const string   SOCKET_          = "socket_";
    protected static const string   _PLUGGED            = "_plugged";
    protected static const string   _AVAILABLE            = "_available";
    static const string             SEL_CORD_PLUGGED    = "cord_plugged";
    static const string             SEL_CORD_FOLDED      = "cord_folded";
    
    protected ref TIntArray            m_CompatiblePlugTypes;
    EntityAI                        m_EnergySource; // Energy source can be any EntityAI object
    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];
    
    
 
    // Constructor
    void ComponentEnergyManager()
    {
        // Disable debug arrows on public release, so that they don't use their timers.
        #ifndef DEVELOPER
        m_DebugPlugs = false;
        #endif
    }
    
    void ~ComponentEnergyManager()
    {
        if (m_DebugPlugArrow)
        {
            m_DebugPlugArrow.Destroy();
            m_DebugPlugArrow = NULL; 
        }
    }
 
    // Initialization. Energy Manager is ready.
    override void Event_OnInit()
    {
        if (!m_ThisEntityAI)
            return;
        
        m_ThisEntityAI.m_EM = this;
        g_Game.GameScript.CallFunction(m_ThisEntityAI, "OnInitEnergy", NULL, 0);
    }
    
    // Update debug arrows
    void DebugUpdate()
    {
        if ( GetDebugPlugs() )
        {
            if ( g_Game.IsMultiplayer()  &&  g_Game.IsServer() )
            {
                if (m_DebugUpdate)
                    m_DebugUpdate.Stop();
                
                return;
            }
        
            if (m_DebugPlugArrow)
            {
                m_DebugPlugArrow.Destroy();
                m_DebugPlugArrow = NULL; 
            }
            
            if (GetEnergySource() && m_ThisEntityAI)
            {
                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 );
            }
        }
    }
    
    Shape DrawArrow(vector from, vector to, float size = 0.5, int color = 0xFFFFFFFF, float flags = 0)
    {
        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);
    }
 
    EntityAI GetThisEntityAI()
    {
        return m_ThisEntityAI;
    }
    
    // Prepare everything
    override void Event_OnAwake()
    {
        if (!m_ThisEntityAI)
            return;
        
        string cfg_item = "CfgVehicles " + m_ThisEntityAI.GetType();
        string cfg_energy_manager = cfg_item + " EnergyManager ";
        
        // Read all config parameters
        m_EnergyUsage                  = g_Game.ConfigGetFloat(cfg_energy_manager + "energyUsagePerSecond");
        bool switch_on                  = g_Game.ConfigGetFloat(cfg_energy_manager + "switchOnAtSpawn");
        m_AutoSwitchOff                  = g_Game.ConfigGetFloat(cfg_energy_manager + "autoSwitchOff");
        m_HasElectricityIcon            = g_Game.ConfigGetFloat(cfg_energy_manager + "hasIcon");
        m_AutoSwitchOffWhenInCargo        = g_Game.ConfigGetFloat(cfg_energy_manager + "autoSwitchOffWhenInCargo");
        
        m_EnergyAtSpawn                  = g_Game.ConfigGetFloat(cfg_energy_manager + "energyAtSpawn");
        m_Energy = m_EnergyAtSpawn;
        m_EnergyStorageMax                = g_Game.ConfigGetFloat(cfg_energy_manager + "energyStorageMax");
        m_ReduceMaxEnergyByDamageCoef  = g_Game.ConfigGetFloat(cfg_energy_manager + "reduceMaxEnergyByDamageCoef");
        m_SocketsCount                    = g_Game.ConfigGetFloat(cfg_energy_manager + "powerSocketsCount");
        
        m_IsPassiveDevice              = g_Game.ConfigGetFloat(cfg_energy_manager + "isPassiveDevice");
        m_CordLength                    = g_Game.ConfigGetFloat(cfg_energy_manager + "cordLength");
        m_PlugType                        = g_Game.ConfigGetFloat(cfg_energy_manager + "plugType");
        
        m_AttachmentActionType            = g_Game.ConfigGetFloat(cfg_energy_manager + "attachmentAction");
        m_WetnessExposure              = g_Game.ConfigGetFloat(cfg_energy_manager + "wetnessExposure");
        
        float update_interval           = g_Game.ConfigGetFloat(cfg_energy_manager + "updateInterval");
        
        m_ConvertEnergyToQuantity      = g_Game.ConfigGetFloat(cfg_energy_manager + "convertEnergyToQuantity");
        
        
        // Check if energy->quantity converion is configured properly
        float cfg_max_quantity = g_Game.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 ( !g_Game.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 ( g_Game.ConfigIsExisting (cfg_check_plug_types) )
        {
            m_CompatiblePlugTypes = new TIntArray;
            g_Game.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 = g_Game.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;
                g_Game.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.
        
        g_Game.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
        g_Game.m_EnergyManagerArray.Insert( this );
        #endif
    }
 
    // Returns the type of this component
    override int GetCompType()
    {
        return COMP_TYPE_ENERGY_MANAGER;
    }
    
    // When the object is deleted
    void OnDeviceDestroyed()
    {
        if (!m_ThisEntityAI)
            return;
        
        bool was_working = m_ThisEntityAI.GetCompEM().IsWorking();
        
        SwitchOff();
        UnplugAllDevices();
        UnplugThis();
        SetPowered( false );
        
        if ( was_working )
            m_ThisEntityAI.OnWorkStop();
        ;
    }
    
    //Restart the debug timer when relogging
    void RefreshDebug()
    {
        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; 
            }
        }
    }
    
    bool GetDebugPlugs()
    {
        return m_DebugPlugs;
    }
    
    void SetDebugPlugs( bool newVal )
    {
        m_DebugPlugs = newVal;
        RefreshDebug();
    }
 
    //======================================================================================
    //                                   PUBLIC FUNCTIONS
    //                      Use these to control the Energy Manager
    // Functions are in order of their return value: void, bool, int, float, string, array.
    //======================================================================================

    void SwitchOn()
    {
        m_IsSwichedOnPreviousState = m_IsSwichedOn;
        
        if (g_Game.IsServer() || !g_Game.IsMultiplayer())
        {
            if (CanSwitchOn() && m_ThisEntityAI)
            {
                m_IsSwichedOn = true;
                Synch();
                
                DeviceUpdate(); // 'Wake up' this device now
                StartUpdates();
                
                // 'Wakes up' all connected devices
                WakeUpWholeBranch(m_ThisEntityAI);
                
                UpdateCanWork();
                
                // Call event
                g_Game.GameScript.CallFunction(m_ThisEntityAI, "OnSwitchOn", NULL, 0);
            }
        }
        
        if ( !g_Game.IsServer()  &&  g_Game.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.)
        {
            g_Game.GameScript.CallFunction(m_ThisEntityAI, "OnSwitchOn", NULL, 0);
        }
    }

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

    void SetPassiveState(bool state = true)
    {
        m_IsPassiveDevice = state;
        if ( !m_IsPassiveDevice )
        {
            DeviceUpdate();
        }
    }

    void UnplugDevice(EntityAI device_to_unplug)
    {
        if (g_Game)
        {
            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 && m_ThisEntityAI)
            {
                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);
            }
        }
    }

    void UnplugThis()
    {
        if (g_Game)
        {
            if (GetEnergySource() && m_ThisEntityAI)
            {
                GetEnergySource().GetCompEM().UnplugDevice(m_ThisEntityAI);
            }
        }
    }
    
    void UnplugAllDevices()
    {
        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));
            }
        }
    }
    
    // Used only for storing of the plug's state through server restart
    void RestorePlugState(bool state)
    {
        m_RestorePlugState = state;
    }

    void SetEnergy(float new_energy)
    {
        if (m_ThisEntityAI && (g_Game.IsServer() || !g_Game.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();
            }
        }
    }
    
    void SetEnergy0To1(float energy01)
    {
        SetEnergy( Math.Lerp(0, GetEnergyMax(),energy01));
    }

    void UpdateSelections()
    {
        if (!m_ThisEntityAI)
            return;
        
        // 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);
        }
    }

    void UpdatePlugState()
    {
        if (m_ThisEntityAI && 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();
            }
        }
    }
 
    // Returns an array of plug types this device can accept
    void GetCompatiblePlugTypes(out TIntArray IDs)
    {
        IDs = m_CompatiblePlugTypes;
    }
 
    // Stores IDs of the energy source.
    void StoreEnergySourceIDs(int b1, int b2, int b3, int b4)
    {
        m_EnergySourceStorageIDb1 = b1;
        m_EnergySourceStorageIDb2 = b2;
        m_EnergySourceStorageIDb3 = b3;
        m_EnergySourceStorageIDb4 = b4;
    }
    
    void SetEnergyMaxPristine(float new_limit)
    {
        m_EnergyStorageMax = new_limit;
    }
    
    void SetCordLength( float new_length )
    {
        m_CordLength = new_length;
    }
    
    // Sets the plug type (for plug -> socket compatibility checks).
    void SetPlugType( int new_type )
    {
        m_PlugType = new_type;
    }
    
    // Sets the new attachment action type.
    void SetAttachmentAction( int new_action_type )
    {
        m_AttachmentActionType = new_action_type;
    }
    
    void SetEnergyUsage( float new_usage )
    {
        m_EnergyUsage = new_usage;
    }
    
    void ResetEnergyUsage()
    {
        if (!m_ThisEntityAI)
            return;
        
        string cfg_energy_usage = "CfgVehicles " + m_ThisEntityAI.GetType() + " EnergyManager ";
        m_EnergyUsage = g_Game.ConfigGetFloat (cfg_energy_usage + "energyUsagePerSecond");
    }
    
    // Sets path to the cord texture file.
    void SetCordTextureFile( string new_path )
    {
        m_CordTextureFile = new_path;
    }
    
    // Sets energy source. Intended to be called only on client through RPC.
    void SetEnergySourceClient( EntityAI source )
    {   
        SetEnergySource(source);
    }
    
    void SetDeviceBySocketID(int id, EntityAI plugged_device)
    {
        m_Sockets[id] = plugged_device;
    }
    
        
    void SetElectricityIconVisibility( bool make_visible )
    {
        m_HasElectricityIcon = make_visible;
    }
    
    // Checks whenever this device can work or not and updates this information on all clients. Can be called many times per frame because synchronization happens only once if a change has occured.
    void UpdateCanWork()
    {
        if (g_Game.IsServer() || !g_Game.IsMultiplayer())
        {
            bool current_state = CanWork();
            if (current_state != m_CanWork)
            {
                m_CanWork = current_state;
 
                if (m_ThisEntityAI)
                {
                    Synch();
                    if (m_ThisEntityAI.GetHierarchyParent() && m_ThisEntityAI.GetHierarchyParent().GetCompEM())
                    {
                        m_ThisEntityAI.GetHierarchyParent().GetCompEM().UpdateCanWork();
                    }
                }
            }
        }
    }
    
    void HandleMoveInsideCargo(EntityAI container)
    {
        if ( m_AutoSwitchOffWhenInCargo )
        {
            if (IsSwitchedOn())
            {
                SwitchOff();
            }
        }
    }
    
    void SetUpdateInterval( float value )
    {
        m_UpdateInterval = value;
    }
    
    // Returns true if this device was plugged into something at the end of previous session
    bool GetRestorePlugState()
    {
        return m_RestorePlugState;
    }
    
    bool PlugThisInto(EntityAI energy_source, int socket_id = -1)
    {
        if (m_ThisEntityAI)
        {
            return energy_source.GetCompEM().PlugInDevice(m_ThisEntityAI, socket_id);
        }
        else
        {
            return false;
        }
    }
    
    bool CanSwitchOn()
    {
        if ( !IsSwitchedOn() )
        {
            return true;
        }
        
        return false;
    }
 
    
    bool CanWork( float test_energy = -1)
    {
        if ( g_Game.IsMultiplayer()  &&  g_Game.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;
    }

    bool CheckWetness()
    {
        if (m_ThisEntityAI)
        {
            return (m_ThisEntityAI.GetWet() <= 1-m_WetnessExposure);
        }
        else
        {
            return false;
        }
    }
    
    bool CanSwitchOff()
    {
        if ( IsPassive() )
        {
            return false;
        }
        
        return IsSwitchedOn();
    }
 
    // Returns previous state of the switch.
    bool GetPreviousSwitchState()
    {
        return m_IsSwichedOnPreviousState;
    }
    
    bool IsSwitchedOn()
    {
        return m_IsSwichedOn;
    }

    bool IsCordFolded()
    {
        if ( IsPlugged() )
            return false;
        
        return true;
    }
    
    bool IsPassive()
    {
        return m_IsPassiveDevice;
    }

    bool IsPlugged()
    {
        return m_IsPlugged;
    }
    
    
    bool ConsumeEnergy(float amount)
    {
        if (m_ThisEntityAI)
        {
            return FindAndConsumeEnergy(m_ThisEntityAI, amount, true);
        }
        else
        {
            return false;
        }
    }

    bool IsWorking()
    {
        return m_IsWorking;
    }

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

    bool HasFreeSocket( int socket_id = -1 )
    {
        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;
            }
        }
    }

    bool IsPlugCompatible(int plug_ID)
    {
        if ( plug_ID == PLUG_UNDEFINED )
        {
            return true; // When plugType is undefined in config then make it compatible.
        }
        
        if ( m_CompatiblePlugTypes )
        {
            int nCompatiblePlugTypes = m_CompatiblePlugTypes.Count();
            for ( int i = 0; i < nCompatiblePlugTypes; ++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;
    }
    
    bool CanReceivePlugFrom( EntityAI device_to_plug )
    {
        // The following conditions are broken down for the sake of easier reading/debugging.
        if (m_ThisEntityAI && 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;
    }
    
    bool CanBePluggedInto( EntityAI potential_energy_provider )
    {
        if (m_ThisEntityAI)
        {
            return potential_energy_provider.GetCompEM().CanReceivePlugFrom(m_ThisEntityAI);
        }
        else
        {
            return false;
        }
    }
    
    bool HasElectricityIcon()
    {
        return m_HasElectricityIcon;
    }
    
    bool HasConversionOfEnergyToQuantity()
    {
        return m_ConvertEnergyToQuantity;
    }

    bool IsEnergySourceAtReach( vector from_position, float add_tolerance = 0, vector override_source_position = "-1 -1 -1" )
    {
        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;
        }
    }
    
    bool HasVisibleSocketsInInventory()
    {
        return m_ShowSocketsInInventory;
    }
    
    bool IsSelectionAPlug(string selection_to_test )
    {
        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;
    }
    
    
    
    
    int GetSocketsCount()
    {
        return m_SocketsCount;
    }

    int GetPlugType()
    {
        return m_PlugType;
    }
 
    // Returns the action ID which is supposed to be done upon receiving an attachment
    int GetAttachmentAction()
    {
        return m_AttachmentActionType;
    }
 
    // Returns persistent ID (block 1) of the energy source
    int GetEnergySourceStorageIDb1()
    {
        return m_EnergySourceStorageIDb1;
    }
 
    // Returns persistent ID (block 2) of the energy source
    int GetEnergySourceStorageIDb2()
    {
        return m_EnergySourceStorageIDb2;
    }
    
    // Returns persistent ID (block 3) of the energy source
    int GetEnergySourceStorageIDb3()
    {
        return m_EnergySourceStorageIDb3;
    }
    
    // Returns persistent ID (block 4) of the energy source
    int GetEnergySourceStorageIDb4()
    {
        return m_EnergySourceStorageIDb4;
    }
    
    // Returns network ID (low) of the energy source
    int GetEnergySourceNetworkIDLow()
    {
        return m_EnergySourceNetworkIDLow;
    }
 
    // Returns network ID (high) of the energy source
    int GetEnergySourceNetworkIDHigh()
    {
        return m_EnergySourceNetworkIDHigh;
    }
    
    int GetPluggedDevicesCount()
    {
        if ( GetPluggedDevices() )
        {
            return GetPluggedDevices().Count();
        }
        
        return 0;
    }
    
    int GetEnergy0To100()
    {
        if ( m_EnergyStorageMax > 0 )
        {
            int coef = Math.Round( m_Energy / m_EnergyStorageMax * 100 );
            return coef;
        }
        
        return 0;
    }
    
    float GetEnergy0To1()
    {
        if ( m_EnergyStorageMax > 0 )
        {
            return m_Energy / m_EnergyStorageMax;
        }
        
        return 0;
    }
    
    float GetUpdateInterval()
    {
        #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;
    }
    
    float GetWetnessExposure()
    {
        return m_WetnessExposure;
    }
    
    float GetEnergyUsage()
    {
        return m_EnergyUsage;
    }

    float GetEnergy()
    {
        return m_Energy;
    }

    float AddEnergy(float added_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;
    }
    
    float GetEnergyMax()
    {
        float max_health = 0;
        
        if (m_ThisEntityAI && 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 (m_ThisEntityAI && (g_Game.IsServer() || !g_Game.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 ) );
    }
    
    float GetEnergyMaxPristine()
    {
        return m_EnergyStorageMax;
    }
    
    float GetEnergyAtSpawn()
    {
        return m_EnergyAtSpawn;
    }
    
    float GetCordLength()
    {
        return m_CordLength;
    }

    EntityAI GetEnergySource()
    {
        return m_EnergySource;
    }
    
    EntityAI GetDeviceBySocketID(int id)
    {
        return m_Sockets[id];
    }

    EntityAI GetPlugOwner(string plug_selection_name)
    {
        if ( m_DeviceByPlugSelection && m_DeviceByPlugSelection.Contains(plug_selection_name) )
        {
            return m_DeviceByPlugSelection.Get(plug_selection_name);
        }
        
        return NULL;
    }
    
    EntityAI GetPluggedDevice()
    {
        if ( GetPluggedDevicesCount() > 0 )
        {
            return GetPluggedDevices().Get(0);
        }
        
        return NULL;
    }
    
    string GetCordTextureFile()
    {
        return m_CordTextureFile;
    }

    array<EntityAI> GetPluggedDevices()
    {
        return m_PluggedDevices;
    }

    array<EntityAI> GetPoweredDevices()
    {
        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;
    }
    
    
    /*===================================
                PUBLIC EVENTS
    ===================================*/
 
    // Called every device update if its supposed to do some work. The update can be every second or at random, depending on its manipulation.
    void OnWork( float consumed_energy ) 
    {
        if (m_ThisEntityAI)
            m_ThisEntityAI.OnWork(consumed_energy);
    }
 
    // Called when this device is plugged into some energy source
    void OnIsPlugged(EntityAI source_device) 
    {
        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();
        if (m_ThisEntityAI)
            m_ThisEntityAI.OnIsPlugged(source_device);
    }
 
    // Called when this device is UNPLUGGED from the energy source
    void OnIsUnplugged( EntityAI last_energy_source ) 
    {
        UpdateCanWork();
        if (m_ThisEntityAI)
            m_ThisEntityAI.OnIsUnplugged( last_energy_source );
    }
 
    // When something is plugged into this device
    void OnOwnSocketTaken( EntityAI device ) 
    {
        if (!m_ThisEntityAI)
            return;
 
        //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);
    }
 
    // When something is UNPLUGGED from this device
    void OnOwnSocketReleased( EntityAI device ) 
    {
        if (!m_ThisEntityAI)
            return;
        
        //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 );
    }
    
    
    // Handles automatic attachment action
    void OnAttachmentAdded(EntityAI elec_device)
    {
        if (!m_ThisEntityAI)
            return;
        
        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);
        }
    }
 
    // Handles automatic detachment action
    void OnAttachmentRemoved(EntityAI elec_device)
    {
        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();
        }
    }
 
    // Starts the device's main cycle
    void StartUpdates()
    {
        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);
            }
        }
    }
    
    void OnEnergyConsumed()
    {
        if (m_ThisEntityAI)
            m_ThisEntityAI.OnEnergyConsumed();
    }
    
    void OnEnergyAdded()
    {
        if (m_UpdateQuantityTimer)
        {
            m_UpdateQuantityTimer.Stop();
            m_UpdateQuantityTimer = NULL;
        }
        
        if (m_ThisEntityAI)
            m_ThisEntityAI.OnEnergyAdded();
    }
 
 
    /*===================================
             PROTECTED FUNCTIONS
    ===================================*/
 
    // Stops the device's main cycle
    protected void StopUpdates()
    {
        if (m_UpdateTimer)
        {
            m_UpdateTimer.Stop();
            m_UpdateTimer = NULL; // Delete timer from memory
        }
    }

    void InteractBranch(EntityAI originalCaller, Man player = null, int system = 0)
    {
        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 );
                }
            }
        }
    }
    
    protected void OnInteractBranch(EntityAI originalCaller, Man player, int system)
    {
        if (m_ThisEntityAI)
            m_ThisEntityAI.IncreaseLifetime();
    
    }
        
    // 'Wakes up' all devices down the network so they start working, if they have enough power, and are switched ON
    protected void WakeUpWholeBranch( EntityAI original_caller )
    {
        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 );
                }
            }
        }
    }
 
    // Finds an available socket and plugs the given device into it.
    // This is mainly about visualisation.
    protected void PlugCordIntoSocket( EntityAI device_to_plug, int socket_id = -1 )
    {
        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;
            }
        }
    }
    
    // Updates socket selections (plugged/unplugged) of the given ID and sets color texture of the plug.
    protected void UpdateSocketSelections(int socket_id, EntityAI device_to_plug)
    {
        if (!m_ThisEntityAI)
            return;
        
        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);
    }
    
    
    // Sets energy source for this device
    protected void SetEnergySource( EntityAI source )
    {   
        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();
    }
 
    // Plugs the given device into this one
    protected bool PlugInDevice(EntityAI device_to_plug, int socket_id = -1)
    {
        if (m_ThisEntityAI && 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 (g_Game.IsServer() || !g_Game.IsMultiplayer())
            {
                device_to_plug.HideSelection(SEL_CORD_FOLDED);
                device_to_plug.ShowSelection(SEL_CORD_PLUGGED);
            }
            
            return true;
        }
        
        return false;
    }
 
    // Sets the device to which the given plug selection belongs to
    protected void SetPlugOwner(string selection_name, EntityAI device)
    {
        if ( m_DeviceByPlugSelection.Contains(selection_name) )
        {
            m_DeviceByPlugSelection.Set(selection_name, device);
        }
    }
    
    // Frees the given socket.
    // This is only about visualisation.
    protected void UnplugCordFromSocket( int socket_to_unplug_ID )
    {
        EntityAI plug_owner = GetDeviceBySocketID(socket_to_unplug_ID);
        
        if (m_ThisEntityAI && 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);
        }
    }
 
    // Sets the state of the device
    protected void SetPowered( bool state )
    {
        m_IsWorking = state;
    }
    
    // Tries to consume the given amount of energy. If there is none in this device, then it tries to take it from some power source.
    protected bool FindAndConsumeEnergy(EntityAI original_caller, float amount, bool ignore_switch_state = false)
    {
        if ((ignore_switch_state || IsSwitchedOn()) && m_ThisEntityAI && !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;
        }
    }
    
    // Gets the socket ID this device is powered from.
    protected int GetMySocketID()
    {
        return m_MySocketID;
    }
    
    // Sets the socket ID this device is plugged into.
    protected void SetMySocketID( int slot_ID )
    {
        m_MySocketID = slot_ID;
    }
 
    void Synch()
    {
        if (m_ThisEntityAI && g_Game.IsServer())
            m_ThisEntityAI.SetSynchDirty();
    }
    
    void ClearLastUpdateTime()
    {
        m_LastUpdateTime = 0;
    }
    
    void RememberLastUpdateTime()
    {
        m_LastUpdateTime = GetCurrentUpdateTime();
    }
    
    float GetCurrentUpdateTime()
    {
        return g_Game.GetTime();
    }
    
    // Updates the device's state of power. This function is visualized in the diagram at DayZ Confluence >> Camping & Squatting >> Electricity >> Energy Manager functionalities
    void DeviceUpdate()
    {
        /*
        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 && !g_Game.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 (g_Game.IsServer() || !g_Game.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);
                            g_Game.GameScript.CallFunction(m_ThisEntityAI, "OnWorkStart", NULL, 0);
                            UpdateCanWork();
                        }
                        
                        OnWork( consume_energy );
                    }
                    else
                    {
                        if ( was_powered )
                        {
                            if (m_CanStopWork)
                            {
                                m_CanStopWork = false;
                                ClearLastUpdateTime();
                                g_Game.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();
                    g_Game.GameScript.CallFunction(m_ThisEntityAI, "OnWorkStop", NULL, 0); // This event is called only once when the device STOPS being powered
                    UpdateCanWork();
                    
                    if (m_AutoSwitchOff)
                    {
                        SwitchOff(); 
                    }
                }
            }
        }
    }
}