ItemBase.c

Go to the documentation of this file.

typedef ItemBase Inventory_Base;
 
class DummyItem extends ItemBase
{
  override bool CanPutAsAttachment(EntityAI parent)
  {
    return true;
  }
};
 
//const bool QUANTITY_DEBUG_REMOVE_ME = false;
 
class ItemBase extends InventoryItem
{
  static ref map<typename, ref TInputActionMap> m_ItemTypeActionsMap = new map<typename, ref TInputActionMap>;
  TInputActionMap m_InputActionMap;
  bool  m_ActionsInitialize;
 
  static int  m_DebugActionsMask;
  bool    m_RecipesInitialized;
  // ============================================
  // Variable Manipulation System
  // ============================================
  //ref map<string,string>  m_ItemVarsString;
 
  int   m_VariablesMask;//this holds information about which vars have been changed from their default values
  // Quantity
 
  float   m_VarQuantity;
  float   m_VarQuantityPrev;//for client to know quantity changed during synchronization
  int   m_VarQuantityInit;
  int   m_VarQuantityMin;
  int   m_VarQuantityMax;
  int   m_Count;
  float m_VarStackMax;
  float m_StoreLoadedQuantity = float.LOWEST;
  // Temperature
  float   m_VarTemperature;
  float   m_VarTemperatureInit;
  float   m_VarTemperatureMin;
  float   m_VarTemperatureMax;
  // Wet
  float   m_VarWet;
  float   m_VarWetPrev;//for client to know wetness changed during synchronization
  float   m_VarWetInit;
  float   m_VarWetMin;
  float   m_VarWetMax;
  // Cleanness
  int   m_Cleanness;
  int   m_CleannessInit;
  int   m_CleannessMin;
  int   m_CleannessMax;
  // impact sounds
  bool  m_WantPlayImpactSound;
  bool  m_CanPlayImpactSound = true;
  float m_ImpactSpeed;
  int   m_ImpactSoundSurfaceHash;
  //
  float m_HeatIsolation;
  float   m_ItemModelLength;
  float m_ItemAttachOffset; // Offset length for when the item is attached e.g. to weapon
  int   m_VarLiquidType;
  int   m_ItemBehaviour = -1; // -1 = not specified; 0 = heavy item; 1= onehanded item; 2 = twohanded item
  int   m_QuickBarBonus = 0;
  bool  m_IsBeingPlaced;
  bool  m_IsHologram;
  bool  m_IsPlaceSound;
  bool  m_IsDeploySound;
  bool  m_IsTakeable;
  bool  m_IsSoundSynchRemote;
  bool  m_ThrowItemOnDrop;
  bool  m_ItemBeingDroppedPhys;
  bool    m_CanBeMovedOverride;
  bool  m_FixDamageSystemInit = false; //can be changed on storage version check
  bool  can_this_be_combined = false; //Check if item can be combined
  bool  m_CanThisBeSplit = false; //Check if item can be split
  bool  m_IsStoreLoad = false;
  bool  m_CanShowQuantity;
  bool  m_HasQuantityBar;
  protected bool m_CanBeDigged;
  protected bool m_IsResultOfSplit 
 
  protected EffectSound m_DeployLoopSoundEx;
 
  string  m_SoundAttType;
  // items color variables
  int   m_ColorComponentR;
  int   m_ColorComponentG;
  int   m_ColorComponentB;
  int   m_ColorComponentA;
  //-------------------------------------------------------
 
  // light source managing
  ItemBase m_LightSourceItem;
 
  ref TIntArray m_SingleUseActions;
  ref TIntArray m_ContinuousActions;
  ref TIntArray m_InteractActions;
 
  //==============================================
  // agent system
  private int m_AttachedAgents;
 
  void TransferModifiers(PlayerBase reciever);
 
 
  // Weapons & suppressors particle effects
  ref static map<int, ref array<ref WeaponParticlesOnFire>>         m_OnFireEffect;
  ref static map<int, ref array<ref WeaponParticlesOnBulletCasingEject>>  m_OnBulletCasingEjectEffect;
  ref map<int, ref array<ref WeaponParticlesOnOverheating>>         m_OnOverheatingEffect;
  ref static map<string, int> m_WeaponTypeToID;
  static int m_LastRegisteredWeaponID = 0;
 
  // Overheating effects
  bool                m_IsOverheatingEffectActive;
  float               m_OverheatingShots;
  ref Timer               m_CheckOverheating;
  int                 m_ShotsToStartOverheating = 0; // After these many shots, the overheating effect begins
  int                 m_MaxOverheatingValue = 0; // Limits the number of shots that will be tracked
  float                 m_OverheatingDecayInterval = 1; // Timer's interval for decrementing overheat effect's lifespan
  ref array <ref OverheatingParticle> m_OverheatingParticles;
 
  protected ref TStringArray m_HeadHidingSelections;
  protected bool m_HideSelectionsBySlot;
 
  // Admin Log
  PluginAdminLog      m_AdminLog;
 
  // misc
  ref Timer         m_PhysDropTimer;
 
  // Attachment Locking variables
  ref array<int>        m_CompatibleLocks = new array<int>;
  protected int       m_LockType;
  protected ref EffectSound   m_LockingSound;
  protected string      m_LockSoundSet = "";
 
  protected EffectSound     m_SoundPlace;
  protected EffectSound     m_SoundDeploy;
  protected EffectSound     m_SoundDeployFinish;
 
  // -------------------------------------------------------------------------
  void ItemBase()
  {
    SetEventMask(EntityEvent.INIT); // Enable EOnInit event
    InitItemVariables();
 
    m_SingleUseActions = new TIntArray;
    m_ContinuousActions = new TIntArray;
    m_InteractActions = new TIntArray;
 
    if (!GetGame().IsDedicatedServer())
    {
      if (HasMuzzle())
      {
        LoadParticleConfigOnFire(GetMuzzleID());
 
        if (m_ShotsToStartOverheating == 0)
        {
          LoadParticleConfigOnOverheating(GetMuzzleID());
        }
      }
 
      PreLoadSoundAttachmentType();
      m_ActionsInitialize = false;
    }
 
    m_OldLocation = null;
 
    if (GetGame().IsServer())
    {
      m_AdminLog = PluginAdminLog.Cast(GetPlugin(PluginAdminLog));
    }
 
    if (ConfigIsExisting("headSelectionsToHide"))
    {
      m_HeadHidingSelections = new TStringArray;
      ConfigGetTextArray("headSelectionsToHide",m_HeadHidingSelections);
    }
 
    m_HideSelectionsBySlot = false;
    if (ConfigIsExisting("hideSelectionsByinventorySlot"))
    {
      m_HideSelectionsBySlot = ConfigGetBool("hideSelectionsByinventorySlot");
    }
 
 
 
    m_QuickBarBonus = Math.Max(0, ConfigGetInt("quickBarBonus"));
 
    m_IsResultOfSplit = false;
  }
 
  void InitItemVariables()
  {
    m_VarQuantityInit = ConfigGetInt("varQuantityInit");
    m_VarQuantity = m_VarQuantityInit;//should be by the CE, this is just a precaution
    m_VarQuantityMin = ConfigGetInt("varQuantityMin");
    m_VarQuantityMax = ConfigGetInt("varQuantityMax");
    m_VarStackMax = ConfigGetFloat("varStackMax");
    m_Count = ConfigGetInt("count");
 
    m_CanShowQuantity = ConfigGetBool("quantityShow");
    m_HasQuantityBar = ConfigGetBool("quantityBar");
 
    m_VarTemperatureInit = ConfigGetFloat("varTemperatureInit");
    m_VarTemperature = m_VarTemperatureInit;
    m_VarTemperatureMin = ConfigGetFloat("varTemperatureMin");
    m_VarTemperatureMax = ConfigGetFloat("varTemperatureMax");
 
 
    m_CleannessInit = ConfigGetInt("varCleannessInit");
    m_Cleanness = m_CleannessInit;
    m_CleannessMin = ConfigGetInt("varCleannessMin");
    m_CleannessMax = ConfigGetInt("varCleannessMax");
 
    m_WantPlayImpactSound = false;
    m_ImpactSpeed = 0.0;
 
    m_VarWetInit = ConfigGetFloat("varWetInit");
    m_VarWet = m_VarWetInit;
    m_VarWetMin = ConfigGetFloat("varWetMin");
    m_VarWetMax = ConfigGetFloat("varWetMax");
 
    m_VarLiquidType = GetLiquidTypeInit();
    m_IsBeingPlaced = false;
    m_IsHologram = false;
    m_IsPlaceSound = false;
    m_IsDeploySound = false;
    m_IsTakeable = true;
    m_IsSoundSynchRemote = false;
    m_CanBeMovedOverride = false;
    m_HeatIsolation = GetHeatIsolationInit();
    m_ItemModelLength = GetItemModelLength();
    m_ItemAttachOffset = GetItemAttachOffset();
    m_CanBeDigged = ConfigGetBool("canBeDigged");
 
    ConfigGetIntArray("compatibleLocks", m_CompatibleLocks);
    m_LockType = ConfigGetInt("lockType");
 
    //Define if item can be split and set ability to be combined accordingly
    if (ConfigIsExisting("canBeSplit"))
    {
      can_this_be_combined = ConfigGetBool("canBeSplit");
      m_CanThisBeSplit = can_this_be_combined;
    }
 
    if (ConfigIsExisting("itemBehaviour"))
      m_ItemBehaviour = ConfigGetInt("itemBehaviour");
 
    //RegisterNetSyncVariableInt("m_VariablesMask");
    if (HasQuantity()) RegisterNetSyncVariableFloat("m_VarQuantity", GetQuantityMin(), m_VarQuantityMax);
    RegisterNetSyncVariableFloat("m_VarTemperature", GetTemperatureMin(),GetTemperatureMax());
    RegisterNetSyncVariableFloat("m_VarWet", GetWetMin(), GetWetMax(), 2);
    RegisterNetSyncVariableInt("m_VarLiquidType");
    RegisterNetSyncVariableInt("m_Cleanness",0,1);
 
    RegisterNetSyncVariableBoolSignal("m_WantPlayImpactSound");
    RegisterNetSyncVariableFloat("m_ImpactSpeed");
    RegisterNetSyncVariableInt("m_ImpactSoundSurfaceHash");
 
    RegisterNetSyncVariableInt("m_ColorComponentR", 0, 255);
    RegisterNetSyncVariableInt("m_ColorComponentG", 0, 255);
    RegisterNetSyncVariableInt("m_ColorComponentB", 0, 255);
    RegisterNetSyncVariableInt("m_ColorComponentA", 0, 255);
 
    RegisterNetSyncVariableBool("m_IsBeingPlaced");
    RegisterNetSyncVariableBool("m_IsTakeable");
    RegisterNetSyncVariableBool("m_IsHologram");
 
    if (UsesGlobalDeploy())
    {
      RegisterNetSyncVariableBool("m_IsSoundSynchRemote");
      RegisterNetSyncVariableBool("m_IsDeploySound");
    }
 
    m_LockSoundSet = ConfigGetString("lockSoundSet");
  }
 
  // allows for checking whether or not we can safely register net sync variables without causing VMEs for duplicate registration
  protected bool UsesGlobalDeploy()
  {
    return false;
  }
 
  override int GetQuickBarBonus()
  {
    return m_QuickBarBonus;
  }
 
  void InitializeActions()
  {
    m_InputActionMap = m_ItemTypeActionsMap.Get(this.Type());
    if (!m_InputActionMap)
    {
      TInputActionMap iam = new TInputActionMap;
      m_InputActionMap = iam;
      SetActions();
      m_ItemTypeActionsMap.Insert(this.Type(), m_InputActionMap);
    }
  }
 
  override void GetActions(typename action_input_type, out array<ActionBase_Basic> actions)
  {
    if (!m_ActionsInitialize)
    {
      m_ActionsInitialize = true;
      InitializeActions();
    }
 
    actions = m_InputActionMap.Get(action_input_type);
  }
 
  void SetActions()
  {
    AddAction(ActionTakeItem);
    AddAction(ActionTakeItemToHands);
    AddAction(ActionWorldCraft);
    AddAction(ActionDropItem);
    AddAction(ActionAttachWithSwitch);
  }
 
  void AddAction(typename actionName)
  {
    ActionBase action = ActionManagerBase.GetAction(actionName);
 
    if (!action)
    {
      Debug.LogError("Action " + actionName + " dosn't exist!");
      return;
    }
 
    typename ai = action.GetInputType();
    if (!ai)
    {
      m_ActionsInitialize = false;
      return;
    }
 
    array<ActionBase_Basic> action_array = m_InputActionMap.Get(ai);
    if (!action_array)
    {
      action_array = new array<ActionBase_Basic>;
      m_InputActionMap.Insert(ai, action_array);
    }
    if (LogManager.IsActionLogEnable())
    {
      Debug.ActionLog(action.ToString() + " -> " + ai, this.ToString() , "n/a", "Add action");
    }
 
    if (action_array.Find(action) != -1)
    {
      Debug.Log("Action " + action.Type() + " already added to " + this + ", skipping!");
    }
    else
    {
      action_array.Insert(action);
    }
  }
 
  void RemoveAction(typename actionName)
  {
    PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
    ActionBase action = player.GetActionManager().GetAction(actionName);
    typename ai = action.GetInputType();
    array<ActionBase_Basic> action_array = m_InputActionMap.Get(ai);
 
    if (action_array)
    {
      action_array.RemoveItem(action);
    }
  }
 
  void OnItemInHandsPlayerSwimStart(PlayerBase player);
 
  ScriptedLightBase GetLight();
 
  // Loads muzzle flash particle configuration from config and saves it to a map for faster access
  void LoadParticleConfigOnFire(int id)
  {
    if (!m_OnFireEffect)
      m_OnFireEffect = new map<int, ref array<ref WeaponParticlesOnFire>>;
 
    if (!m_OnBulletCasingEjectEffect)
      m_OnBulletCasingEjectEffect = new map<int, ref array<ref WeaponParticlesOnBulletCasingEject>>;
 
    string config_to_search = "CfgVehicles";
    string muzzle_owner_config;
 
    if (!m_OnFireEffect.Contains(id))
    {
      if (IsInherited(Weapon))
        config_to_search = "CfgWeapons";
 
      muzzle_owner_config = config_to_search + " " + GetType() + " ";
 
      string config_OnFire_class = muzzle_owner_config + "Particles " + "OnFire ";
 
      int config_OnFire_subclass_count = GetGame().ConfigGetChildrenCount(config_OnFire_class);
 
      if (config_OnFire_subclass_count > 0)
      {
        array<ref WeaponParticlesOnFire> WPOF_array = new array<ref WeaponParticlesOnFire>;
 
        for (int i = 0; i < config_OnFire_subclass_count; i++)
        {
          string particle_class = "";
          GetGame().ConfigGetChildName(config_OnFire_class, i, particle_class);
          string config_OnFire_entry = config_OnFire_class + particle_class;
          WeaponParticlesOnFire WPOF = new WeaponParticlesOnFire(this, config_OnFire_entry);
          WPOF_array.Insert(WPOF);
        }
 
 
        m_OnFireEffect.Insert(id, WPOF_array);
      }
    }
 
    if (!m_OnBulletCasingEjectEffect.Contains(id))
    {
      config_to_search = "CfgWeapons"; // Bullet Eject efect is supported on weapons only.
      muzzle_owner_config = config_to_search + " " + GetType() + " ";
 
      string config_OnBulletCasingEject_class = muzzle_owner_config + "Particles " + "OnBulletCasingEject ";
 
      int config_OnBulletCasingEject_count = GetGame().ConfigGetChildrenCount(config_OnBulletCasingEject_class);
 
      if (config_OnBulletCasingEject_count > 0  &&  IsInherited(Weapon))
      {
        array<ref WeaponParticlesOnBulletCasingEject> WPOBE_array = new array<ref WeaponParticlesOnBulletCasingEject>;
 
        for (i = 0; i < config_OnBulletCasingEject_count; i++)
        {
          string particle_class2 = "";
          GetGame().ConfigGetChildName(config_OnBulletCasingEject_class, i, particle_class2);
          string config_OnBulletCasingEject_entry = config_OnBulletCasingEject_class + particle_class2;
          WeaponParticlesOnBulletCasingEject WPOBE = new WeaponParticlesOnBulletCasingEject(this, config_OnBulletCasingEject_entry);
          WPOBE_array.Insert(WPOBE);
        }
 
 
        m_OnBulletCasingEjectEffect.Insert(id, WPOBE_array);
      }
    }
  }
 
  // Loads muzzle flash particle configuration from config and saves it to a map for faster access
  void LoadParticleConfigOnOverheating(int id)
  {
    if (!m_OnOverheatingEffect)
      m_OnOverheatingEffect = new map<int, ref array<ref WeaponParticlesOnOverheating>>;
 
    if (!m_OnOverheatingEffect.Contains(id))
    {
      string config_to_search = "CfgVehicles";
 
      if (IsInherited(Weapon))
        config_to_search = "CfgWeapons";
 
      string muzzle_owner_config = config_to_search + " " + GetType() + " ";
      string config_OnOverheating_class = muzzle_owner_config + "Particles " + "OnOverheating ";
 
      if (GetGame().ConfigIsExisting(config_OnOverheating_class))
      {
 
        m_ShotsToStartOverheating = GetGame().ConfigGetFloat(config_OnOverheating_class + "shotsToStartOverheating");
 
        if (m_ShotsToStartOverheating == 0)
        {
          m_ShotsToStartOverheating = -1; // This prevents futher readings from config for future creations of this item
          string error = "Error reading config " + GetType() + ">Particles>OnOverheating - Parameter shotsToStartOverheating is configured wrong or is missing! Its value must be 1 or higher!";
          Error(error);
          return;
        }
 
        m_OverheatingDecayInterval = GetGame().ConfigGetFloat(config_OnOverheating_class + "overheatingDecayInterval");
        m_MaxOverheatingValue = GetGame().ConfigGetFloat(config_OnOverheating_class + "maxOverheatingValue");
 
 
 
        int config_OnOverheating_subclass_count = GetGame().ConfigGetChildrenCount(config_OnOverheating_class);
        array<ref WeaponParticlesOnOverheating> WPOOH_array = new array<ref WeaponParticlesOnOverheating>;
 
        for (int i = 0; i < config_OnOverheating_subclass_count; i++)
        {
          string particle_class = "";
          GetGame().ConfigGetChildName(config_OnOverheating_class, i, particle_class);
          string config_OnOverheating_entry = config_OnOverheating_class + particle_class;
          int  entry_type = GetGame().ConfigGetType(config_OnOverheating_entry);
 
          if (entry_type == CT_CLASS)
          {
            WeaponParticlesOnOverheating WPOF = new WeaponParticlesOnOverheating(this, config_OnOverheating_entry);
            WPOOH_array.Insert(WPOF);
          }
        }
 
 
        m_OnOverheatingEffect.Insert(id, WPOOH_array);
      }
    }
  }
 
  float GetOverheatingValue()
  {
    return m_OverheatingShots;
  }
 
  void IncreaseOverheating(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
  {
    if (m_MaxOverheatingValue > 0)
    {
      m_OverheatingShots++;
 
      if (!m_CheckOverheating)
          m_CheckOverheating = new Timer(CALL_CATEGORY_SYSTEM);
 
      m_CheckOverheating.Stop();
      m_CheckOverheating.Run(m_OverheatingDecayInterval, this, "OnOverheatingDecay");
 
      CheckOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
    }
  }
 
  void CheckOverheating(ItemBase weapon = null, string ammoType = "", ItemBase muzzle_owner = null, ItemBase suppressor = null, string config_to_search = "")
  {
    if (m_OverheatingShots >= m_ShotsToStartOverheating  &&  IsOverheatingEffectActive())
      UpdateOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
 
    if (m_OverheatingShots >= m_ShotsToStartOverheating  &&  !IsOverheatingEffectActive())
      StartOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
 
    if (m_OverheatingShots < m_ShotsToStartOverheating  &&  IsOverheatingEffectActive())
      StopOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
 
    if (m_OverheatingShots > m_MaxOverheatingValue)
    {
      m_OverheatingShots = m_MaxOverheatingValue;
    }
  }
 
  bool IsOverheatingEffectActive()
  {
    return m_IsOverheatingEffectActive;
  }
 
  void OnOverheatingDecay()
  {
    if (m_MaxOverheatingValue > 0)
      m_OverheatingShots -= 1 + m_OverheatingShots / m_MaxOverheatingValue; // The hotter a barrel is, the faster it needs to cool down.
    else
      m_OverheatingShots--;
 
    if (m_OverheatingShots <= 0)
    {
      m_CheckOverheating.Stop();
      m_OverheatingShots = 0;
    }
    else
    {
      if (!m_CheckOverheating)
        m_CheckOverheating = new Timer(CALL_CATEGORY_GAMEPLAY);
 
      m_CheckOverheating.Stop();
      m_CheckOverheating.Run(m_OverheatingDecayInterval, this, "OnOverheatingDecay");
    }
 
    CheckOverheating(this, "", this);
  }
 
  void StartOverheating(ItemBase weapon = null, string ammoType = "", ItemBase muzzle_owner = null, ItemBase suppressor = null, string config_to_search = "")
  {
    m_IsOverheatingEffectActive = true;
    ItemBase.PlayOverheatingParticles(this, ammoType, this, suppressor, "CfgWeapons");
  }
 
  void UpdateOverheating(ItemBase weapon = null, string ammoType = "", ItemBase muzzle_owner = null, ItemBase suppressor = null, string config_to_search = "")
  {
    KillAllOverheatingParticles();
    ItemBase.UpdateOverheatingParticles(this, ammoType, this, suppressor, "CfgWeapons");
    UpdateAllOverheatingParticles();
  }
 
  void StopOverheating(ItemBase weapon = null, string ammoType = "", ItemBase muzzle_owner = null, ItemBase suppressor = null, string config_to_search = "")
  {
    m_IsOverheatingEffectActive = false;
    ItemBase.StopOverheatingParticles(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
  }
 
  void RegisterOverheatingParticle(Particle p, float min_heat_coef, float max_heat_coef, int particle_id, Object parent, vector local_pos, vector local_ori)
  {
    if (!m_OverheatingParticles)
      m_OverheatingParticles = new array<ref OverheatingParticle>;
 
    OverheatingParticle OP = new OverheatingParticle();
    OP.RegisterParticle(p);
    OP.SetOverheatingLimitMin(min_heat_coef);
    OP.SetOverheatingLimitMax(max_heat_coef);
    OP.SetParticleParams(particle_id, parent, local_pos, local_ori);
 
    m_OverheatingParticles.Insert(OP);
  }
 
  float GetOverheatingCoef()
  {
    if (m_MaxOverheatingValue > 0)
      return (m_OverheatingShots - m_ShotsToStartOverheating) / m_MaxOverheatingValue;
 
    return -1;
  }
 
  void UpdateAllOverheatingParticles()
  {
    if (m_OverheatingParticles)
    {
      float overheat_coef = GetOverheatingCoef();
      int count = m_OverheatingParticles.Count();
 
      for (int i = count; i > 0; --i)
      {
        int id = i - 1;
        OverheatingParticle OP = m_OverheatingParticles.Get(id);
        Particle p = OP.GetParticle();
 
        float overheat_min = OP.GetOverheatingLimitMin();
        float overheat_max = OP.GetOverheatingLimitMax();
 
        if (overheat_coef < overheat_min  &&  overheat_coef >= overheat_max)
        {
          if (p)
          {
            p.Stop();
            OP.RegisterParticle(null);
          }
        }
      }
    }
  }
 
  void KillAllOverheatingParticles()
  {
    if (m_OverheatingParticles)
    {
      for (int i = m_OverheatingParticles.Count(); i > 0; i--)
      {
        int id = i - 1;
        OverheatingParticle OP = m_OverheatingParticles.Get(id);
 
        if (OP)
        {
          Particle p = OP.GetParticle();
 
          if (p)
          {
            p.Stop();
          }
 
          delete OP;
        }
      }
 
      m_OverheatingParticles.Clear();
      delete m_OverheatingParticles;
    }
  }
 
  float GetInfectionChance(int system = 0, Param param = null)
  {
    return 0.0;
  }
 
 
  float GetDisinfectQuantity(int system = 0, Param param1 = null)
  {
    return 250;//default value
  }
 
  float GetFilterDamageRatio()
  {
    return 0;
  }
 
  bool HasMuzzle()
  {
    if (IsInherited(Weapon)  ||  IsInherited(SuppressorBase))
      return true;
 
    return false;
  }
 
  int GetMuzzleID()
  {
    if (!m_WeaponTypeToID)
      m_WeaponTypeToID = new map<string, int>;
 
    if (m_WeaponTypeToID.Contains(GetType()))
    {
      return m_WeaponTypeToID.Get(GetType());
    }
    else
    {
      // Register new weapon ID
      m_WeaponTypeToID.Insert(GetType(), ++m_LastRegisteredWeaponID);
    }
 
    return m_LastRegisteredWeaponID;
  }
 
  int GetDamageSystemVersionChange()
  {
    return -1;
  }
 
 
 
  // -------------------------------------------------------------------------
  void ~ItemBase()
  {
    #ifndef SERVER
    if (m_DeployLoopSoundEx)
      m_DeployLoopSoundEx.SoundStop();
    #endif
 
    if (GetGame() && GetGame().GetPlayer() && (!GetGame().IsDedicatedServer()))
    {
      PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
      int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
 
      if (r_index >= 0)
      {
          InventoryLocation r_il = new InventoryLocation;
          player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
 
          player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
          int r_type = r_il.GetType();
          if (r_type == InventoryLocationType.CARGO || r_type == InventoryLocationType.PROXYCARGO)
          {
            r_il.GetParent().GetOnReleaseLock().Invoke(this);
          }
          else if (r_type == InventoryLocationType.ATTACHMENT)
          {
            r_il.GetParent().GetOnAttachmentReleaseLock().Invoke(this, r_il.GetSlot());
          }
 
      }
 
      player.GetHumanInventory().ClearUserReservedLocation(this);
    }
 
    SEffectManager.DestroyEffect(m_LockingSound);
  }
 
 
 
  // -------------------------------------------------------------------------
  static int GetDebugActionsMask()
  {
    return ItemBase.m_DebugActionsMask;
  }
 
  static bool HasDebugActionsMask(int mask)
  {
    return ItemBase.m_DebugActionsMask & mask;
  }
 
  static void SetDebugActionsMask(int mask)
  {
    ItemBase.m_DebugActionsMask = mask;
  }
 
  static void AddDebugActionsMask(int mask)
  {
    ItemBase.m_DebugActionsMask |= mask;
  }
 
  static void RemoveDebugActionsMask(int mask)
  {
    ItemBase.m_DebugActionsMask &= ~mask;
  }
 
  static void ToggleDebugActionsMask(int mask)
  {
    if (HasDebugActionsMask(mask))
    {
      RemoveDebugActionsMask(mask);
    }
    else
    {
      AddDebugActionsMask(mask);
    }
  }
 
  // -------------------------------------------------------------------------
  void SetCEBasedQuantity()
  {
    if (GetEconomyProfile())
    {
      float q_max = GetEconomyProfile().GetQuantityMax();
      if (q_max > 0)
      {
        float q_min = GetEconomyProfile().GetQuantityMin();
        float quantity_randomized = Math.RandomFloatInclusive(q_min, q_max);
 
        if (HasComponent(COMP_TYPE_ENERGY_MANAGER))//more direct access for speed
        {
          ComponentEnergyManager comp = GetCompEM();
          if (comp && (comp.GetEnergyMaxPristine() || comp.GetEnergyAtSpawn()))//checking for a potential for energy, we need to check both values, as both are optional, only when both are set to 0, we know the item can't have energy
          {
            //Print("setting EM quantity for " + this + " to " + quantity_randomized);
            comp.SetEnergy0To1(quantity_randomized);
          }
          /*
          else
            Print("NOT setting EM quantity for " + this + " to " + quantity_randomized);
          */
        }
        else if (HasQuantity())
        {
          SetQuantityNormalized(quantity_randomized, false);
          //PrintString("<==> Normalized quantity for item: "+ GetType()+", qmin:"+q_min.ToString()+"; qmax:"+q_max.ToString()+";quantity:" +quantity_randomized.ToString());
        }
 
      }
    }
  }
 
  void LockToParent()
  {
    EntityAI parent = GetHierarchyParent();
 
    if (parent)
    {
      InventoryLocation inventory_location_to_lock = new InventoryLocation;
      GetInventory().GetCurrentInventoryLocation(inventory_location_to_lock);
      parent.GetInventory().SetSlotLock(inventory_location_to_lock.GetSlot(), true);
    }
  }
 
  void UnlockFromParent()
  {
    EntityAI parent = GetHierarchyParent();
 
    if (parent)
    {
      InventoryLocation inventory_location_to_unlock = new InventoryLocation;
      GetInventory().GetCurrentInventoryLocation(inventory_location_to_unlock);
      parent.GetInventory().SetSlotLock(inventory_location_to_unlock.GetSlot(), false);
    }
  }
 
  override void CombineItemsClient(EntityAI entity2, bool use_stack_max = true)
  {
    /*
    ref Param1<EntityAI> item = new Param1<EntityAI>(entity2);
    RPCSingleParam(ERPCs.RPC_ITEM_COMBINE, item, GetGame().GetPlayer());
    */
    ItemBase item2 = ItemBase.Cast(entity2);
 
    if (GetGame().IsClient())
    {
      if (ScriptInputUserData.CanStoreInputUserData())
      {
        ScriptInputUserData ctx = new ScriptInputUserData;
        ctx.Write(INPUT_UDT_ITEM_MANIPULATION);
        ctx.Write(-1);
        ItemBase i1 = this; // @NOTE: workaround for correct serialization
        ctx.Write(i1);
        ctx.Write(item2);
        ctx.Write(use_stack_max);
        ctx.Write(-1);
        ctx.Send();
 
        if (IsCombineAll(item2, use_stack_max))
        {
          GetGame().GetPlayer().GetInventory().AddInventoryReservationEx(item2,null,GameInventory.c_InventoryReservationTimeoutShortMS);
        }
      }
    }
    else if (!GetGame().IsMultiplayer())
    {
      CombineItems(item2, use_stack_max);
    }
  }
 
  bool IsLiquidPresent()
  {
 
    return (GetLiquidType() != 0 && HasQuantity());
  }
 
  bool IsLiquidContainer()
  {
    return (ConfigGetFloat("liquidContainerType") != 0);
  }
 
  bool IsBloodContainer()
  {
    return false;
  }
 
  bool IsNVG()
  {
    return false;
  }
 
  bool IsExplosive()
  {
    return false;
  }
 
  string GetExplosiveTriggerSlotName()
  {
    return "";
  }
 
 
  bool IsLightSource()
  {
    return false;
  }
 
  bool CanBeRepairedByCrafting()
  {
    return true;
  }
 
  //--- ACTION CONDITIONS
  //direction
  bool IsFacingPlayer(PlayerBase player, string selection)
  {
    return true;
  }
 
  bool IsPlayerInside(PlayerBase player, string selection)
  {
    return true;
  }
 
  override bool CanObstruct()
  {
    PlayerBase player = PlayerBase.Cast(g_Game.GetPlayer());
    return !player || !IsPlayerInside(player, "");
  }
 
  override bool IsBeingPlaced()
  {
    return m_IsBeingPlaced;
  }
 
  void SetIsBeingPlaced(bool is_being_placed)
  {
    m_IsBeingPlaced = is_being_placed;
    if (!is_being_placed)
      OnEndPlacement();
    SetSynchDirty();
  }
 
  //server-side
  void OnEndPlacement() {}
 
  override bool IsHologram()
  {
    return m_IsHologram;
  }
 
  bool CanBeDigged()
  {
    return m_CanBeDigged;
  }
 
  bool CanMakeGardenplot()
  {
    return false;
  }
 
  void SetIsHologram(bool is_hologram)
  {
    m_IsHologram = is_hologram;
    SetSynchDirty();
  }
  /*
  protected float GetNutritionalEnergy()
  {
    Edible_Base edible = Edible_Base.Cast(this);
    return edible.GetFoodEnergy();
  }
 
  protected float GetNutritionalWaterContent()
  {
    Edible_Base edible = Edible_Base.Cast(this);
    return edible.GetFoodWater();
  }
 
  protected float GetNutritionalIndex()
  {
    Edible_Base edible = Edible_Base.Cast(this);
    return edible.GetFoodNutritionalIndex();
  }
 
  protected float GetNutritionalFullnessIndex()
  {
    Edible_Base edible = Edible_Base.Cast(this);
    return edible.GetFoodTotalVolume();
  }
 
  protected float GetNutritionalToxicity()
  {
    Edible_Base edible = Edible_Base.Cast(this);
    return edible.GetFoodToxicity();
 
  }
  */
 
 
  // -------------------------------------------------------------------------
  override void OnMovedInsideCargo(EntityAI container)
  {
    super.OnMovedInsideCargo(container);
 
    MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
  }
 
  override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
  {
    super.EEItemLocationChanged(oldLoc,newLoc);
 
    PlayerBase new_player = null;
    PlayerBase old_player = null;
 
    if (newLoc.GetParent())
      new_player = PlayerBase.Cast(newLoc.GetParent().GetHierarchyRootPlayer());
 
    if (oldLoc.GetParent())
      old_player = PlayerBase.Cast(oldLoc.GetParent().GetHierarchyRootPlayer());
 
    if (old_player && oldLoc.GetType() == InventoryLocationType.HANDS)
    {
      int r_index = old_player.GetHumanInventory().FindUserReservedLocationIndex(this);
 
      if (r_index >= 0)
      {
          InventoryLocation r_il = new InventoryLocation;
          old_player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
 
          old_player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
          int r_type = r_il.GetType();
          if (r_type == InventoryLocationType.CARGO || r_type == InventoryLocationType.PROXYCARGO)
          {
            r_il.GetParent().GetOnReleaseLock().Invoke(this);
          }
          else if (r_type == InventoryLocationType.ATTACHMENT)
          {
            r_il.GetParent().GetOnAttachmentReleaseLock().Invoke(this, r_il.GetSlot());
          }
 
      }
    }
 
    if (newLoc.GetType() == InventoryLocationType.HANDS)
    {
      if (new_player)
        new_player.ForceStandUpForHeavyItems(newLoc.GetItem());
 
      if (new_player == old_player)
      {
 
        if (oldLoc.GetParent() && !(oldLoc.GetParent() != new_player && oldLoc.GetType() == InventoryLocationType.ATTACHMENT) && new_player.GetHumanInventory().LocationGetEntity(oldLoc) == NULL)
        {
          if (oldLoc.GetType() == InventoryLocationType.CARGO)
          {
            if (oldLoc.GetParent().GetInventory().TestAddEntityInCargoExLoc(oldLoc, false, false, false, true, false, false))
            {
              new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
            }
          }
          else
          {
            new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
          }
        }
 
        if (new_player.GetHumanInventory().FindUserReservedLocationIndex(this) >= 0)
        {
          int type = oldLoc.GetType();
          if (type == InventoryLocationType.CARGO || type == InventoryLocationType.PROXYCARGO)
          {
            oldLoc.GetParent().GetOnSetLock().Invoke(this);
          }
          else if (type == InventoryLocationType.ATTACHMENT)
          {
            oldLoc.GetParent().GetOnAttachmentSetLock().Invoke(this, oldLoc.GetSlot());
          }
        }
        if (!m_OldLocation)
        {
          m_OldLocation = new InventoryLocation;
        }
        m_OldLocation.Copy(oldLoc);
      }
      else
      {
        if (m_OldLocation)
        {
          m_OldLocation.Reset();
        }
      }
 
      GetGame().GetAnalyticsClient().OnItemAttachedAtPlayer(this,"Hands");
    }
    else
    {
      if (new_player)
      {
        int res_index = new_player.GetHumanInventory().FindCollidingUserReservedLocationIndex(this, newLoc);
        if (res_index >= 0)
        {
          InventoryLocation il = new InventoryLocation;
          new_player.GetHumanInventory().GetUserReservedLocation(res_index,il);
          ItemBase it = ItemBase.Cast(il.GetItem());
          new_player.GetHumanInventory().ClearUserReservedLocationAtIndex(res_index);
          int rel_type = il.GetType();
          if (rel_type == InventoryLocationType.CARGO || rel_type == InventoryLocationType.PROXYCARGO)
          {
            il.GetParent().GetOnReleaseLock().Invoke(it);
          }
          else if (rel_type == InventoryLocationType.ATTACHMENT)
          {
            il.GetParent().GetOnAttachmentReleaseLock().Invoke(it, il.GetSlot());
          }
          //it.GetOnReleaseLock().Invoke(it);
        }
      }
      else if (old_player && newLoc.GetType() == InventoryLocationType.GROUND && m_ThrowItemOnDrop)
      {
        //Print("---ThrowPhysically---");
        //ThrowPhysically(old_player, vector.Zero);
        m_ThrowItemOnDrop = false;
      }
 
      if (m_OldLocation)
      {
        m_OldLocation.Reset();
      }
    }
  }
 
  override void EOnContact(IEntity other, Contact extra)
  {
    if (m_CanPlayImpactSound)
    {
      int liquidType = -1;
      float impactSpeed = ProcessImpactSoundEx(other, extra, m_ConfigWeight, m_ImpactSoundSurfaceHash, liquidType);
      if (impactSpeed > 0.0)
      {
        m_ImpactSpeed  = impactSpeed;
        #ifndef SERVER
        PlayImpactSound(m_ConfigWeight, m_ImpactSpeed, m_ImpactSoundSurfaceHash);
        #else
        m_WantPlayImpactSound = true;
        SetSynchDirty();
        #endif
        m_CanPlayImpactSound = (liquidType == -1);// prevents further playing of the sound when the surface is a liquid type
      }
    }
 
    #ifdef SERVER
    if (GetCompEM() && GetCompEM().IsPlugged())
    {
      if (GetCompEM().GetCordLength() < vector.Distance(GetPosition(), GetCompEM().GetEnergySource().GetPosition()))
        GetCompEM().UnplugThis();
    }
    #endif
  }
 
  void RefreshPhysics();
 
  override void OnCreatePhysics()
  {
    RefreshPhysics();
  }
 
  override void OnItemAttachmentSlotChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
  {
 
  }
  // -------------------------------------------------------------------------
  override void OnItemLocationChanged(EntityAI old_owner, EntityAI new_owner)
  {
    super.OnItemLocationChanged(old_owner, new_owner);
 
    Man ownerPlayerOld = null;
    Man ownerPlayerNew = null;
 
    if (old_owner)
    {
      if (old_owner.IsMan())
      {
        ownerPlayerOld = Man.Cast(old_owner);
      }
      else
      {
        ownerPlayerOld = Man.Cast(old_owner.GetHierarchyRootPlayer());
      }
    }
 
    if (new_owner)
    {
      if (new_owner.IsMan())
      {
        ownerPlayerNew = Man.Cast(new_owner);
      }
      else
      {
        ownerPlayerNew = Man.Cast(new_owner.GetHierarchyRootPlayer());
      }
    }
 
    if (ownerPlayerOld != ownerPlayerNew)
    {
      if (ownerPlayerOld)
      {
        array<EntityAI> subItemsExit = new array<EntityAI>;
        GetInventory().EnumerateInventory(InventoryTraversalType.PREORDER,subItemsExit);
        for (int i = 0; i < subItemsExit.Count(); i++)
        {
          ItemBase itemExit = ItemBase.Cast(subItemsExit.Get(i));
          itemExit.OnInventoryExit(ownerPlayerOld);
        }
      }
 
      if (ownerPlayerNew)
      {
        array<EntityAI> subItemsEnter = new array<EntityAI>;
        GetInventory().EnumerateInventory(InventoryTraversalType.PREORDER,subItemsEnter);
        for (int j = 0; j < subItemsEnter.Count(); j++)
        {
          ItemBase itemEnter = ItemBase.Cast(subItemsEnter.Get(j));
          itemEnter.OnInventoryEnter(ownerPlayerNew);
        }
      }
    }
  }
 
  // -------------------------------------------------------------------------------
  override void EEDelete(EntityAI parent)
  {
    super.EEDelete(parent);
    PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
    if (player)
    {
      OnInventoryExit(player);
 
      if (player.IsAlive())
      {
        int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
        if (r_index >= 0)
        {
          InventoryLocation r_il = new InventoryLocation;
          player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
 
          player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
          int r_type = r_il.GetType();
          if (r_type == InventoryLocationType.CARGO || r_type == InventoryLocationType.PROXYCARGO)
          {
            r_il.GetParent().GetOnReleaseLock().Invoke(this);
          }
          else if (r_type == InventoryLocationType.ATTACHMENT)
          {
            r_il.GetParent().GetOnAttachmentReleaseLock().Invoke(this, r_il.GetSlot());
          }
 
        }
 
        player.RemoveQuickBarEntityShortcut(this);
      }
    }
  }
  // -------------------------------------------------------------------------------
  override void EEKilled(Object killer)
  {
    super.EEKilled(killer);
 
    if (killer && killer.IsFireplace() && CanExplodeInFire())
    {
      if (GetTemperature() >= GameConstants.ITEM_TEMPERATURE_TO_EXPLODE_MIN)
      {
        if (IsMagazine())
        {
          if (Magazine.Cast(this).GetAmmoCount() > 0)
          {
            ExplodeAmmo();
          }
        }
        else
        {
          Explode(DamageType.EXPLOSION);
        }
      }
    }
  }
 
  override void OnWasAttached(EntityAI parent, int slot_id)
  {
    MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
 
    super.OnWasAttached(parent, slot_id);
 
    if (HasQuantity())
      UpdateNetSyncVariableFloat("m_VarQuantity", GetQuantityMin(), m_VarQuantityMax);
 
    PlayAttachSound(InventorySlots.GetSlotName(slot_id));
  }
 
  override void OnWasDetached(EntityAI parent, int slot_id)
  {
    super.OnWasDetached(parent, slot_id);
 
    if (HasQuantity())
      UpdateNetSyncVariableFloat("m_VarQuantity", GetQuantityMin(), m_VarQuantityMax);
  }
 
  override string ChangeIntoOnAttach(string slot)
  {
    int idx;
    TStringArray inventory_slots = new TStringArray;
    TStringArray attach_types = new TStringArray;
 
    ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
    if (inventory_slots.Count() < 1) //is string
    {
      inventory_slots.Insert(ConfigGetString("ChangeInventorySlot"));
      attach_types.Insert(ConfigGetString("ChangeIntoOnAttach"));
    }
    else //is array
    {
      ConfigGetTextArray("ChangeIntoOnAttach",attach_types);
    }
 
    idx = inventory_slots.Find(slot);
    if (idx < 0)
      return "";
 
    return attach_types.Get(idx);
  }
 
  override string ChangeIntoOnDetach()
  {
    int idx = -1;
    string slot;
 
    TStringArray inventory_slots = new TStringArray;
    TStringArray detach_types = new TStringArray;
 
    this.ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
    if (inventory_slots.Count() < 1) //is string
    {
      inventory_slots.Insert(this.ConfigGetString("ChangeInventorySlot"));
      detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
    }
    else //is array
    {
      this.ConfigGetTextArray("ChangeIntoOnDetach",detach_types);
      if (detach_types.Count() < 1)
        detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
    }
 
    for (int i = 0; i < inventory_slots.Count(); i++)
    {
      slot = inventory_slots.Get(i);
    }
 
    if (slot != "")
    {
      if (detach_types.Count() == 1)
        idx = 0;
      else
        idx = inventory_slots.Find(slot);
    }
    if (idx < 0)
      return "";
 
    return detach_types.Get(idx);
  }
 
  void ExplodeAmmo()
  {
    //timer
    ref Timer explode_timer = new Timer(CALL_CATEGORY_SYSTEM);
 
    //min/max time
    float min_time = 1;
    float max_time = 3;
    float delay = Math.RandomFloat(min_time, max_time);
 
    explode_timer.Run(delay, this, "DoAmmoExplosion");
  }
 
  void DoAmmoExplosion()
  {
    Magazine magazine = Magazine.Cast(this);
    int pop_sounds_count = 6;
    string pop_sounds[ 6 ] = { "ammopops_1","ammopops_2","ammopops_3","ammopops_4","ammopops_5","ammopops_6" };
 
    //play sound
    int sound_idx = Math.RandomInt(0, pop_sounds_count - 1);
    string sound_name = pop_sounds[ sound_idx ];
    GetGame().CreateSoundOnObject(this, sound_name, 20, false);
 
    //remove ammo count
    magazine.ServerAddAmmoCount(-1);
 
    //if condition then repeat -> ExplodeAmmo
    float min_temp_to_explode = 100;    //min temperature for item to explode
 
    if (magazine.GetAmmoCount() > 0 && GetTemperature() >= min_temp_to_explode) //TODO ? add check for parent -> fireplace
    {
      ExplodeAmmo();
    }
  }
 
  // -------------------------------------------------------------------------------
  override void EEHitBy(TotalDamageResult damageResult, int damageType, EntityAI source, int component, string dmgZone, string ammo, vector modelPos, float speedCoef)
  {
    super.EEHitBy(damageResult, damageType, source, component, dmgZone, ammo, modelPos, speedCoef);
 
    const int CHANCE_DAMAGE_CARGO = 4;
    const int CHANCE_DAMAGE_ATTACHMENT = 1;
    const int CHANCE_DAMAGE_NOTHING = 2;
 
    if (IsClothing() || IsContainer() || IsItemTent())
    {
      float dmg = damageResult.GetDamage("","Health") * -0.5;
      int chances;
      int rnd;
 
      if (GetInventory().GetCargo())
      {
        chances = CHANCE_DAMAGE_CARGO + CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
        rnd = Math.RandomInt(0,chances);
 
        if (rnd < CHANCE_DAMAGE_CARGO)
        {
          DamageItemInCargo(dmg);
        }
        else if (rnd < (chances - CHANCE_DAMAGE_NOTHING))
        {
          DamageItemAttachments(dmg);
        }
      }
      else
      {
        chances = CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
        rnd = Math.RandomInt(0,chances);
 
        if (rnd < CHANCE_DAMAGE_ATTACHMENT)
        {
          DamageItemAttachments(dmg);
        }
      }
    }
  }
 
  bool DamageItemInCargo(float damage)
  {
    if (GetInventory().GetCargo())
    {
      int item_count = GetInventory().GetCargo().GetItemCount();
      if (item_count > 0)
      {
        int random_pick = Math.RandomInt(0, item_count);
        ItemBase item = ItemBase.Cast(GetInventory().GetCargo().GetItem(random_pick));
        if (!item.IsExplosive())
        {
          item.AddHealth("","",damage);
          return true;
        }
      }
    }
    return false;
  }
 
  bool DamageItemAttachments(float damage)
  {
    int attachment_count = GetInventory().AttachmentCount();
    if (attachment_count > 0)
    {
      int random_pick = Math.RandomInt(0, attachment_count);
      ItemBase attachment = ItemBase.Cast(GetInventory().GetAttachmentFromIndex(random_pick));
      if (!attachment.IsExplosive())
      {
        attachment.AddHealth("","",damage);
        return true;
      }
    }
    return false;
  }
 
  //----------------
  override bool CanBeSplit()
  {
    if (m_CanThisBeSplit)
      return (GetQuantity() > 1);
 
    return false;
  }
 
  void SplitIntoStackMaxClient(EntityAI destination_entity, int slot_id )
  {
    if (GetGame().IsClient())
    {
      if (ScriptInputUserData.CanStoreInputUserData())
      {
        ScriptInputUserData ctx = new ScriptInputUserData;
        ctx.Write(INPUT_UDT_ITEM_MANIPULATION);
        ctx.Write(1);
        ItemBase i1 = this; // @NOTE: workaround for correct serialization
        ctx.Write(i1);
        ctx.Write(destination_entity);
        ctx.Write(true);
        ctx.Write(slot_id);
        ctx.Send();
      }
    }
    else if (!GetGame().IsMultiplayer())
    {
      SplitIntoStackMax(destination_entity, slot_id, PlayerBase.Cast(GetGame().GetPlayer()));
    }
  }
 
  void SplitIntoStackMax(EntityAI destination_entity, int slot_id, PlayerBase player)
  {
    float split_quantity_new;
    ref ItemBase new_item;
    float quantity = GetQuantity();
    float stack_max = GetTargetQuantityMax(slot_id);
    InventoryLocation loc = new InventoryLocation;
 
    if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
    {
      if (stack_max <= GetQuantity())
        split_quantity_new = stack_max;
      else
        split_quantity_new = GetQuantity();
 
      new_item = ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(this.GetType(), slot_id));
      if (new_item)
      {
        new_item.SetResultOfSplit(true);
        MiscGameplayFunctions.TransferItemProperties(this, new_item);
        AddQuantity(-split_quantity_new);
        new_item.SetQuantity(split_quantity_new);
      }
    }
    else if (destination_entity && slot_id == -1)
    {
      if (quantity > stack_max)
        split_quantity_new = stack_max;
      else
        split_quantity_new = quantity;
 
      if (destination_entity.GetInventory().FindFreeLocationFor(this, FindInventoryLocationType.ANY, loc))
      {
        Object o = destination_entity.GetInventory().LocationCreateEntity(loc, GetType(), ECE_IN_INVENTORY, RF_DEFAULT);
        new_item = ItemBase.Cast(o);
      }
 
      if (new_item)
      {
        new_item.SetResultOfSplit(true);
        MiscGameplayFunctions.TransferItemProperties(this, new_item);
        AddQuantity(-split_quantity_new);
        new_item.SetQuantity(split_quantity_new);
      }
    }
    else
    {
      if (stack_max != 0)
      {
        if (stack_max < GetQuantity())
        {
          split_quantity_new = GetQuantity() - stack_max;
        }
 
        if (split_quantity_new == 0)
        {
          if (!GetGame().IsMultiplayer())
            player.PhysicalPredictiveDropItem(this);
          else
            player.ServerDropEntity(this);
          return;
        }
 
        new_item = ItemBase.Cast(GetGame().CreateObjectEx(GetType(), player.GetWorldPosition(), ECE_PLACE_ON_SURFACE));
 
        if (new_item)
        {
          new_item.SetResultOfSplit(true);
          MiscGameplayFunctions.TransferItemProperties(this, new_item);
          SetQuantity(split_quantity_new);
          new_item.SetQuantity(stack_max);
          new_item.PlaceOnSurface();
        }
      }
    }
  }
 
  void SplitIntoStackMaxToInventoryLocationClient(notnull InventoryLocation dst)
  {
    if (GetGame().IsClient())
    {
      if (ScriptInputUserData.CanStoreInputUserData())
      {
        ScriptInputUserData ctx = new ScriptInputUserData;
        ctx.Write(INPUT_UDT_ITEM_MANIPULATION);
        ctx.Write(4);
        ItemBase thiz = this; // @NOTE: workaround for correct serialization
        ctx.Write(thiz);
        dst.WriteToContext(ctx);
        ctx.Send();
      }
    }
    else if (!GetGame().IsMultiplayer())
    {
      SplitIntoStackMaxToInventoryLocation(dst);
    }
  }
 
  void SplitIntoStackMaxCargoClient(EntityAI destination_entity, int idx, int row, int col)
  {
    if (GetGame().IsClient())
    {
      if (ScriptInputUserData.CanStoreInputUserData())
      {
        ScriptInputUserData ctx = new ScriptInputUserData;
        ctx.Write(INPUT_UDT_ITEM_MANIPULATION);
        ctx.Write(2);
        ItemBase dummy = this; // @NOTE: workaround for correct serialization
        ctx.Write(dummy);
        ctx.Write(destination_entity);
        ctx.Write(true);
        ctx.Write(idx);
        ctx.Write(row);
        ctx.Write(col);
        ctx.Send();
      }
    }
    else if (!GetGame().IsMultiplayer())
    {
      SplitIntoStackMaxCargo(destination_entity, idx, row, col);
    }
  }
 
  void SplitIntoStackMaxToInventoryLocation(notnull InventoryLocation dst)
  {
    SplitIntoStackMaxToInventoryLocationEx(dst);
  }
 
  ItemBase SplitIntoStackMaxToInventoryLocationEx(notnull InventoryLocation dst)
  {
    float quantity = GetQuantity();
    float split_quantity_new;
    ItemBase new_item;
    if (dst.IsValid())
    {
      int slot_id = dst.GetSlot();
      float stack_max = GetTargetQuantityMax(slot_id);
 
      if (quantity > stack_max)
        split_quantity_new = stack_max;
      else
        split_quantity_new = quantity;
 
      new_item = ItemBase.Cast(GameInventory.LocationCreateEntity(dst, this.GetType(), ECE_IN_INVENTORY, RF_DEFAULT));
 
      if (new_item)
      {
        new_item.SetResultOfSplit(true);
        MiscGameplayFunctions.TransferItemProperties(this,new_item);
        AddQuantity(-split_quantity_new);
        new_item.SetQuantity(split_quantity_new);
      }
 
      return new_item;
    }
 
    return null;
  }
 
  void SplitIntoStackMaxCargo(EntityAI destination_entity, int idx, int row, int col)
  {
    float quantity = GetQuantity();
    float split_quantity_new;
    ref ItemBase new_item;
    if (destination_entity)
    {
      float stackable = GetTargetQuantityMax();
      if (quantity > stackable)
        split_quantity_new = stackable;
      else
        split_quantity_new = quantity;
 
      new_item = ItemBase.Cast(destination_entity.GetInventory().CreateEntityInCargoEx(this.GetType(), idx, row, col, false));
      if (new_item)
      {
        new_item.SetResultOfSplit(true);
        MiscGameplayFunctions.TransferItemProperties(this,new_item);
        AddQuantity(-split_quantity_new);
        new_item.SetQuantity(split_quantity_new);
      }
    }
  }
 
  void SplitIntoStackMaxHandsClient(PlayerBase player)
  {
    if (GetGame().IsClient())
    {
      if (ScriptInputUserData.CanStoreInputUserData())
      {
        ScriptInputUserData ctx = new ScriptInputUserData;
        ctx.Write(INPUT_UDT_ITEM_MANIPULATION);
        ctx.Write(3);
        ItemBase i1 = this; // @NOTE: workaround for correct serialization
        ctx.Write(i1);
        ItemBase destination_entity = this;
        ctx.Write(destination_entity);
        ctx.Write(true);
        ctx.Write(0);
        ctx.Send();
      }
    }
    else if (!GetGame().IsMultiplayer())
    {
      SplitIntoStackMaxHands(player);
    }
  }
 
  void SplitIntoStackMaxHands(PlayerBase player)
  {
    float quantity = GetQuantity();
    float split_quantity_new;
    ref ItemBase new_item;
    if (player)
    {
      float stackable = GetTargetQuantityMax();
      if (quantity > stackable)
        split_quantity_new = stackable;
      else
        split_quantity_new = quantity;
 
      EntityAI in_hands = player.GetHumanInventory().CreateInHands(this.GetType());
      new_item = ItemBase.Cast(in_hands);
      if (new_item)
      {
        new_item.SetResultOfSplit(true);
        MiscGameplayFunctions.TransferItemProperties(this,new_item);
        AddQuantity(-split_quantity_new);
        new_item.SetQuantity(split_quantity_new);
      }
    }
  }
 
  void SplitItemToInventoryLocation(notnull InventoryLocation dst)
  {
    if (!CanBeSplit())
      return;
 
    float quantity = GetQuantity();
    float split_quantity_new = Math.Floor(quantity * 0.5);
 
    ItemBase new_item = ItemBase.Cast(GameInventory.LocationCreateEntity(dst, GetType(), ECE_IN_INVENTORY, RF_DEFAULT));
 
    if (new_item)
    {
      if (new_item.GetQuantityMax() < split_quantity_new)
      {
        split_quantity_new = new_item.GetQuantityMax();
      }
 
      new_item.SetResultOfSplit(true);
      MiscGameplayFunctions.TransferItemProperties(this, new_item);
 
      if (dst.IsValid() && dst.GetType() == InventoryLocationType.ATTACHMENT && split_quantity_new > 1)
      {
        AddQuantity(-1);
        new_item.SetQuantity(1);
      }
      else
      {
        AddQuantity(-split_quantity_new);
        new_item.SetQuantity(split_quantity_new);
      }
    }
  }
 
  void SplitItem(PlayerBase player)
  {
    if (!CanBeSplit())
    {
      return;
    }
 
    float quantity = GetQuantity();
    float split_quantity_new = Math.Floor(quantity / 2);
 
    InventoryLocation invloc = new InventoryLocation;
    bool found = player.GetInventory().FindFirstFreeLocationForNewEntity(GetType(), FindInventoryLocationType.ATTACHMENT, invloc);
 
    ItemBase new_item;
    new_item = player.CreateCopyOfItemInInventoryOrGroundEx(this, true);
 
    if (new_item)
    {
      if (new_item.GetQuantityMax() < split_quantity_new)
      {
        split_quantity_new = new_item.GetQuantityMax();
      }
      if (found && invloc.IsValid() && invloc.GetType() == InventoryLocationType.ATTACHMENT && split_quantity_new > 1)
      {
        AddQuantity(-1);
        new_item.SetQuantity(1);
      }
      else
      {
        AddQuantity(-split_quantity_new);
        new_item.SetQuantity(split_quantity_new);
      }
    }
  }
 
  void OnQuantityChanged(float delta)
  {
    SetWeightDirty();
    ItemBase parent = ItemBase.Cast(GetHierarchyParent());
 
    if (parent)
    {
      parent.OnAttachmentQuantityChangedEx(this, delta);
    }
  }
 
  void OnAttachmentQuantityChanged(ItemBase item)
  {
    // insert code here
  }
 
  void OnAttachmentQuantityChangedEx(ItemBase item , float delta)
  {
    OnAttachmentQuantityChanged(item);
  }
 
  override void EEHealthLevelChanged(int oldLevel, int newLevel, string zone)
  {
    super.EEHealthLevelChanged(oldLevel,newLevel,zone);
 
    if (GetGame().IsServer())
    {
      if (newLevel == GameConstants.STATE_RUINED)
      {
        EntityAI parent = GetHierarchyParent();
        if (parent && parent.IsFireplace())
        {
          CargoBase cargo = GetInventory().GetCargo();
          if (cargo)
          {
            for (int i = 0; i < cargo.GetItemCount(); ++i)
            {
              parent.GetInventory().TakeEntityToInventory(InventoryMode.SERVER, FindInventoryLocationType.CARGO, cargo.GetItem(i));
            }
          }
        }
      }
 
      if (IsResultOfSplit())
      {
        // reset the splitting result flag, return to normal item behavior
        SetResultOfSplit(false);
        return;
      }
 
      if (m_Cleanness != 0 && oldLevel < newLevel && newLevel != 0)
      {
        SetCleanness(0);//unclean the item upon damage dealt
      }
    }
  }
 
  // just the split? TODO: verify
  override void OnRightClick()
  {
    super.OnRightClick();
 
    if (CanBeSplit() && !GetDayZGame().IsLeftCtrlDown() && !GetGame().GetPlayer().GetInventory().HasInventoryReservation(this,null))
    {
      if (GetGame().IsClient())
      {
        if (ScriptInputUserData.CanStoreInputUserData())
        {
          vector m4[4];
          PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 
          EntityAI root = GetHierarchyRoot();
 
          InventoryLocation dst = new InventoryLocation;
          if (!player.GetInventory().FindFirstFreeLocationForNewEntity(GetType(), FindInventoryLocationType.CARGO, dst))
          {
            if (root)
            {
              root.GetTransform(m4);
              dst.SetGround(this, m4);
            }
            else
              GetInventory().GetCurrentInventoryLocation(dst);
          }
          else
          {
            dst.SetCargo(dst.GetParent(), this, dst.GetIdx(), dst.GetRow(), dst.GetCol(), dst.GetFlip());
            if (GetGame().GetPlayer().GetInventory().HasInventoryReservation(null, dst))
            {
              if (root)
              {
                root.GetTransform(m4);
                dst.SetGround(this, m4);
              }
              else
                GetInventory().GetCurrentInventoryLocation(dst);
            }
            else
            {
              GetGame().GetPlayer().GetInventory().AddInventoryReservationEx(null, dst, GameInventory.c_InventoryReservationTimeoutShortMS);
            }
          }
 
          ScriptInputUserData ctx = new ScriptInputUserData;
          ctx.Write(INPUT_UDT_ITEM_MANIPULATION);
          ctx.Write(4);
          ItemBase thiz = this; // @NOTE: workaround for correct serialization
          ctx.Write(thiz);
          dst.WriteToContext(ctx);
          ctx.Write(true); // dummy
          ctx.Send();
        }
      }
      else if (!GetGame().IsMultiplayer())
      {
        SplitItem(PlayerBase.Cast(GetGame().GetPlayer()));
      }
    }
  }
 
  override bool CanBeCombined(EntityAI other_item, bool reservation_check = true, bool stack_max_limit = false)
  {
    //Print("CanBeCombined - " + this + ": " + GetQuantity() + " + " + other_item + ": " + other_item.GetQuantity());
    //TODO: delete check zero quantity check after fix double posts hands fsm events
    if (!other_item || GetType() != other_item.GetType() || (IsFullQuantity() && other_item.GetQuantity() > 0) || other_item == this)
      return false;
 
    if (GetHealthLevel() == GameConstants.STATE_RUINED || other_item.GetHealthLevel() == GameConstants.STATE_RUINED)
      return false;
 
    //can_this_be_combined = ConfigGetBool("canBeSplit");
    if (!can_this_be_combined)
      return false;
 
 
    Magazine mag = Magazine.Cast(this);
    if (mag)
    {
      if (mag.GetAmmoCount() >= mag.GetAmmoMax())
        return false;
 
      if (stack_max_limit)
      {
        Magazine other_mag = Magazine.Cast(other_item);
        if (other_item)
        {
          if (mag.GetAmmoCount() + other_mag.GetAmmoCount() > mag.GetAmmoMax())
            return false;
        }
 
      }
    }
    else
    {
      //TODO: delete check zero quantity check after fix double posts hands fsm events
      if (GetQuantity() >= GetQuantityMax() && other_item.GetQuantity() > 0 )
        return false;
 
      if (stack_max_limit && (GetQuantity() + other_item.GetQuantity()  > GetQuantityMax()))
        return false;
    }
 
    PlayerBase player = null;
    if (CastTo(player, GetHierarchyRootPlayer())) //false when attached to player's attachment slot
    {
      if (player.GetInventory().HasAttachment(this))
        return false;
 
      if (player.IsItemsToDelete())
        return false;
    }
 
    if (reservation_check && (GetInventory().HasInventoryReservation(this, null) || other_item.GetInventory().HasInventoryReservation(other_item, null)))
      return false;
 
    int slotID;
    string slotName;
    if (GetInventory().GetCurrentAttachmentSlotInfo(slotID,slotName) && GetHierarchyParent().GetInventory().GetSlotLock(slotID))
      return false;
 
    return true;
  }
 
  bool IsCombineAll(ItemBase other_item, bool use_stack_max = false)
  {
    return ComputeQuantityUsed(other_item, use_stack_max) == other_item.GetQuantity();
  }
 
  bool IsResultOfSplit()
  {
    return m_IsResultOfSplit;
  }
 
  void SetResultOfSplit(bool value)
  {
    m_IsResultOfSplit = value;
  }
 
  int ComputeQuantityUsed(ItemBase other_item, bool use_stack_max = true)
  {
    return ComputeQuantityUsedEx(other_item, use_stack_max);
  }
 
  float ComputeQuantityUsedEx(ItemBase other_item, bool use_stack_max = true)
  {
    float other_item_quantity = other_item.GetQuantity();
    float this_free_space;
 
    float stack_max = GetQuantityMax();
 
    this_free_space = stack_max - GetQuantity();
 
    if (other_item_quantity > this_free_space)
    {
      return this_free_space;
    }
    else
    {
      return other_item_quantity;
    }
  }
 
  void CombineItems(ItemBase other_item, bool use_stack_max = true)
  {
    if (!CanBeCombined(other_item, false))
      return;
 
    if (!IsMagazine() && other_item)
    {
      float quantity_used = ComputeQuantityUsedEx(other_item,use_stack_max);
      if (quantity_used != 0)
      {
        float hp1 = GetHealth01("","");
        float hp2 = other_item.GetHealth01("","");
        float hpResult = ((hp1*GetQuantity()) + (hp2*quantity_used));
        hpResult = hpResult / (GetQuantity() + quantity_used);
 
        hpResult *= GetMaxHealth();
        Math.Round(hpResult);
        SetHealth("", "Health", hpResult);
 
        AddQuantity(quantity_used);
        other_item.AddQuantity(-quantity_used);
      }
    }
    OnCombine(other_item);
  }
 
  void OnCombine(ItemBase other_item)
  {
    #ifdef SERVER
    if (!GetHierarchyRootPlayer() && GetHierarchyParent())
      GetHierarchyParent().IncreaseLifetimeUp();
    #endif
  };
 
  void GetRecipesActions(Man player, out TSelectableActionInfoArray outputList)
  {
    PlayerBase p = PlayerBase.Cast(player);
 
    array<int> recipesIds = p.m_Recipes;
    PluginRecipesManager moduleRecipesManager = PluginRecipesManager.Cast(GetPlugin(PluginRecipesManager));
    if (moduleRecipesManager)
    {
      EntityAI itemInHands = player.GetHumanInventory().GetEntityInHands();
      moduleRecipesManager.GetValidRecipes(ItemBase.Cast(this), ItemBase.Cast(itemInHands), recipesIds, p);
    }
 
    for (int i = 0;i < recipesIds.Count(); i++)
    {
      int key = recipesIds.Get(i);
      string recipeName = moduleRecipesManager.GetRecipeName(key);
      outputList.Insert(new TSelectableActionInfo(SAT_CRAFTING, key, recipeName));
    }
  }
 
  // -------------------------------------------------------------------------
  override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
  {
    super.GetDebugActions(outputList);
 
    //quantity
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.ADD_QUANTITY, "Quantity +20%", FadeColors.LIGHT_GREY));
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.REMOVE_QUANTITY, "Quantity -20%", FadeColors.LIGHT_GREY));
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SET_QUANTITY_0, "Set Quantity 0", FadeColors.LIGHT_GREY));
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SET_MAX_QUANTITY, "Set Quantity Max", FadeColors.LIGHT_GREY));
 
    //health
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.ADD_HEALTH, "Health +20%", FadeColors.LIGHT_GREY));
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.REMOVE_HEALTH, "Health -20%", FadeColors.LIGHT_GREY));
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.DESTROY_HEALTH, "Health 0", FadeColors.LIGHT_GREY));
    //temperature
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.ADD_TEMPERATURE, "Temperature +20", FadeColors.LIGHT_GREY));
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.REMOVE_TEMPERATURE, "Temperature -20", FadeColors.LIGHT_GREY));
 
    //wet
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.ADD_WETNESS, "Wetness +20", FadeColors.LIGHT_GREY));
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.REMOVE_WETNESS, "Wetness -20", FadeColors.LIGHT_GREY));
 
    //liquidtype
    if (IsLiquidContainer())
    {
      outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.LIQUIDTYPE_UP, "LiquidType Next", FadeColors.LIGHT_GREY));
      outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.LIQUIDTYPE_DOWN, "LiquidType Previous", FadeColors.LIGHT_GREY));
    }
 
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.MAKE_SPECIAL, "Make Special", FadeColors.LIGHT_GREY));
    // watch
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.WATCH_ITEM, "Watch (CTRL-Z)", FadeColors.LIGHT_GREY));
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.WATCH_PLAYER, "Watch Player", FadeColors.LIGHT_GREY));
 
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "", FadeColors.RED));
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.DELETE, "Delete", FadeColors.RED));
    outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "", FadeColors.RED));
  }
 
  // -------------------------------------------------------------------------
  // -------------------------------------------------------------------------
  // -------------------------------------------------------------------------
  override bool OnAction(int action_id, Man player, ParamsReadContext ctx)
  {
    super.OnAction(action_id, player, ctx);
    if (action_id >= EActions.RECIPES_RANGE_START && action_id < EActions.RECIPES_RANGE_END)
    {
      PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast(GetPlugin(PluginRecipesManager));
      int idWithoutOffset = action_id - EActions.RECIPES_RANGE_START;
      PlayerBase p = PlayerBase.Cast(player);
      if (EActions.RECIPES_RANGE_START  < 1000)
      {
        float anim_length = plugin_recipes_manager.GetRecipeLengthInSecs(idWithoutOffset);
        float specialty_weight = plugin_recipes_manager.GetRecipeSpecialty(idWithoutOffset);
      }
    }
    #ifndef SERVER
    else if (action_id == EActions.WATCH_PLAYER)
    {
      PluginDeveloper.SetDeveloperItemClientEx(player);
    }
    #endif
    if (GetGame().IsServer())
    {
      if (action_id >= EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START && action_id < EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_END)
      {
        int id = action_id - EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START;
        OnDebugButtonPressServer(id + 1);
      }
 
      else if (action_id >= EActions.DEBUG_AGENTS_RANGE_INJECT_START && action_id < EActions.DEBUG_AGENTS_RANGE_INJECT_END)
      {
        int agent_id = action_id - EActions.DEBUG_AGENTS_RANGE_INJECT_START;
        InsertAgent(agent_id,100);
      }
 
      else if (action_id >= EActions.DEBUG_AGENTS_RANGE_REMOVE_START && action_id < EActions.DEBUG_AGENTS_RANGE_REMOVE_END)
      {
        int agent_id2 = action_id - EActions.DEBUG_AGENTS_RANGE_REMOVE_START;
        RemoveAgent(agent_id2);
      }
 
      else if (action_id == EActions.ADD_QUANTITY)
      {
        if (IsMagazine())
        {
          Magazine mag = Magazine.Cast(this);
          mag.ServerSetAmmoCount(mag.GetAmmoCount() + mag.GetAmmoMax() * 0.2);
        }
        else
        {
          AddQuantity(GetQuantityMax() * 0.2);
        }
 
        if (m_EM)
        {
          m_EM.AddEnergy(m_EM.GetEnergyMax() * 0.2);
        }
        //PrintVariables();
      }
 
      else if (action_id == EActions.REMOVE_QUANTITY) //Quantity -20%
      {
        if (IsMagazine())
        {
          Magazine mag2 = Magazine.Cast(this);
          mag2.ServerSetAmmoCount(mag2.GetAmmoCount() - mag2.GetAmmoMax() * 0.2);
        }
        else
        {
          AddQuantity(- GetQuantityMax() * 0.2);
        }
        if (m_EM)
        {
          m_EM.AddEnergy(- m_EM.GetEnergyMax() * 0.2);
        }
        //PrintVariables();
      }
 
      else if (action_id == EActions.SET_QUANTITY_0) //SetMaxQuantity
      {
        SetQuantity(0);
 
        if (m_EM)
        {
          m_EM.SetEnergy(0);
        }
      }
 
      else if (action_id == EActions.SET_MAX_QUANTITY) //SetMaxQuantity
      {
        SetQuantityMax();
 
        if (m_EM)
        {
          m_EM.SetEnergy(m_EM.GetEnergyMax());
        }
      }
 
      else if (action_id == EActions.ADD_HEALTH)
      {
        AddHealth("","",GetMaxHealth("","Health")/5);
      }
      else if (action_id == EActions.REMOVE_HEALTH)
      {
        AddHealth("","",-GetMaxHealth("","Health")/5);
      }
      else if (action_id == EActions.DESTROY_HEALTH)
      {
        SetHealth01("","",0);
      }
      else if (action_id == EActions.WATCH_ITEM)
      {
        PluginItemDiagnostic mid = PluginItemDiagnostic.Cast(GetPlugin(PluginItemDiagnostic));
        mid.RegisterDebugItem(ItemBase.Cast(this), PlayerBase.Cast(player));
        #ifdef DEVELOPER
        SetDebugDeveloper_item(this);
        #endif
      }
 
      else if (action_id == EActions.ADD_TEMPERATURE)
      {
        AddTemperature(20);
        //PrintVariables();
      }
 
      else if (action_id == EActions.REMOVE_TEMPERATURE)
      {
        AddTemperature(-20);
        //PrintVariables();
      }
 
      else if (action_id == EActions.ADD_WETNESS)
      {
        AddWet(GetWetMax()/5);
        //PrintVariables();
      }
 
      else if (action_id == EActions.REMOVE_WETNESS)
      {
        AddWet(-GetWetMax()/5);
        //PrintVariables();
      }
 
      else if (action_id == EActions.LIQUIDTYPE_UP)
      {
        int curr_type = GetLiquidType();
        SetLiquidType(curr_type * 2);
        //AddWet(1);
        //PrintVariables();
      }
 
      else if (action_id == EActions.LIQUIDTYPE_DOWN)
      {
        int curr_type2 = GetLiquidType();
        SetLiquidType(curr_type2 / 2);
      }
 
      else if (action_id == EActions.MAKE_SPECIAL)
      {
        auto debugParams = DebugSpawnParams.WithPlayer(player);
        OnDebugSpawnEx(debugParams);
      }
 
      else if (action_id == EActions.DELETE)
      {
        Delete();
      }
 
    }
 
 
    return false;
  }
 
  // -------------------------------------------------------------------------
 
 
  void OnActivatedByTripWire();
 
  void OnActivatedByItem(notnull ItemBase item);
 
  //----------------------------------------------------------------
  //returns true if item is able to explode when put in fire
  bool CanExplodeInFire()
  {
    return false;
  }
 
  //----------------------------------------------------------------
  bool CanEat()
  {
    return true;
  }
 
  //----------------------------------------------------------------
  override bool IsIgnoredByConstruction()
  {
    return true;
  }
 
  //----------------------------------------------------------------
  //has FoodStages in config?
  bool HasFoodStage()
  {
    string config_path = string.Format("CfgVehicles %1 Food FoodStages", GetType());
    return GetGame().ConfigIsExisting(config_path);
  }
 
  bool CanBeCooked()
  {
    return false;
  }
 
  bool CanBeCookedOnStick()
  {
    return false;
  }
 
  //----------------------------------------------------------------
  bool CanRepair(ItemBase item_repair_kit)
  {
    PluginRepairing module_repairing = PluginRepairing.Cast(GetPlugin(PluginRepairing));
    return module_repairing.CanRepair(this, item_repair_kit);
  }
 
  //----------------------------------------------------------------
  bool Repair(PlayerBase player, ItemBase item_repair_kit, float specialty_weight)
  {
    PluginRepairing module_repairing = PluginRepairing.Cast(GetPlugin(PluginRepairing));
    return module_repairing.Repair(player, this, item_repair_kit, specialty_weight);
  }
 
  //----------------------------------------------------------------
  int GetItemSize()
  {
    /*
    vector v_size = this.ConfigGetVector("itemSize");
    int v_size_x = v_size[0];
    int v_size_y = v_size[1];
    int size = v_size_x * v_size_y;
    return size;
    */
 
    return 1;
  }
 
  //----------------------------------------------------------------
  //Override for allowing seemingly unallowed moves when two clients send a conflicting message simultaneously
  bool CanBeMovedOverride()
  {
    return m_CanBeMovedOverride;
  }
 
  //----------------------------------------------------------------
  //Override for allowing seemingly unallowed moves when two clients send a conflicting message simultaneously
  void SetCanBeMovedOverride(bool setting)
  {
    m_CanBeMovedOverride = setting;
  }
 
  //----------------------------------------------------------------
  void MessageToOwnerStatus(string text)
  {
    PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
 
    if (player)
    {
      player.MessageStatus(text);
    }
  }
 
  //----------------------------------------------------------------
  void MessageToOwnerAction(string text)
  {
    PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
 
    if (player)
    {
      player.MessageAction(text);
    }
  }
 
  //----------------------------------------------------------------
  void MessageToOwnerFriendly(string text)
  {
    PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
 
    if (player)
    {
      player.MessageFriendly(text);
    }
  }
 
  //----------------------------------------------------------------
  void MessageToOwnerImportant(string text)
  {
    PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
 
    if (player)
    {
      player.MessageImportant(text);
    }
  }
 
  override bool IsItemBase()
  {
    return true;
  }
 
  // Checks if item is of questioned kind
  override bool KindOf(string tag)
  {
    bool found = false;
    string item_name = this.GetType();
    ref TStringArray item_tag_array = new TStringArray;
    GetGame().ConfigGetTextArray("cfgVehicles " + item_name + " itemInfo", item_tag_array);
 
    int array_size = item_tag_array.Count();
    for (int i = 0; i < array_size; i++)
    {
      if (item_tag_array.Get(i) == tag)
      {
        found = true;
        break;
      }
    }
    return found;
  }
 
 
  override void OnRPC(PlayerIdentity sender, int rpc_type,ParamsReadContext ctx)
  {
    //Debug.Log("OnRPC called");
    super.OnRPC(sender, rpc_type,ctx);
 
    //Play soundset for attachment locking (ActionLockAttachment.c)
    switch (rpc_type)
    {
      #ifndef SERVER
      case ERPCs.RPC_SOUND_LOCK_ATTACH:
        Param2<bool, string> p = new Param2<bool, string>(false, "");
 
        if (!ctx.Read(p))
          return;
 
        bool play = p.param1;
        string soundSet = p.param2;
 
        if (play)
        {
          if (m_LockingSound)
          {
            if (!m_LockingSound.IsSoundPlaying())
            {
              m_LockingSound = SEffectManager.PlaySound(soundSet, GetPosition(), 0, 0, true);
            }
          }
          else
          {
            m_LockingSound = SEffectManager.PlaySound(soundSet, GetPosition(), 0, 0, true);
          }
        }
        else
        {
          SEffectManager.DestroyEffect(m_LockingSound);
        }
 
      break;
      #endif
 
    }
 
    if (GetWrittenNoteData())
    {
      GetWrittenNoteData().OnRPC(sender, rpc_type,ctx);
    }
  }
 
  //-----------------------------
  // VARIABLE MANIPULATION SYSTEM
  //-----------------------------
 
  void TransferVariablesFloat(array<float> float_vars)
  {
    DeSerializeNumericalVars(float_vars);
  }
 
  array<float> GetVariablesFloat()
  {
    CachedObjectsArrays.ARRAY_FLOAT.Clear();
    SerializeNumericalVars(CachedObjectsArrays.ARRAY_FLOAT);
    return CachedObjectsArrays.ARRAY_FLOAT;
  }
 
  int NameToID(string name)
  {
    PluginVariables plugin = PluginVariables.Cast(GetPlugin(PluginVariables));
    return plugin.GetID(name);
  }
 
  string IDToName(int id)
  {
    PluginVariables plugin = PluginVariables.Cast(GetPlugin(PluginVariables));
    return plugin.GetName(id);
  }
 
  void OnSyncVariables(ParamsReadContext ctx)//with ID optimization
  {
    //Debug.Log("OnSyncVariables called for item:  "+ ToString(this.GetType()),"varSync");
    //read the flags
    //ref Param1<int> pflags = new Param1<int>(0);
    int varFlags;
    if (!ctx.Read(varFlags))
      return;
 
    //ctx.Read(CachedObjectsParams.PARAM1_INT);
 
    //int varFlags = CachedObjectsParams.PARAM1_INT.param1;
    //--------------
 
 
    if (varFlags & ItemVariableFlags.FLOAT)
    {
      ReadVarsFromCTX(ctx);
    }
    /*
    if (varFlags & ItemVariableFlags.STRING)
    {
      OnSyncStrings(ctx);
    }
    */
  }
 
  void SerializeNumericalVars(array<float> floats_out)
  {
    // the order of serialization must be the same as the order of de-serialization
    floats_out.Insert(m_VariablesMask);
    //--------------------------------------------
    if (IsVariableSet(VARIABLE_QUANTITY))
    {
      floats_out.Insert(m_VarQuantity);
    }
    //--------------------------------------------
    if (IsVariableSet(VARIABLE_TEMPERATURE))
    {
      floats_out.Insert(m_VarTemperature);
    }
    //--------------------------------------------
    if (IsVariableSet(VARIABLE_WET))
    {
      floats_out.Insert(m_VarWet);
    }
    //--------------------------------------------
    if (IsVariableSet(VARIABLE_LIQUIDTYPE))
    {
      floats_out.Insert(m_VarLiquidType);
    }
    //--------------------------------------------
    if (IsVariableSet(VARIABLE_COLOR))
    {
      floats_out.Insert(m_ColorComponentR);
      floats_out.Insert(m_ColorComponentG);
      floats_out.Insert(m_ColorComponentB);
      floats_out.Insert(m_ColorComponentA);
    }
    //--------------------------------------------
    if (IsVariableSet(VARIABLE_CLEANNESS))
    {
      floats_out.Insert(m_Cleanness);
    }
    //--------------------------------------------
  }
 
  void DeSerializeNumericalVars(array<float> floats)
  {
    // the order of serialization must be the same as the order of de-serialization
    int index = 0;
    int mask = Math.Round(floats.Get(index));
 
    index++;
    //--------------------------------------------
    if (mask & VARIABLE_QUANTITY)
    {
      if (m_IsStoreLoad)
      {
        m_StoreLoadedQuantity = floats.Get(index);
      }
      else
      {
        float quantity = floats.Get(index);
        SetQuantity(quantity, true, false, false, false);
      }
      index++;
    }
    //--------------------------------------------
    if (mask & VARIABLE_TEMPERATURE)
    {
      float temperature = floats.Get(index);
      SetTemperature(temperature);
      index++;
    }
    //--------------------------------------------
    if (mask & VARIABLE_WET)
    {
      float wet = floats.Get(index);
      SetWet(wet);
      index++;
    }
    //--------------------------------------------
    if (mask & VARIABLE_LIQUIDTYPE)
    {
      int liquidtype = Math.Round(floats.Get(index));
      SetLiquidType(liquidtype);
      index++;
    }
    //--------------------------------------------
    if (mask & VARIABLE_COLOR)
    {
      m_ColorComponentR = Math.Round(floats.Get(index));
      index++;
      m_ColorComponentG = Math.Round(floats.Get(index));
      index++;
      m_ColorComponentB = Math.Round(floats.Get(index));
      index++;
      m_ColorComponentA = Math.Round(floats.Get(index));
      index++;
    }
    if (mask & VARIABLE_CLEANNESS)
    {
      int cleanness = Math.Round(floats.Get(index));
      SetCleanness(cleanness);
      index++;
    }
    //--------------------------------------------
  }
 
 
  void WriteVarsToCTX(ParamsWriteContext ctx)
  {
    ctx.Write(m_VariablesMask);
 
    //--------------------------------------------
    if (IsVariableSet(VARIABLE_QUANTITY))
    {
      ctx.Write(m_VarQuantity);
    }
    //--------------------------------------------
    if (IsVariableSet(VARIABLE_TEMPERATURE))
    {
      ctx.Write(m_VarTemperature);
    }
    //--------------------------------------------
    if (IsVariableSet(VARIABLE_WET))
    {
      ctx.Write(m_VarWet);
    }
    //--------------------------------------------
    if (IsVariableSet(VARIABLE_LIQUIDTYPE))
    {
      ctx.Write(m_VarLiquidType);
    }
    //--------------------------------------------
    if (IsVariableSet(VARIABLE_COLOR))
    {
      ctx.Write(m_ColorComponentR);
      ctx.Write(m_ColorComponentG);
      ctx.Write(m_ColorComponentB);
      ctx.Write(m_ColorComponentA);
    }
    //--------------------------------------------
    if (IsVariableSet(VARIABLE_CLEANNESS))
    {
      ctx.Write(m_Cleanness);
    }
  }
 
  bool ReadVarsFromCTX(ParamsReadContext ctx, int version = -1)//with ID optimization
  {
    int numOfItems;
    int intValue;
    float value;
    if (version <= 108 && version!= -1)
    {
      if (!ctx.Read(CachedObjectsParams.PARAM1_INT))
        return false;
 
      numOfItems = CachedObjectsParams.PARAM1_INT.param1;
      CachedObjectsArrays.ARRAY_FLOAT.Clear();
 
      for (int i = 0; i < numOfItems; i++)
      {
        if (!ctx.Read(CachedObjectsParams.PARAM1_FLOAT))
          return false;
        value = CachedObjectsParams.PARAM1_FLOAT.param1;
 
        CachedObjectsArrays.ARRAY_FLOAT.Insert(value);
      }
 
      DeSerializeNumericalVars(CachedObjectsArrays.ARRAY_FLOAT);
      return true;
    }
    else if (version <= 116 && version!= -1)
    {
      if (!ctx.Read(numOfItems))
        return false;
 
      CachedObjectsArrays.ARRAY_FLOAT.Clear();
 
      for (int j = 0; j < numOfItems; j++)
      {
        if (!ctx.Read(value))
          return false;
        CachedObjectsArrays.ARRAY_FLOAT.Insert(value);
      }
 
      DeSerializeNumericalVars(CachedObjectsArrays.ARRAY_FLOAT);
      return true;
    }
    else
    {
      int mask;
      if (!ctx.Read(mask))
        return false;
 
      if (mask & VARIABLE_QUANTITY)
      {
        if (!ctx.Read(value))
          return false;
 
        if (m_IsStoreLoad)
        {
          m_StoreLoadedQuantity = value;
        }
        else
        {
          SetQuantity(value, true, false, false, false);
        }
      }
      //--------------------------------------------
      if (mask & VARIABLE_TEMPERATURE)
      {
        if (!ctx.Read(value))
          return false;
        SetTemperature(value);
      }
      //--------------------------------------------
      if (mask & VARIABLE_WET)
      {
        if (!ctx.Read(value))
          return false;
        SetWet(value);
      }
      //--------------------------------------------
      if (mask & VARIABLE_LIQUIDTYPE)
      {
        if (!ctx.Read(intValue))
          return false;
        SetLiquidType(intValue);
      }
      //--------------------------------------------
      if (mask & VARIABLE_COLOR)
      {
        if (!ctx.Read(intValue))
          return false;
 
        m_ColorComponentR = intValue;
        if (!ctx.Read(value))
          return false;
 
        m_ColorComponentG = intValue;
        if (!ctx.Read(value))
          return false;
 
        m_ColorComponentB = intValue;
        if (!ctx.Read(value))
          return false;
 
        m_ColorComponentA = intValue;
      }
      //--------------------------------------------
      if (mask & VARIABLE_CLEANNESS)
      {
        if (!ctx.Read(intValue))
          return false;
        SetCleanness(intValue);
      }
    }
    return true;
  }
 
  void SaveVariables(ParamsWriteContext ctx)
  {
    //Debug.Log("Saving Item Stage 0 "+ClassName(this)+" " + ToString(this));
 
    //first set the flags
 
    int varFlags = 0;
 
    if (m_VariablesMask)
      varFlags = ItemVariableFlags.FLOAT;
 
    ctx.Write(varFlags);
    //-------------------
 
    //now serialize the variables
 
    //floats
    if (m_VariablesMask)
      WriteVarsToCTX(ctx);
  }
 
 
  //----------------------------------------------------------------
  bool LoadVariables(ParamsReadContext ctx, int version = -1)
  {
    int varFlags;
    if (version <= 108 && version != -1)
    {
      //read the flags
      if (!ctx.Read(CachedObjectsParams.PARAM1_INT))
      {
        return false;
      }
      else
      {
        varFlags = CachedObjectsParams.PARAM1_INT.param1;
        //--------------
        if (varFlags & ItemVariableFlags.FLOAT)
        {
          if (!ReadVarsFromCTX(ctx, version))
            return false;
        }
      }
    }
    else
    {
      //read the flags
      if (!ctx.Read(varFlags))
      {
        return false;
      }
      else
      {
        //--------------
        if (varFlags & ItemVariableFlags.FLOAT)
        {
          if (!ReadVarsFromCTX(ctx, version))
            return false;
        }
      }
    }
    return true;
  }
 
 
  //----------------------------------------------------------------
  override bool OnStoreLoad(ParamsReadContext ctx, int version)
  {
    m_IsStoreLoad = true;
 
    if (GetDamageSystemVersionChange() != -1 && version < GetDamageSystemVersionChange())
    {
      m_FixDamageSystemInit = true;
    }
 
    if (!super.OnStoreLoad(ctx, version))
    {
      m_IsStoreLoad = false;
      return false;
    }
 
    if (version >= 114)
    {
      bool hasQuickBarIndexSaved;
 
      if (!ctx.Read(hasQuickBarIndexSaved))
      {
        m_IsStoreLoad = false;
        return false;
      }
 
      if (hasQuickBarIndexSaved)
      {
        int itmQBIndex;
 
        //Load quickbar item bind
        if (!ctx.Read(itmQBIndex))
        {
          m_IsStoreLoad = false;
          return false;
        }
 
        PlayerBase parentPlayer = PlayerBase.Cast(GetHierarchyRootPlayer());
        if (itmQBIndex != -1 && parentPlayer)
          parentPlayer.SetLoadedQuickBarItemBind(this, itmQBIndex);
      }
    }
    else
    {
      // Backup of how it used to be
      PlayerBase player;
      int itemQBIndex;
      if (version == int.MAX)
      {
        if (!ctx.Read(itemQBIndex))
        {
          m_IsStoreLoad = false;
          return false;
        }
      }
      else if (Class.CastTo(player, GetHierarchyRootPlayer()))
      {
        //Load quickbar item bind
        if (!ctx.Read(itemQBIndex))
        {
          m_IsStoreLoad = false;
          return false;
        }
        if (itemQBIndex != -1 && player)
          player.SetLoadedQuickBarItemBind(this,itemQBIndex);
      }
    }
 
    // variable management system
    if (!LoadVariables(ctx, version))
    {
      m_IsStoreLoad = false;
      return false;
    }
 
    //agent trasmission system
    if (!LoadAgents(ctx, version))
    {
      m_IsStoreLoad = false;
      return false;
    }
    if (version >= 132)
    {
      RemotelyActivatedItemBehaviour raib = GetRemotelyActivatedItemBehaviour();
      if (raib)
      {
        if (!raib.OnStoreLoad(ctx,version))
        {
          m_IsStoreLoad = false;
          return false;
        }
      }
    }
 
    m_IsStoreLoad = false;
    return true;
  }
 
  //----------------------------------------------------------------
 
  override void OnStoreSave(ParamsWriteContext ctx)
  {
    super.OnStoreSave(ctx);
    PlayerBase player;
    if (PlayerBase.CastTo(player,GetHierarchyRootPlayer()))
    {
      ctx.Write(true); // Keep track of if we should actually read this in or not
      //Save quickbar item bind
      int itemQBIndex = -1;
      itemQBIndex = player.FindQuickBarEntityIndex(this);
      ctx.Write(itemQBIndex);
    }
    else
    {
      ctx.Write(false); // Keep track of if we should actually read this in or not
    }
 
    SaveVariables(ctx);// variable management system
    SaveAgents(ctx);//agent trasmission system
 
    RemotelyActivatedItemBehaviour raib = GetRemotelyActivatedItemBehaviour();
    if (raib)
    {
      raib.OnStoreSave(ctx);
    }
  }
  //----------------------------------------------------------------
 
  override void AfterStoreLoad()
  {
    super.AfterStoreLoad();
 
    if (m_FixDamageSystemInit)
    {
      PerformDamageSystemReinit();
    }
 
    if (m_StoreLoadedQuantity != float.LOWEST)
    {
      SetQuantity(m_StoreLoadedQuantity);
      m_StoreLoadedQuantity = float.LOWEST;//IMPORTANT to do this !! we use 'm_StoreLoadedQuantity' inside SetQuantity to distinguish between initial quantity setting and the consequent(normal gameplay) calls
    }
  }
 
  override void EEOnAfterLoad()
  {
    super.EEOnAfterLoad();
 
    if (m_FixDamageSystemInit)
    {
      m_FixDamageSystemInit = false;
    }
 
    if (GetRemotelyActivatedItemBehaviour())
      GetRemotelyActivatedItemBehaviour().OnAfterLoad();
  }
 
  bool CanBeDisinfected()
  {
    return false;
  }
 
 
  //----------------------------------------------------------------
  override void OnVariablesSynchronized()
  {
    if (m_Initialized)
    {
      #ifdef PLATFORM_CONSOLE
      //bruteforce it is
      if (m_CanThisBeSplit)
      {
        UIScriptedMenu menu = GetGame().GetUIManager().FindMenu(MENU_INVENTORY);
        if (menu)
        {
          menu.Refresh();
        }
      }
      #endif
    }
 
    if (CanPlayDeployLoopSound())
    {
      PlayDeployLoopSoundEx();
    }
 
    if (m_DeployLoopSoundEx && !CanPlayDeployLoopSound())
    {
      StopDeployLoopSoundEx();
    }
 
    if (IsDeploySound())
    {
      PlayDeploySound();
    }
 
    if (!dBodyIsDynamic(this) && m_WantPlayImpactSound)
    {
      PlayImpactSound(m_ConfigWeight, m_ImpactSpeed, m_ImpactSoundSurfaceHash);
      m_WantPlayImpactSound = false;
    }
 
    if (m_VarQuantity != m_VarQuantityPrev)
    {
      SetWeightDirty();
      m_VarQuantityPrev = m_VarQuantity;
    }
    if (m_VarWet != m_VarWetPrev)
    {
      OnWetChanged(m_VarWet,m_VarWetPrev);
      m_VarWetPrev = m_VarWet;
    }
 
    super.OnVariablesSynchronized();
  }
 
  //------------------------- Quantity
  //----------------------------------------------------------------
  bool SetQuantity(float value, bool destroy_config = true, bool destroy_forced = false, bool allow_client = false, bool clamp_to_stack_max = true)
  {
    if (!IsServerCheck(allow_client))
      return false;
 
    if (!HasQuantity())
      return false;
 
    if (IsLiquidContainer() && GetLiquidType() == 0)
    {
      Debug.LogError("No LiquidType specified, try setting 'varLiquidTypeInit' to a particular liquid type");
      return false;
    }
 
    float min = GetQuantityMin();
    float max = GetQuantityMax();
 
    if (value <= (min + 0.001))
      value = min;
 
    if (value == min)
    {
      if (destroy_config)
      {
        bool dstr = ConfigGetBool("varQuantityDestroyOnMin");
        if (dstr)
        {
          m_VarQuantity = Math.Clamp(value, min, max);
          this.Delete();
          return true;
        }
      }
      else if (destroy_forced)
      {
        m_VarQuantity = Math.Clamp(value, min, max);
        this.Delete();
        return true;
      }
      // we get here if destroy_config IS true AND dstr(config destroy param) IS false;
      RemoveAllAgents();//we remove all agents when we got to the min value, but the item is not getting deleted
    }
 
    float delta = m_VarQuantity;
    m_VarQuantity = Math.Clamp(value, min, max);
 
    if (m_StoreLoadedQuantity == float.LOWEST)//any other value means we are setting quantity from storage
    {
      delta = m_VarQuantity - delta;
 
      if (delta)
      {
        OnQuantityChanged(delta);
      }
    }
 
    SetVariableMask(VARIABLE_QUANTITY);
 
    return false;
  }
 
  //----------------------------------------------------------------
  bool AddQuantity(float value, bool destroy_config = true, bool destroy_forced = false)
  {
    return SetQuantity(GetQuantity() + value, destroy_config, destroy_forced);
  }
  //----------------------------------------------------------------
  void SetQuantityMax()
  {
    float max = GetQuantityMax();
    SetQuantity(max);
  }
 
  override void SetQuantityToMinimum()
  {
    float min = GetQuantityMin();
    SetQuantity(min);
  }
  //----------------------------------------------------------------
  void SetQuantityNormalized(float value, bool destroy_config = true, bool destroy_forced = false)
  {
    float value_clamped = Math.Clamp(value, 0, 1);//just to make sure
    int result = Math.Round(Math.Lerp(GetQuantityMin(), GetQuantityMax(), value_clamped));
    SetQuantity(result, destroy_config, destroy_forced);
  }
 
  //----------------------------------------------------------------
  float GetQuantityNormalized()
  {
    return Math.InverseLerp(GetQuantityMin(), GetQuantityMax(),m_VarQuantity);
  }
 
  /*void SetAmmoNormalized(float value)
  {
    float value_clamped = Math.Clamp(value, 0, 1);
    Magazine this_mag = Magazine.Cast(this);
    int max_rounds = this_mag.GetAmmoMax();
    int result = value * max_rounds;//can the rounded if higher precision is required
    this_mag.SetAmmoCount(result);
  }*/
  //----------------------------------------------------------------
  override int GetQuantityMax()
  {
    float max = 0;
 
    InventoryLocation il = new InventoryLocation;
    if (GetInventory())
      GetInventory().GetCurrentInventoryLocation(il);
 
    int slot = il.GetSlot();
 
    if (slot != -1)
      max = InventorySlots.GetStackMaxForSlotId(slot);
 
    if (max <= 0)
      max = m_VarStackMax;
 
    if (max <= 0)
      max = m_VarQuantityMax;
 
    return max;
  }
 
  override int GetTargetQuantityMax(int attSlotID = -1)
  {
    float quantity_max = 0;
 
    if (attSlotID != -1)
      quantity_max = InventorySlots.GetStackMaxForSlotId(attSlotID);
 
    if (quantity_max <= 0)
      quantity_max = m_VarStackMax;
 
    if (quantity_max <= 0)
      quantity_max = m_VarQuantityMax;
 
    return quantity_max;
  }
  //----------------------------------------------------------------
  int GetQuantityMin()
  {
    return m_VarQuantityMin;
  }
  //----------------------------------------------------------------
  int GetQuantityInit()
  {
    return m_VarQuantityInit;
  }
 
  //----------------------------------------------------------------
  bool HasQuantity()
  {
    return !(GetQuantityMax() - GetQuantityMin() == 0);
  }
 
  override float GetQuantity()
  {
    return m_VarQuantity;
  }
 
  bool IsFullQuantity()
  {
    return GetQuantity() >= GetQuantityMax();
  }
 
  //Calculates weight of single item without attachments and cargo
  override float GetSingleInventoryItemWeightEx()
  {
    //this needs to be first stored inside local variables, when returned directly during inside  return call, the result is completely different due to enforce script bug
    float weightEx = GetWeightEx();//overall weight of the item
    float special = GetInventoryAndCargoWeight();//cargo and attachment weight
    return weightEx - special;
  }
 
  // Obsolete, use GetSingleInventoryItemWeightEx() instead
  float GetSingleInventoryItemWeight()
  {
    return GetSingleInventoryItemWeightEx();
  }
 
  override protected float GetWeightSpecialized(bool forceRecalc = false)
  {
    if (m_CanThisBeSplit) //quantity determines size of the stack
    {
      #ifdef DEVELOPER
      if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
      {
        WeightDebugData data1 = WeightDebug.GetWeightDebug(this);
        data1.SetCalcDetails("TIB1: " + GetConfigWeightModifiedDebugText() +" * " + GetQuantity()+"(quantity)");
      }
      #endif
 
      return GetQuantity() * GetConfigWeightModified();
    }
    else if (HasEnergyManager())// items with energy manager
    {
      #ifdef DEVELOPER
      if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
      {
        WeightDebugData data2 = WeightDebug.GetWeightDebug(this);
        data2.SetCalcDetails("TIB2: "+super.GetWeightSpecialized(forceRecalc)+"(contents weight) + " + GetConfigWeightModifiedDebugText() +" + " + GetCompEM().GetEnergy()+"(energy) * " + ConfigGetFloat("weightPerQuantityUnit") +"(weightPerQuantityUnit)");
      }
      #endif
      return super.GetWeightSpecialized(forceRecalc) + (GetCompEM().GetEnergy() * ConfigGetFloat("weightPerQuantityUnit")) + GetConfigWeightModified());
    }
    else//everything else
    {
      #ifdef DEVELOPER
      if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
      {
        WeightDebugData data3 = WeightDebug.GetWeightDebug(this);
        data3.SetCalcDetails("TIB3: "+super.GetWeightSpecialized(forceRecalc)+"(contents weight) + " + GetConfigWeightModifiedDebugText() +" + " + GetQuantity()+"(quantity) * " + ConfigGetFloat("weightPerQuantityUnit") +"(weightPerQuantityUnit))");
      }
      #endif
      return super.GetWeightSpecialized(forceRecalc) + (GetQuantity() * ConfigGetFloat("weightPerQuantityUnit")) + GetConfigWeightModified());
    }
  }
 
  int GetNumberOfItems()
  {
    int item_count = 0;
    ItemBase item;
 
    if (GetInventory().GetCargo() != NULL)
    {
      item_count = GetInventory().GetCargo().GetItemCount();
    }
 
    for (int i = 0; i < GetInventory().AttachmentCount(); i++)
    {
      Class.CastTo(item,GetInventory().GetAttachmentFromIndex(i));
      if (item)
        item_count += item.GetNumberOfItems();
    }
    return item_count;
  }
 
  float GetUnitWeight(bool include_wetness = true)
  {
    float weight = 0;
    float wetness = 1;
    if (include_wetness)
      wetness += GetWet();
    if (m_CanThisBeSplit) //quantity determines size of the stack
    {
      weight = wetness * m_ConfigWeight;
    }
    else if (ConfigGetFloat("liquidContainerType") > 0) //is a liquid container, default liquid weight is set to 1. May revisit later?
    {
      weight = 1;
    }
    return weight;
  }
 
  void SetVariableMask(int variable)
  {
    m_VariablesMask = variable | m_VariablesMask;
    if (GetGame().IsServer())
    {
      SetSynchDirty();
    }
  }
 
  void RemoveItemVariable(int variable)
  {
    m_VariablesMask = ~variable & m_VariablesMask;
  }
 
  bool IsVariableSet(int variable)
  {
    return (variable & m_VariablesMask);
  }
 
  //-----------------------------------------------------------------
 
  override void ClearInventory()
  {
    if ((GetGame().IsServer() || !GetGame().IsMultiplayer()) && GetInventory())
    {
      GameInventory inv = GetInventory();
      array<EntityAI> items = new array<EntityAI>;
      inv.EnumerateInventory(InventoryTraversalType.INORDER, items);
      for (int i = 0; i < items.Count(); i++)
      {
        ItemBase item = ItemBase.Cast(items.Get(i));
        if (item)
        {
          GetGame().ObjectDelete(item);
        }
      }
    }
  }
 
  //------------------------- Energy
 
  //----------------------------------------------------------------
  float GetEnergy()
  {
    float energy = 0;
    if (HasEnergyManager())
    {
      energy = GetCompEM().GetEnergy();
    }
    return energy;
  }
 
 
  override void OnEnergyConsumed()
  {
    super.OnEnergyConsumed();
 
    ConvertEnergyToQuantity();
  }
 
  override void OnEnergyAdded()
  {
    super.OnEnergyAdded();
 
    ConvertEnergyToQuantity();
  }
 
  // Converts energy (from Energy Manager) to quantity, if enabled.
  void ConvertEnergyToQuantity()
  {
    if (GetGame().IsServer() && HasEnergyManager() && GetCompEM().HasConversionOfEnergyToQuantity())
    {
      if (HasQuantity())
      {
        float energy_0to1 = GetCompEM().GetEnergy0To1();
        SetQuantityNormalized(energy_0to1);
      }
    }
  }
 
  override void SetTemperature(float value, bool allow_client = false)
  {
    if (!IsServerCheck(allow_client))
      return;
 
    float min = GetTemperatureMin();
    float max = GetTemperatureMax();
 
    float previousValue = m_VarTemperature;
 
    m_VarTemperature = Math.Clamp(value, min, max);
 
    if (previousValue != m_VarTemperature)
      SetVariableMask(VARIABLE_TEMPERATURE);
  }
  //----------------------------------------------------------------
  override void AddTemperature(float value)
  {
    SetTemperature(value + GetTemperature());
  }
  //----------------------------------------------------------------
  override void SetTemperatureMax()
  {
    SetTemperature(m_VarTemperatureMax);
  }
  //----------------------------------------------------------------
  override float GetTemperature()
  {
    return m_VarTemperature;
  }
 
  override float GetTemperatureInit()
  {
    return m_VarTemperatureInit;
  }
 
  override float GetTemperatureMin()
  {
    return m_VarTemperatureMin;
  }
 
  override float GetTemperatureMax()
  {
    return m_VarTemperatureMax;
  }
  //----------------------------------------------------------------
  float GetHeatIsolationInit()
  {
    return ConfigGetFloat("heatIsolation");
  }
 
  float GetHeatIsolation()
  {
    return m_HeatIsolation;
  }
 
  float GetDryingIncrement(string pIncrementName)
  {
    string paramPath = string.Format("CfgVehicles %1 EnvironmentWetnessIncrements Drying %2", GetType(), pIncrementName);
    if (GetGame().ConfigIsExisting(paramPath))
      return GetGame().ConfigGetFloat(paramPath);
 
    return 0.0;
  }
 
  float GetSoakingIncrement(string pIncrementName)
  {
    string paramPath = string.Format("CfgVehicles %1 EnvironmentWetnessIncrements Soaking %2", GetType(), pIncrementName);
    if (GetGame().ConfigIsExisting(paramPath))
      return GetGame().ConfigGetFloat(paramPath);
 
    return 0.0;
  }
  //----------------------------------------------------------------
  override void SetWet(float value, bool allow_client = false)
  {
    if (!IsServerCheck(allow_client))
      return;
 
    float min = GetWetMin();
    float max = GetWetMax();
 
    float previousValue = m_VarWet;
 
    m_VarWet = Math.Clamp(value, min, max);
 
    if (previousValue != m_VarWet)
    {
      SetVariableMask(VARIABLE_WET);
      OnWetChanged(m_VarWet, previousValue);
    }
  }
  //----------------------------------------------------------------
  override void AddWet(float value)
  {
    SetWet(GetWet() + value);
  }
  //----------------------------------------------------------------
  override void SetWetMax()
  {
    SetWet(m_VarWetMax);
  }
  //----------------------------------------------------------------
  override float GetWet()
  {
    return m_VarWet;
  }
  //----------------------------------------------------------------
  override float GetWetMax()
  {
    return m_VarWetMax;
  }
  //----------------------------------------------------------------
  override float GetWetMin()
  {
    return m_VarWetMin;
  }
  //----------------------------------------------------------------
  override float GetWetInit()
  {
    return m_VarWetInit;
  }
  //----------------------------------------------------------------
  override void OnWetChanged(float newVal, float oldVal)
  {
    EWetnessLevel newLevel = GetWetLevelInternal(newVal);
    EWetnessLevel oldLevel = GetWetLevelInternal(oldVal);
    if (newLevel != oldLevel)
    {
      OnWetLevelChanged(newLevel,oldLevel);
    }
  }
 
  override void OnWetLevelChanged(EWetnessLevel newLevel, EWetnessLevel oldLevel)
  {
    SetWeightDirty();
  }
 
  override EWetnessLevel GetWetLevel()
  {
    return GetWetLevelInternal(m_VarWet);
  }
 
  //----------------------------------------------------------------
  bool IsServerCheck(bool allow_client)
  {
    if (g_Game.IsServer())
      return true;
 
    if (allow_client)
      return true;
 
    if (GetGame().IsClient() && GetGame().IsMultiplayer())
    {
      Error("Attempting to change variable client side, variables are supposed to be changed on server only !!");
      return false;
    }
 
    return true;
  }
 
  float GetItemModelLength()
  {
    if (ConfigIsExisting("itemModelLength"))
    {
      return ConfigGetFloat("itemModelLength");
    }
    return 0;
  }
 
  float GetItemAttachOffset()
  {
    if (ConfigIsExisting("itemAttachOffset"))
    {
      return ConfigGetFloat("itemAttachOffset");
    }
    return 0;
  }
 
  void SetCleanness(int value, bool allow_client = false)
  {
    if (!IsServerCheck(allow_client))
      return;
 
    int previousValue = m_Cleanness;
 
    m_Cleanness = Math.Clamp(value, m_CleannessMin, m_CleannessMax);
 
    if (previousValue != m_Cleanness)
      SetVariableMask(VARIABLE_CLEANNESS);
  }
 
 
  bool AllowFoodConsumption()
  {
    return true;
  }
 
  //----------------------------------------------------------------
  // ATTACHMENT LOCKING
  // Getters relevant to generic ActionLockAttachment
  int GetLockType()
  {
    return m_LockType;
  }
 
  string GetLockSoundSet()
  {
    return m_LockSoundSet;
  }
 
  //----------------------------------------------------------------
  //------------------------- Color
  // sets items color variable given color components
  void SetColor(int r, int g, int b, int a)
  {
    m_ColorComponentR = r;
    m_ColorComponentG = g;
    m_ColorComponentB = b;
    m_ColorComponentA = a;
    SetVariableMask(VARIABLE_COLOR);
  }
  void GetColor(out int r,out int g,out int b,out int a)
  {
    r = m_ColorComponentR;
    g = m_ColorComponentG;
    b = m_ColorComponentB;
    a = m_ColorComponentA;
  }
 
  bool IsColorSet()
  {
    return IsVariableSet(VARIABLE_COLOR);
  }
 
  string GetColorString()
  {
    int r,g,b,a;
    GetColor(r,g,b,a);
    r = r/255;
    g = g/255;
    b = b/255;
    a = a/255;
    return MiscGameplayFunctions.GetColorString(r, g, b, a);
  }
  //----------------------------------------------------------------
  //------------------------- LiquidType
 
  void SetLiquidType(int value, bool allow_client = false)
  {
    if (!IsServerCheck(allow_client))
      return;
 
    m_VarLiquidType = value;
    SetVariableMask(VARIABLE_LIQUIDTYPE);
  }
 
  int GetLiquidTypeInit()
  {
    return ConfigGetInt("varLiquidTypeInit");
  }
 
  int GetLiquidType()
  {
    return m_VarLiquidType;
  }
 
  // -------------------------------------------------------------------------
  void OnInventoryEnter(Man player)
  {
    PlayerBase nplayer;
    if (PlayerBase.CastTo(nplayer, player))
    {
      m_CanPlayImpactSound = true;
      //nplayer.OnItemInventoryEnter(this);
      nplayer.SetEnableQuickBarEntityShortcut(this,true);
    }
  }
 
  // -------------------------------------------------------------------------
  void OnInventoryExit(Man player)
  {
    PlayerBase nplayer;
    if (PlayerBase.CastTo(nplayer,player))
    {
      //nplayer.OnItemInventoryExit(this);
      nplayer.SetEnableQuickBarEntityShortcut(this,false);
 
    }
 
    //if (!GetGame().IsDedicatedServer())
    player.GetHumanInventory().ClearUserReservedLocationForContainer(this);
 
 
    if (HasEnergyManager())
    {
      GetCompEM().UpdatePlugState(); // Unplug the el. device if it's necesarry.
    }
  }
 
  // ADVANCED PLACEMENT EVENTS
  override void OnPlacementStarted(Man player)
  {
    super.OnPlacementStarted(player);
 
    SetTakeable(false);
  }
 
  override void OnPlacementComplete(Man player, vector position = "0 0 0", vector orientation = "0 0 0")
  {
    if (m_AdminLog)
    {
      m_AdminLog.OnPlacementComplete(player, this);
    }
    if (GetGame().IsServer())
    {
      SetIsDeploySound(true);
    }
    super.OnPlacementComplete(player, position, orientation);
  }
 
  //-----------------------------
  // AGENT SYSTEM
  //-----------------------------
  //--------------------------------------------------------------------------
  bool ContainsAgent(int agent_id)
  {
    if (agent_id & m_AttachedAgents)
    {
      return true;
    }
    else
    {
      return false;
    }
  }
 
  //--------------------------------------------------------------------------
  override void RemoveAgent(int agent_id)
  {
    if (ContainsAgent(agent_id))
    {
      m_AttachedAgents = ~agent_id & m_AttachedAgents;
    }
  }
 
  //--------------------------------------------------------------------------
  override void RemoveAllAgents()
  {
    m_AttachedAgents = 0;
  }
  //--------------------------------------------------------------------------
  override void RemoveAllAgentsExcept(int agents_to_keep_mask)
  {
    m_AttachedAgents = m_AttachedAgents & agent_to_keep;
  }
  // -------------------------------------------------------------------------
  override void InsertAgent(int agent, float count = 1)
  {
    if (count < 1)
      return;
    //Debug.Log("Inserting Agent on item: " + agent.ToString() +" count: " + count.ToString());
    m_AttachedAgents = (agent | m_AttachedAgents);
  }
 
  void TransferAgents(int agents)
  {
    m_AttachedAgents = (m_AttachedAgents | agents);
  }
 
  // -------------------------------------------------------------------------
  override int GetAgents()
  {
    return m_AttachedAgents;
  }
  //----------------------------------------------------------------------
 
  /*int GetContaminationType()
  {
    int contamination_type;
 
    const int CONTAMINATED_MASK = eAgents.CHOLERA | eAgents.INFLUENZA | eAgents.SALMONELLA | eAgents.BRAIN;
    const int POISONED_MASK = eAgents.FOOD_POISON | eAgents.CHEMICAL_POISON;
    const int NERVE_GAS_MASK = eAgents.CHEMICAL_POISON;
    const int DIRTY_MASK = eAgents.WOUND_AGENT;
 
    Edible_Base edible = Edible_Base.Cast(this);
    int agents = GetAgents();
    if (edible)
    {
      NutritionalProfile profile = Edible_Base.GetNutritionalProfile(edible);
      if (profile)
      {
        //Print("profile agents:" +profile.GetAgents());
        agents = agents | profile.GetAgents();//merge item's agents with nutritional agents
      }
    }
    if (agents & CONTAMINATED_MASK)
    {
      contamination_type = contamination_type | EContaminationTypes.ITEM_BADGE_CONTAMINATED;
    }
    if (agents & POISONED_MASK)
    {
      contamination_type = contamination_type | EContaminationTypes.ITEM_BADGE_POISONED;
    }
    if (agents & NERVE_GAS_MASK)
    {
      contamination_type = contamination_type | EContaminationTypes.ITEM_BADGE_NERVE_GAS;
    }
    if (agents & DIRTY_MASK)
    {
      contamination_type = contamination_type | EContaminationTypes.ITEM_BADGE_DIRTY;
    }
 
    return agents;
  }*/
 
  // -------------------------------------------------------------------------
  bool LoadAgents(ParamsReadContext ctx, int version)
  {
    if (!ctx.Read(m_AttachedAgents))
      return false;
    return true;
  }
  // -------------------------------------------------------------------------
  void SaveAgents(ParamsWriteContext ctx)
  {
 
    ctx.Write(m_AttachedAgents);
  }
  // -------------------------------------------------------------------------
 
 
  // returns item's protection level against enviromental hazard, for masks with filters, returns the filters protection for valid filter, otherwise 0
  float GetProtectionLevel(int type, bool consider_filter = false, int system = 0)
  {
    if (IsDamageDestroyed() || (HasQuantity() && GetQuantity() <= 0))
    {
      return 0;
    }
 
    if (GetInventory().GetAttachmentSlotsCount() != 0)//is it an item with attachable filter ?
    {
      ItemBase filter = ItemBase.Cast(FindAttachmentBySlotName("GasMaskFilter"));
      if (filter)
        return filter.GetProtectionLevel(type, false, system);//it's a valid filter, return the protection
      else
        return 0;//otherwise return 0 when no filter attached
    }
 
    string subclassPath, entryName;
 
    switch (type)
    {
      case DEF_BIOLOGICAL:
        entryName = "biological";
        break;
      case DEF_CHEMICAL:
        entryName = "chemical";
        break;
      default:
        entryName = "biological";
        break;
    }
 
    subclassPath = "CfgVehicles " + this.GetType() + " Protection ";
 
    return GetGame().ConfigGetFloat(subclassPath + entryName);
  }
 
 
 
  override void EEOnCECreate()
  {
    //Print("EEOnCECreate");
    if (!IsMagazine())
      SetCEBasedQuantity();
 
    SetZoneDamageCEInit();
  }
 
 
  //-------------------------
  // OPEN/CLOSE USER ACTIONS
  //-------------------------
  void Open();
  void Close();
  bool IsOpen()
  {
    return true;
  }
 
  override bool CanDisplayCargo()
  {
    return IsOpen();
  }
 
 
  // ------------------------------------------------------------
  // CONDITIONS
  // ------------------------------------------------------------
  override bool CanPutInCargo(EntityAI parent)
  {
    if (parent)
    {
      if (parent.IsInherited(DayZInfected))
        return true;
 
      if (!parent.IsRuined())
        return true;
    }
 
    return true;
  }
 
  override bool CanPutAsAttachment(EntityAI parent)
  {
    if (!super.CanPutAsAttachment(parent))
    {
      return false;
    }
 
    if (!IsRuined() && !parent.IsRuined())
    {
      return true;
    }
 
    return false;
  }
 
  override bool CanReceiveItemIntoCargo(EntityAI item)
  {
    //removed 15.06. coz of loading from storage -> after load items in cargo was lost -> waiting for proper solution
    //if (GetHealthLevel() == GameConstants.STATE_RUINED)
    //  return false;
 
    return super.CanReceiveItemIntoCargo(item);
  }
 
  override bool CanReceiveAttachment(EntityAI attachment, int slotId)
  {
    //removed 15.06. coz of loading from storage -> after load items in cargo was lost -> waiting for proper solution
    //if (GetHealthLevel() == GameConstants.STATE_RUINED)
    //  return false;
 
    GameInventory attachmentInv = attachment.GetInventory();
    if (attachmentInv && attachmentInv.GetCargo() && attachmentInv.GetCargo().GetItemCount() > 0)
    {
      if (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase))
        return false;
    }
 
    return super.CanReceiveAttachment(attachment, slotId);
  }
 
  /*override bool CanLoadAttachment(EntityAI attachment)
  {
    //removed 15.06. coz of loading from storage -> after load items in cargo was lost -> waiting for proper solution
    //if (GetHealthLevel() == GameConstants.STATE_RUINED)
    //  return false;
 
    GameInventory attachmentInv = attachment.GetInventory();
    if (attachmentInv && attachmentInv.GetCargo() && attachmentInv.GetCargo().GetItemCount() > 0)
    {
      bool boo = (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase));
      ErrorEx("CanLoadAttachment | this: " + this + " | attachment: " + attachment + " | boo: " + boo,ErrorExSeverity.INFO);
 
      if (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase))
        return false;
    }
 
    return super.CanLoadAttachment(attachment);
  }*/
 
  // Plays muzzle flash particle effects
  static void PlayFireParticles(ItemBase weapon, int muzzle_index, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
  {
    int id = muzzle_owner.GetMuzzleID();
    array<ref WeaponParticlesOnFire> WPOF_array = m_OnFireEffect.Get(id);
 
    if (WPOF_array)
    {
      for (int i = 0; i < WPOF_array.Count(); i++)
      {
        WeaponParticlesOnFire WPOF = WPOF_array.Get(i);
 
        if (WPOF)
        {
          WPOF.OnActivate(weapon, muzzle_index, ammoType, muzzle_owner, suppressor, config_to_search);
        }
      }
    }
  }
 
  // Plays bullet eject particle effects (usually just smoke, the bullet itself is a 3D model and is not part of this function)
  static void PlayBulletCasingEjectParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
  {
    int id = muzzle_owner.GetMuzzleID();
    array<ref WeaponParticlesOnBulletCasingEject> WPOBE_array = m_OnBulletCasingEjectEffect.Get(id);
 
    if (WPOBE_array)
    {
      for (int i = 0; i < WPOBE_array.Count(); i++)
      {
        WeaponParticlesOnBulletCasingEject WPOBE = WPOBE_array.Get(i);
 
        if (WPOBE)
        {
          WPOBE.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
        }
      }
    }
  }
 
  // Plays all weapon overheating particles
  static void PlayOverheatingParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
  {
    int id = muzzle_owner.GetMuzzleID();
    array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
 
    if (WPOOH_array)
    {
      for (int i = 0; i < WPOOH_array.Count(); i++)
      {
        WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
 
        if (WPOOH)
        {
          WPOOH.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
        }
      }
    }
  }
 
  // Updates all weapon overheating particles
  static void UpdateOverheatingParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
  {
    int id = muzzle_owner.GetMuzzleID();
    array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
 
    if (WPOOH_array)
    {
      for (int i = 0; i < WPOOH_array.Count(); i++)
      {
        WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
 
        if (WPOOH)
        {
          WPOOH.OnUpdate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
        }
      }
    }
  }
 
  // Stops overheating particles
  static void StopOverheatingParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
  {
    int id = muzzle_owner.GetMuzzleID();
    array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
 
    if (WPOOH_array)
    {
      for (int i = 0; i < WPOOH_array.Count(); i++)
      {
        WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
 
        if (WPOOH)
        {
          WPOOH.OnDeactivate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
        }
      }
    }
  }
 
  //----------------------------------------------------------------
  //Item Behaviour - unified approach
  override bool IsHeavyBehaviour()
  {
    if (m_ItemBehaviour == 0)
    {
      return true;
    }
 
    return false;
  }
 
  override bool IsOneHandedBehaviour()
  {
    if (m_ItemBehaviour == 1)
    {
      return true;
    }
 
    return false;
  }
 
  override bool IsTwoHandedBehaviour()
  {
    if (m_ItemBehaviour == 2)
    {
      return true;
    }
 
    return false;
  }
 
  bool IsDeployable()
  {
    return false;
  }
 
  float GetDeployTime()
  {
    return UATimeSpent.DEFAULT_DEPLOY;
  }
 
 
  //----------------------------------------------------------------
  // Item Targeting (User Actions)
  override void SetTakeable(bool pState)
  {
    m_IsTakeable = pState;
    SetSynchDirty();
  }
 
  override bool IsTakeable()
  {
    return m_IsTakeable;
  }
 
  protected void PreLoadSoundAttachmentType()
  {
    string att_type = "None";
 
    if (ConfigIsExisting("soundAttType"))
    {
      att_type = ConfigGetString("soundAttType");
    }
 
    m_SoundAttType = att_type;
  }
 
  override string GetAttachmentSoundType()
  {
    return m_SoundAttType;
  }
 
  //----------------------------------------------------------------
  //SOUNDS FOR ADVANCED PLACEMNT
  //----------------------------------------------------------------
 
  void SoundSynchRemoteReset()
  {
    m_IsSoundSynchRemote = false;
 
    SetSynchDirty();
  }
 
  void SoundSynchRemote()
  {
    m_IsSoundSynchRemote = true;
 
    SetSynchDirty();
  }
 
  bool IsSoundSynchRemote()
  {
    return m_IsSoundSynchRemote;
  }
 
  string GetDeploySoundset();
  string GetPlaceSoundset();
  string GetLoopDeploySoundset();
  string GetDeployFinishSoundset();
 
  void SetIsPlaceSound(bool is_place_sound)
  {
    m_IsPlaceSound = is_place_sound;
  }
 
  bool IsPlaceSound()
  {
    return m_IsPlaceSound;
  }
 
  void SetIsDeploySound(bool is_deploy_sound)
  {
    m_IsDeploySound = is_deploy_sound;
  }
 
  bool IsDeploySound()
  {
    return m_IsDeploySound;
  }
 
  void PlayDeployLoopSoundEx()
  {
    if (!GetGame().IsDedicatedServer() && !m_DeployLoopSoundEx)
    {
      m_DeployLoopSoundEx = SEffectManager.PlaySound(GetLoopDeploySoundset(), GetPosition());
      if (m_DeployLoopSoundEx)
        m_DeployLoopSoundEx.SetAutodestroy(true);
      else
        Debug.Log("dbgSounds | null m_DeployLoopSoundEx from sound set: " + GetLoopDeploySoundset());
    }
  }
 
  void StopDeployLoopSoundEx()
  {
    if (!GetGame().IsDedicatedServer())
    {
      m_DeployLoopSoundEx.SetSoundFadeOut(0.5);
      m_DeployLoopSoundEx.SoundStop();
    }
  }
 
  void PlayDeploySound()
  {
    if (!GetGame().IsDedicatedServer() && !m_SoundDeploy)
    {
      m_SoundDeploy = SEffectManager.PlaySound(GetDeploySoundset(), GetPosition());
      if (m_SoundDeploy)
        m_SoundDeploy.SetAutodestroy(true);
      else
        Debug.Log("dbgSounds | null m_SoundDeploy from sound set: " + GetDeploySoundset());
    }
  }
 
  void PlayDeployFinishSound()
  {
    if (!GetGame().IsDedicatedServer() && !m_SoundDeployFinish)
    {
      m_SoundDeployFinish = SEffectManager.PlaySound(GetDeployFinishSoundset(), GetPosition());
      if (m_SoundDeployFinish)
        m_SoundDeployFinish.SetAutodestroy(true);
      else
        Debug.Log("dbgSounds | null m_SoundDeployFinish from sound set: " + GetDeployFinishSoundset());
    }
  }
 
  void PlayPlaceSound()
  {
    if (!GetGame().IsDedicatedServer() && !m_SoundPlace)
    {
      m_SoundPlace = SEffectManager.PlaySound(GetPlaceSoundset(), GetPosition());
      if (m_SoundPlace)
        m_SoundPlace.SetAutodestroy(true);
      else
        Debug.Log("dbgSounds | null m_SoundPlace from sound set: " + GetPlaceSoundset());
    }
  }
 
  bool CanPlayDeployLoopSound()
  {
    return IsBeingPlaced() && IsSoundSynchRemote();
  }
 
  void PlayAttachSound(string slot_type)
  {
    if (!GetGame().IsDedicatedServer())
    {
      if (ConfigIsExisting("attachSoundSet"))
      {
        string cfg_path = "";
        string soundset = "";
        string type_name = GetType();
 
        TStringArray cfg_soundset_array = new TStringArray;
        TStringArray cfg_slot_array = new TStringArray;
        ConfigGetTextArray("attachSoundSet",cfg_soundset_array);
        ConfigGetTextArray("attachSoundSlot",cfg_slot_array);
 
        if (cfg_soundset_array.Count() > 0 && cfg_soundset_array.Count() == cfg_slot_array.Count())
        {
          for (int i = 0; i < cfg_soundset_array.Count(); i++)
          {
            if (cfg_slot_array[i] == slot_type)
            {
              soundset = cfg_soundset_array[i];
              break;
            }
          }
        }
 
        if (soundset != "")
        {
          EffectSound sound = SEffectManager.PlaySound(soundset, GetPosition());
          sound.SetAutodestroy(true);
        }
      }
    }
  }
 
  void PlayDetachSound(string slot_type)
  {
    //TODO - evaluate if needed and devise universal config structure if so
  }
 
  void OnApply(PlayerBase player);
 
  float GetBandagingEffectivity()
  {
    return 1.0;
  };
  //returns applicable selection
  array<string> GetHeadHidingSelection()
  {
    return m_HeadHidingSelections;
  }
 
  bool HidesSelectionBySlot()
  {
    return m_HideSelectionsBySlot;
  }
 
  WrittenNoteData GetWrittenNoteData() {};
 
  void StopItemDynamicPhysics()
  {
    SetDynamicPhysicsLifeTime(0.01);
    m_ItemBeingDroppedPhys = false;
  }
 
  void PerformDamageSystemReinit()
  {
    array<string> zone_names = new array<string>;
    GetDamageZones(zone_names);
    for (int i = 0; i < zone_names.Count(); i++)
    {
      SetHealthMax(zone_names.Get(i),"Health");
    }
    SetHealthMax("","Health");
  }
 
  void SetZoneDamageCEInit()
  {
    float global_health = GetHealth01("","Health");
    array<string> zones = new array<string>;
    GetDamageZones(zones);
    //set damage of all zones to match global health level
    for (int i = 0; i < zones.Count(); i++)
    {
      SetHealth01(zones.Get(i),"Health",global_health);
    }
  }
 
  bool IsCoverFaceForShave(string slot_name)
  {
    return IsExclusionFlagPresent(PlayerBase.GetFaceCoverageShaveValues());
  }
 
  void ProcessItemWetness(float delta, bool hasParent, bool hasRootAsPlayer, ItemBase refParentIB)
  {
    if (!hasRootAsPlayer)
    {
      if (refParentIB)
      {
        // parent is wet
        if ((refParentIB.GetWet() >= GameConstants.STATE_SOAKING_WET) && (m_VarWet < m_VarWetMax))
          AddWet(delta * GameConstants.WETNESS_RATE_WETTING_INSIDE);
        // parent has liquid inside
        else if ((refParentIB.GetLiquidType() != 0) && (refParentIB.GetQuantity() > 0) && (m_VarWet < m_VarWetMax))
          AddWet(delta * GameConstants.WETNESS_RATE_WETTING_LIQUID);
        // drying
        else if (m_VarWet > m_VarWetMin)
          AddWet(-1 * delta * GetDryingIncrement("ground") * 2);
      }
      else
      {
        // drying on ground or inside non-itembase (car, ...)
        if (m_VarWet > m_VarWetMin)
          AddWet(-1 * delta * GetDryingIncrement("ground"));
      }
    }
  }
 
  void ProcessItemTemperature(float delta, bool hasParent, bool hasRootAsPlayer, ItemBase refParentIB)
  {
    if (!hasRootAsPlayer && GetTemperature() > GetTemperatureMin() && !IsFireplace())
    {
      if (refParentIB)
      {
        // cooling of an item inside other
        if (GetTemperature() > refParentIB.GetTemperature())
          AddTemperature(delta * GameConstants.TEMPERATURE_RATE_COOLING_INSIDE);
      }
      else
      {
        // cooling of an item on ground or inside non-itembase (car, ...)
        AddTemperature(delta * GameConstants.TEMPERATURE_RATE_COOLING_INSIDE);
      }
    }
  }
 
  // Backwards compatibility
  void ProcessItemWetnessAndTemperature(float delta, bool hasParent, bool hasRootAsPlayer, ItemBase refParentIB)
  {
    ProcessItemWetness(delta, hasParent, hasRootAsPlayer, refParentIB);
    ProcessItemTemperature(delta, hasParent, hasRootAsPlayer, refParentIB);
  }
 
  void HierarchyCheck(out bool hasParent, out bool hasRootAsPlayer, out ItemBase refParentIB)
  {
    // hierarchy check for an item to decide whether it has some parent and it is in some player inventory
    EntityAI parent = GetHierarchyParent();
    if (!parent)
    {
      hasParent = false;
      hasRootAsPlayer = false;
    }
    else
    {
      hasParent = true;
      hasRootAsPlayer = (GetHierarchyRootPlayer() != null);
      refParentIB = ItemBase.Cast(parent);
    }
  }
 
  protected void ProcessDecay(float delta, bool hasRootAsPlayer)
  {
    // this is stub, implemented on Edible_Base
  }
 
  bool CanDecay() //Was protected, changed for access from TransferItemVariables method
  {
    // return true used on selected food clases so they can decay
    return false;
  }
 
  protected bool CanProcessDecay()
  {
    // this is stub, implemented on Edible_Base class
    // used to determine whether it is still necessary for the food to decay
    return false;
  }
 
  protected bool CanHaveWetness()
  {
    // return true used on selected items that have a wetness effect
    return false;
  }
 
  protected bool CanHaveTemperature()
  {
    // return true used on selected items that have a temperature effect
    return false;
  }
 
  override void OnCEUpdate()
  {
    super.OnCEUpdate();
 
    bool hasParent = false, hasRootAsPlayer = false;
    ItemBase refParentIB;
 
    bool wwtu = g_Game.IsWorldWetTempUpdateEnabled();
    bool foodDecay = g_Game.IsFoodDecayEnabled();
 
    if (wwtu || foodDecay)
    {
      bool processWetness = wwtu && CanHaveWetness();
      bool processTemperature = wwtu && CanHaveTemperature();
      bool processDecay  = foodDecay && CanDecay() && CanProcessDecay();
 
      if (processWetness || processTemperature || processDecay)
      {
        HierarchyCheck(hasParent, hasRootAsPlayer, refParentIB);
 
        if (processWetness)
          ProcessItemWetness(m_ElapsedSinceLastUpdate, hasParent, hasRootAsPlayer, refParentIB);
 
        if (processTemperature)
          ProcessItemTemperature(m_ElapsedSinceLastUpdate, hasParent, hasRootAsPlayer, refParentIB);
 
        if (processDecay)
          ProcessDecay(m_ElapsedSinceLastUpdate, hasRootAsPlayer);
      }
    }
  }
 
  bool IsCargoException4x3(EntityAI item)
  {
    return (item.IsKindOf("Cauldron") || item.IsKindOf("Pot") || item.IsKindOf("FryingPan") || item.IsKindOf("SmallProtectorCase") || (item.IsKindOf("PortableGasStove") && item.FindAttachmentBySlotName("CookingEquipment")));
  }
 
  void CopyScriptPropertiesFrom(EntityAI oldItem)
  {
    MiscGameplayFunctions.TransferItemProperties(oldItem, this);
  }
 
  void AddLightSourceItem(ItemBase lightsource)
  {
    m_LightSourceItem = lightsource;
  }
 
  void RemoveLightSourceItem()
  {
    m_LightSourceItem = null;
  }
 
  ItemBase GetLightSourceItem()
  {
    return m_LightSourceItem;
  }
 
  array<int> GetValidFinishers()
  {
    return null;
  }
 
  bool GetActionWidgetOverride(out typename name)
  {
    return false;
  }
 
  bool PairWithDevice(notnull ItemBase otherDevice)
  {
    if (GetGame().IsServer())
    {
      ItemBase explosive = otherDevice;
      RemoteDetonatorTrigger trg = RemoteDetonatorTrigger.Cast(this);
      if (!trg)
      {
        trg = RemoteDetonatorTrigger.Cast(otherDevice);
        explosive = this;
      }
 
      explosive.PairRemote(trg);
      trg.SetControlledDevice(explosive);
 
      int persistentID = RemotelyActivatedItemBehaviour.GeneratePersistentID();
      trg.SetPersistentPairID(persistentID);
      explosive.SetPersistentPairID(persistentID);
 
      return true;
    }
    return false;
  }
 
  #ifdef DEVELOPER
  override void SetDebugItem()
  {
    super.SetDebugItem();
    _itemBase = this;
  }
  #endif
 
  bool CanBeUsedForSuicide()
  {
    return true;
  }
}
 
EntityAI SpawnItemOnLocation(string object_name, notnull InventoryLocation loc, bool full_quantity)
{
  EntityAI entity = SpawnEntity(object_name, loc, ECE_IN_INVENTORY, RF_DEFAULT);
  if (entity)
  {
    bool is_item = entity.IsInherited(ItemBase);
    if (is_item && full_quantity)
    {
      ItemBase item = ItemBase.Cast(entity);
      item.SetQuantity(item.GetQuantityInit());
    }
  }
  else
  {
    Print("Cannot spawn entity: " + object_name);
    return NULL;
  }
  return entity;
}
 
void SetupSpawnedItem(ItemBase item, float health, float quantity)
{
  if (item)
  {
    if (health > 0)
      item.SetHealth("", "", health);
 
 
    if (item.HasEnergyManager())
    {
      if (quantity >= 0)
      {
        item.GetCompEM().SetEnergy0To1(quantity);
      }
      else
      {
        item.GetCompEM().SetEnergy(Math.AbsFloat(quantity));
      }
    }
    else if (item.IsMagazine())
    {
      Magazine mag = Magazine.Cast(item);
      if (quantity >= 0)
      {
        mag.ServerSetAmmoCount(mag.GetAmmoMax() * quantity);
      }
      else
      {
        mag.ServerSetAmmoCount(Math.AbsFloat(quantity));
      }
 
    }
    else
    {
      if (quantity >= 0)
      {
        item.SetQuantityNormalized(quantity, false);
      }
      else
      {
        item.SetQuantity(Math.AbsFloat(quantity));
      }
 
    }
  }
}
 
#ifdef DEVELOPER
ItemBase _itemBase;//watched item goes here(LCTRL+RMB->Watch)
#endif