ComponentEnergyManager.c

Go to the documentation of this file.

//-----------------------------
// 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()
  {
    m_ThisEntityAI.m_EM = this;
    GetGame().GameScript.CallFunction(m_ThisEntityAI, "OnInitEnergy", NULL, 0);
  }
 
  // Update debug arrows
  void DebugUpdate()
  {
    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);
      }
    }
  }
 
  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()
  {
    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
  }
 
  // Returns the type of this component
  override int GetCompType()
  {
    return COMP_TYPE_ENERGY_MANAGER;
  }
 
  // When the object is deleted
  void OnDeviceDestroyed()
  {
    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 (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);
  }
 
  void SwitchOff()
  {
    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);
    }
  }
 
  void SetPassiveState(bool state = true)
  {
    m_IsPassiveDevice = state;
    if (!m_IsPassiveDevice)
      DeviceUpdate();
  }
 
  void UnplugDevice(EntityAI device_to_unplug)
  {
    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);
      }
    }
  }
 
  void UnplugThis()
  {
    if (GetGame())
    {
      if (GetEnergySource())
        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 (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();
    }
  }
 
  void SetEnergy0To1(float energy01)
  {
    SetEnergy(Math.Lerp(0, GetEnergyMax(), energy01));
  }
 
  void UpdateSelections()
  {
    // 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.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()
  {
    string cfg_energy_usage = "CfgVehicles " + m_ThisEntityAI.GetType() + " EnergyManager ";
    m_EnergyUsage = GetGame().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 (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();
      }
    }
  }
 
  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)
  {
    return energy_source.GetCompEM().PlugInDevice(m_ThisEntityAI, socket_id);
  }
 
  bool CanSwitchOn()
  {
    if (!IsSwitchedOn())
      return true;
 
    return false;
  }
 
 
  bool CanWork(float test_energy = -1)
  {
    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;
  }
 
  bool CheckWetness()
  {
    return (m_ThisEntityAI.GetWet() <= 1 - m_WetnessExposure);
  }
 
  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)
  {
    return FindAndConsumeEnergy(m_ThisEntityAI, amount, true);
  }
 
  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)
    {
      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;
  }
 
  bool CanReceivePlugFrom(EntityAI device_to_plug)
  {
    // 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;
  }
 
  bool CanBePluggedInto(EntityAI potential_energy_provider)
  {
    return potential_energy_provider.GetCompEM().CanReceivePlugFrom(m_ThisEntityAI);
  }
 
  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.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));
  }
 
  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.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)
  {
    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();
    m_ThisEntityAI.OnIsPlugged(source_device);
  }
 
  // Called when this device is UNPLUGGED from the energy source
  void OnIsUnplugged(EntityAI last_energy_source)
  {
    UpdateCanWork();
    m_ThisEntityAI.OnIsUnplugged(last_energy_source);
  }
 
  // When something is plugged into this device
  void OnOwnSocketTaken(EntityAI device)
  {
    //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)
  {
    //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)
  {
    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()
  {
    m_ThisEntityAI.OnEnergyConsumed();
  }
 
  void OnEnergyAdded()
  {
    if (m_UpdateQuantityTimer)
    {
      m_UpdateQuantityTimer.Stop();
      m_UpdateQuantityTimer = NULL;
    }
 
    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)
  {
    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)
  {
    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 (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;
  }
 
  // 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 (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.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()
  {
    m_ThisEntityAI.SetSynchDirty();
  }
 
  void ClearLastUpdateTime()
  {
    m_LastUpdateTime = 0;
  }
 
  void RememberLastUpdateTime()
  {
    m_LastUpdateTime = GetCurrentUpdateTime();
  }
 
  float GetCurrentUpdateTime()
  {
    return GetGame().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 && !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();
        }
      }
    }
  }
}