EntityAI.c

Go to the documentation of this file.

enum EWetnessLevel
{
  DRY,
  DAMP,
  WET,
  SOAKING,
  DRENCHED
}
 
enum SurfaceAnimationBone
{
  LeftFrontLimb = 0,
  RightFrontLimb,
  LeftBackLimb,
  RightBackLimb
}
 
enum PlantType
{
  TREE_HARD = 1000,
  TREE_SOFT = 1001,
  BUSH_HARD = 1002,
  BUSH_SOFT = 1003,
}
 
enum WeightUpdateType
{
  FULL = 0,
  ADD,
  REMOVE,
  RECURSIVE_ADD,
  RECURSIVE_REMOVE
}
 
enum EItemManipulationContext
{
  UPDATE, //generic operation
  ATTACHING,
  DETACHING,
}
 
enum EInventoryIconVisibility
{
  ALWAYS = 0,
  HIDE_VICINITY = 1,
  //further values yet unused, but nice to have anyway
  HIDE_PLAYER_CONTAINER = 2,
  HIDE_HANDS_SLOT = 4
}
 
enum EAttExclusions
{
  OCCUPANCY_INVALID = -1,
  //Legacy relations
  LEGACY_EYEWEAR_HEADGEAR,
  LEGACY_EYEWEAR_MASK,
  LEGACY_HEADSTRAP_HEADGEAR,
  LEGACY_HEADSTRAP_MASK,
  LEGACY_HEADGEAR_MASK,
  LEGACY_HEADGEAR_EYEWEWEAR,
  LEGACY_HEADGEAR_HEADSTRAP,
  LEGACY_MASK_HEADGEAR,
  LEGACY_MASK_EYEWEWEAR,
  LEGACY_MASK_HEADSTRAP,
  //
  EXCLUSION_HEADGEAR_HELMET_0, //full helmet
  //EXCLUSION_HEADGEAR_HELMET_0_A, //example of another 'vector' of potential conflict, like between helmet and eyewear..otherwise the other non-helmet entities would collide through the 'EXCLUSION_HEADSTRAP_0' value.
  EXCLUSION_HEADSTRAP_0,
  EXCLUSION_MASK_0,
  EXCLUSION_MASK_1,
  EXCLUSION_MASK_2, //Mostly Gasmasks
  EXCLUSION_MASK_3, //bandana mask special behavior
  EXCLUSION_GLASSES_REGULAR_0,
  EXCLUSION_GLASSES_TIGHT_0,
  //values to solve the edge-cases with shaving action
  SHAVING_MASK_ATT_0,
  SHAVING_HEADGEAR_ATT_0,
  SHAVING_EYEWEAR_ATT_0,
}
 
class DebugSpawnParams
{
  Man m_Player;
 
  static DebugSpawnParams WithPlayer(Man player)
  {
    DebugSpawnParams params = new DebugSpawnParams();
    params.m_Player = player;
    return params;
  }
};
 
class TSelectableActionInfoArrayEx extends array<ref Param> {}
typedef Param3<int, int, string> TSelectableActionInfo;
typedef Param4<int, int, string, int> TSelectableActionInfoWithColor;
 
class EntityAI extends Entity
{
  bool m_DeathSyncSent;
  bool m_KilledByHeadshot;
  bool m_PreparedToDelete = false;
  bool m_RefresherViable = false;
  bool m_WeightDirty = 1;
  private ref map<int, ref set<int>> m_AttachmentExclusionSlotMap; //own masks for different slots <slot,mask>. Kept on instance to better respond to various state changes
  private ref set<int> m_AttachmentExclusionMaskGlobal; //additional mask values and simple item values. Independent of slot-specific behavior!
  private ref set<int> m_AttachmentExclusionMaskChildren; //additional mask values and simple item values
 
  ref DestructionEffectBase m_DestructionBehaviourObj;
 
  ref KillerData m_KillerData;
  private ref HiddenSelectionsData m_HiddenSelectionsData;
 
  const int DEAD_REPLACE_DELAY = 2000;
  const int DELETE_CHECK_DELAY = 100;
 
  ref array<EntityAI> m_AttachmentsWithCargo;
  ref array<EntityAI> m_AttachmentsWithAttachments;
  ref InventoryLocation m_OldLocation;
 
  protected ref DamageZoneMap m_DamageZoneMap;
  private ref map<int, string> m_DamageDisplayNameMap = new map<int, string>; //values are localization keys as strings, use 'Widget.TranslateString' method to get the localized one
 
  float m_Weight;
  float m_WeightEx;
  float m_ConfigWeight = ConfigGetInt("weight");
  protected bool m_CanDisplayWeight;
  private float m_LastUpdatedTime;
  protected float m_ElapsedSinceLastUpdate;
 
  protected UTemperatureSource m_UniversalTemperatureSource;
 
  bool m_PendingDelete = false;
  bool m_Initialized = false;
  bool m_TransportHitRegistered = false;
  vector m_TransportHitVelocity;
 
  //Called on item attached to this item (EntityAI item, string slot, EntityAI parent)
  protected ref ScriptInvoker m_OnItemAttached;
  //Called on item detached from this item (EntityAI item, string slot, EntityAI parent)
  protected ref ScriptInvoker m_OnItemDetached;
  //Called when an item is added to the cargo of this item (EntityAI item, EntityAI parent)
  protected ref ScriptInvoker m_OnItemAddedIntoCargo;
  //Called when an item is removed from the cargo of this item (EntityAI item, EntityAI parent)
  protected ref ScriptInvoker m_OnItemRemovedFromCargo;
  //Called when an item is moved around in the cargo of this item (EntityAI item, EntityAI parent)
  protected ref ScriptInvoker m_OnItemMovedInCargo;
  //Called when an item is flipped around in cargo (bool flip)
  protected ref ScriptInvoker m_OnItemFlipped;
  //Called when an items view index is changed
  protected ref ScriptInvoker m_OnViewIndexChanged;
  //Called when an location in this item is reserved (EntityAI item) - cargo
  protected ref ScriptInvoker m_OnSetLock;
  //Called when this item is unreserved (EntityAI item) - cargo
  protected ref ScriptInvoker m_OnReleaseLock;
  //Called when an location in this item is reserved (EntityAI item) - attachment
  protected ref ScriptInvoker m_OnAttachmentSetLock;
  //Called when this item is unreserved (EntityAI item) - attachment
  protected ref ScriptInvoker m_OnAttachmentReleaseLock;
  //Called when this entity is hit
  protected ref ScriptInvoker m_OnHitByInvoker;
  //Called when this entity is killed
  protected ref ScriptInvoker m_OnKilledInvoker;
 
  void EntityAI()
  {
    // Set up the Energy Manager
    string type = GetType();
    string param_access_energy_sys = "CfgVehicles " + type + " EnergyManager ";
    bool is_electic_device = GetGame().ConfigIsExisting(param_access_energy_sys);
 
    if (is_electic_device) // TO DO: Check if this instance is a hologram (advanced placement). If Yes, then do not create Energy Manager component.
    {
      CreateComponent(COMP_TYPE_ENERGY_MANAGER);
      RegisterNetSyncVariableBool("m_EM.m_IsSwichedOn");
      RegisterNetSyncVariableBool("m_EM.m_CanWork");
      RegisterNetSyncVariableBool("m_EM.m_IsPlugged");
      RegisterNetSyncVariableInt("m_EM.m_EnergySourceNetworkIDLow");
      RegisterNetSyncVariableInt("m_EM.m_EnergySourceNetworkIDHigh");
      RegisterNetSyncVariableFloat("m_EM.m_Energy");
    }
 
    // Item preview index
    RegisterNetSyncVariableInt("m_ViewIndex", 0, 99);
    // Refresher signalization
    RegisterNetSyncVariableBool("m_RefresherViable");
 
    m_AttachmentsWithCargo = new array<EntityAI>();
    m_AttachmentsWithAttachments = new array<EntityAI>();
    m_LastUpdatedTime = 0.0;
    m_ElapsedSinceLastUpdate = 0.0;
 
    m_CanDisplayWeight = ConfigGetBool("displayWeight");
 
    InitDamageZoneMapping();
    InitDamageZoneDisplayNameMapping();
 
    m_HiddenSelectionsData = new HiddenSelectionsData(GetType());
 
    GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).CallLater(DeferredInit, 34);
  }
 
  void ~EntityAI()
  {
 
  }
 
  void DeferredInit()
  {
    m_Initialized = true;
  }
 
  bool IsInitialized()
  {
    return m_Initialized;
  }
 
  int GetHideIconMask()
  {
    return EInventoryIconVisibility.ALWAYS;
  }
 
  private ref ComponentsBank m_ComponentsBank;
  ComponentEnergyManager m_EM; // This reference is necesarry due to synchronization, since it's impossible to synchronize values from a component :(
 
  Component CreateComponent(int comp_type, string extended_class_name = "")
  {
    return GetComponent(comp_type, extended_class_name);
  }
 
  Component GetComponent(int comp_type, string extended_class_name = "")
  {
    if (m_ComponentsBank == NULL)
      m_ComponentsBank = new ComponentsBank(this);
 
    return m_ComponentsBank.GetComponent(comp_type, extended_class_name);
  }
 
  bool DeleteComponent(int comp_type)
  {
    return m_ComponentsBank.DeleteComponent(comp_type);
  }
 
  string GetDestructionBehaviour()
  {
    return "";
  }
 
  bool IsDestructionBehaviour()
  {
    return false;
  }
 
  bool HasComponent(int comp_type)
  {
    if (m_ComponentsBank)
      return m_ComponentsBank.IsComponentAlreadyExist(comp_type);
 
    return false;
  }
 
  void MaxLifetimeRefreshCalc()
  {
    if ((!GetGame().IsMultiplayer() || GetGame().IsServer()) && GetEconomyProfile())
    {
      float lifetime = GetEconomyProfile().GetLifetime();
      int frequency = GetCEApi().GetCEGlobalInt("FlagRefreshFrequency");
      if (frequency <= 0)
        frequency = GameConstants.REFRESHER_FREQUENCY_DEFAULT;
 
      if (frequency <= lifetime)
      {
        m_RefresherViable = true;
        SetSynchDirty();
      }
    }
  }
 
  bool IsRefresherSignalingViable()
  {
    if (IsRuined())
      return false;
    return m_RefresherViable;
  }
 
#ifdef DEVELOPER
  override void SetDebugItem()
  {
    super.SetDebugItem();
    _item = this;
  }
#endif
 
 
  void InitDamageZoneMapping()
  {
    m_DamageZoneMap = new DamageZoneMap;
    DamageSystem.GetDamageZoneMap(this, m_DamageZoneMap);
  }
 
  void InitDamageZoneDisplayNameMapping()
  {
    string path_base;
    string path;
    string component_name;
 
    if (IsWeapon())
      path_base = CFG_WEAPONSPATH;
    else if (IsMagazine())
      path_base = CFG_MAGAZINESPATH;
    else
      path_base = CFG_VEHICLESPATH;
 
    path_base = string.Format("%1 %2 DamageSystem DamageZones", path_base, GetType());
 
    if (!GetGame().ConfigIsExisting(path_base))
    {
      component_name = GetDisplayName();
      GetGame().FormatRawConfigStringKeys(component_name);
      m_DamageDisplayNameMap.Insert("".Hash(), component_name);
    }
    else
    {
      TStringArray zone_names = new TStringArray;
      GetDamageZones(zone_names);
 
      for (int i = 0; i < zone_names.Count(); i++)
      {
        path = string.Format("%1 %2 displayName", path_base, zone_names[i]);
 
        if (GetGame().ConfigIsExisting(path) && GetGame().ConfigGetTextRaw(path, component_name))
        {
          GetGame().FormatRawConfigStringKeys(component_name);
          m_DamageDisplayNameMap.Insert(zone_names[i].Hash(), component_name);
        }
      }
    }
  }
 
  protected float ConvertNonlethalDamage(float damage, DamageType damageType)
  {
    return 0.0;
  }
 
  float ConvertNonlethalDamage(float damage)
  {
    return 0.0;
  }
 
  DamageZoneMap GetEntityDamageZoneMap()
  {
    return m_DamageZoneMap;
  }
 
  map<int, string> GetEntityDamageDisplayNameMap()
  {
    return m_DamageDisplayNameMap;
  }
 
  bool CanDisplayWeight()
  {
    return m_CanDisplayWeight;
  }
 
  void Log(string msg, string fnc_name = "n/a")
  {
    Debug.Log(msg, "Object", "n/a", fnc_name, this.GetType());
  }
 
  void LogWarning(string msg, string fnc_name = "n/a")
  {
    Debug.LogWarning(msg, "Object", "n/a", fnc_name, this.GetType());
  }
 
  void LogError(string msg, string fnc_name = "n/a")
  {
    Debug.LogError(msg, "Object", "n/a", fnc_name, this.GetType());
  }
 
  bool IsSkinned()
  {
    return GetCompBS() && GetCompBS().IsSkinned();
  }
 
  void SetAsSkinned()
  {
    if (GetCompBS())
      GetCompBS().SetAsSkinned();
  }
 
  bool CanBeSkinnedWith(EntityAI tool)
  {
    if (!IsSkinned() && tool)
      if (!IsAlive())
        return true;
    return false;
  }
 
  // ITEM TO ITEM FIRE DISTRIBUTION
  bool HasFlammableMaterial()
  {
    return false;
  }
 
  bool CanBeIgnitedBy(EntityAI igniter = NULL)
  {
    return false;
  }
 
  bool CanIgniteItem(EntityAI ignite_target = NULL)
  {
    return false;
  }
 
  bool IsIgnited()
  {
    if (m_EM)
      return m_EM.IsWorking();
    return false;
  }
 
  // Change return value to true if last detached item cause disassemble of item - different handlig some inventory operations
  bool DisassembleOnLastDetach()
  {
    return false;
  }
 
  bool IsBasebuildingKit()
  {
    return false;
  }
 
  bool PlacementCanBeRotated()
  {
    return true;
  }
 
  void OnIgnitedTarget(EntityAI target_item)
  {
 
  }
 
  void OnIgnitedThis(EntityAI fire_source)
  {
 
  }
 
  void OnIgnitedTargetFailed(EntityAI target_item)
  {
 
  }
 
  void OnIgnitedThisFailed(EntityAI fire_source)
  {
 
  }
 
  bool IsTargetIgnitionSuccessful(EntityAI item_target)
  {
    return true;
  }
 
  bool IsThisIgnitionSuccessful(EntityAI item_source = NULL)
  {
    return true;
  }
  // End of fire distribution ^
 
  // ADVANCED PLACEMENT EVENTS
  void OnPlacementStarted(Man player);
  void OnHologramBeingPlaced(Man player);
  void OnPlacementComplete(Man player, vector position = "0 0 0", vector orientation = "0 0 0");
  void OnPlacementCancelled(Man player);
 
  bool CanBePlaced(Man player, vector position)
  {
    return true;
  }
 
  string CanBePlacedFailMessage(Man player, vector position)
  {
    return "";
  }
 
  bool DoPlacingHeightCheck()
  {
    return false;
  }
 
  float HeightCheckOverride()
  {
    return 0.0;
  }
 
  float HeightStartCheckOverride()
  {
    return 0.0;
  }
 
  bool IsEmpty()
  {
    return (!HasAnyCargo() && GetInventory().AttachmentCount() == 0);
  }
 
  bool CanBeSplit()
  {
    return false;
  }
 
  bool HasAnyCargo()
  {
    CargoBase cargo = GetInventory().GetCargo();
 
    if (!cargo) return false; //this is not a cargo container
 
    if (cargo.GetItemCount() > 0)
      return true;
    else
      return false;
  }
 
  array<EntityAI> GetAttachmentsWithCargo()
  {
    return m_AttachmentsWithCargo;
  }
 
  array<EntityAI> GetAttachmentsWithAttachments()
  {
    return m_AttachmentsWithAttachments;
  }
 
  int GetAgents() { return 0; }
  void RemoveAgent(int agent_id);
  void RemoveAllAgents();
  void RemoveAllAgentsExcept(int agent_to_keep);
  void InsertAgent(int agent, float count = 1);
 
  override bool IsEntityAI() { return true; }
 
  bool IsInventoryVisible()
  {
    return !(GetParent() || GetHierarchyParent());
  }
 
  bool IsPlayer()
  {
    return false;
  }
 
  bool IsAnimal()
  {
    return false;
  }
 
  bool IsZombie()
  {
    return false;
  }
 
  bool IsZombieMilitary()
  {
    return false;
  }
 
  bool IsIgnoredByConstruction()
  {
    return IsDamageDestroyed();
  }
 
  bool CanBeTargetedByAI(EntityAI ai)
  {
    if (ai && ai.IsBeingBackstabbed())
      return false;
 
    if (!dBodyIsActive(this) && !IsMan())
      return false;
    return !IsDamageDestroyed();
  }
 
  bool CanBeBackstabbed()
  {
    return false;
  }
 
  override void Delete()
  {
    m_PendingDelete = true;
    super.Delete();
  }
 
  void DeleteOnClient()
  {
    GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).Call(GetGame().ObjectDeleteOnClient, this);
  }
 
  // delete synchronized between server and client
  void DeleteSafe()
  {
    if (GetHierarchyRootPlayer() == null)
      Delete();
    else
    {
      if (GetGame().IsServer() && GetGame().IsMultiplayer())
        GetHierarchyRootPlayer().JunctureDeleteItem(this);
      else
        GetHierarchyRootPlayer().AddItemToDelete(this);
    }
  }
 
  //legacy, wrong name, use 'DeleteSafe()' instead
  void DeleteSave()
  {
    DeleteSafe();
  }
 
  bool IsSetForDeletion()
  {
    return IsPreparedToDelete() || m_PendingDelete || ToDelete() || IsPendingDeletion();
  }
 
  override bool CanBeActionTarget()
  {
    if (super.CanBeActionTarget())
      return !IsSetForDeletion();
    else
      return false;
  }
 
  void SetPrepareToDelete()
  {
    m_PreparedToDelete = true;
  }
 
  bool IsPreparedToDelete()
  {
    return m_PreparedToDelete;
  }
 
 
  void CheckForDestroy()
  {
    if (IsPrepareToDelete())
      GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).CallLater(TryDelete, DELETE_CHECK_DELAY, false);
  }
 
  bool IsPrepareToDelete()
  {
    return false;
  }
 
  bool TryDelete()
  {
    if (!IsPrepareToDelete())
    {
      Debug.Log("TryDelete - not ready for deletion");
      return false;
    }
 
    if (GetGame().HasInventoryJunctureItem(this))
    {
      Debug.Log("TryDelete - deferred call");
      GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).CallLater(TryDelete, DELETE_CHECK_DELAY, false);
      return false;
    }
 
    OnBeforeTryDelete();
    Debug.Log("TryDelete - OnBeforeTryDelete end");
    DeleteSafe();
    Debug.Log("TryDelete - DeleteSafe end");
 
    return true;
  }
 
  void OnBeforeTryDelete();
 
  proto native EntityAI GetHierarchyRoot();
 
  proto native Man GetHierarchyRootPlayer();
 
  proto native EntityAI GetHierarchyParent();
 
  proto native CEItemProfile GetEconomyProfile();
 
  // !returns the number of levels bellow the hierarchy root this entity is at
  int GetHierarchyLevel(int lvl = 0)
  {
    if (!GetHierarchyParent())
      return lvl;
 
    return GetHierarchyParent().GetHierarchyLevel(lvl + 1);
  }
 
  void OnInventoryInit()
  {
    InitAttachmentExclusionValues();
  }
 
  void EEInit()
  {
    if (GetInventory())
    {
      GetInventory().EEInit();
      m_AttachmentsWithCargo.Clear();
      m_AttachmentsWithAttachments.Clear();
      for (int i = 0; i < GetInventory().AttachmentCount(); i++)
      {
        EntityAI attachment = GetInventory().GetAttachmentFromIndex(i);
        if (attachment)
        {
          if (attachment.GetInventory().GetCargo())
            m_AttachmentsWithCargo.Insert(attachment);
 
          if (attachment.GetInventory().GetAttachmentSlotsCount() > 0)
            m_AttachmentsWithAttachments.Insert(attachment);
        }
      }
    }
 
    MaxLifetimeRefreshCalc();
  }
 
  void EEDelete(EntityAI parent)
  {
    m_PendingDelete = true;
    GetInventory().EEDelete(parent);
 
    if (m_EM)
      m_EM.OnDeviceDestroyed();
  }
 
  override void OnExplosionEffects(Object source, Object directHit, int componentIndex, string surface, vector pos, vector surfNormal, float energyFactor, float explosionFactor, bool isWater, string ammoType)
  {
    super.OnExplosionEffects(source, directHit, componentIndex, surface, pos, surfNormal, energyFactor, explosionFactor, isWater, ammoType);
#ifndef SERVER
    g_Game.GetWorld().AddEnvShootingSource(pos, 1.0);
#endif
    if (m_DestructionBehaviourObj && m_DestructionBehaviourObj.HasExplosionDamage())
      m_DestructionBehaviourObj.OnExplosionEffects(source, directHit, componentIndex, surface, pos, surfNormal, energyFactor, explosionFactor, isWater, ammoType);
  }
 
 
  void OnItemLocationChanged(EntityAI old_owner, EntityAI new_owner) { }
 
  void OnItemAttachmentSlotChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc) {}
 
  void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
  {
    EntityAI old_owner = oldLoc.GetParent();
    EntityAI new_owner = newLoc.GetParent();
    OnItemLocationChanged(old_owner, new_owner);
 
    if (oldLoc.GetType() == InventoryLocationType.ATTACHMENT && newLoc.GetType() == InventoryLocationType.ATTACHMENT)
      OnItemAttachmentSlotChanged(oldLoc, newLoc);
 
    if (oldLoc.GetType() == InventoryLocationType.ATTACHMENT)
    {
      if (old_owner)
        OnWasDetached(old_owner, oldLoc.GetSlot());
      else
        Error("EntityAI::EEItemLocationChanged - detached, but old_owner is null");
    }
 
    if (newLoc.GetType() == InventoryLocationType.ATTACHMENT)
    {
      if (new_owner)
        OnWasAttached(newLoc.GetParent(), newLoc.GetSlot());
      else
        Error("EntityAI::EEItemLocationChanged - attached, but new_owner is null");
    }
  }
 
  void EEParentedTo(EntityAI parent)
  {
  }
 
  void EEParentedFrom(EntityAI parent)
  {
  }
 
  void EEInventoryIn(Man newParentMan, EntityAI diz, EntityAI newParent)
  {
  }
  void EEInventoryOut(Man oldParentMan, EntityAI diz, EntityAI newParent)
  {
    m_LastUpdatedTime = 0.0;
 
    if (GetInventory() && newParent == null)
      GetInventory().ResetFlipCargo();
  }
 
  void EEAmmoChanged()
  {
    SetWeightDirty();
  }
 
  void EEHealthLevelChanged(int oldLevel, int newLevel, string zone)
  {
    // Notify potential parent that this item was ruined
    EntityAI parent = GetHierarchyParent();
 
    if (newLevel == GameConstants.STATE_RUINED)
    {
      if (parent)
        parent.OnAttachmentRuined(this);
      if (!zone)
        OnDamageDestroyed(oldLevel);
      AttemptDestructionBehaviour(oldLevel, newLevel, zone);
    }
  }
 
  void OnDamageDestroyed(int oldLevel);
 
  void AttemptDestructionBehaviour(int oldLevel, int newLevel, string zone)
  {
    if (IsDestructionBehaviour() && GetDestructionBehaviour())
    {
      typename destType = GetDestructionBehaviour().ToType();
 
      if (destType)
      {
        if (!m_DestructionBehaviourObj)
          m_DestructionBehaviourObj = DestructionEffectBase.Cast(destType.Spawn());
 
        if (m_DestructionBehaviourObj)
          m_DestructionBehaviourObj.OnHealthLevelChanged(this, oldLevel, newLevel, zone);
      }
      else
        ErrorEx("Incorrect destruction behaviour type, make sure the class returned in 'GetDestructionBehaviour()' is a valid type inheriting from 'DestructionEffectBase'");
    }
  }
 
 
  void SetTakeable(bool pState);
 
  void EEKilled(Object killer)
  {
    if (m_OnKilledInvoker)
      m_OnKilledInvoker.Invoke(this, killer);
    //analytics
    GetGame().GetAnalyticsServer().OnEntityKilled(killer, this);
 
    if (ReplaceOnDeath())
      GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).CallLater(DeathUpdate, DEAD_REPLACE_DELAY, false);
  }
 
  bool ReplaceOnDeath()
  {
    return false;
  }
 
  string GetDeadItemName()
  {
    return "";
  }
 
  bool KeepHealthOnReplace()
  {
    return false;
  }
 
  void DeathUpdate()
  {
    EntityAI dead_entity = EntityAI.Cast(GetGame().CreateObjectEx(GetDeadItemName(), GetPosition(), ECE_OBJECT_SWAP, RF_ORIGINAL));
    dead_entity.SetOrientation(GetOrientation());
    if (KeepHealthOnReplace())
      dead_entity.SetHealth(GetHealth());
    this.Delete();
  }
 
  void OnAttachmentRuined(EntityAI attachment)
  {
    // ...
  }
 
  void EEHitBy(TotalDamageResult damageResult, int damageType, EntityAI source, int component, string dmgZone, string ammo, vector modelPos, float speedCoef)
  {
    if (m_OnHitByInvoker)
      m_OnHitByInvoker.Invoke(this, damageResult, damageType, source, component, dmgZone, ammo, modelPos, speedCoef);
#ifdef DEVELOPER
    //Print("EEHitBy: " + this + "; damageResult:"+ damageResult.GetDamage("","") +"; damageType: "+ damageType +"; source: "+ source +"; component: "+ component +"; dmgZone: "+ dmgZone +"; ammo: "+ ammo +"; modelPos: "+ modelPos);
#endif
  }
 
  // called only on the client who caused the hit
  void EEHitByRemote(int damageType, EntityAI source, int component, string dmgZone, string ammo, vector modelPos)
  {
 
  }
 
  // !Called on PARENT when a child is attached to it.
  void EEItemAttached(EntityAI item, string slot_name)
  {
    int slotId = InventorySlots.GetSlotIdFromString(slot_name);
    PropagateExclusionValueRecursive(item.GetAttachmentExclusionMaskAll(slotId), slotId); //Performed from parent to avoid event order issues on swap
    SetWeightDirty();
 
    if (m_ComponentsBank != NULL)
    {
      for (int comp_key = 0; comp_key < COMP_TYPE_COUNT; ++comp_key)
      {
        if (m_ComponentsBank.IsComponentAlreadyExist(comp_key))
          m_ComponentsBank.GetComponent(comp_key).Event_OnItemAttached(item, slot_name);
      }
    }
 
    // Energy Manager
    if (m_EM && item.GetCompEM())
      m_EM.OnAttachmentAdded(item);
 
    if (item.GetInventory().GetCargo())
      m_AttachmentsWithCargo.Insert(item);
 
    if (item.GetInventory().GetAttachmentSlotsCount() > 0)
      m_AttachmentsWithAttachments.Insert(item);
 
    if (m_OnItemAttached)
      m_OnItemAttached.Invoke(item, slot_name, this);
  }
 
  void SwitchItemSelectionTexture(EntityAI item, string slot_name);
  void SwitchItemSelectionTextureEx(EItemManipulationContext context, Param par = null);
 
  // !Called on PARENT when a child is detached from it.
  void EEItemDetached(EntityAI item, string slot_name)
  {
    int slotId = InventorySlots.GetSlotIdFromString(slot_name);
    ClearExclusionValueRecursive(item.GetAttachmentExclusionMaskAll(slotId), slotId); //Performed from parent to avoid event order issues on swap
    SetWeightDirty();
 
    if (m_ComponentsBank != NULL)
    {
      for (int comp_key = 0; comp_key < COMP_TYPE_COUNT; ++comp_key)
      {
        if (m_ComponentsBank.IsComponentAlreadyExist(comp_key))
          m_ComponentsBank.GetComponent(comp_key).Event_OnItemDetached(item, slot_name);
      }
    }
 
    // Energy Manager
    if (m_EM && item.GetCompEM())
      m_EM.OnAttachmentRemoved(item);
 
    if (m_AttachmentsWithCargo.Find(item) > -1)
      m_AttachmentsWithCargo.RemoveItem(item);
 
    if (m_AttachmentsWithAttachments.Find(item) > -1)
      m_AttachmentsWithAttachments.RemoveItem(item);
 
 
    if (m_OnItemDetached)
      m_OnItemDetached.Invoke(item, slot_name, this);
  }
 
  void EECargoIn(EntityAI item)
  {
    SetWeightDirty();
 
    if (m_OnItemAddedIntoCargo)
      m_OnItemAddedIntoCargo.Invoke(item, this);
 
    item.OnMovedInsideCargo(this);
  }
 
  void EECargoOut(EntityAI item)
  {
    SetWeightDirty();
 
    if (m_OnItemRemovedFromCargo)
      m_OnItemRemovedFromCargo.Invoke(item, this);
 
    item.OnRemovedFromCargo(this);
  }
 
  void EECargoMove(EntityAI item)
  {
    if (m_OnItemMovedInCargo)
      m_OnItemMovedInCargo.Invoke(item, this);
    item.OnMovedWithinCargo(this);
  }
 
  ScriptInvoker GetOnItemAttached()
  {
    if (!m_OnItemAttached)
      m_OnItemAttached = new ScriptInvoker;
    return m_OnItemAttached;
  }
 
  ScriptInvoker GetOnItemDetached()
  {
    if (!m_OnItemDetached)
      m_OnItemDetached = new ScriptInvoker;
    return m_OnItemDetached;
  }
 
  ScriptInvoker GetOnItemAddedIntoCargo()
  {
    if (!m_OnItemAddedIntoCargo)
      m_OnItemAddedIntoCargo = new ScriptInvoker;
    return m_OnItemAddedIntoCargo;
  }
 
  ScriptInvoker GetOnItemRemovedFromCargo()
  {
    if (!m_OnItemRemovedFromCargo)
      m_OnItemRemovedFromCargo = new ScriptInvoker;
    return m_OnItemRemovedFromCargo;
  }
 
  ScriptInvoker GetOnItemMovedInCargo()
  {
    if (!m_OnItemMovedInCargo)
      m_OnItemMovedInCargo = new ScriptInvoker;
    return m_OnItemMovedInCargo;
  }
 
  ScriptInvoker GetOnItemFlipped()
  {
    if (!m_OnItemFlipped)
      m_OnItemFlipped = new ScriptInvoker;
    return m_OnItemFlipped;
  }
 
  ScriptInvoker GetOnViewIndexChanged()
  {
    if (!m_OnViewIndexChanged)
      m_OnViewIndexChanged = new ScriptInvoker;
    return m_OnViewIndexChanged;
  }
 
  ScriptInvoker GetOnSetLock()
  {
    if (!m_OnSetLock)
      m_OnSetLock = new ScriptInvoker;
    return m_OnSetLock;
  }
 
  ScriptInvoker GetOnReleaseLock()
  {
    if (!m_OnReleaseLock)
      m_OnReleaseLock = new ScriptInvoker;
    return m_OnReleaseLock;
  }
 
  ScriptInvoker GetOnAttachmentSetLock()
  {
    if (!m_OnAttachmentSetLock)
      m_OnAttachmentSetLock = new ScriptInvoker;
    return m_OnAttachmentSetLock;
  }
 
  ScriptInvoker GetOnAttachmentReleaseLock()
  {
    if (!m_OnAttachmentReleaseLock)
      m_OnAttachmentReleaseLock = new ScriptInvoker;
    return m_OnAttachmentReleaseLock;
  }
 
  ScriptInvoker GetOnHitByInvoker()
  {
    if (!m_OnHitByInvoker)
      m_OnHitByInvoker = new ScriptInvoker;
    return m_OnHitByInvoker;
  }
 
  ScriptInvoker GetOnKilledInvoker()
  {
    if (!m_OnKilledInvoker)
      m_OnKilledInvoker = new ScriptInvoker;
    return m_OnKilledInvoker;
  }
 
 
  void OnMovedInsideCargo(EntityAI container)
  {
    if (m_EM)
      m_EM.HandleMoveInsideCargo(container);
  }
 
  void OnRemovedFromCargo(EntityAI container)
  {
 
  }
 
  void OnMovedWithinCargo(EntityAI container)
  {
 
  }
 
  void EEOnAfterLoad()
  {
    // ENERGY MANAGER
    // Restore connections between devices which were connected before server restart
    if (m_EM && m_EM.GetRestorePlugState())
    {
      int b1 = m_EM.GetEnergySourceStorageIDb1();
      int b2 = m_EM.GetEnergySourceStorageIDb2();
      int b3 = m_EM.GetEnergySourceStorageIDb3();
      int b4 = m_EM.GetEnergySourceStorageIDb4();
 
      // get pointer to EntityAI based on this ID
      EntityAI potential_energy_source = GetGame().GetEntityByPersitentID(b1, b2, b3, b4); // This function is available only in this event!
 
      // IMPORTANT!
      // Object IDs acquired here become INVALID when electric devices are transfered to another server while in plugged state (like Flashlight plugged into its attachment 9V battery)
      // To avoid issues, these items must be excluded from this system of restoring plug state so they don't unintentionally plug to incorrect devices through these invalid IDs.
      // Therefore their plug state is being restored withing the EEItemAttached() event while being excluded by the following 'if' conditions...
 
      bool is_attachment = false;
 
      if (potential_energy_source)
        is_attachment = GetInventory().HasAttachment(potential_energy_source);
 
      if (!is_attachment && potential_energy_source)
        is_attachment = potential_energy_source.GetInventory().HasAttachment(this);
 
      if (potential_energy_source && potential_energy_source.GetCompEM() /*&& potential_energy_source.HasEnergyManager()*/ && !is_attachment)
        m_EM.PlugThisInto(potential_energy_source); // restore connection
    }
  }
 
  void EEOnCECreate()
  {
  }
 
  void AfterStoreLoad()
  {
  }
 
  void OnBinLoadItemsDropped()
  {
    if (GetHierarchyRootPlayer())
      GetHierarchyRootPlayer().SetProcessUIWarning(true);
  }
 
  void HideAllSelections()
  {
    string cfg_path = "cfgVehicles " + GetType() + " AnimationSources";
 
    if (GetGame().ConfigIsExisting(cfg_path))
    {
      int selections = GetGame().ConfigGetChildrenCount(cfg_path);
 
      for (int i = 0; i < selections; i++)
      {
        string selection_name;
        GetGame().ConfigGetChildName(cfg_path, i, selection_name);
        HideSelection(selection_name);
      }
    }
  }
 
  void ShowAllSelections()
  {
    string cfg_path = "cfgVehicles " + GetType() + " AnimationSources";
 
    if (GetGame().ConfigIsExisting(cfg_path))
    {
      int selections = GetGame().ConfigGetChildrenCount(cfg_path);
 
      for (int i = 0; i < selections; i++)
      {
        string selection_name;
        GetGame().ConfigGetChildName(cfg_path, i, selection_name);
        ShowSelection(selection_name);
      }
    }
  }
 
  bool CanReceiveAttachment(EntityAI attachment, int slotId)
  {
    //generic occupancy check
    EntityAI currentAtt = GetInventory().FindAttachment(slotId);
    bool hasInternalConflict = attachment.HasInternalExclusionConflicts(slotId);
    if (currentAtt) //probably a swap or same-type swap
    {
      set<int> diff = attachment.GetAttachmentExclusionMaskAll(slotId);
      diff.RemoveItems(currentAtt.GetAttachmentExclusionMaskAll(slotId));
      if (diff.Count() == 0)
        return !hasInternalConflict;
      else
        return !hasInternalConflict && !IsExclusionFlagPresentRecursive(diff, slotId);
    }
    return !hasInternalConflict && !IsExclusionFlagPresentRecursive(attachment.GetAttachmentExclusionMaskAll(slotId), slotId);
  }
 
  bool CanLoadAttachment(EntityAI attachment)
  {
    return true;
  }
 
  bool CanPutAsAttachment(EntityAI parent)
  {
    return !IsHologram();
  }
 
  //If return true, item can be attached even from parent to this. Item will be switched during proccess. (only hands)
  bool CanSwitchDuringAttach(EntityAI parent)
  {
    return false;
  }
  bool CanReleaseAttachment(EntityAI attachment)
  {
    if (attachment && attachment.GetInventory() && GetInventory())
    {
      InventoryLocation il = new InventoryLocation();
      attachment.GetInventory().GetCurrentInventoryLocation(il);
      if (il.IsValid())
      {
        int slot = il.GetSlot();
        return !GetInventory().GetSlotLock(slot);
      }
    }
    return true;
  }
  bool CanDetachAttachment(EntityAI parent)
  {
    return true;
  }
 
  bool CanBeFSwaped()
  {
    return true;
  }
 
  bool CanCombineAttachment(notnull EntityAI e, int slot, bool stack_max_limit = false)
  {
    EntityAI att = GetInventory().FindAttachment(slot);
    if (att)
      return att.CanBeCombined(e, true, stack_max_limit);
    return false;
  }
 
  bool CanBeCombined(EntityAI other_item, bool reservation_check = true, bool stack_max_limit = false)
  {
    return false;
  }
 
  void CombineItemsClient(EntityAI entity2, bool use_stack_max = false)
  {}
 
  bool CanReceiveItemIntoCargo(EntityAI item)
  {
    if (GetInventory() && GetInventory().GetCargo())
      return GetInventory().GetCargo().CanReceiveItemIntoCargo(item));
 
      return true;
    }
 
  bool CanLoadItemIntoCargo(EntityAI item)
  {
    return true;
  }
 
  bool CanPutInCargo(EntityAI parent)
  {
    return !IsHologram();
  }
 
  bool CanSwapItemInCargo(EntityAI child_entity, EntityAI new_entity)
  {
    if (GetInventory() && GetInventory().GetCargo())
      return GetInventory().GetCargo().CanSwapItemInCargo(child_entity, new_entity));
 
      return true;
    }
 
  bool CanReleaseCargo(EntityAI cargo)
  {
    return true;
  }
 
  bool CanRemoveFromCargo(EntityAI parent)
  {
    return true;
  }
 
  /*bool CanReceiveItemIntoInventory (EntityAI entity_ai)
    {
    return true;
    }*/
 
  /*bool CanPutInInventory (EntityAI parent)
    {
    return true;
    }*/
 
  bool CanReceiveItemIntoHands(EntityAI item_to_hands)
  {
    return true;
  }
 
  bool IsBeingPlaced()
  {
    return false;
  }
 
  override bool IsHologram()
  {
    return false;
  }
 
  bool CanSaveItemInHands(EntityAI item_in_hands)
  {
    return true;
  }
 
  bool CanPutIntoHands(EntityAI parent)
  {
    return !IsHologram();
  }
 
  bool CanReleaseFromHands(EntityAI handheld)
  {
    return true;
  }
 
  bool CanRemoveFromHands(EntityAI parent)
  {
    return true;
  }
 
  bool CanDisplayAttachmentSlot(string slot_name)
  {
    Debug.LogWarning("Obsolete function - use CanDisplayAttachmentSlot with slot id parameter");
    return InventorySlots.GetShowForSlotId(InventorySlots.GetSlotIdFromString(slot_name));
  }
 
  bool CanDisplayAttachmentSlot(int slot_id)
  {
    return InventorySlots.GetShowForSlotId(slot_id);
  }
 
  bool CanDisplayAnyAttachmentSlot()
  {
    int count = GetInventory().GetAttachmentSlotsCount();
    int slotID;
    for (int i = 0; i < count; i++)
    {
      slotID = GetInventory().GetAttachmentSlotId(i);
      if (CanDisplayAttachmentSlot(slotID))
        return true;
    }
 
    return false;
  }
 
  bool CanDisplayAttachmentCategory(string category_name)
  {
    return true;
  }
 
  bool CanDisplayCargo()
  {
    return GetInventory().GetCargo() != null;
  }
 
  bool CanAssignToQuickbar()
  {
    return true;
  }
 
  bool CanAssignAttachmentsToQuickbar()
  {
    return true;
  }
 
  bool IgnoreOutOfReachCondition()
  {
    return GetHierarchyRootPlayer() == GetGame().GetPlayer();
  }
 
  // !Called on CHILD when it's attached to parent.
  void OnWasAttached(EntityAI parent, int slot_id);
 
  // !Called on CHILD when it's detached from parent.
  void OnWasDetached(EntityAI parent, int slot_id)
  {
    if (!IsFlagSet(EntityFlags.VISIBLE))
    {
      SetInvisible(false);
      OnInvisibleSet(false);
      SetInvisibleRecursive(false, parent);
    }
  }
 
  void OnCargoChanged() { }
 
  bool IsTakeable()
  {
    return false;
  }
 
  proto native GameInventory GetInventory();
  proto native void CreateAndInitInventory();
  proto native void DestroyInventory();
 
  int GetSlotsCountCorrect()
  {
    if (GetInventory())
      return GetInventory().GetAttachmentSlotsCount();
    else
      return -1;
  }
 
  EntityAI FindAttachmentBySlotName(string slot_name)
  {
    if (GetGame())
    {
      int slot_id = InventorySlots.GetSlotIdFromString(slot_name);
      if (slot_id != InventorySlots.INVALID)
        return GetInventory().FindAttachment(slot_id);
    }
    return null;
  }
 
  bool IsLockedInSlot()
  {
    EntityAI parent = GetHierarchyParent();
    if (parent)
    {
      InventoryLocation inventory_location = new InventoryLocation();
      GetInventory().GetCurrentInventoryLocation(inventory_location);
 
      return parent.GetInventory().GetSlotLock(inventory_location.GetSlot());
    }
 
    return false;
  }
 
  bool PredictiveTakeEntityToInventory(FindInventoryLocationType flags, notnull EntityAI item)
  {
    if (GetGame().IsMultiplayer())
      return GetInventory().TakeEntityToInventory(InventoryMode.JUNCTURE, flags, item);
    else
      return GetInventory().TakeEntityToInventory(InventoryMode.PREDICTIVE, flags, item);
  }
  bool LocalTakeEntityToInventory(FindInventoryLocationType flags, notnull EntityAI item)
  {
    return GetInventory().TakeEntityToInventory(InventoryMode.LOCAL, flags, item);
  }
  bool ServerTakeEntityToInventory(FindInventoryLocationType flags, notnull EntityAI item)
  {
    return GetInventory().TakeEntityToInventory(InventoryMode.SERVER, flags, item);
  }
  bool PredictiveTakeEntityToTargetInventory(notnull EntityAI target, FindInventoryLocationType flags, notnull EntityAI item)
  {
    if (GetGame().IsMultiplayer())
      return GetInventory().TakeEntityToTargetInventory(InventoryMode.JUNCTURE, target, flags, item);
    else
      return GetInventory().TakeEntityToTargetInventory(InventoryMode.PREDICTIVE, target, flags, item);
  }
  bool LocalTakeEntityToTargetInventory(notnull EntityAI target, FindInventoryLocationType flags, notnull EntityAI item)
  {
    return GetInventory().TakeEntityToTargetInventory(InventoryMode.LOCAL, target, flags, item);
  }
  bool ServerTakeEntityToTargetInventory(notnull EntityAI target, FindInventoryLocationType flags, notnull EntityAI item)
  {
    return GetInventory().TakeEntityToTargetInventory(InventoryMode.SERVER, target, flags, item);
  }
  bool PredictiveTakeEntityToCargo(notnull EntityAI item)
  {
    if (GetGame().IsMultiplayer())
      return GetInventory().TakeEntityToCargo(InventoryMode.JUNCTURE, item);
    else
      return GetInventory().TakeEntityToCargo(InventoryMode.PREDICTIVE, item);
  }
  bool LocalTakeEntityToCargo(notnull EntityAI item)
  {
    return GetInventory().TakeEntityToCargo(InventoryMode.LOCAL, item);
  }
  bool ServerTakeEntityToCargo(notnull EntityAI item)
  {
    return GetInventory().TakeEntityToCargo(InventoryMode.SERVER, item);
  }
 
  bool PredictiveTakeEntityToTargetCargo(notnull EntityAI target, notnull EntityAI item)
  {
    if (GetGame().IsMultiplayer())
      return GetInventory().TakeEntityToTargetCargo(InventoryMode.JUNCTURE, target, item);
    else
      return GetInventory().TakeEntityToTargetCargo(InventoryMode.PREDICTIVE, target, item);
  }
  bool LocalTakeEntityToTargetCargo(notnull EntityAI target, notnull EntityAI item)
  {
    return GetInventory().TakeEntityToTargetCargo(InventoryMode.LOCAL, target, item);
  }
  bool ServerTakeEntityToTargetCargo(notnull EntityAI target, notnull EntityAI item)
  {
    return GetInventory().TakeEntityToTargetCargo(InventoryMode.SERVER, target, item);
  }
  bool PredictiveTakeEntityToCargoEx(notnull EntityAI item, int idx, int row, int col)
  {
    if (GetGame().IsMultiplayer())
      return GetInventory().TakeEntityToCargoEx(InventoryMode.JUNCTURE, item, idx, row, col);
    else
      return GetInventory().TakeEntityToCargoEx(InventoryMode.PREDICTIVE, item, idx, row, col);
  }
  bool LocalTakeEntityToCargoEx(notnull EntityAI item, int idx, int row, int col)
  {
    return GetInventory().TakeEntityToCargoEx(InventoryMode.LOCAL, item, idx, row, col);
  }
 
  bool PredictiveTakeEntityToTargetCargoEx(notnull CargoBase cargo, notnull EntityAI item, int row, int col)
  {
    if (GetGame().IsMultiplayer())
      return GetInventory().TakeEntityToTargetCargoEx(InventoryMode.JUNCTURE, cargo, item, row, col);
    else
      return GetInventory().TakeEntityToTargetCargoEx(InventoryMode.PREDICTIVE, cargo, item, row, col);
  }
  bool LocalTakeEntityToTargetCargoEx(notnull CargoBase cargo, notnull EntityAI item, int row, int col)
  {
    return GetInventory().TakeEntityToTargetCargoEx(InventoryMode.LOCAL, cargo, item, row, col);
  }
  bool ServerTakeEntityToTargetCargoEx(notnull CargoBase cargo, notnull EntityAI item, int row, int col)
  {
    return GetInventory().TakeEntityToTargetCargoEx(InventoryMode.SERVER, cargo, item, row, col);
  }
  bool PredictiveTakeEntityAsAttachmentEx(notnull EntityAI item, int slot)
  {
    if (GetGame().IsMultiplayer())
      return GetInventory().TakeEntityAsAttachmentEx(InventoryMode.JUNCTURE, item, slot);
    else
      return GetInventory().TakeEntityAsAttachmentEx(InventoryMode.PREDICTIVE, item, slot);
  }
  bool LocalTakeEntityAsAttachmentEx(notnull EntityAI item, int slot)
  {
    return GetInventory().TakeEntityAsAttachmentEx(InventoryMode.LOCAL, item, slot);
  }
  bool ServerTakeEntityAsAttachmentEx(notnull EntityAI item, int slot)
  {
    return GetInventory().TakeEntityAsAttachmentEx(InventoryMode.SERVER, item, slot);
  }
 
  bool PredictiveTakeEntityToTargetAttachmentEx(notnull EntityAI target, notnull EntityAI item, int slot)
  {
    if (GetGame().IsMultiplayer())
      return GetInventory().TakeEntityAsTargetAttachmentEx(InventoryMode.JUNCTURE, target, item, slot);
    else
      return GetInventory().TakeEntityAsTargetAttachmentEx(InventoryMode.PREDICTIVE, target, item, slot);
  }
  bool LocalTakeEntityToTargetAttachmentEx(notnull EntityAI target, notnull EntityAI item, int slot)
  {
    return GetInventory().TakeEntityAsTargetAttachmentEx(InventoryMode.LOCAL, target, item, slot);
  }
  bool ServerTakeEntityToTargetAttachmentEx(notnull EntityAI target, notnull EntityAI item, int slot)
  {
    return GetInventory().TakeEntityAsTargetAttachmentEx(InventoryMode.SERVER, target, item, slot);
  }
 
  bool PredictiveTakeEntityToTargetAttachment(notnull EntityAI target, notnull EntityAI item)
  {
    if (GetGame().IsMultiplayer())
      return GetInventory().TakeEntityAsTargetAttachment(InventoryMode.JUNCTURE, target, item);
    else
      return GetInventory().TakeEntityAsTargetAttachment(InventoryMode.PREDICTIVE, target, item);
  }
  bool LocalTakeEntityToTargetAttachment(notnull EntityAI target, notnull EntityAI item)
  {
    return GetInventory().TakeEntityAsTargetAttachment(InventoryMode.LOCAL, target, item);
  }
  bool ServerTakeEntityToTargetAttachment(notnull EntityAI target, notnull EntityAI item)
  {
    return GetInventory().TakeEntityAsTargetAttachment(InventoryMode.SERVER, target, item);
  }
 
  bool PredictiveTakeToDst(notnull InventoryLocation src, notnull InventoryLocation dst)
  {
    if (GetGame().IsMultiplayer())
      return GetInventory().TakeToDst(InventoryMode.JUNCTURE, src, dst);
    else
      return GetInventory().TakeToDst(InventoryMode.PREDICTIVE, src, dst);
  }
  bool LocalTakeToDst(notnull InventoryLocation src, notnull InventoryLocation dst)
  {
    return GetInventory().TakeToDst(InventoryMode.LOCAL, src, dst);
  }
  bool ServerTakeToDst(notnull InventoryLocation src, notnull InventoryLocation dst)
  {
    return GetInventory().TakeToDst(InventoryMode.SERVER, src, dst);
  }
 
  bool PredictiveTakeEntityAsAttachment(notnull EntityAI item)
  {
    if (GetGame().IsMultiplayer())
      return GetInventory().TakeEntityAsAttachment(InventoryMode.JUNCTURE, item);
    else
      return GetInventory().TakeEntityAsAttachment(InventoryMode.PREDICTIVE, item);
  }
  bool LocalTakeEntityAsAttachment(notnull EntityAI item)
  {
    return GetInventory().TakeEntityAsAttachment(InventoryMode.LOCAL, item);
  }
  bool ServerTakeEntityAsAttachment(notnull EntityAI item)
  {
    return GetInventory().TakeEntityAsAttachment(InventoryMode.SERVER, item);
  }
 
  bool PredictiveDropEntity(notnull EntityAI item)
  {
    return false;
  }
 
  bool LocalDropEntity(notnull EntityAI item)
  {
    return false;
  }
 
  bool ServerDropEntity(notnull EntityAI item)
  {
    return false;
  }
 
  EntityAI GetAttachmentByType(typename type)
  {
    for (int i = 0; i < GetInventory().AttachmentCount(); i++)
    {
      EntityAI attachment = GetInventory().GetAttachmentFromIndex(i);
      if (attachment && attachment.IsInherited(type))
        return attachment;
    }
    return NULL;
  }
 
  EntityAI GetAttachmentByConfigTypeName(string type)
  {
    for (int i = 0; i < GetInventory().AttachmentCount(); i++)
    {
      EntityAI attachment = GetInventory().GetAttachmentFromIndex(i);
      if (attachment.IsKindOf(type))
        return attachment;
    }
    return NULL;
  }
  bool CanDropEntity(notnull EntityAI item)
  {
    return true;
  }
 
  EntityAI SpawnInInventoryOrGroundPos(string object_name, GameInventory inv, vector pos)
  {
    if (inv)
    {
      EntityAI res = inv.CreateInInventory(object_name);
      if (res)
        return res;
    }
 
    return SpawnEntityOnGroundPos(object_name, pos);
  }
 
  EntityAI SpawnEntityOnGroundPos(string object_name, vector pos)
  {
    InventoryLocation il = new InventoryLocation();
    vector mat[4];
    Math3D.MatrixIdentity4(mat);
    mat[3] = pos;
    il.SetGround(NULL, mat);
    return SpawnEntity(object_name, il, ECE_PLACE_ON_SURFACE, RF_DEFAULT);
  }
  EntityAI SpawnEntityOnGround(string object_name, vector mat[4])
  {
    InventoryLocation il = new InventoryLocation();
    il.SetGround(NULL, mat);
    return SpawnEntity(object_name, il, ECE_PLACE_ON_SURFACE, RF_DEFAULT);
  }
 
  //----------------------------------------------------------------
 
  bool CanSwapEntities(EntityAI otherItem, InventoryLocation otherDestination, InventoryLocation destination)
  {
    return true;
  }
 
  // Forward declarations to allow lower modules to access properties that are modified from higher modules
  // These are mainly used within the ItemBase
  void SetWet(float value, bool allow_client = false);
  void AddWet(float value);
  void SetWetMax();
 
  float GetWet()
  {
    return 0;
  }
 
  float GetWetMax()
  {
    return 0;
  }
 
  float GetWetMin()
  {
    return 0;
  }
 
  float GetWetInit()
  {
    return 0;
  }
 
  bool HasWetness()
  {
    return GetWetMax() - GetWetMin() != 0;
  }
 
  void OnWetChanged(float newVal, float oldVal);
 
  void OnWetLevelChanged(EWetnessLevel newLevel, EWetnessLevel oldLevel);
  // ! Returns current wet level of the entity
  EWetnessLevel GetWetLevel();
 
  // ! Calculates wet level from a given wetness, to get level of an entity, use 'GetWetLevel()' instead
  static EWetnessLevel GetWetLevelInternal(float wetness)
  {
    if (wetness < GameConstants.STATE_DAMP)
      return EWetnessLevel.DRY;
    else if (wetness < GameConstants.STATE_WET)
      return EWetnessLevel.DAMP;
    else if (wetness < GameConstants.STATE_SOAKING_WET)
      return EWetnessLevel.WET;
    else if (wetness < GameConstants.STATE_DRENCHED)
      return EWetnessLevel.SOAKING;
    return EWetnessLevel.DRENCHED;
  }
  //----------------------------------------------------------------
 
  float GetQuantity()
  {
    return 0;
  }
 
  int GetQuantityMax()
  {
    return 0;
  }
 
  void SetQuantityToMinimum();
 
  int GetTargetQuantityMax(int attSlotID = -1)
  {
    return 0;
  }
 
  int GetQuickBarBonus()
  {
    return 0;
  }
 
  //----------------------------------------------------------------
 
  void SetTemperature(float value, bool allow_client = false) {};
  void AddTemperature(float value) {};
  void SetTemperatureMax() {};
 
  float GetTemperature()
  {
    return 0;
  }
 
  float GetTemperatureInit()
  {
    return 0;
  }
 
  float GetTemperatureMin()
  {
    return 0;
  }
 
  float GetTemperatureMax()
  {
    return 0;
  }
 
  //----------------------------------------------------------------
 
  HiddenSelectionsData GetHiddenSelectionsData()
  {
    return m_HiddenSelectionsData;
  }
 
  int GetHiddenSelectionIndex(string selection)
  {
    if (m_HiddenSelectionsData)
      return m_HiddenSelectionsData.GetHiddenSelectionIndex(selection);
 
    return -1;
  }
 
  override TStringArray GetHiddenSelections()
  {
    if (m_HiddenSelectionsData)
      return m_HiddenSelectionsData.m_HiddenSelections;
    else
      return super.GetHiddenSelections();
  }
 
  override TStringArray GetHiddenSelectionsTextures()
  {
    if (m_HiddenSelectionsData)
      return m_HiddenSelectionsData.m_HiddenSelectionsTextures;
    else
      return super.GetHiddenSelectionsTextures();
  }
 
  override TStringArray GetHiddenSelectionsMaterials()
  {
    if (m_HiddenSelectionsData)
      return m_HiddenSelectionsData.m_HiddenSelectionsMaterials;
    else
      return super.GetHiddenSelectionsMaterials();
  }
 
  proto native void PlaceOnSurfaceRotated(out vector trans[4], vector pos, float dx = 0, float dz = 0, float fAngle = 0, bool align = false);
 
  proto native void RegisterNetSyncVariableBool(string variableName);
 
  proto native void RegisterNetSyncVariableBoolSignal(string variableName);
 
  proto native void RegisterNetSyncVariableInt(string variableName, int minValue = 0, int maxValue = 0);
 
  proto native void RegisterNetSyncVariableFloat(string variableName, float minValue = 0, float maxValue = 0, int precision = 1);
 
  proto native void RegisterNetSyncVariableObject(string variableName);
 
  proto native void UpdateNetSyncVariableInt(string variableName, float minValue = 0, float maxValue = 0);
  proto native void UpdateNetSyncVariableFloat(string variableName, float minValue = 0, float maxValue = 0, int precision = 1);
 
  proto native void SwitchLight(bool isOn);
 
  proto native void SetSimpleHiddenSelectionState(int index, bool state);
  proto native bool IsSimpleHiddenSelectionVisible(int index);
 
  proto native void SetObjectTexture(int index, string texture_name);
  proto native owned string GetObjectTexture(int index);
  proto native void SetObjectMaterial(int index, string mat_name);
  proto native owned string GetObjectMaterial(int index);
 
  proto native bool IsPilotLight();
  proto native void SetPilotLight(bool isOn);
 
  void OnStoreSave(ParamsWriteContext ctx)
  {
    // Saving of energy related states
    if (m_EM)
    {
      // Save energy amount
      ctx.Write(m_EM.GetEnergy());
 
      // Save passive/active state
      ctx.Write(m_EM.IsPassive());
 
      // Save ON/OFF state
      ctx.Write(m_EM.IsSwitchedOn());
 
      // Save plugged/unplugged state
      ctx.Write(m_EM.IsPlugged());
 
      // ENERGY SOURCE
      // Save energy source IDs
      EntityAI energy_source = m_EM.GetEnergySource();
      int b1 = 0;
      int b2 = 0;
      int b3 = 0;
      int b4 = 0;
 
      if (energy_source)
        energy_source.GetPersistentID(b1, b2, b3, b4);
 
      ctx.Write(b1); // Save energy source block 1
      ctx.Write(b2); // Save energy source block 2
      ctx.Write(b3); // Save energy source block 3
      ctx.Write(b4); // Save energy source block 4
    }
  }
 
  bool OnStoreLoad(ParamsReadContext ctx, int version)
  {
    // Restoring of energy related states
 
    if (m_EM)
    {
      // Load energy amount
      float f_energy = 0;
      if (!ctx.Read(f_energy))
        f_energy = 0;
      m_EM.SetEnergy(f_energy);
 
      // Load passive/active state
      bool b_is_passive = false;
      if (!ctx.Read(b_is_passive))
        return false;
      m_EM.SetPassiveState(b_is_passive);
 
      // Load ON/OFF state
      bool b_is_on = false;
      if (!ctx.Read(b_is_on))
      {
        m_EM.SwitchOn();
        return false;
      }
 
      // Load plugged/unplugged state
      bool b_is_plugged = false;
      if (!ctx.Read(b_is_plugged))
        return false;
 
      // ENERGY SOURCE
      if (version <= 103)
      {
        // Load energy source ID low
        int i_energy_source_ID_low = 0; // Even 0 can be valid ID!
        if (!ctx.Read(i_energy_source_ID_low))
          return false;
 
        // Load energy source ID high
        int i_energy_source_ID_high = 0; // Even 0 can be valid ID!
        if (!ctx.Read(i_energy_source_ID_high))
          return false;
      }
      else
      {
        int b1 = 0;
        int b2 = 0;
        int b3 = 0;
        int b4 = 0;
 
        if (!ctx.Read(b1)) return false;
        if (!ctx.Read(b2)) return false;
        if (!ctx.Read(b3)) return false;
        if (!ctx.Read(b4)) return false;
 
        if (b_is_plugged)
        {
          // Because function GetEntityByPersitentID() cannot be called here, ID values must be stored and used later.
          m_EM.StoreEnergySourceIDs(b1, b2, b3, b4);
          m_EM.RestorePlugState(true);
        }
      }
 
      if (b_is_on)
        m_EM.SwitchOn();
    }
    return true;
  }
 
  proto native void SetSynchDirty();
 
  void OnVariablesSynchronized()
  {
    if (m_EM)
    {
      if (GetGame().IsMultiplayer())
      {
        bool is_on = m_EM.IsSwitchedOn();
 
        if (is_on != m_EM.GetPreviousSwitchState())
        {
          if (is_on)
            m_EM.SwitchOn();
          else
            m_EM.SwitchOff();
        }
 
        int id_low = m_EM.GetEnergySourceNetworkIDLow();
        int id_High = m_EM.GetEnergySourceNetworkIDHigh();
 
        EntityAI energy_source = EntityAI.Cast(GetGame().GetObjectByNetworkId(id_low, id_High));
 
        if (energy_source)
        {
          ComponentEnergyManager esem = energy_source.GetCompEM();
 
          if (!esem)
          {
            string object = energy_source.GetType();
            Error("Synchronization error! Object " + object + " has no instance of the Energy Manager component!");
          }
 
          m_EM.PlugThisInto(energy_source);
 
        }
        else
          m_EM.UnplugThis();
 
        m_EM.DeviceUpdate();
        m_EM.StartUpdates();
      }
    }
  }
 
  proto native void SetAITargetCallbacks(AbstractAITargetCallbacks callbacks);
 
  override void EOnFrame(IEntity other, float timeSlice)
  {
    if (m_ComponentsBank != NULL)
    {
      for (int comp_key = 0; comp_key < COMP_TYPE_COUNT; ++comp_key)
      {
        if (m_ComponentsBank.IsComponentAlreadyExist(comp_key))
          m_ComponentsBank.GetComponent(comp_key).Event_OnFrame(other, timeSlice);
      }
    }
  }
 
  string GetDebugText()
  {
    string text = string.Empty;
 
    text += "Weight: " + GetWeightEx() + "\n";
    text += "Disabled: " + GetIsSimulationDisabled() + "\n";
#ifdef SERVER
    if (GetEconomyProfile())
      text += "CE Lifetime default: " + (int)GetEconomyProfile().GetLifetime() + "\n";
    text += "CE Lifetime remaining: " + (int)GetLifetime() + "\n";
#endif
 
    ComponentEnergyManager compEM = GetCompEM();
    if (compEM)
    {
      text += "Energy Source: " + Object.GetDebugName(compEM.GetEnergySource()) + "\n";
      text += "Switched On: " + compEM.IsSwitchedOn() + "\n";
      text += "Is Working: " + compEM.IsWorking() + "\n";
    }
 
    return text;
  }
 
 
  void GetDebugButtonNames(out string button1, out string button2, out string button3, out string button4) {} //DEPRICATED, USE GetDebugActions / OnAction
  void OnDebugButtonPressClient(int button_index) {} //DEPRICATED, USE GetDebugActions / OnAction
  void OnDebugButtonPressServer(int button_index) {} //DEPRICATED, USE GetDebugActions / OnAction
 
 
  Shape DebugBBoxDraw()
  {
    return GetComponent(COMP_TYPE_ETITY_DEBUG).DebugBBoxDraw();
  }
 
  void DebugBBoxSetColor(int color)
  {
    GetComponent(COMP_TYPE_ETITY_DEBUG).DebugBBoxSetColor(color);
  }
 
  void DebugBBoxDelete()
  {
    GetComponent(COMP_TYPE_ETITY_DEBUG).DebugBBoxDelete();
  }
 
  Shape DebugDirectionDraw(float distance = 1)
  {
    return GetComponent(COMP_TYPE_ETITY_DEBUG).DebugDirectionDraw(distance);
  }
 
  void DebugDirectionSetColor(int color)
  {
    GetComponent(COMP_TYPE_ETITY_DEBUG).DebugDirectionSetColor(color);
  }
 
  void DebugDirectionDelete()
  {
    GetComponent(COMP_TYPE_ETITY_DEBUG).DebugDirectionDelete();
  }
 
  void HideSelection(string selection_name)
  {
    if (!ToDelete())
    {
      SetAnimationPhase(selection_name, 1); // 1 = hide, 0 = unhide!
    }
  }
 
  void ShowSelection(string selection_name)
  {
    if (!ToDelete())
    {
      SetAnimationPhase(selection_name, 0); // 1 = hide, 0 = unhide!
    }
  }
 
  proto void GetPersistentID(out int b1, out int b2, out int b3, out int b4);
 
  proto native void SetLifetime(float fLifeTime);
  proto native float GetLifetime();
  proto native void IncreaseLifetime();
 
  proto native void SetLifetimeMax(float fLifeTime);
  proto native float GetLifetimeMax();
 
  void IncreaseLifetimeUp()
  {
    IncreaseLifetime();
    if (GetHierarchyParent())
      GetHierarchyParent().IncreaseLifetimeUp();
  }
 
 
  // BODY STAGING
  ComponentBodyStaging GetCompBS()
  {
    if (HasComponent(COMP_TYPE_BODY_STAGING))
      return ComponentBodyStaging.Cast(GetComponent(COMP_TYPE_BODY_STAGING));
    return NULL;
  }
 
  ComponentEnergyManager GetCompEM()
  {
    if (m_EM)
      return m_EM;
 
    if (HasComponent(COMP_TYPE_ENERGY_MANAGER))
      return ComponentEnergyManager.Cast(GetComponent(COMP_TYPE_ENERGY_MANAGER));
    return NULL;
  }
 
  bool HasEnergyManager()
  {
    return HasComponent(COMP_TYPE_ENERGY_MANAGER);
  }
 
  // ------ Public Events for Energy manager component. Overwrite these and put your own functionality into them. ------
 
  void OnWorkStart() {}
 
  void OnWork(float consumed_energy) {}
 
  void OnWorkStop() {}
 
  void OnSwitchOn() {}
 
  void OnSwitchOff() {}
 
  void OnIsPlugged(EntityAI source_device) {}
 
  void OnIsUnplugged(EntityAI last_energy_source) {}
 
  void OnOwnSocketTaken(EntityAI device) {}
 
  void OnOwnSocketReleased(EntityAI device) {}
 
  void OnInitEnergy() {}
 
  void OnEnergyConsumed() {}
 
  void OnEnergyAdded() {}
 
  override void OnRPC(PlayerIdentity sender, int rpc_type, ParamsReadContext ctx)
  {
    super.OnRPC(sender, rpc_type, ctx);
 
    if (GetGame().IsClient())
    {
      switch (rpc_type)
      {
      // BODY STAGING - server => client synchronization of skinned state.
      case ERPCs.RPC_BS_SKINNED_STATE:
      {
        Param1<bool> p_skinned_state = new Param1<bool>(false);
        if (ctx.Read(p_skinned_state))
        {
          float state = p_skinned_state.param1;
          if (state && GetCompBS())
            GetCompBS().SetAsSkinnedClient();
        }
        break;
      }
 
      case ERPCs.RPC_EXPLODE_EVENT:
      {
        OnExplodeClient();
        break;
      }
      }
    }
  }
 
#ifdef DIAG_DEVELOPER
  void FixEntity()
  {
    if (!(GetGame().IsServer()))
      return;
    SetFullHealth();
 
    if (GetInventory())
    {
      int i = 0;
      int AttachmentsCount = GetInventory().AttachmentCount();
      if (AttachmentsCount > 0)
      {
        for (i = 0; i < AttachmentsCount; i++)
          GetInventory().GetAttachmentFromIndex(i).FixEntity();
      }
 
      CargoBase cargo = GetInventory().GetCargo();
      if (cargo)
      {
        int cargoCount = cargo.GetItemCount();
        for (i = 0; i < cargoCount; i++)
          cargo.GetItem(i).FixEntity();
      }
    }
  }
#endif
 
  float GetWetWeightModifier()
  {
    return CfgGameplayHandler.GetWetnessWeightModifiers()[GetWetLevel()];
  }
 
  float GetConfigWeightModified()
  {
    return m_ConfigWeight * GetWetWeightModifier();
  }
 
#ifdef DEVELOPER
  string GetConfigWeightModifiedDebugText()
  {
    if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
      return "(" + m_ConfigWeight + "(config weight) * " + GetWetWeightModifier() + "(Wetness Modifier))";
    return string.Empty;
  }
#endif
 
 
  //Obsolete, use GetWeightEx()
  int GetWeight()
  {
    return GetWeightEx();
  }
 
  void ClearWeightDirty()
  {
    //Print("ent:" + this + " - ClearWeightDirty");
    m_WeightDirty = 0;
  }
 
  void SetWeightDirty()
  {
#ifdef DEVELOPER
    if (WeightDebug.m_VerbosityFlags & WeightDebugType.SET_DIRTY_FLAG)
    {
      Print("---------------------------------------");
      Print("ent:" + this + " - SetWeightDirty");
      if (WeightDebug.m_VerbosityFlags & WeightDebugType.DUMP_STACK)
        DumpStack();
      Print("---------------------------------------");
    }
#endif
    m_WeightDirty = 1;
    if (GetHierarchyParent())
      GetHierarchyParent().SetWeightDirty();
  }
  // returns weight of all cargo and attachments
  float GetInventoryAndCargoWeight(bool forceRecalc = false)
  {
    float totalWeight;
    if (GetInventory())
    {
      int i = 0;
      int AttachmentsCount = GetInventory().AttachmentCount();
      if (AttachmentsCount > 0)
      {
        for (i = 0; i < AttachmentsCount; i++)
          totalWeight += GetInventory().GetAttachmentFromIndex(i).GetWeightEx(forceRecalc);
      }
 
      CargoBase cargo = GetInventory().GetCargo();
      if (cargo)
      {
        int cargoCount = cargo.GetItemCount();
        for (i = 0; i < cargoCount; i++)
          totalWeight += cargo.GetItem(i).GetWeightEx(forceRecalc);
      }
    }
    return totalWeight;
  }
  protected float GetWeightSpecialized(bool forceRecalc = false)
  {
    return GetInventoryAndCargoWeight(forceRecalc);
  }
 
  //this method is not meant to be overriden, to adjust weight calculation for specific item type, override 'GetWeightSpecialized(bool forceRecalc = false)' instead
  float GetWeightEx(bool forceRecalc = false)
  {
    if (m_WeightDirty || forceRecalc)//recalculate
    {
      m_WeightEx = GetWeightSpecialized(forceRecalc);
      ClearWeightDirty();
 
#ifdef DEVELOPER
      if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
        WeightDebug.GetWeightDebug(this).SetWeight(m_WeightEx);
      if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_DIRTY)
      {
        Print("ent:" + this + " - Dirty Recalc");
        if (WeightDebug.m_VerbosityFlags & WeightDebugType.DUMP_STACK)
          DumpStack();
      }
#endif
    }
 
    return m_WeightEx;
  }
 
  void UpdateWeight(WeightUpdateType updateType = WeightUpdateType.FULL, float weightAdjustment = 0);
 
  float GetSingleInventoryItemWeightEx() {}
 
  void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
  {
    //fix entity
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.FIX_ENTITY, "Fix Entity", FadeColors.LIGHT_GREY));
 
    //weight
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.GET_TOTAL_WEIGHT, "Print Weight", FadeColors.LIGHT_GREY));
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.GET_TOTAL_WEIGHT_RECALC, "Print Weight Verbose", FadeColors.LIGHT_GREY));
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.GET_PLAYER_WEIGHT, "Print Player Weight", FadeColors.LIGHT_GREY));
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.GET_PLAYER_WEIGHT_RECALC, "Print Player Weight Verbose", FadeColors.LIGHT_GREY));
  }
  bool OnAction(int action_id, Man player, ParamsReadContext ctx)
  {
    if (action_id == EActions.FIX_ENTITY)
    {
#ifdef DIAG_DEVELOPER
      FixEntity();
#endif
    }
    else if (action_id == EActions.GET_TOTAL_WEIGHT) //Prints total weight of item + its contents
    {
      WeightDebug.ClearWeightDebug();
#ifndef SERVER
      Debug.Log("======================== " + GetType() + " =================================");
#endif
      Debug.Log("Weight:" + GetWeightEx().ToString());
      Debug.Log("Weight excluding cargo and attachments:" + GetSingleInventoryItemWeightEx());
      Debug.Log("----------------------------------------------------------------------------------------------");
    }
    else if (action_id == EActions.GET_TOTAL_WEIGHT_RECALC) //Prints total weight of item + its contents
    {
      WeightDebug.ClearWeightDebug();
      WeightDebug.SetVerbosityFlags(WeightDebugType.RECALC_FORCED);
#ifndef SERVER
      Debug.Log("======================== " + GetType() + " RECALC ===========================");
#endif
      Debug.Log("Weight:" + GetWeightEx(true).ToString());
      Debug.Log("Weight excluding cargo and attachments:" + GetSingleInventoryItemWeightEx());
      WeightDebug.PrintAll(this);
      Debug.Log("----------------------------------------------------------------------------------------------");
      WeightDebug.SetVerbosityFlags(0);
    }
    else if (action_id == EActions.GET_PLAYER_WEIGHT) //Prints total weight of item + its contents
    {
      WeightDebug.ClearWeightDebug();
#ifndef SERVER
      Debug.Log("======================== PLAYER: " + player + " ===========================");
#endif
      Debug.Log("New overall weight Player:" + player.GetWeightEx().ToString());
 
      Debug.Log("----------------------------------------------------------------------------------------------");
    }
    else if (action_id == EActions.GET_PLAYER_WEIGHT_RECALC) //Prints total weight of item + its contents
    {
      WeightDebug.ClearWeightDebug();
      WeightDebug.SetVerbosityFlags(WeightDebugType.RECALC_FORCED);
#ifndef SERVER
      Debug.Log("======================== PLAYER RECALC: " + player + " ===========================");
#endif
      Debug.Log("New overall weight Player:" + player.GetWeightEx(true).ToString());
      WeightDebug.PrintAll(player);
      Debug.Log("----------------------------------------------------------------------------------------------");
      WeightDebug.SetVerbosityFlags(0);
    }
    return false;
  }
 
  int m_ViewIndex = 0;
 
  void SetViewIndex(int index)
  {
    m_ViewIndex = index;
 
    if (GetGame().IsServer())
      SetSynchDirty();
  }
 
  int GetViewIndex()
  {
    if (MemoryPointExists("invView2"))
    {
#ifdef PLATFORM_WINDOWS
      InventoryLocation il = new InventoryLocation();
      GetInventory().GetCurrentInventoryLocation(il);
      InventoryLocationType type = il.GetType();
      switch (type)
      {
      case InventoryLocationType.CARGO:
      {
        return 0;
      }
      case InventoryLocationType.ATTACHMENT:
      {
        return 1;
      }
      case InventoryLocationType.HANDS:
      {
        return 0;
      }
      case InventoryLocationType.GROUND:
      {
        return 1;
      }
      case InventoryLocationType.PROXYCARGO:
      {
        return 0;
      }
      default:
      {
        return 0;
      }
      }
#endif
 
#ifdef PLATFORM_CONSOLE
      return 1;
#endif
    }
    return 0;
  }
 
  string GetHitComponentForAI()
  {
    Debug.LogError("EntityAI: HitComponentForAI not set properly for that entity (" + GetType() + ")");
    return "";
  }
 
  string GetDefaultHitComponent()
  {
    Debug.LogError("EntityAI: DefaultHitComponent not set properly for that entity (" + GetType() + ")");
    return "";
  }
 
  string GetDefaultHitPositionComponent()
  {
    Debug.LogError("EntityAI: DefaultHitPositionComponent not set for that entity (" + GetType() + ")");
    return "";
  }
 
  array<string> GetSuitableFinisherHitComponents()
  {
    Debug.LogError("EntityAI: SuitableFinisherHitComponents not set for that entity (" + GetType() + ")");
    return null;
  }
 
  vector GetDefaultHitPosition()
  {
    Debug.LogError("EntityAI: DefaultHitPosition not set for that entity (" + GetType() + ")");
    return vector.Zero;
  }
 
  int GetMeleeTargetType()
  {
    return EMeleeTargetType.ALIGNABLE;
  }
 
  string GetAttachmentSoundType()
  {
    return "None";
  }
 
  bool IsHeavyBehaviour()
  {
    return false;
  }
 
  bool IsOneHandedBehaviour()
  {
    return false;
  }
 
  bool IsTwoHandedBehaviour()
  {
    return false;
  }
 
  string ChangeIntoOnAttach(string slot) {}
  string ChangeIntoOnDetach() {}
 
  void OnCEUpdate()
  {
    float currentTime = GetGame().GetTickTime();
    if (m_LastUpdatedTime == 0)
      m_LastUpdatedTime = currentTime;
 
    m_ElapsedSinceLastUpdate = currentTime - m_LastUpdatedTime;
    m_LastUpdatedTime = currentTime;
  }
 
  void OnDebugSpawnEx(DebugSpawnParams params)
  {
    OnDebugSpawn();
  }
 
  void OnDebugSpawn()
  {
    array<string> slots = new array<string>;
    ConfigGetTextArray("Attachments", slots);
 
    array<string> mags = new array<string>;
    ConfigGetTextArray("magazines", mags);
 
    //-------
 
    TStringArray all_paths = new TStringArray;
 
    all_paths.Insert(CFG_VEHICLESPATH);
    all_paths.Insert(CFG_MAGAZINESPATH);
    all_paths.Insert(CFG_WEAPONSPATH);
 
    string config_path;
    string child_name;
    int scope;
    string path;
    int consumable_count;
 
    for (int i = 0; i < all_paths.Count(); i++)
    {
      config_path = all_paths.Get(i);
      int children_count = GetGame().ConfigGetChildrenCount(config_path);
 
      for (int x = 0; x < children_count; x++)
      {
        GetGame().ConfigGetChildName(config_path, x, child_name);
        path = config_path + " " + child_name;
        scope = GetGame().ConfigGetInt(config_path + " " + child_name + " scope");
        bool should_check = 1;
        if (config_path == "CfgVehicles" && scope == 0)
          should_check = 0;
 
        if (should_check)
        {
          string inv_slot;
          GetGame().ConfigGetText(config_path + " " + child_name + " inventorySlot", inv_slot);
          for (int z = 0; z < slots.Count(); z++)
          {
            if (slots.Get(z) == inv_slot)
            {
              this.GetInventory().CreateInInventory(child_name);
              continue;
              //Print("matching attachment: " + child_name + " for inv. slot name:" +inv_slot);
            }
          }
        }
      }
    }
  };
 
  override EntityAI ProcessMeleeItemDamage(int mode = 0)
  {
    if (GetGame().IsServer())
      AddHealth("", "Health", -MELEE_ITEM_DAMAGE);
    return this;
  }
 
  float GetLiquidThroughputCoef()
  {
    return LIQUID_THROUGHPUT_DEFAULT;
  }
 
  string GetInvulnerabilityTypeString()
  {
    return "";
  }
 
  void ProcessInvulnerabilityCheck(string servercfg_param)
  {
    if (GetGame() && GetGame().IsMultiplayer() && GetGame().IsServer())
    {
      int invulnerability;
      switch (servercfg_param)
      {
      case "disableContainerDamage":
        invulnerability = CfgGameplayHandler.GetDisableContainerDamage();
        break;
 
      case "disableBaseDamage":
        invulnerability = CfgGameplayHandler.GetDisableBaseDamage();
        break;
      }
 
      if (invulnerability > 0)
        SetAllowDamage(false);
    }
  }
 
  void SetBayonetAttached(bool pState, int slot_idx = -1) {};
  bool HasBayonetAttached() {};
  int GetBayonetAttachmentIdx() {};
 
  void SetButtstockAttached(bool pState, int slot_idx = -1) {};
  bool HasButtstockAttached() {};
  int GetButtstockAttachmentIdx() {};
 
  void SetInvisibleRecursive(bool invisible, EntityAI parent = null, array<int> attachments = null)
  {
    array<int> childrenAtt = new array<int>;
    array<int> attachmentsArray = new array<int>;
    if (attachments)
      attachmentsArray.Copy(attachments);
    else
    {
      for (int i = 0; i < GetInventory().GetAttachmentSlotsCount(); i++)
        attachmentsArray.Insert(GetInventory().GetAttachmentSlotId(i));
    }
 
    EntityAI item;
 
    foreach (int slot : attachmentsArray)
    {
      if (parent)
        item = parent.GetInventory().FindAttachment(slot);
      else
        item = this;//GetInventory().FindAttachment(slot);
 
      if (item)
      {
        if (item.GetInventory().AttachmentCount() > 0)
        {
          for (i = 0; i < item.GetInventory().GetAttachmentSlotsCount(); i++)
            childrenAtt.Insert(item.GetInventory().GetAttachmentSlotId(i));
 
          SetInvisibleRecursive(invisible, item, childrenAtt);
        }
 
        item.SetInvisible(invisible);
        item.OnInvisibleSet(invisible);
      }
    }
  }
 
  void SoundHardTreeFallingPlay()
  {
    EffectSound sound = SEffectManager.PlaySound("hardTreeFall_SoundSet", GetPosition());
    sound.SetAutodestroy(true);
  }
 
  void SoundSoftTreeFallingPlay()
  {
    EffectSound sound = SEffectManager.PlaySound("softTreeFall_SoundSet", GetPosition());
    sound.SetAutodestroy(true);
  }
 
  void SoundHardBushFallingPlay()
  {
    EffectSound sound = SEffectManager.PlaySound("hardBushFall_SoundSet", GetPosition());
    sound.SetAutodestroy(true);
  }
 
  void SoundSoftBushFallingPlay()
  {
    EffectSound sound = SEffectManager.PlaySound("softBushFall_SoundSet", GetPosition());
    sound.SetAutodestroy(true);
  }
 
  void RegisterTransportHit(Transport transport)
  {
    if (!m_TransportHitRegistered)
    {
      m_TransportHitRegistered = true;
      m_TransportHitVelocity = GetVelocity(transport);
      Car car;
      float damage;
      vector impulse;
 
      // a different attempt to solve hits from "standing" car to the players
      if (Car.CastTo(car, transport))
      {
        if (car.GetSpeedometerAbsolute() > 2)
        {
          damage = m_TransportHitVelocity.Length();
          ProcessDirectDamage(DT_CUSTOM, transport, "", "TransportHit", "0 0 0", damage);
        }
        else
          m_TransportHitRegistered = false;
 
        // compute impulse and apply only if the body dies
        if (IsDamageDestroyed() && car.GetSpeedometerAbsolute() > 3)
        {
          impulse = 40 * m_TransportHitVelocity;
          impulse[1] = 40 * 1.5;
          dBodyApplyImpulse(this, impulse);
        }
      }
      else //old solution just in case if somebody use it
      {
        // avoid damage because of small movements
        if (m_TransportHitVelocity.Length() > 0.1)
        {
          damage = m_TransportHitVelocity.Length();
          ProcessDirectDamage(DT_CUSTOM, transport, "", "TransportHit", "0 0 0", damage);
        }
        else
          m_TransportHitRegistered = false;
 
        // compute impulse and apply only if the body dies
        if (IsDamageDestroyed() && m_TransportHitVelocity.Length() > 0.3)
        {
          impulse = 40 * m_TransportHitVelocity;
          impulse[1] = 40 * 1.5;
          dBodyApplyImpulse(this, impulse);
        }
      }
    }
  }
 
  bool GetInventoryHandAnimation(notnull InventoryLocation loc, out int value)
  {
    value = -1;
    return false;
  }
 
  bool TranslateSlotFromSelection(string selection_name, out int slot_id)
  {
    return false;
  }
 
  bool IsUniversalTemperatureSource()
  {
    return GetUniversalTemperatureSource() != null && GetUniversalTemperatureSource().IsActive();
  }
 
  UTemperatureSource GetUniversalTemperatureSource()
  {
    return m_UniversalTemperatureSource;
  }
 
  void SetUniversalTemperatureSource(UTemperatureSource uts)
  {
    m_UniversalTemperatureSource = uts;
  }
 
  vector GetUniversalTemperatureSourcePosition()
  {
    return GetPosition();
  }
 
  RemotelyActivatedItemBehaviour GetRemotelyActivatedItemBehaviour();
 
  void PairRemote(notnull EntityAI trigger);
 
  void UnpairRemote();
 
  EntityAI GetPairDevice();
 
  void SetPersistentPairID(int id)
  {
    RemotelyActivatedItemBehaviour raib = GetRemotelyActivatedItemBehaviour();
    if (raib)
      raib.SetPersistentPairID(id);
  }
 
  bool HasTurnableValveBehavior();
  bool IsValveTurnable(int pValveIndex);
  int GetTurnableValveIndex(int pComponentIndex);
  void ExecuteActionsConnectedToValve(int pValveIndex);
 
  // attachment exclusion section //
  private void InitAttachmentExclusionValues()
  {
    m_AttachmentExclusionSlotMap = new map<int, ref set<int>>();
    m_AttachmentExclusionMaskGlobal = new set<int>;
    m_AttachmentExclusionMaskChildren = new set<int>();
 
    int count = GetInventory().GetSlotIdCount();
    //no sense in performing inits for something that cannot be attached anywhere (hand/lefthand and some other 'special' slots are the reason for creating 'new' sets above)
    if (count == 0)
      return;
 
    InitInherentSlotExclusionMap();
    InitGlobalExclusionValues();
    InitLegacyConfigExclusionValues();
  }
 
  private void InitInherentSlotExclusionMap()
  {
    int count = GetInventory().GetSlotIdCount();
    //starting with the INVALID slot, so it is always in the map of attachable items
    SetAttachmentExclusionMaskSlot(InventorySlots.INVALID, GetAttachmentExclusionInitSlotValue(InventorySlots.INVALID));
 
    int slotId;
    for (int i = 0; i < count; i++)
    {
      slotId = GetInventory().GetSlotId(i);
      SetAttachmentExclusionMaskSlot(slotId, GetAttachmentExclusionInitSlotValue(slotId));
    }
  }
 
  protected set<int> GetAttachmentExclusionInitSlotValue(int slotId)
  {
    set<int> dflt = new set<int>;
    return dflt;
  }
 
  //Initiated last, and only for items that do not have others defined already
  protected void InitLegacyConfigExclusionValues()
  {
    bool performLegacyInit = InitLegacyExclusionCheck();
 
    //adding implicit slot info AFTER the check is performed
    InitLegacySlotExclusionValuesImplicit();
 
    if (performLegacyInit)
      InitLegacySlotExclusionValuesDerived();
  }
 
  //returns 'false' if the script initialization
  protected bool InitLegacyExclusionCheck()
  {
    //first check the globals
    if (m_AttachmentExclusionMaskGlobal.Count() > 0)
      return false;
 
    //now the map
    int count = m_AttachmentExclusionSlotMap.Count();
    if (count > 1) //more than InventorySlots.INVALID
    {
      for (int i = 0; i < count; i++)
      {
        int countSet = m_AttachmentExclusionSlotMap.GetElement(i).Count();
        if (countSet > 0) //SOMETHING is defined
          return false;
      }
    }
 
    return true;
  }
 
  protected void InitLegacySlotExclusionValuesImplicit()
  {
    int slotId;
    int slotCount = GetInventory().GetSlotIdCount();
    for (int i = 0; i < slotCount; i++)
    {
      slotId = GetInventory().GetSlotId(i);
      set<int> tmp;
      switch (slotId)
      {
      case InventorySlots.HEADGEAR:
      {
        tmp = new set<int>;
        tmp.Copy(GetAttachmentExclusionInitSlotValue(slotId));
        tmp.Insert(EAttExclusions.LEGACY_HEADGEAR_MASK);
        tmp.Insert(EAttExclusions.LEGACY_HEADGEAR_HEADSTRAP);
        tmp.Insert(EAttExclusions.LEGACY_HEADGEAR_EYEWEWEAR);
        SetAttachmentExclusionMaskSlot(slotId, tmp);
        break;
      }
 
      case InventorySlots.MASK:
      {
        tmp = new set<int>;
        tmp.Copy(GetAttachmentExclusionInitSlotValue(slotId));
        tmp.Insert(EAttExclusions.LEGACY_MASK_HEADGEAR);
        tmp.Insert(EAttExclusions.LEGACY_MASK_HEADSTRAP);
        tmp.Insert(EAttExclusions.LEGACY_MASK_EYEWEWEAR);
        SetAttachmentExclusionMaskSlot(slotId, tmp);
        break;
      }
 
      case InventorySlots.EYEWEAR:
      {
        tmp = new set<int>;
        tmp.Copy(GetAttachmentExclusionInitSlotValue(slotId));
        if (ConfigGetBool("isStrap"))
        {
          tmp.Insert(EAttExclusions.LEGACY_HEADSTRAP_HEADGEAR);
          tmp.Insert(EAttExclusions.LEGACY_HEADSTRAP_MASK);
        }
        else
        {
          tmp.Insert(EAttExclusions.LEGACY_EYEWEAR_HEADGEAR);
          tmp.Insert(EAttExclusions.LEGACY_EYEWEAR_MASK);
        }
        SetAttachmentExclusionMaskSlot(slotId, tmp);
        break;
      }
      }
    }
  }
 
  protected void InitLegacySlotExclusionValuesDerived()
  {
    int slotId;
    int slotCount = GetInventory().GetSlotIdCount();
    for (int i = 0; i < slotCount; i++)
    {
      slotId = GetInventory().GetSlotId(i);
      set<int> tmp;
      switch (slotId)
      {
      case InventorySlots.HEADGEAR:
      {
        tmp = new set<int>;
        tmp.Copy(GetAttachmentExclusionMaskSlot(slotId));
        if (ConfigGetBool("noNVStrap"))
          tmp.Insert(EAttExclusions.LEGACY_HEADSTRAP_HEADGEAR);
        if (ConfigGetBool("noMask"))
          tmp.Insert(EAttExclusions.LEGACY_MASK_HEADGEAR);
        if (ConfigGetBool("noEyewear"))
          tmp.Insert(EAttExclusions.LEGACY_EYEWEAR_HEADGEAR);
        SetAttachmentExclusionMaskSlot(slotId, tmp);
        break;
      }
 
      case InventorySlots.MASK:
      {
        tmp = new set<int>;
        tmp.Copy(GetAttachmentExclusionMaskSlot(slotId));
        if (ConfigGetBool("noNVStrap"))
          tmp.Insert(EAttExclusions.LEGACY_HEADSTRAP_MASK);
        if (ConfigGetBool("noHelmet"))
          tmp.Insert(EAttExclusions.LEGACY_HEADGEAR_MASK);
        if (ConfigGetBool("noEyewear"))
          tmp.Insert(EAttExclusions.LEGACY_EYEWEAR_MASK);
        SetAttachmentExclusionMaskSlot(slotId, tmp);
        break;
      }
 
      case InventorySlots.EYEWEAR:
      {
        tmp = new set<int>;
        tmp.Copy(GetAttachmentExclusionMaskSlot(slotId));
        if (ConfigGetBool("isStrap"))
        {
          if (ConfigGetBool("noHelmet"))
            tmp.Insert(EAttExclusions.LEGACY_HEADGEAR_HEADSTRAP);
          if (ConfigGetBool("noMask"))
            tmp.Insert(EAttExclusions.LEGACY_MASK_HEADSTRAP);
        }
        else
        {
          if (ConfigGetBool("noHelmet"))
            tmp.Insert(EAttExclusions.LEGACY_HEADGEAR_EYEWEWEAR);
          if (ConfigGetBool("noMask"))
            tmp.Insert(EAttExclusions.LEGACY_MASK_EYEWEWEAR);
        }
        SetAttachmentExclusionMaskSlot(slotId, tmp);
        break;
      }
      }
    }
  }
 
  protected void InitGlobalExclusionValues();
 
  protected void AddSingleExclusionValueGlobal(EAttExclusions value)
  {
    if (m_AttachmentExclusionMaskGlobal.Find(value) == -1)
      m_AttachmentExclusionMaskGlobal.Insert(value);
  }
 
  protected void ClearSingleExclusionValueGlobal(EAttExclusions value)
  {
    int idx = m_AttachmentExclusionMaskGlobal.Find(value);
    if (idx != -1)
      m_AttachmentExclusionMaskGlobal.Remove(idx);
  }
 
  protected void SetAttachmentExclusionMaskGlobal(set<int> values)
  {
    m_AttachmentExclusionMaskGlobal.Clear();
    m_AttachmentExclusionMaskGlobal.Copy(values);
  }
 
  protected void SetAttachmentExclusionMaskSlot(int slotId, set<int> values)
  {
    if (m_AttachmentExclusionSlotMap)
      m_AttachmentExclusionSlotMap.Set(slotId, values);
    else
      ErrorEx("m_AttachmentExclusionSlotMap not available! Fill the 'inventorySlot[]' in the " + this + " config file.");
  }
 
  private void PropagateExclusionValueRecursive(set<int> values, int slotId)
  {
    if (values && values.Count() != 0)
    {
      set<int> passThis;
      InventoryLocation lcn = new InventoryLocation();
      GetInventory().GetCurrentInventoryLocation(lcn);
      if (CheckExclusionAccessPropagation(lcn.GetSlot(), slotId, values, passThis))
      {
        m_AttachmentExclusionMaskChildren.InsertSet(passThis);
        EntityAI parent = GetHierarchyParent();
        if (parent)
          parent.PropagateExclusionValueRecursive(passThis, lcn.GetSlot());
      }
    }
  }
 
  private void ClearExclusionValueRecursive(set<int> values, int slotId)
  {
    if (values && values.Count() != 0)
    {
      set<int> passThis;
      InventoryLocation lcn = new InventoryLocation();
      GetInventory().GetCurrentInventoryLocation(lcn);
      if (CheckExclusionAccessPropagation(lcn.GetSlot(), slotId, values, passThis))
      {
        int count = passThis.Count();
        for (int i = 0; i < count; i++)
          m_AttachmentExclusionMaskChildren.RemoveItem(passThis[i]);
        EntityAI parent = GetHierarchyParent();
        if (parent)
          parent.ClearExclusionValueRecursive(passThis, lcn.GetSlot());
      }
    }
  }
 
  set<int> GetAttachmentExclusionMaskAll(int slotId)
  {
    set<int> values = new set<int>();
    set<int> slotValues = GetAttachmentExclusionMaskSlot(slotId);
    if (slotValues)
      values.InsertSet(slotValues);
    values.InsertSet(m_AttachmentExclusionMaskGlobal);
    values.InsertSet(m_AttachmentExclusionMaskChildren);
 
    return values;
  }
 
  set<int> GetAttachmentExclusionMaskSlot(int slotId)
  {
    return m_AttachmentExclusionSlotMap.Get(slotId);
  }
 
  set<int> GetAttachmentExclusionMaskGlobal()
  {
    return m_AttachmentExclusionMaskGlobal;
  }
 
  set<int> GetAttachmentExclusionMaskChildren()
  {
    return m_AttachmentExclusionMaskChildren;
  }
 
  private bool HasInternalExclusionConflicts(int targetSlot)
  {
    set<int> targetSlotValues = GetAttachmentExclusionMaskSlot(targetSlot);
    if (targetSlotValues) //can be null, if so, no conflict
    {
      set<int> additionalValues = new set<int>(); //NOT slot values
      additionalValues.InsertSet(GetAttachmentExclusionMaskGlobal());
      additionalValues.InsertSet(GetAttachmentExclusionMaskChildren());
 
      int countTarget = targetSlotValues.Count();
      for (int i = 0; i < countTarget; i++)
      {
        if (additionalValues.Find(targetSlotValues[i]) != -1)
          return true;
      }
    }
    return false;
  }
 
  protected bool IsExclusionFlagPresent(set<int> values)
  {
    int slotId;
    string slotName;
    GetInventory().GetCurrentAttachmentSlotInfo(slotId, slotName); //if currently attached, treat it accordingly
 
    set<int> currentSlotValuesAll = GetAttachmentExclusionMaskAll(slotId);
    int count = values.Count();
    for (int i = 0; i < count; i++)
    {
      if (currentSlotValuesAll.Find(values[i]) != -1)
        return true;
    }
    return false;
  }
 
  protected bool IsExclusionFlagPresentRecursive(set<int> values, int targetSlot)
  {
    if (values && values.Count() != 0)
    {
      InventoryLocation lcn = new InventoryLocation();
      GetInventory().GetCurrentInventoryLocation(lcn);
      EntityAI parent = GetHierarchyParent();
      set<int> passThis;
      if (CheckExclusionAccessCondition(lcn.GetSlot(), targetSlot, values, passThis))
      {
        if (parent && parent != this) //we reached root if false
          return parent.IsExclusionFlagPresentRecursive(passThis, lcn.GetSlot());
      }
      return IsExclusionFlagPresent(passThis);
    }
 
    return false;
  }
 
  protected bool CheckExclusionAccessCondition(int occupiedSlot, int targetSlot, set<int> value, inout set<int> adjustedValue)
  {
    bool occupiedException = occupiedSlot == InventorySlots.HANDS || occupiedSlot == InventorySlots.SHOULDER || occupiedSlot == InventorySlots.MELEE || occupiedSlot == InventorySlots.LEFTHAND;
    bool targetException = targetSlot == InventorySlots.HANDS || targetSlot == InventorySlots.SHOULDER || targetSlot == InventorySlots.MELEE || targetSlot == InventorySlots.LEFTHAND;
 
    if (occupiedException)
    {
      adjustedValue = value;
      return false;
    }
 
    if (targetException)
    {
      adjustedValue = null;
      return false;
    }
 
    AdjustExclusionAccessCondition(occupiedSlot, targetSlot, value, adjustedValue);
    return adjustedValue.Count() != 0;
  }
 
  protected void AdjustExclusionAccessCondition(int occupiedSlot, int testedSlot, set<int> value, inout set<int> adjustedValue)
  {
    adjustedValue = value;
  }
 
  protected bool CheckExclusionAccessPropagation(int occupiedSlot, int targetSlot, set<int> value, inout set<int> adjustedValue)
  {
    bool occupiedException = occupiedSlot == InventorySlots.HANDS || occupiedSlot == InventorySlots.SHOULDER || occupiedSlot == InventorySlots.MELEE || occupiedSlot == InventorySlots.LEFTHAND;
    bool targetException = targetSlot == InventorySlots.HANDS || targetSlot == InventorySlots.SHOULDER || targetSlot == InventorySlots.MELEE || targetSlot == InventorySlots.LEFTHAND || targetSlot == InventorySlots.INVALID;
 
    if (targetException)
    {
      adjustedValue = null;
      return false;
    }
 
    AdjustExclusionAccessPropagation(occupiedSlot, targetSlot, value, adjustedValue);
    return adjustedValue.Count() != 0;
  }
 
  protected void AdjustExclusionAccessPropagation(int occupiedSlot, int testedSlot, set<int> value, inout set<int> adjustedValue)
  {
    AdjustExclusionAccessCondition(occupiedSlot, testedSlot, value, adjustedValue);
  }
 
  bool IsManagingArrows()
  {
    return false;
  }
 
  ArrowManagerBase GetArrowManager()
  {
    return null;
  }
 
  void SetFromProjectile(ProjectileStoppedInfo info)
  {
  }
 
  void ClearInventory();
};
 
#ifdef DEVELOPER
void SetDebugDeveloper_item(Object entity)//without a setter,the place where the setting happens is near impossible to find as way too many hits for "_item" exist
{
  if (entity)
    entity.SetDebugItem();
 
}
Object _item;//watched item goes here(LCTRL+RMB->Watch)
#endif