DayZ 1.28
DayZ Explorer by KGB
 
Загрузка...
Поиск...
Не найдено

◆ HasQuantity()

override bool SpawnItemOnLocation::HasQuantity ( )
protected

См. определение в файле ItemBase.c строка 8291

8295{
8296 override bool CanPutAsAttachment(EntityAI parent)
8297 {
8298 return true;
8299 }
8300};
8301
8302//const bool QUANTITY_DEBUG_REMOVE_ME = false;
8303
8304class ItemBase extends InventoryItem
8305{
8309
8311
8312 static int m_DebugActionsMask;
8314 // ============================================
8315 // Variable Manipulation System
8316 // ============================================
8317 // Quantity
8318
8319 float m_VarQuantity;
8320 float m_VarQuantityPrev;//for client to know quantity changed during synchronization
8322 int m_VarQuantityMin;
8323 int m_VarQuantityMax;
8324 int m_Count;
8325 float m_VarStackMax;
8326 float m_StoreLoadedQuantity = float.LOWEST;
8327 // Wet
8328 float m_VarWet;
8329 float m_VarWetPrev;//for client to know wetness changed during synchronization
8330 float m_VarWetInit;
8331 float m_VarWetMin;
8332 float m_VarWetMax;
8333 // Cleanness
8334 int m_Cleanness;
8335 int m_CleannessInit;
8336 int m_CleannessMin;
8337 int m_CleannessMax;
8338 // impact sounds
8340 bool m_CanPlayImpactSound = true;
8341 float m_ImpactSpeed;
8343 //
8344 float m_HeatIsolation;
8345 float m_ItemModelLength;
8346 float m_ItemAttachOffset; // Offset length for when the item is attached e.g. to weapon
8348 int m_VarLiquidType;
8349 int m_ItemBehaviour; // -1 = not specified; 0 = heavy item; 1= onehanded item; 2 = twohanded item
8350 int m_QuickBarBonus;
8351 bool m_IsBeingPlaced;
8352 bool m_IsHologram;
8353 bool m_IsTakeable;
8354 bool m_ThrowItemOnDrop;
8357 bool m_FixDamageSystemInit = false; //can be changed on storage version check
8358 bool can_this_be_combined; //Check if item can be combined
8359 bool m_CanThisBeSplit; //Check if item can be split
8360 bool m_IsStoreLoad = false;
8361 bool m_CanShowQuantity;
8362 bool m_HasQuantityBar;
8363 protected bool m_CanBeDigged;
8364 protected bool m_IsResultOfSplit
8365
8366 string m_SoundAttType;
8367 // items color variables
8372 //-------------------------------------------------------
8373
8374 // light source managing
8376
8380
8381 //==============================================
8382 // agent system
8383 private int m_AttachedAgents;
8384
8386 void TransferModifiers(PlayerBase reciever);
8387
8388
8389 // Weapons & suppressors particle effects
8394 static int m_LastRegisteredWeaponID = 0;
8395
8396 // Overheating effects
8398 float m_OverheatingShots;
8399 ref Timer m_CheckOverheating;
8400 int m_ShotsToStartOverheating = 0; // After these many shots, the overheating effect begins
8401 int m_MaxOverheatingValue = 0; // Limits the number of shots that will be tracked
8402 float m_OverheatingDecayInterval = 1; // Timer's interval for decrementing overheat effect's lifespan
8403 ref array <ref OverheatingParticle> m_OverheatingParticles;
8404
8406 protected bool m_HideSelectionsBySlot;
8407
8408 // Admin Log
8409 PluginAdminLog m_AdminLog;
8410
8411 // misc
8412 ref Timer m_PhysDropTimer;
8413
8414 // Attachment Locking variables
8415 ref array<int> m_CompatibleLocks;
8416 protected int m_LockType;
8417 protected ref EffectSound m_LockingSound;
8418 protected string m_LockSoundSet;
8419
8420 // ItemSoundHandler
8421 protected const int ITEM_SOUNDS_MAX = 63; // optimize network synch
8422 protected int m_SoundSyncPlay; // id for sound to play
8423 protected int m_SoundSyncStop; // id for sound to stop
8425
8426 //temperature
8427 private float m_TemperaturePerQuantityWeight;
8428
8429 // -------------------------------------------------------------------------
8430 void ItemBase()
8431 {
8432 SetEventMask(EntityEvent.INIT); // Enable EOnInit event
8436
8437 if (!GetGame().IsDedicatedServer())
8438 {
8439 if (HasMuzzle())
8440 {
8442
8444 {
8446 }
8447 }
8448
8450 m_ActionsInitialize = false;
8451 }
8452
8453 m_OldLocation = null;
8454
8455 if (GetGame().IsServer())
8456 {
8457 m_AdminLog = PluginAdminLog.Cast(GetPlugin(PluginAdminLog));
8458 }
8459
8460 if (ConfigIsExisting("headSelectionsToHide"))
8461 {
8463 ConfigGetTextArray("headSelectionsToHide",m_HeadHidingSelections);
8464 }
8465
8466 m_HideSelectionsBySlot = false;
8467 if (ConfigIsExisting("hideSelectionsByinventorySlot"))
8468 {
8469 m_HideSelectionsBySlot = ConfigGetBool("hideSelectionsByinventorySlot");
8470 }
8471
8472 m_QuickBarBonus = Math.Max(0, ConfigGetInt("quickBarBonus"));
8473
8474 m_IsResultOfSplit = false;
8475
8477 }
8478
8479 override void InitItemVariables()
8480 {
8481 super.InitItemVariables();
8482
8483 m_VarQuantityInit = ConfigGetInt("varQuantityInit");
8484 m_VarQuantity = m_VarQuantityInit;//should be by the CE, this is just a precaution
8485 m_VarQuantityMin = ConfigGetInt("varQuantityMin");
8486 m_VarQuantityMax = ConfigGetInt("varQuantityMax");
8487 m_VarStackMax = ConfigGetFloat("varStackMax");
8488 m_Count = ConfigGetInt("count");
8489
8490 m_CanShowQuantity = ConfigGetBool("quantityShow");
8491 m_HasQuantityBar = ConfigGetBool("quantityBar");
8492
8493 m_CleannessInit = ConfigGetInt("varCleannessInit");
8495 m_CleannessMin = ConfigGetInt("varCleannessMin");
8496 m_CleannessMax = ConfigGetInt("varCleannessMax");
8497
8498 m_WantPlayImpactSound = false;
8499 m_ImpactSpeed = 0.0;
8500
8501 m_VarWetInit = ConfigGetFloat("varWetInit");
8503 m_VarWetMin = ConfigGetFloat("varWetMin");
8504 m_VarWetMax = ConfigGetFloat("varWetMax");
8505
8506 m_LiquidContainerMask = ConfigGetInt("liquidContainerType");
8507 if (IsLiquidContainer() && GetQuantity() != 0)
8509 m_IsBeingPlaced = false;
8510 m_IsHologram = false;
8511 m_IsTakeable = true;
8512 m_CanBeMovedOverride = false;
8516 m_CanBeDigged = ConfigGetBool("canBeDigged");
8517
8518 m_CompatibleLocks = new array<int>();
8519 ConfigGetIntArray("compatibleLocks", m_CompatibleLocks);
8520 m_LockType = ConfigGetInt("lockType");
8521
8522 //Define if item can be split and set ability to be combined accordingly
8523 m_CanThisBeSplit = false;
8524 can_this_be_combined = false;
8525 if (ConfigIsExisting("canBeSplit"))
8526 {
8527 can_this_be_combined = ConfigGetBool("canBeSplit");
8529 }
8530
8531 m_ItemBehaviour = -1;
8532 if (ConfigIsExisting("itemBehaviour"))
8533 m_ItemBehaviour = ConfigGetInt("itemBehaviour");
8534
8535 //RegisterNetSyncVariableInt("m_VariablesMask");
8536 if (HasQuantity()) RegisterNetSyncVariableFloat("m_VarQuantity", GetQuantityMin(), m_VarQuantityMax);
8537 RegisterNetSyncVariableFloat("m_VarWet", GetWetMin(), GetWetMax(), 2);
8538 RegisterNetSyncVariableInt("m_VarLiquidType");
8539 RegisterNetSyncVariableInt("m_Cleanness",0,1);
8540
8541 RegisterNetSyncVariableBoolSignal("m_WantPlayImpactSound");
8542 RegisterNetSyncVariableFloat("m_ImpactSpeed");
8543 RegisterNetSyncVariableInt("m_ImpactSoundSurfaceHash");
8544
8545 RegisterNetSyncVariableInt("m_ColorComponentR", 0, 255);
8546 RegisterNetSyncVariableInt("m_ColorComponentG", 0, 255);
8547 RegisterNetSyncVariableInt("m_ColorComponentB", 0, 255);
8548 RegisterNetSyncVariableInt("m_ColorComponentA", 0, 255);
8549
8550 RegisterNetSyncVariableBool("m_IsBeingPlaced");
8551 RegisterNetSyncVariableBool("m_IsTakeable");
8552 RegisterNetSyncVariableBool("m_IsHologram");
8553
8554 InitItemSounds();
8556 {
8557 RegisterNetSyncVariableInt("m_SoundSyncPlay", 0, ITEM_SOUNDS_MAX);
8558 RegisterNetSyncVariableInt("m_SoundSyncStop", 0, ITEM_SOUNDS_MAX);
8559 }
8560
8561 m_LockSoundSet = ConfigGetString("lockSoundSet");
8562
8564 if (ConfigIsExisting("temperaturePerQuantityWeight"))
8565 m_TemperaturePerQuantityWeight = ConfigGetFloat("temperaturePerQuantityWeight");
8566
8567 }
8568
8569 override int GetQuickBarBonus()
8570 {
8571 return m_QuickBarBonus;
8572 }
8573
8574 void InitializeActions()
8575 {
8577 if (!m_InputActionMap)
8578 {
8580 m_InputActionMap = iam;
8581 SetActions();
8583 }
8584 }
8585
8586 override void GetActions(typename action_input_type, out array<ActionBase_Basic> actions)
8587 {
8589 {
8590 m_ActionsInitialize = true;
8592 }
8593
8594 actions = m_InputActionMap.Get(action_input_type);
8595 }
8596
8597 void SetActions()
8598 {
8599 AddAction(ActionTakeItem);
8600 AddAction(ActionTakeItemToHands);
8601 AddAction(ActionWorldCraft);
8603 AddAction(ActionAttachWithSwitch);
8604 }
8605
8606 void SetActionAnimOverrides(); // Override action animation for specific item
8607
8608 void AddAction(typename actionName)
8609 {
8610 ActionBase action = ActionManagerBase.GetAction(actionName);
8611
8612 if (!action)
8613 {
8614 Debug.LogError("Action " + actionName + " dosn't exist!");
8615 return;
8616 }
8617
8618 typename ai = action.GetInputType();
8619 if (!ai)
8620 {
8621 m_ActionsInitialize = false;
8622 return;
8623 }
8624
8625 array<ActionBase_Basic> action_array = m_InputActionMap.Get(ai);
8626 if (!action_array)
8627 {
8628 action_array = new array<ActionBase_Basic>;
8629 m_InputActionMap.Insert(ai, action_array);
8630 }
8631 if (LogManager.IsActionLogEnable())
8632 {
8633 Debug.ActionLog(action.ToString() + " -> " + ai, this.ToString() , "n/a", "Add action");
8634 }
8635
8636 if (action_array.Find(action) != -1)
8637 {
8638 Debug.Log("Action " + action.Type() + " already added to " + this + ", skipping!");
8639 }
8640 else
8641 {
8642 action_array.Insert(action);
8643 }
8644 }
8645
8646 void RemoveAction(typename actionName)
8647 {
8648 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
8649 ActionBase action = player.GetActionManager().GetAction(actionName);
8650 typename ai = action.GetInputType();
8651 array<ActionBase_Basic> action_array = m_InputActionMap.Get(ai);
8652
8653 if (action_array)
8654 {
8655 action_array.RemoveItem(action);
8656 }
8657 }
8658
8659 // Allows override of default action command per item, defined in the SetActionAnimOverrides() of the item's class
8660 // Set -1 for params which should stay in default state
8661 void OverrideActionAnimation(typename action, int commandUID, int stanceMask = -1, int commandUIDProne = -1)
8662 {
8663 ActionOverrideData overrideData = new ActionOverrideData();
8664 overrideData.m_CommandUID = commandUID;
8665 overrideData.m_CommandUIDProne = commandUIDProne;
8666 overrideData.m_StanceMask = stanceMask;
8667
8668 TActionAnimOverrideMap actionMap = m_ItemActionOverrides.Get(action);
8669 if (!actionMap) // create new map of action > overidables map
8670 {
8671 actionMap = new TActionAnimOverrideMap();
8672 m_ItemActionOverrides.Insert(action, actionMap);
8673 }
8674
8675 actionMap.Insert(this.Type(), overrideData); // insert item -> overrides
8676
8677 }
8678
8679 void OnItemInHandsPlayerSwimStart(PlayerBase player);
8680
8681 ScriptedLightBase GetLight();
8682
8683 // Loads muzzle flash particle configuration from config and saves it to a map for faster access
8684 void LoadParticleConfigOnFire(int id)
8685 {
8686 if (!m_OnFireEffect)
8688
8691
8692 string config_to_search = "CfgVehicles";
8693 string muzzle_owner_config;
8694
8695 if (!m_OnFireEffect.Contains(id))
8696 {
8697 if (IsInherited(Weapon))
8698 config_to_search = "CfgWeapons";
8699
8700 muzzle_owner_config = config_to_search + " " + GetType() + " ";
8701
8702 string config_OnFire_class = muzzle_owner_config + "Particles " + "OnFire ";
8703
8704 int config_OnFire_subclass_count = GetGame().ConfigGetChildrenCount(config_OnFire_class);
8705
8706 if (config_OnFire_subclass_count > 0)
8707 {
8708 array<ref WeaponParticlesOnFire> WPOF_array = new array<ref WeaponParticlesOnFire>;
8709
8710 for (int i = 0; i < config_OnFire_subclass_count; i++)
8711 {
8712 string particle_class = "";
8713 GetGame().ConfigGetChildName(config_OnFire_class, i, particle_class);
8714 string config_OnFire_entry = config_OnFire_class + particle_class;
8715 WeaponParticlesOnFire WPOF = new WeaponParticlesOnFire(this, config_OnFire_entry);
8716 WPOF_array.Insert(WPOF);
8717 }
8718
8719
8720 m_OnFireEffect.Insert(id, WPOF_array);
8721 }
8722 }
8723
8724 if (!m_OnBulletCasingEjectEffect.Contains(id))
8725 {
8726 config_to_search = "CfgWeapons"; // Bullet Eject efect is supported on weapons only.
8727 muzzle_owner_config = config_to_search + " " + GetType() + " ";
8728
8729 string config_OnBulletCasingEject_class = muzzle_owner_config + "Particles " + "OnBulletCasingEject ";
8730
8731 int config_OnBulletCasingEject_count = GetGame().ConfigGetChildrenCount(config_OnBulletCasingEject_class);
8732
8733 if (config_OnBulletCasingEject_count > 0 && IsInherited(Weapon))
8734 {
8735 array<ref WeaponParticlesOnBulletCasingEject> WPOBE_array = new array<ref WeaponParticlesOnBulletCasingEject>;
8736
8737 for (i = 0; i < config_OnBulletCasingEject_count; i++)
8738 {
8739 string particle_class2 = "";
8740 GetGame().ConfigGetChildName(config_OnBulletCasingEject_class, i, particle_class2);
8741 string config_OnBulletCasingEject_entry = config_OnBulletCasingEject_class + particle_class2;
8742 WeaponParticlesOnBulletCasingEject WPOBE = new WeaponParticlesOnBulletCasingEject(this, config_OnBulletCasingEject_entry);
8743 WPOBE_array.Insert(WPOBE);
8744 }
8745
8746
8747 m_OnBulletCasingEjectEffect.Insert(id, WPOBE_array);
8748 }
8749 }
8750 }
8751
8752 // Loads muzzle flash particle configuration from config and saves it to a map for faster access
8754 {
8757
8758 if (!m_OnOverheatingEffect.Contains(id))
8759 {
8760 string config_to_search = "CfgVehicles";
8761
8762 if (IsInherited(Weapon))
8763 config_to_search = "CfgWeapons";
8764
8765 string muzzle_owner_config = config_to_search + " " + GetType() + " ";
8766 string config_OnOverheating_class = muzzle_owner_config + "Particles " + "OnOverheating ";
8767
8768 if (GetGame().ConfigIsExisting(config_OnOverheating_class))
8769 {
8770
8771 m_ShotsToStartOverheating = GetGame().ConfigGetFloat(config_OnOverheating_class + "shotsToStartOverheating");
8772
8774 {
8775 m_ShotsToStartOverheating = -1; // This prevents futher readings from config for future creations of this item
8776 string error = "Error reading config " + GetType() + ">Particles>OnOverheating - Parameter shotsToStartOverheating is configured wrong or is missing! Its value must be 1 or higher!";
8777 Error(error);
8778 return;
8779 }
8780
8781 m_OverheatingDecayInterval = GetGame().ConfigGetFloat(config_OnOverheating_class + "overheatingDecayInterval");
8782 m_MaxOverheatingValue = GetGame().ConfigGetFloat(config_OnOverheating_class + "maxOverheatingValue");
8783
8784
8785
8786 int config_OnOverheating_subclass_count = GetGame().ConfigGetChildrenCount(config_OnOverheating_class);
8787 array<ref WeaponParticlesOnOverheating> WPOOH_array = new array<ref WeaponParticlesOnOverheating>;
8788
8789 for (int i = 0; i < config_OnOverheating_subclass_count; i++)
8790 {
8791 string particle_class = "";
8792 GetGame().ConfigGetChildName(config_OnOverheating_class, i, particle_class);
8793 string config_OnOverheating_entry = config_OnOverheating_class + particle_class;
8794 int entry_type = GetGame().ConfigGetType(config_OnOverheating_entry);
8795
8796 if (entry_type == CT_CLASS)
8797 {
8798 WeaponParticlesOnOverheating WPOF = new WeaponParticlesOnOverheating(this, config_OnOverheating_entry);
8799 WPOOH_array.Insert(WPOF);
8800 }
8801 }
8802
8803
8804 m_OnOverheatingEffect.Insert(id, WPOOH_array);
8805 }
8806 }
8807 }
8808
8809 float GetOverheatingValue()
8810 {
8811 return m_OverheatingShots;
8812 }
8813
8814 void IncreaseOverheating(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
8815 {
8816 if (m_MaxOverheatingValue > 0)
8817 {
8819
8820 if (!m_CheckOverheating)
8822
8824 m_CheckOverheating.Run(m_OverheatingDecayInterval, this, "OnOverheatingDecay");
8825
8826 CheckOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
8827 }
8828 }
8829
8830 void CheckOverheating(ItemBase weapon = null, string ammoType = "", ItemBase muzzle_owner = null, ItemBase suppressor = null, string config_to_search = "")
8831 {
8833 UpdateOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
8834
8836 StartOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
8837
8839 StopOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
8840
8842 {
8844 }
8845 }
8846
8848 {
8850 }
8851
8852 void OnOverheatingDecay()
8853 {
8854 if (m_MaxOverheatingValue > 0)
8855 m_OverheatingShots -= 1 + m_OverheatingShots / m_MaxOverheatingValue; // The hotter a barrel is, the faster it needs to cool down.
8856 else
8858
8859 if (m_OverheatingShots <= 0)
8860 {
8863 }
8864 else
8865 {
8866 if (!m_CheckOverheating)
8868
8870 m_CheckOverheating.Run(m_OverheatingDecayInterval, this, "OnOverheatingDecay");
8871 }
8872
8873 CheckOverheating(this, "", this);
8874 }
8875
8876 void StartOverheating(ItemBase weapon = null, string ammoType = "", ItemBase muzzle_owner = null, ItemBase suppressor = null, string config_to_search = "")
8877 {
8879 ItemBase.PlayOverheatingParticles(this, ammoType, this, suppressor, "CfgWeapons");
8880 }
8881
8882 void UpdateOverheating(ItemBase weapon = null, string ammoType = "", ItemBase muzzle_owner = null, ItemBase suppressor = null, string config_to_search = "")
8883 {
8885 ItemBase.UpdateOverheatingParticles(this, ammoType, this, suppressor, "CfgWeapons");
8887 }
8888
8889 void StopOverheating(ItemBase weapon = null, string ammoType = "", ItemBase muzzle_owner = null, ItemBase suppressor = null, string config_to_search = "")
8890 {
8892 ItemBase.StopOverheatingParticles(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
8893 }
8894
8895 void RegisterOverheatingParticle(Particle p, float min_heat_coef, float max_heat_coef, int particle_id, Object parent, vector local_pos, vector local_ori)
8896 {
8898 m_OverheatingParticles = new array<ref OverheatingParticle>;
8899
8900 OverheatingParticle OP = new OverheatingParticle();
8901 OP.RegisterParticle(p);
8902 OP.SetOverheatingLimitMin(min_heat_coef);
8903 OP.SetOverheatingLimitMax(max_heat_coef);
8904 OP.SetParticleParams(particle_id, parent, local_pos, local_ori);
8905
8906 m_OverheatingParticles.Insert(OP);
8907 }
8908
8909 float GetOverheatingCoef()
8910 {
8911 if (m_MaxOverheatingValue > 0)
8913
8914 return -1;
8915 }
8916
8918 {
8920 {
8921 float overheat_coef = GetOverheatingCoef();
8922 int count = m_OverheatingParticles.Count();
8923
8924 for (int i = count; i > 0; --i)
8925 {
8926 int id = i - 1;
8927 OverheatingParticle OP = m_OverheatingParticles.Get(id);
8928 Particle p = OP.GetParticle();
8929
8930 float overheat_min = OP.GetOverheatingLimitMin();
8931 float overheat_max = OP.GetOverheatingLimitMax();
8932
8933 if (overheat_coef < overheat_min && overheat_coef >= overheat_max)
8934 {
8935 if (p)
8936 {
8937 p.Stop();
8938 OP.RegisterParticle(null);
8939 }
8940 }
8941 }
8942 }
8943 }
8944
8946 {
8948 {
8949 for (int i = m_OverheatingParticles.Count(); i > 0; i--)
8950 {
8951 int id = i - 1;
8952 OverheatingParticle OP = m_OverheatingParticles.Get(id);
8953
8954 if (OP)
8955 {
8956 Particle p = OP.GetParticle();
8957
8958 if (p)
8959 {
8960 p.Stop();
8961 }
8962
8963 delete OP;
8964 }
8965 }
8966
8967 m_OverheatingParticles.Clear();
8969 }
8970 }
8971
8973 float GetInfectionChance(int system = 0, Param param = null)
8974 {
8975 return 0.0;
8976 }
8977
8978
8979 float GetDisinfectQuantity(int system = 0, Param param1 = null)
8980 {
8981 return 250;//default value
8982 }
8983
8984 float GetFilterDamageRatio()
8985 {
8986 return 0;
8987 }
8988
8990 bool HasMuzzle()
8991 {
8992 if (IsInherited(Weapon) || IsInherited(SuppressorBase))
8993 return true;
8994
8995 return false;
8996 }
8997
8999 int GetMuzzleID()
9000 {
9001 if (!m_WeaponTypeToID)
9003
9004 if (m_WeaponTypeToID.Contains(GetType()))
9005 {
9006 return m_WeaponTypeToID.Get(GetType());
9007 }
9008 else
9009 {
9010 // Register new weapon ID
9012 }
9013
9015 }
9016
9023 {
9024 return -1;
9025 }
9026
9027
9028
9029 // -------------------------------------------------------------------------
9030 void ~ItemBase()
9031 {
9032 if (GetGame() && GetGame().GetPlayer() && (!GetGame().IsDedicatedServer()))
9033 {
9034 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
9035 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
9036
9037 if (r_index >= 0)
9038 {
9039 InventoryLocation r_il = new InventoryLocation;
9040 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
9041
9042 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
9043 int r_type = r_il.GetType();
9044 if (r_type == InventoryLocationType.CARGO || r_type == InventoryLocationType.PROXYCARGO)
9045 {
9046 r_il.GetParent().GetOnReleaseLock().Invoke(this);
9047 }
9048 else if (r_type == InventoryLocationType.ATTACHMENT)
9049 {
9050 r_il.GetParent().GetOnAttachmentReleaseLock().Invoke(this, r_il.GetSlot());
9051 }
9052
9053 }
9054
9055 player.GetHumanInventory().ClearUserReservedLocation(this);
9056 }
9057
9058 if (m_LockingSound)
9059 SEffectManager.DestroyEffect(m_LockingSound);
9060 }
9061
9062
9063
9064 // -------------------------------------------------------------------------
9065 static int GetDebugActionsMask()
9066 {
9067 return ItemBase.m_DebugActionsMask;
9068 }
9069
9070 static bool HasDebugActionsMask(int mask)
9071 {
9072 return ItemBase.m_DebugActionsMask & mask;
9073 }
9074
9075 static void SetDebugActionsMask(int mask)
9076 {
9077 ItemBase.m_DebugActionsMask = mask;
9078 }
9079
9080 static void AddDebugActionsMask(int mask)
9081 {
9082 ItemBase.m_DebugActionsMask |= mask;
9083 }
9084
9085 static void RemoveDebugActionsMask(int mask)
9086 {
9087 ItemBase.m_DebugActionsMask &= ~mask;
9088 }
9089
9090 static void ToggleDebugActionsMask(int mask)
9091 {
9092 if (HasDebugActionsMask(mask))
9093 {
9095 }
9096 else
9097 {
9098 AddDebugActionsMask(mask);
9099 }
9100 }
9101
9102 // -------------------------------------------------------------------------
9103 void SetCEBasedQuantity()
9104 {
9105 if (GetEconomyProfile())
9106 {
9107 float q_max = GetEconomyProfile().GetQuantityMax();
9108 if (q_max > 0)
9109 {
9110 float q_min = GetEconomyProfile().GetQuantityMin();
9111 float quantity_randomized = Math.RandomFloatInclusive(q_min, q_max);
9112
9113 if (HasComponent(COMP_TYPE_ENERGY_MANAGER))//more direct access for speed
9114 {
9115 ComponentEnergyManager comp = GetCompEM();
9116 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
9117 {
9118 comp.SetEnergy0To1(quantity_randomized);
9119 }
9120 }
9121 else if (HasQuantity())
9122 {
9123 SetQuantityNormalized(quantity_randomized, false);
9124 //PrintString("<==> Normalized quantity for item: "+ GetType()+", qmin:"+q_min.ToString()+"; qmax:"+q_max.ToString()+";quantity:" +quantity_randomized.ToString());
9125 }
9126
9127 }
9128 }
9129 }
9130
9132 void LockToParent()
9133 {
9134 EntityAI parent = GetHierarchyParent();
9135
9136 if (parent)
9137 {
9138 InventoryLocation inventory_location_to_lock = new InventoryLocation;
9139 GetInventory().GetCurrentInventoryLocation(inventory_location_to_lock);
9140 parent.GetInventory().SetSlotLock(inventory_location_to_lock.GetSlot(), true);
9141 }
9142 }
9143
9145 void UnlockFromParent()
9146 {
9147 EntityAI parent = GetHierarchyParent();
9148
9149 if (parent)
9150 {
9151 InventoryLocation inventory_location_to_unlock = new InventoryLocation;
9152 GetInventory().GetCurrentInventoryLocation(inventory_location_to_unlock);
9153 parent.GetInventory().SetSlotLock(inventory_location_to_unlock.GetSlot(), false);
9154 }
9155 }
9156
9157 override void CombineItemsClient(EntityAI entity2, bool use_stack_max = true)
9158 {
9159 /*
9160 ref Param1<EntityAI> item = new Param1<EntityAI>(entity2);
9161 RPCSingleParam(ERPCs.RPC_ITEM_COMBINE, item, GetGame().GetPlayer());
9162 */
9163 ItemBase item2 = ItemBase.Cast(entity2);
9164
9165 if (GetGame().IsClient())
9166 {
9167 if (ScriptInputUserData.CanStoreInputUserData())
9168 {
9169 ScriptInputUserData ctx = new ScriptInputUserData;
9171 ctx.Write(-1);
9172 ItemBase i1 = this; // @NOTE: workaround for correct serialization
9173 ctx.Write(i1);
9174 ctx.Write(item2);
9175 ctx.Write(use_stack_max);
9176 ctx.Write(-1);
9177 ctx.Send();
9178
9179 if (IsCombineAll(item2, use_stack_max))
9180 {
9181 GetGame().GetPlayer().GetInventory().AddInventoryReservationEx(item2,null,GameInventory.c_InventoryReservationTimeoutShortMS);
9182 }
9183 }
9184 }
9185 else if (!GetGame().IsMultiplayer())
9186 {
9187 CombineItems(item2, use_stack_max);
9188 }
9189 }
9190
9191 bool IsLiquidPresent()
9192 {
9193 return (GetLiquidType() != 0 && HasQuantity());
9194 }
9195
9196 bool IsLiquidContainer()
9197 {
9198 return m_LiquidContainerMask != 0;
9199 }
9200
9202 {
9203 return m_LiquidContainerMask;
9204 }
9205
9206 bool IsBloodContainer()
9207 {
9208 //m_LiquidContainerMask & GROUP_LIQUID_BLOOD ???
9209 return false;
9210 }
9211
9212 bool IsNVG()
9213 {
9214 return false;
9215 }
9216
9219 bool IsExplosive()
9220 {
9221 return false;
9222 }
9223
9225 {
9226 return "";
9227 }
9228
9230
9231 bool IsLightSource()
9232 {
9233 return false;
9234 }
9235
9237 {
9238 return true;
9239 }
9240
9241 //--- ACTION CONDITIONS
9242 //direction
9243 bool IsFacingPlayer(PlayerBase player, string selection)
9244 {
9245 return true;
9246 }
9247
9248 bool IsPlayerInside(PlayerBase player, string selection)
9249 {
9250 return true;
9251 }
9252
9253 override bool CanObstruct()
9254 {
9255 PlayerBase player = PlayerBase.Cast(g_Game.GetPlayer());
9256 return !player || !IsPlayerInside(player, "");
9257 }
9258
9259 override bool IsBeingPlaced()
9260 {
9261 return m_IsBeingPlaced;
9262 }
9263
9264 void SetIsBeingPlaced(bool is_being_placed)
9265 {
9266 m_IsBeingPlaced = is_being_placed;
9267 if (!is_being_placed)
9269 SetSynchDirty();
9270 }
9271
9272 //server-side
9273 void OnEndPlacement() {}
9274
9275 override bool IsHologram()
9276 {
9277 return m_IsHologram;
9278 }
9279
9280 bool CanBeDigged()
9281 {
9282 return m_CanBeDigged;
9283 }
9284
9286 {
9287 return 1;
9288 }
9289
9290 bool CanMakeGardenplot()
9291 {
9292 return false;
9293 }
9294
9295 void SetIsHologram(bool is_hologram)
9296 {
9297 m_IsHologram = is_hologram;
9298 SetSynchDirty();
9299 }
9300 /*
9301 protected float GetNutritionalEnergy()
9302 {
9303 Edible_Base edible = Edible_Base.Cast(this);
9304 return edible.GetFoodEnergy();
9305 }
9306
9307 protected float GetNutritionalWaterContent()
9308 {
9309 Edible_Base edible = Edible_Base.Cast(this);
9310 return edible.GetFoodWater();
9311 }
9312
9313 protected float GetNutritionalIndex()
9314 {
9315 Edible_Base edible = Edible_Base.Cast(this);
9316 return edible.GetFoodNutritionalIndex();
9317 }
9318
9319 protected float GetNutritionalFullnessIndex()
9320 {
9321 Edible_Base edible = Edible_Base.Cast(this);
9322 return edible.GetFoodTotalVolume();
9323 }
9324
9325 protected float GetNutritionalToxicity()
9326 {
9327 Edible_Base edible = Edible_Base.Cast(this);
9328 return edible.GetFoodToxicity();
9329
9330 }
9331 */
9332
9333
9334 // -------------------------------------------------------------------------
9335 override void OnMovedInsideCargo(EntityAI container)
9336 {
9337 super.OnMovedInsideCargo(container);
9338
9339 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
9340 }
9341
9342 override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
9343 {
9344 super.EEItemLocationChanged(oldLoc,newLoc);
9345
9346 PlayerBase new_player = null;
9347 PlayerBase old_player = null;
9348
9349 if (newLoc.GetParent())
9350 new_player = PlayerBase.Cast(newLoc.GetParent().GetHierarchyRootPlayer());
9351
9352 if (oldLoc.GetParent())
9353 old_player = PlayerBase.Cast(oldLoc.GetParent().GetHierarchyRootPlayer());
9354
9355 if (old_player && oldLoc.GetType() == InventoryLocationType.HANDS)
9356 {
9357 int r_index = old_player.GetHumanInventory().FindUserReservedLocationIndex(this);
9358
9359 if (r_index >= 0)
9360 {
9361 InventoryLocation r_il = new InventoryLocation;
9362 old_player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
9363
9364 old_player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
9365 int r_type = r_il.GetType();
9366 if (r_type == InventoryLocationType.CARGO || r_type == InventoryLocationType.PROXYCARGO)
9367 {
9368 r_il.GetParent().GetOnReleaseLock().Invoke(this);
9369 }
9370 else if (r_type == InventoryLocationType.ATTACHMENT)
9371 {
9372 r_il.GetParent().GetOnAttachmentReleaseLock().Invoke(this, r_il.GetSlot());
9373 }
9374
9375 }
9376 }
9377
9378 if (newLoc.GetType() == InventoryLocationType.HANDS)
9379 {
9380 if (new_player)
9381 new_player.ForceStandUpForHeavyItems(newLoc.GetItem());
9382
9383 if (new_player == old_player)
9384 {
9385
9386 if (oldLoc.GetParent() && new_player.GetHumanInventory().LocationGetEntity(oldLoc) == NULL)
9387 {
9388 if (oldLoc.GetType() == InventoryLocationType.CARGO)
9389 {
9390 if (oldLoc.GetParent().GetInventory().TestAddEntityInCargoExLoc(oldLoc, false, false, false, true, false, false))
9391 {
9392 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
9393 }
9394 }
9395 else
9396 {
9397 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
9398 }
9399 }
9400
9401 if (new_player.GetHumanInventory().FindUserReservedLocationIndex(this) >= 0)
9402 {
9403 int type = oldLoc.GetType();
9404 if (type == InventoryLocationType.CARGO || type == InventoryLocationType.PROXYCARGO)
9405 {
9406 oldLoc.GetParent().GetOnSetLock().Invoke(this);
9407 }
9408 else if (type == InventoryLocationType.ATTACHMENT)
9409 {
9410 oldLoc.GetParent().GetOnAttachmentSetLock().Invoke(this, oldLoc.GetSlot());
9411 }
9412 }
9413 if (!m_OldLocation)
9414 {
9415 m_OldLocation = new InventoryLocation;
9416 }
9417 m_OldLocation.Copy(oldLoc);
9418 }
9419 else
9420 {
9421 if (m_OldLocation)
9422 {
9423 m_OldLocation.Reset();
9424 }
9425 }
9426
9428 }
9429 else
9430 {
9431 if (new_player)
9432 {
9433 int res_index = new_player.GetHumanInventory().FindCollidingUserReservedLocationIndex(this, newLoc);
9434 if (res_index >= 0)
9435 {
9436 InventoryLocation il = new InventoryLocation;
9437 new_player.GetHumanInventory().GetUserReservedLocation(res_index,il);
9438 ItemBase it = ItemBase.Cast(il.GetItem());
9439 new_player.GetHumanInventory().ClearUserReservedLocationAtIndex(res_index);
9440 int rel_type = il.GetType();
9441 if (rel_type == InventoryLocationType.CARGO || rel_type == InventoryLocationType.PROXYCARGO)
9442 {
9443 il.GetParent().GetOnReleaseLock().Invoke(it);
9444 }
9445 else if (rel_type == InventoryLocationType.ATTACHMENT)
9446 {
9447 il.GetParent().GetOnAttachmentReleaseLock().Invoke(it, il.GetSlot());
9448 }
9449 //it.GetOnReleaseLock().Invoke(it);
9450 }
9451 }
9452 else if (old_player && newLoc.GetType() == InventoryLocationType.GROUND && m_ThrowItemOnDrop)
9453 {
9454 //ThrowPhysically(old_player, vector.Zero);
9455 m_ThrowItemOnDrop = false;
9456 }
9457
9458 if (m_OldLocation)
9459 {
9460 m_OldLocation.Reset();
9461 }
9462 }
9463 }
9464
9465 override void EOnContact(IEntity other, Contact extra)
9466 {
9468 {
9469 int liquidType = -1;
9470 float impactSpeed = ProcessImpactSoundEx(other, extra, m_ConfigWeight, m_ImpactSoundSurfaceHash, liquidType);
9471 if (impactSpeed > 0.0)
9472 {
9473 m_ImpactSpeed = impactSpeed;
9474 #ifndef SERVER
9475 PlayImpactSound(m_ConfigWeight, m_ImpactSpeed, m_ImpactSoundSurfaceHash);
9476 #else
9477 m_WantPlayImpactSound = true;
9478 SetSynchDirty();
9479 #endif
9480 m_CanPlayImpactSound = (liquidType == -1);// prevents further playing of the sound when the surface is a liquid type
9481 }
9482 }
9483
9484 #ifdef SERVER
9485 if (GetCompEM() && GetCompEM().IsPlugged())
9486 {
9487 if (GetCompEM().GetCordLength() < vector.Distance(GetPosition(), GetCompEM().GetEnergySource().GetPosition()))
9488 GetCompEM().UnplugThis();
9489 }
9490 #endif
9491 }
9492
9493 void RefreshPhysics();
9494
9495 override void OnCreatePhysics()
9496 {
9498 }
9499
9500 override void OnItemAttachmentSlotChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
9501 {
9502
9503 }
9504 // -------------------------------------------------------------------------
9505 override void OnItemLocationChanged(EntityAI old_owner, EntityAI new_owner)
9506 {
9507 super.OnItemLocationChanged(old_owner, new_owner);
9508
9509 PlayerBase relatedPlayer = PlayerBase.Cast(old_owner);
9510 PlayerBase playerNew = PlayerBase.Cast(new_owner);
9511
9512 if (!relatedPlayer && playerNew)
9513 relatedPlayer = playerNew;
9514
9515 if (relatedPlayer && relatedPlayer.GetPerformedActionID() != -1)
9516 {
9517 ActionManagerBase actionMgr = relatedPlayer.GetActionManager();
9518 if (actionMgr)
9519 {
9520 ActionBase currentAction = actionMgr.GetRunningAction();
9521 if (currentAction)
9522 currentAction.OnItemLocationChanged(this);
9523 }
9524 }
9525
9526 Man ownerPlayerOld = null;
9527 Man ownerPlayerNew = null;
9528
9529 if (old_owner)
9530 {
9531 if (old_owner.IsMan())
9532 {
9533 ownerPlayerOld = Man.Cast(old_owner);
9534 }
9535 else
9536 {
9537 ownerPlayerOld = Man.Cast(old_owner.GetHierarchyRootPlayer());
9538 }
9539 }
9540 else
9541 {
9542 if (new_owner && IsElectricAppliance() && GetCompEM() && GetCompEM().IsPlugged())
9543 {
9544 ActionBase action = ActionManagerBase.GetAction(ActionRepositionPluggedItem);
9545
9546 if (!action || !playerNew || playerNew.GetPerformedActionID() != action.GetID())
9547 {
9548 GetCompEM().UnplugThis();
9549 }
9550 }
9551 }
9552
9553 if (new_owner)
9554 {
9555 if (new_owner.IsMan())
9556 {
9557 ownerPlayerNew = Man.Cast(new_owner);
9558 }
9559 else
9560 {
9561 ownerPlayerNew = Man.Cast(new_owner.GetHierarchyRootPlayer());
9562 }
9563 }
9564
9565 if (ownerPlayerOld != ownerPlayerNew)
9566 {
9567 if (ownerPlayerOld)
9568 {
9569 array<EntityAI> subItemsExit = new array<EntityAI>;
9570 GetInventory().EnumerateInventory(InventoryTraversalType.PREORDER,subItemsExit);
9571 for (int i = 0; i < subItemsExit.Count(); i++)
9572 {
9573 ItemBase itemExit = ItemBase.Cast(subItemsExit.Get(i));
9574 itemExit.OnInventoryExit(ownerPlayerOld);
9575 }
9576 }
9577
9578 if (ownerPlayerNew)
9579 {
9580 array<EntityAI> subItemsEnter = new array<EntityAI>;
9581 GetInventory().EnumerateInventory(InventoryTraversalType.PREORDER,subItemsEnter);
9582 for (int j = 0; j < subItemsEnter.Count(); j++)
9583 {
9584 ItemBase itemEnter = ItemBase.Cast(subItemsEnter.Get(j));
9585 itemEnter.OnInventoryEnter(ownerPlayerNew);
9586 }
9587 }
9588 }
9589 else if (ownerPlayerNew != null)
9590 {
9591 PlayerBase nplayer;
9592 if (PlayerBase.CastTo(nplayer, ownerPlayerNew))
9593 {
9594 array<EntityAI> subItemsUpdate = new array<EntityAI>;
9595 GetInventory().EnumerateInventory(InventoryTraversalType.PREORDER,subItemsUpdate);
9596 for (int k = 0; k < subItemsUpdate.Count(); k++)
9597 {
9598 ItemBase itemUpdate = ItemBase.Cast(subItemsUpdate.Get(k));
9599 itemUpdate.UpdateQuickbarShortcutVisibility(nplayer);
9600 }
9601 }
9602 }
9603
9604 if (old_owner)
9605 old_owner.OnChildItemRemoved(this);
9606 if (new_owner)
9607 new_owner.OnChildItemReceived(this);
9608 }
9609
9610 // -------------------------------------------------------------------------------
9611 override void EEDelete(EntityAI parent)
9612 {
9613 super.EEDelete(parent);
9614 PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
9615 if (player)
9616 {
9617 OnInventoryExit(player);
9618
9619 if (player.IsAlive())
9620 {
9621 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
9622 if (r_index >= 0)
9623 {
9624 InventoryLocation r_il = new InventoryLocation;
9625 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
9626
9627 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
9628 int r_type = r_il.GetType();
9629 if (r_type == InventoryLocationType.CARGO || r_type == InventoryLocationType.PROXYCARGO)
9630 {
9631 r_il.GetParent().GetOnReleaseLock().Invoke(this);
9632 }
9633 else if (r_type == InventoryLocationType.ATTACHMENT)
9634 {
9635 r_il.GetParent().GetOnAttachmentReleaseLock().Invoke(this, r_il.GetSlot());
9636 }
9637
9638 }
9639
9640 player.RemoveQuickBarEntityShortcut(this);
9641 }
9642 }
9643 }
9644 // -------------------------------------------------------------------------------
9645 override void EEKilled(Object killer)
9646 {
9647 super.EEKilled(killer);
9648
9650 if (killer && killer.IsFireplace() && CanExplodeInFire())
9651 {
9652 if (GetTemperature() >= GameConstants.ITEM_TEMPERATURE_TO_EXPLODE_MIN)
9653 {
9654 if (IsMagazine())
9655 {
9656 if (Magazine.Cast(this).GetAmmoCount() > 0)
9657 {
9658 ExplodeAmmo();
9659 }
9660 }
9661 else
9662 {
9663 Explode(DamageType.EXPLOSION);
9664 }
9665 }
9666 }
9667 }
9668
9669 override void OnWasAttached(EntityAI parent, int slot_id)
9670 {
9671 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
9672
9673 super.OnWasAttached(parent, slot_id);
9674
9675 if (HasQuantity())
9676 UpdateNetSyncVariableFloat("m_VarQuantity", GetQuantityMin(), m_VarQuantityMax);
9677
9678 PlayAttachSound(InventorySlots.GetSlotName(slot_id));
9679 }
9680
9681 override void OnWasDetached(EntityAI parent, int slot_id)
9682 {
9683 super.OnWasDetached(parent, slot_id);
9684
9685 if (HasQuantity())
9686 UpdateNetSyncVariableFloat("m_VarQuantity", GetQuantityMin(), m_VarQuantityMax);
9687 }
9688
9689 override string ChangeIntoOnAttach(string slot)
9690 {
9691 int idx;
9692 TStringArray inventory_slots = new TStringArray;
9693 TStringArray attach_types = new TStringArray;
9694
9695 ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
9696 if (inventory_slots.Count() < 1) //is string
9697 {
9698 inventory_slots.Insert(ConfigGetString("ChangeInventorySlot"));
9699 attach_types.Insert(ConfigGetString("ChangeIntoOnAttach"));
9700 }
9701 else //is array
9702 {
9703 ConfigGetTextArray("ChangeIntoOnAttach",attach_types);
9704 }
9705
9706 idx = inventory_slots.Find(slot);
9707 if (idx < 0)
9708 return "";
9709
9710 return attach_types.Get(idx);
9711 }
9712
9713 override string ChangeIntoOnDetach()
9714 {
9715 int idx = -1;
9716 string slot;
9717
9718 TStringArray inventory_slots = new TStringArray;
9719 TStringArray detach_types = new TStringArray;
9720
9721 this.ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
9722 if (inventory_slots.Count() < 1) //is string
9723 {
9724 inventory_slots.Insert(this.ConfigGetString("ChangeInventorySlot"));
9725 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
9726 }
9727 else //is array
9728 {
9729 this.ConfigGetTextArray("ChangeIntoOnDetach",detach_types);
9730 if (detach_types.Count() < 1)
9731 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
9732 }
9733
9734 for (int i = 0; i < inventory_slots.Count(); i++)
9735 {
9736 slot = inventory_slots.Get(i);
9737 }
9738
9739 if (slot != "")
9740 {
9741 if (detach_types.Count() == 1)
9742 idx = 0;
9743 else
9744 idx = inventory_slots.Find(slot);
9745 }
9746 if (idx < 0)
9747 return "";
9748
9749 return detach_types.Get(idx);
9750 }
9751
9752 void ExplodeAmmo()
9753 {
9754 //timer
9755 ref Timer explode_timer = new Timer(CALL_CATEGORY_SYSTEM);
9756
9757 //min/max time
9758 float min_time = 1;
9759 float max_time = 3;
9760 float delay = Math.RandomFloat(min_time, max_time);
9761
9762 explode_timer.Run(delay, this, "DoAmmoExplosion");
9763 }
9764
9765 void DoAmmoExplosion()
9766 {
9767 Magazine magazine = Magazine.Cast(this);
9768 int pop_sounds_count = 6;
9769 string pop_sounds[ 6 ] = { "ammopops_1","ammopops_2","ammopops_3","ammopops_4","ammopops_5","ammopops_6" };
9770
9771 //play sound
9772 int sound_idx = Math.RandomInt(0, pop_sounds_count - 1);
9773 string sound_name = pop_sounds[ sound_idx ];
9774 GetGame().CreateSoundOnObject(this, sound_name, 20, false);
9775
9776 //remove ammo count
9777 magazine.ServerAddAmmoCount(-1);
9778
9779 //if condition then repeat -> ExplodeAmmo
9780 float min_temp_to_explode = 100; //min temperature for item to explode
9781
9782 if (magazine.GetAmmoCount() > 0 && GetTemperature() >= min_temp_to_explode) //TODO ? add check for parent -> fireplace
9783 {
9784 ExplodeAmmo();
9785 }
9786 }
9787
9788 // -------------------------------------------------------------------------------
9789 override void EEHitBy(TotalDamageResult damageResult, int damageType, EntityAI source, int component, string dmgZone, string ammo, vector modelPos, float speedCoef)
9790 {
9791 super.EEHitBy(damageResult, damageType, source, component, dmgZone, ammo, modelPos, speedCoef);
9792
9793 const int CHANCE_DAMAGE_CARGO = 4;
9794 const int CHANCE_DAMAGE_ATTACHMENT = 1;
9795 const int CHANCE_DAMAGE_NOTHING = 2;
9796
9797 if (IsClothing() || IsContainer() || IsItemTent())
9798 {
9799 float dmg = damageResult.GetDamage("","Health") * -0.5;
9800 int chances;
9801 int rnd;
9802
9803 if (GetInventory().GetCargo())
9804 {
9805 chances = CHANCE_DAMAGE_CARGO + CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
9806 rnd = Math.RandomInt(0,chances);
9807
9808 if (rnd < CHANCE_DAMAGE_CARGO)
9809 {
9810 DamageItemInCargo(dmg);
9811 }
9812 else if (rnd < (chances - CHANCE_DAMAGE_NOTHING))
9813 {
9815 }
9816 }
9817 else
9818 {
9819 chances = CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
9820 rnd = Math.RandomInt(0,chances);
9821
9822 if (rnd < CHANCE_DAMAGE_ATTACHMENT)
9823 {
9825 }
9826 }
9827 }
9828 }
9829
9830 bool DamageItemInCargo(float damage)
9831 {
9832 if (GetInventory().GetCargo())
9833 {
9834 int item_count = GetInventory().GetCargo().GetItemCount();
9835 if (item_count > 0)
9836 {
9837 int random_pick = Math.RandomInt(0, item_count);
9838 ItemBase item = ItemBase.Cast(GetInventory().GetCargo().GetItem(random_pick));
9839 if (!item.IsExplosive())
9840 {
9841 item.AddHealth("","",damage);
9842 return true;
9843 }
9844 }
9845 }
9846 return false;
9847 }
9848
9849 bool DamageItemAttachments(float damage)
9850 {
9851 int attachment_count = GetInventory().AttachmentCount();
9852 if (attachment_count > 0)
9853 {
9854 int random_pick = Math.RandomInt(0, attachment_count);
9855 ItemBase attachment = ItemBase.Cast(GetInventory().GetAttachmentFromIndex(random_pick));
9856 if (!attachment.IsExplosive())
9857 {
9858 attachment.AddHealth("","",damage);
9859 return true;
9860 }
9861 }
9862 return false;
9863 }
9864
9865 override bool IsSplitable()
9866 {
9867 return m_CanThisBeSplit;
9868 }
9869 //----------------
9870 override bool CanBeSplit()
9871 {
9872 if (IsSplitable() && (GetQuantity() > 1))
9873 return GetInventory().CanRemoveEntity();
9874
9875 return false;
9876 }
9877
9878 protected bool ShouldSplitQuantity(float quantity)
9879 {
9880 // don't call 'CanBeSplit' here, too strict and will introduce a freeze-crash when dismantling fence with a fireplace nearby
9881 if (!IsSplitable())
9882 return false;
9883
9884 // nothing to split?
9885 if (GetQuantity() <= 1)
9886 return false;
9887
9888 // check if we should re-use the item instead of creating a new copy?
9889 // implicit cast to int, if 'IsSplitable' returns true, these values are assumed ints
9890 int delta = GetQuantity() - quantity;
9891 if (delta == 0)
9892 return false;
9893
9894 // valid to split
9895 return true;
9896 }
9897
9898 override void SplitIntoStackMaxClient(EntityAI destination_entity, int slot_id )
9899 {
9900 if (GetGame().IsClient())
9901 {
9902 if (ScriptInputUserData.CanStoreInputUserData())
9903 {
9904 ScriptInputUserData ctx = new ScriptInputUserData;
9906 ctx.Write(1);
9907 ItemBase i1 = this; // @NOTE: workaround for correct serialization
9908 ctx.Write(i1);
9909 ctx.Write(destination_entity);
9910 ctx.Write(true);
9911 ctx.Write(slot_id);
9912 ctx.Send();
9913 }
9914 }
9915 else if (!GetGame().IsMultiplayer())
9916 {
9917 SplitIntoStackMax(destination_entity, slot_id, PlayerBase.Cast(GetGame().GetPlayer()));
9918 }
9919 }
9920
9921 void SplitIntoStackMax(EntityAI destination_entity, int slot_id, PlayerBase player)
9922 {
9923 float split_quantity_new;
9924 ItemBase new_item;
9925 float quantity = GetQuantity();
9926 float stack_max = GetTargetQuantityMax(slot_id);
9927 InventoryLocation loc = new InventoryLocation;
9928
9929 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
9930 {
9931 if (stack_max <= GetQuantity())
9932 split_quantity_new = stack_max;
9933 else
9934 split_quantity_new = GetQuantity();
9935
9936 if (ShouldSplitQuantity(split_quantity_new))
9937 {
9938 new_item = ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(this.GetType(), slot_id));
9939 if (new_item)
9940 {
9941 new_item.SetResultOfSplit(true);
9942 MiscGameplayFunctions.TransferItemProperties(this, new_item);
9943 AddQuantity(-split_quantity_new, false, true);
9944 new_item.SetQuantity(split_quantity_new, false, true);
9945 }
9946 }
9947 }
9948 else if (destination_entity && slot_id == -1)
9949 {
9950 if (quantity > stack_max)
9951 split_quantity_new = stack_max;
9952 else
9953 split_quantity_new = quantity;
9954
9955 if (ShouldSplitQuantity(split_quantity_new))
9956 {
9957 if (destination_entity.GetInventory().FindFreeLocationFor(this, FindInventoryLocationType.ANY, loc))
9958 {
9959 Object o = destination_entity.GetInventory().LocationCreateEntity(loc, GetType(), ECE_IN_INVENTORY, RF_DEFAULT);
9960 new_item = ItemBase.Cast(o);
9961 }
9962
9963 if (new_item)
9964 {
9965 new_item.SetResultOfSplit(true);
9966 MiscGameplayFunctions.TransferItemProperties(this, new_item);
9967 AddQuantity(-split_quantity_new, false, true);
9968 new_item.SetQuantity(split_quantity_new, false, true);
9969 }
9970 }
9971 }
9972 else
9973 {
9974 if (stack_max != 0)
9975 {
9976 if (stack_max < GetQuantity())
9977 {
9978 split_quantity_new = GetQuantity() - stack_max;
9979 }
9980
9981 if (split_quantity_new == 0)
9982 {
9983 if (!GetGame().IsMultiplayer())
9984 player.PhysicalPredictiveDropItem(this);
9985 else
9986 player.ServerDropEntity(this);
9987 return;
9988 }
9989
9990 if (ShouldSplitQuantity(split_quantity_new))
9991 {
9992 new_item = ItemBase.Cast(GetGame().CreateObjectEx(GetType(), player.GetWorldPosition(), ECE_PLACE_ON_SURFACE));
9993
9994 if (new_item)
9995 {
9996 new_item.SetResultOfSplit(true);
9997 MiscGameplayFunctions.TransferItemProperties(this, new_item);
9998 SetQuantity(split_quantity_new, false, true);
9999 new_item.SetQuantity(stack_max, false, true);
10000 new_item.PlaceOnSurface();
10001 }
10002 }
10003 }
10004 }
10005 }
10006
10007 override void SplitIntoStackMaxEx(EntityAI destination_entity, int slot_id)
10008 {
10009 float split_quantity_new;
10010 ItemBase new_item;
10011 float quantity = GetQuantity();
10012 float stack_max = GetTargetQuantityMax(slot_id);
10013 InventoryLocation loc = new InventoryLocation;
10014
10015 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
10016 {
10017 if (stack_max <= GetQuantity())
10018 split_quantity_new = stack_max;
10019 else
10020 split_quantity_new = GetQuantity();
10021
10022 if (ShouldSplitQuantity(split_quantity_new))
10023 {
10024 new_item = ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(this.GetType(), slot_id));
10025 if (new_item)
10026 {
10027 new_item.SetResultOfSplit(true);
10028 MiscGameplayFunctions.TransferItemProperties(this, new_item);
10029 AddQuantity(-split_quantity_new, false, true);
10030 new_item.SetQuantity(split_quantity_new, false, true);
10031 }
10032 }
10033 }
10034 else if (destination_entity && slot_id == -1)
10035 {
10036 if (quantity > stack_max)
10037 split_quantity_new = stack_max;
10038 else
10039 split_quantity_new = quantity;
10040
10041 if (ShouldSplitQuantity(split_quantity_new))
10042 {
10043 if (destination_entity.GetInventory().FindFreeLocationFor(this, FindInventoryLocationType.ANY, loc))
10044 {
10045 Object o = destination_entity.GetInventory().LocationCreateEntity(loc, GetType(), ECE_IN_INVENTORY, RF_DEFAULT);
10046 new_item = ItemBase.Cast(o);
10047 }
10048
10049 if (new_item)
10050 {
10051 new_item.SetResultOfSplit(true);
10052 MiscGameplayFunctions.TransferItemProperties(this, new_item);
10053 AddQuantity(-split_quantity_new, false, true);
10054 new_item.SetQuantity(split_quantity_new, false, true);
10055 }
10056 }
10057 }
10058 else
10059 {
10060 if (stack_max != 0)
10061 {
10062 if (stack_max < GetQuantity())
10063 {
10064 split_quantity_new = GetQuantity() - stack_max;
10065 }
10066
10067 if (ShouldSplitQuantity(split_quantity_new))
10068 {
10069 new_item = ItemBase.Cast(GetGame().CreateObjectEx(GetType(),GetWorldPosition(), ECE_PLACE_ON_SURFACE));
10070
10071 if (new_item)
10072 {
10073 new_item.SetResultOfSplit(true);
10074 MiscGameplayFunctions.TransferItemProperties(this, new_item);
10075 SetQuantity(split_quantity_new, false, true);
10076 new_item.SetQuantity(stack_max, false, true);
10077 new_item.PlaceOnSurface();
10078 }
10079 }
10080 }
10081 }
10082 }
10083
10084 void SplitIntoStackMaxToInventoryLocationClient(notnull InventoryLocation dst)
10085 {
10086 if (GetGame().IsClient())
10087 {
10088 if (ScriptInputUserData.CanStoreInputUserData())
10089 {
10090 ScriptInputUserData ctx = new ScriptInputUserData;
10092 ctx.Write(4);
10093 ItemBase thiz = this; // @NOTE: workaround for correct serialization
10094 ctx.Write(thiz);
10095 dst.WriteToContext(ctx);
10096 ctx.Send();
10097 }
10098 }
10099 else if (!GetGame().IsMultiplayer())
10100 {
10102 }
10103 }
10104
10105 void SplitIntoStackMaxCargoClient(EntityAI destination_entity, int idx, int row, int col)
10106 {
10107 if (GetGame().IsClient())
10108 {
10109 if (ScriptInputUserData.CanStoreInputUserData())
10110 {
10111 ScriptInputUserData ctx = new ScriptInputUserData;
10113 ctx.Write(2);
10114 ItemBase dummy = this; // @NOTE: workaround for correct serialization
10115 ctx.Write(dummy);
10116 ctx.Write(destination_entity);
10117 ctx.Write(true);
10118 ctx.Write(idx);
10119 ctx.Write(row);
10120 ctx.Write(col);
10121 ctx.Send();
10122 }
10123 }
10124 else if (!GetGame().IsMultiplayer())
10125 {
10126 SplitIntoStackMaxCargo(destination_entity, idx, row, col);
10127 }
10128 }
10129
10130 void SplitIntoStackMaxToInventoryLocation(notnull InventoryLocation dst)
10131 {
10133 }
10134
10135 ItemBase SplitIntoStackMaxToInventoryLocationEx(notnull InventoryLocation dst)
10136 {
10137 float quantity = GetQuantity();
10138 float split_quantity_new;
10139 ItemBase new_item;
10140 if (dst.IsValid())
10141 {
10142 int slot_id = dst.GetSlot();
10143 float stack_max = GetTargetQuantityMax(slot_id);
10144
10145 if (quantity > stack_max)
10146 split_quantity_new = stack_max;
10147 else
10148 split_quantity_new = quantity;
10149
10150 if (ShouldSplitQuantity(split_quantity_new))
10151 {
10152 new_item = ItemBase.Cast(GameInventory.LocationCreateEntity(dst, this.GetType(), ECE_IN_INVENTORY, RF_DEFAULT));
10153
10154 if (new_item)
10155 {
10156 new_item.SetResultOfSplit(true);
10157 MiscGameplayFunctions.TransferItemProperties(this,new_item);
10158 AddQuantity(-split_quantity_new, false, true);
10159 new_item.SetQuantity(split_quantity_new, false, true);
10160 }
10161
10162 return new_item;
10163 }
10164 }
10165
10166 return null;
10167 }
10168
10169 void SplitIntoStackMaxCargo(EntityAI destination_entity, int idx, int row, int col)
10170 {
10171 float quantity = GetQuantity();
10172 float split_quantity_new;
10173 ItemBase new_item;
10174 if (destination_entity)
10175 {
10176 float stackable = GetTargetQuantityMax();
10177 if (quantity > stackable)
10178 split_quantity_new = stackable;
10179 else
10180 split_quantity_new = quantity;
10181
10182 if (ShouldSplitQuantity(split_quantity_new))
10183 {
10184 new_item = ItemBase.Cast(destination_entity.GetInventory().CreateEntityInCargoEx(this.GetType(), idx, row, col, false));
10185 if (new_item)
10186 {
10187 new_item.SetResultOfSplit(true);
10188 MiscGameplayFunctions.TransferItemProperties(this,new_item);
10189 AddQuantity(-split_quantity_new, false, true);
10190 new_item.SetQuantity(split_quantity_new, false, true);
10191 }
10192 }
10193 }
10194 }
10195
10196 void SplitIntoStackMaxHandsClient(PlayerBase player)
10197 {
10198 if (GetGame().IsClient())
10199 {
10200 if (ScriptInputUserData.CanStoreInputUserData())
10201 {
10202 ScriptInputUserData ctx = new ScriptInputUserData;
10204 ctx.Write(3);
10205 ItemBase i1 = this; // @NOTE: workaround for correct serialization
10206 ctx.Write(i1);
10207 ItemBase destination_entity = this;
10208 ctx.Write(destination_entity);
10209 ctx.Write(true);
10210 ctx.Write(0);
10211 ctx.Send();
10212 }
10213 }
10214 else if (!GetGame().IsMultiplayer())
10215 {
10216 SplitIntoStackMaxHands(player);
10217 }
10218 }
10219
10220 void SplitIntoStackMaxHands(PlayerBase player)
10221 {
10222 float quantity = GetQuantity();
10223 float split_quantity_new;
10224 ref ItemBase new_item;
10225 if (player)
10226 {
10227 float stackable = GetTargetQuantityMax();
10228 if (quantity > stackable)
10229 split_quantity_new = stackable;
10230 else
10231 split_quantity_new = quantity;
10232
10233 if (ShouldSplitQuantity(split_quantity_new))
10234 {
10235 EntityAI in_hands = player.GetHumanInventory().CreateInHands(this.GetType());
10236 new_item = ItemBase.Cast(in_hands);
10237 if (new_item)
10238 {
10239 new_item.SetResultOfSplit(true);
10240 MiscGameplayFunctions.TransferItemProperties(this,new_item);
10241 AddQuantity(-split_quantity_new, false, true);
10242 new_item.SetQuantity(split_quantity_new, false, true);
10243 }
10244 }
10245 }
10246 }
10247
10248 void SplitItemToInventoryLocation(notnull InventoryLocation dst)
10249 {
10250 float quantity = GetQuantity();
10251 float split_quantity_new = Math.Floor(quantity * 0.5);
10252
10253 if (!ShouldSplitQuantity(split_quantity_new))
10254 return;
10255
10256 ItemBase new_item = ItemBase.Cast(GameInventory.LocationCreateEntity(dst, GetType(), ECE_IN_INVENTORY, RF_DEFAULT));
10257
10258 if (new_item)
10259 {
10260 if (new_item.GetQuantityMax() < split_quantity_new)
10261 {
10262 split_quantity_new = new_item.GetQuantityMax();
10263 }
10264
10265 new_item.SetResultOfSplit(true);
10266 MiscGameplayFunctions.TransferItemProperties(this, new_item);
10267
10268 if (dst.IsValid() && dst.GetType() == InventoryLocationType.ATTACHMENT && split_quantity_new > 1)
10269 {
10270 AddQuantity(-1, false, true);
10271 new_item.SetQuantity(1, false, true);
10272 }
10273 else
10274 {
10275 AddQuantity(-split_quantity_new, false, true);
10276 new_item.SetQuantity(split_quantity_new, false, true);
10277 }
10278 }
10279 }
10280
10281 void SplitItem(PlayerBase player)
10282 {
10283 float quantity = GetQuantity();
10284 float split_quantity_new = Math.Floor(quantity / 2);
10285
10286 if (!ShouldSplitQuantity(split_quantity_new))
10287 return;
10288
10289 InventoryLocation invloc = new InventoryLocation;
10290 bool found = player.GetInventory().FindFirstFreeLocationForNewEntity(GetType(), FindInventoryLocationType.ATTACHMENT, invloc);
10291
10292 ItemBase new_item;
10293 new_item = player.CreateCopyOfItemInInventoryOrGroundEx(this, true);
10294
10295 if (new_item)
10296 {
10297 if (new_item.GetQuantityMax() < split_quantity_new)
10298 {
10299 split_quantity_new = new_item.GetQuantityMax();
10300 }
10301 if (found && invloc.IsValid() && invloc.GetType() == InventoryLocationType.ATTACHMENT && split_quantity_new > 1)
10302 {
10303 AddQuantity(-1, false, true);
10304 new_item.SetQuantity(1, false, true);
10305 }
10306 else if (split_quantity_new > 1)
10307 {
10308 AddQuantity(-split_quantity_new, false, true);
10309 new_item.SetQuantity(split_quantity_new, false, true);
10310 }
10311 }
10312 }
10313
10315 void OnQuantityChanged(float delta)
10316 {
10317 SetWeightDirty();
10318 ItemBase parent = ItemBase.Cast(GetHierarchyParent());
10319
10320 if (parent)
10321 parent.OnAttachmentQuantityChangedEx(this, delta);
10322
10323 if (IsLiquidContainer())
10324 {
10325 if (GetQuantityNormalized() <= 0.0)
10326 {
10328 }
10329 else if (GetLiquidType() == LIQUID_NONE)
10330 {
10331 ErrorEx("Undefined liquid type quantity changed, please define liquid type first! Using init value.",ErrorExSeverity.INFO);
10333 }
10334 }
10335
10336 }
10337
10340 {
10341 // insert code here
10342 }
10343
10345 void OnAttachmentQuantityChangedEx(ItemBase item , float delta)
10346 {
10348 }
10349
10350 override void EEHealthLevelChanged(int oldLevel, int newLevel, string zone)
10351 {
10352 super.EEHealthLevelChanged(oldLevel,newLevel,zone);
10353
10354 if (GetGame().IsServer())
10355 {
10356 if (newLevel == GameConstants.STATE_RUINED)
10357 {
10359 EntityAI parent = GetHierarchyParent();
10360 if (parent && parent.IsFireplace())
10361 {
10362 CargoBase cargo = GetInventory().GetCargo();
10363 if (cargo)
10364 {
10365 for (int i = 0; i < cargo.GetItemCount(); ++i)
10366 {
10367 parent.GetInventory().TakeEntityToInventory(InventoryMode.SERVER, FindInventoryLocationType.CARGO, cargo.GetItem(i));
10368 }
10369 }
10370 }
10371 }
10372
10373 if (IsResultOfSplit())
10374 {
10375 // reset the splitting result flag, return to normal item behavior
10376 SetResultOfSplit(false);
10377 return;
10378 }
10379
10380 if (m_Cleanness != 0 && oldLevel < newLevel && newLevel != 0)
10381 {
10382 SetCleanness(0);//unclean the item upon damage dealt
10383 }
10384 }
10385 }
10386
10387 // just the split? TODO: verify
10388 override void OnRightClick()
10389 {
10390 super.OnRightClick();
10391
10392 if (CanBeSplit() && !GetDayZGame().IsLeftCtrlDown() && !GetGame().GetPlayer().GetInventory().HasInventoryReservation(this,null))
10393 {
10394 if (GetGame().IsClient())
10395 {
10396 if (ScriptInputUserData.CanStoreInputUserData())
10397 {
10398 EntityAI root = GetHierarchyRoot();
10399 Man playerOwner = GetHierarchyRootPlayer();
10400 InventoryLocation dst = new InventoryLocation;
10401
10402 // If we have no hierarchy root player and the root is the same as this item the source item is in the vicinity so we want to create the new split item there also
10403 if (!playerOwner && root && root == this)
10404 {
10406 }
10407 else
10408 {
10409 // Check if we can place the new split item in the same parent where the source item is placed in or otherwise drop it in vicinity
10410 GetInventory().GetCurrentInventoryLocation(dst);
10411 if (!dst.GetParent() || dst.GetParent() && !dst.GetParent().GetInventory().FindFreeLocationFor(this, FindInventoryLocationType.CARGO, dst))
10412 {
10413 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
10414 if (!player.GetInventory().FindFreeLocationFor(this, FindInventoryLocationType.CARGO, dst) || !playerOwner)
10415 {
10417 }
10418 else
10419 {
10420 dst.SetCargo(dst.GetParent(), this, dst.GetIdx(), dst.GetRow(), dst.GetCol(), dst.GetFlip());
10421 /* hacky solution to check reservation of "this" item instead of null since the gamecode is checking null against null and returning reservation=true incorrectly
10422 this shouldnt cause issues within this scope*/
10423 if (GetGame().GetPlayer().GetInventory().HasInventoryReservation(this, dst))
10424 {
10426 }
10427 else
10428 {
10429 GetGame().GetPlayer().GetInventory().AddInventoryReservationEx(null, dst, GameInventory.c_InventoryReservationTimeoutShortMS);
10430 }
10431 }
10432 }
10433 }
10434
10435 ScriptInputUserData ctx = new ScriptInputUserData;
10437 ctx.Write(4);
10438 ItemBase thiz = this; // @NOTE: workaround for correct serialization
10439 ctx.Write(thiz);
10440 dst.WriteToContext(ctx);
10441 ctx.Write(true); // dummy
10442 ctx.Send();
10443 }
10444 }
10445 else if (!GetGame().IsMultiplayer())
10446 {
10447 SplitItem(PlayerBase.Cast(GetGame().GetPlayer()));
10448 }
10449 }
10450 }
10451
10452 protected void SetInventoryLocationToVicinityOrCurrent(EntityAI root, inout InventoryLocation dst)
10453 {
10454 if (root)
10455 {
10456 vector m4[4];
10457 root.GetTransform(m4);
10458 dst.SetGround(this, m4);
10459 }
10460 else
10461 {
10462 GetInventory().GetCurrentInventoryLocation(dst);
10463 }
10464 }
10465
10466 override bool CanBeCombined(EntityAI other_item, bool reservation_check = true, bool stack_max_limit = false)
10467 {
10468 //TODO: delete check zero quantity check after fix double posts hands fsm events
10469 if (!other_item || GetType() != other_item.GetType() || (IsFullQuantity() && other_item.GetQuantity() > 0) || other_item == this)
10470 return false;
10471
10472 if (GetHealthLevel() == GameConstants.STATE_RUINED || other_item.GetHealthLevel() == GameConstants.STATE_RUINED)
10473 return false;
10474
10475 //can_this_be_combined = ConfigGetBool("canBeSplit");
10477 return false;
10478
10479
10480 Magazine mag = Magazine.Cast(this);
10481 if (mag)
10482 {
10483 if (mag.GetAmmoCount() >= mag.GetAmmoMax())
10484 return false;
10485
10486 if (stack_max_limit)
10487 {
10488 Magazine other_mag = Magazine.Cast(other_item);
10489 if (other_item)
10490 {
10491 if (mag.GetAmmoCount() + other_mag.GetAmmoCount() > mag.GetAmmoMax())
10492 return false;
10493 }
10494
10495 }
10496 }
10497 else
10498 {
10499 //TODO: delete check zero quantity check after fix double posts hands fsm events
10500 if (GetQuantity() >= GetQuantityMax() && other_item.GetQuantity() > 0 )
10501 return false;
10502
10503 if (stack_max_limit && (GetQuantity() + other_item.GetQuantity() > GetQuantityMax()))
10504 return false;
10505 }
10506
10507 PlayerBase player = null;
10508 if (CastTo(player, GetHierarchyRootPlayer())) //false when attached to player's attachment slot
10509 {
10510 if (player.GetInventory().HasAttachment(this))
10511 return false;
10512
10513 if (player.IsItemsToDelete())
10514 return false;
10515 }
10516
10517 if (reservation_check && (GetInventory().HasInventoryReservation(this, null) || other_item.GetInventory().HasInventoryReservation(other_item, null)))
10518 return false;
10519
10520 int slotID;
10521 string slotName;
10522 if (GetInventory().GetCurrentAttachmentSlotInfo(slotID,slotName) && GetHierarchyParent().GetInventory().GetSlotLock(slotID))
10523 return false;
10524
10525 return true;
10526 }
10527
10528 bool IsCombineAll(ItemBase other_item, bool use_stack_max = false)
10529 {
10530 return ComputeQuantityUsed(other_item, use_stack_max) == other_item.GetQuantity();
10531 }
10532
10533 bool IsResultOfSplit()
10534 {
10535 return m_IsResultOfSplit;
10536 }
10537
10538 void SetResultOfSplit(bool value)
10539 {
10540 m_IsResultOfSplit = value;
10541 }
10542
10543 int ComputeQuantityUsed(ItemBase other_item, bool use_stack_max = true)
10544 {
10545 return ComputeQuantityUsedEx(other_item, use_stack_max);
10546 }
10547
10548 float ComputeQuantityUsedEx(ItemBase other_item, bool use_stack_max = true)
10549 {
10550 float other_item_quantity = other_item.GetQuantity();
10551 float this_free_space;
10552
10553 float stack_max = GetQuantityMax();
10554
10555 this_free_space = stack_max - GetQuantity();
10556
10557 if (other_item_quantity > this_free_space)
10558 {
10559 return this_free_space;
10560 }
10561 else
10562 {
10563 return other_item_quantity;
10564 }
10565 }
10566
10567 override void CombineItemsEx(EntityAI entity2, bool use_stack_max = true)
10568 {
10569 CombineItems(ItemBase.Cast(entity2),use_stack_max);
10570 }
10571
10572 void CombineItems(ItemBase other_item, bool use_stack_max = true)
10573 {
10574 if (!CanBeCombined(other_item, false))
10575 return;
10576
10577 if (!IsMagazine() && other_item)
10578 {
10579 float quantity_used = ComputeQuantityUsedEx(other_item,use_stack_max);
10580 if (quantity_used != 0)
10581 {
10582 float hp1 = GetHealth01("","");
10583 float hp2 = other_item.GetHealth01("","");
10584 float hpResult = ((hp1*GetQuantity()) + (hp2*quantity_used));
10585 hpResult = hpResult / (GetQuantity() + quantity_used);
10586
10587 hpResult *= GetMaxHealth();
10588 Math.Round(hpResult);
10589 SetHealth("", "Health", hpResult);
10590
10591 AddQuantity(quantity_used);
10592 other_item.AddQuantity(-quantity_used);
10593 }
10594 }
10595 OnCombine(other_item);
10596 }
10597
10598 void OnCombine(ItemBase other_item)
10599 {
10600 #ifdef SERVER
10601 if (!GetHierarchyRootPlayer() && GetHierarchyParent())
10602 GetHierarchyParent().IncreaseLifetimeUp();
10603 #endif
10604 };
10605
10606 void GetRecipesActions(Man player, out TSelectableActionInfoArray outputList)
10607 {
10608 PlayerBase p = PlayerBase.Cast(player);
10609
10610 array<int> recipesIds = p.m_Recipes;
10611 PluginRecipesManager moduleRecipesManager = PluginRecipesManager.Cast(GetPlugin(PluginRecipesManager));
10612 if (moduleRecipesManager)
10613 {
10614 EntityAI itemInHands = player.GetHumanInventory().GetEntityInHands();
10615 moduleRecipesManager.GetValidRecipes(ItemBase.Cast(this), ItemBase.Cast(itemInHands), recipesIds, p);
10616 }
10617
10618 for (int i = 0;i < recipesIds.Count(); i++)
10619 {
10620 int key = recipesIds.Get(i);
10621 string recipeName = moduleRecipesManager.GetRecipeName(key);
10622 outputList.Insert(new TSelectableActionInfo(SAT_CRAFTING, key, recipeName));
10623 }
10624 }
10625
10626 // -------------------------------------------------------------------------
10627 override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
10628 {
10629 super.GetDebugActions(outputList);
10630
10631 //quantity
10632 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.ADD_QUANTITY, "Quantity +20%", FadeColors.LIGHT_GREY));
10633 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.REMOVE_QUANTITY, "Quantity -20%", FadeColors.LIGHT_GREY));
10634 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SET_QUANTITY_0, "Set Quantity 0", FadeColors.LIGHT_GREY));
10635 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SET_MAX_QUANTITY, "Set Quantity Max", FadeColors.LIGHT_GREY));
10636 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
10637
10638 //health
10639 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.ADD_HEALTH, "Health +20%", FadeColors.LIGHT_GREY));
10640 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.REMOVE_HEALTH, "Health -20%", FadeColors.LIGHT_GREY));
10641 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.DESTROY_HEALTH, "Health 0", FadeColors.LIGHT_GREY));
10642 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
10643 //temperature
10644 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.ADD_TEMPERATURE, "Temperature +20", FadeColors.LIGHT_GREY));
10645 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.REMOVE_TEMPERATURE, "Temperature -20", FadeColors.LIGHT_GREY));
10646 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.FLIP_FROZEN, "Toggle Frozen", FadeColors.LIGHT_GREY));
10647 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
10648
10649 //wet
10650 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.ADD_WETNESS, "Wetness +20", FadeColors.LIGHT_GREY));
10651 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.REMOVE_WETNESS, "Wetness -20", FadeColors.LIGHT_GREY));
10652 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
10653
10654 //liquidtype
10655 if (IsLiquidContainer())
10656 {
10657 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.LIQUIDTYPE_UP, "LiquidType Next", FadeColors.LIGHT_GREY));
10658 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.LIQUIDTYPE_DOWN, "LiquidType Previous", FadeColors.LIGHT_GREY));
10659 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
10660 }
10661
10662 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.MAKE_SPECIAL, "Make Special", FadeColors.LIGHT_GREY));
10663 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
10664
10665 // watch
10666 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.WATCH_ITEM, "Watch (CTRL-Z)", FadeColors.LIGHT_GREY));
10667 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.WATCH_PLAYER, "Watch Player", FadeColors.LIGHT_GREY));
10668 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
10669
10670 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.DELETE, "Delete", FadeColors.RED));
10671
10672 InventoryLocation loc = new InventoryLocation();
10673 GetInventory().GetCurrentInventoryLocation(loc);
10674 if (!loc || loc.GetType() == InventoryLocationType.GROUND)
10675 {
10676 if (Gizmo_IsSupported())
10677 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.GIZMO_OBJECT, "Gizmo Object", FadeColors.LIGHT_GREY));
10678 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.GIZMO_PHYSICS, "Gizmo Physics (SP Only)", FadeColors.LIGHT_GREY)); // intentionally allowed for testing physics desync
10679 }
10680
10681 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
10682 }
10683
10684 // -------------------------------------------------------------------------
10685 // -------------------------------------------------------------------------
10686 // -------------------------------------------------------------------------
10687 override bool OnAction(int action_id, Man player, ParamsReadContext ctx)
10688 {
10689 super.OnAction(action_id, player, ctx);
10690
10691 if (GetGame().IsClient() || !GetGame().IsMultiplayer())
10692 {
10693 switch (action_id)
10694 {
10695 case EActions.GIZMO_OBJECT:
10696 GetGame().GizmoSelectObject(this);
10697 return true;
10698 case EActions.GIZMO_PHYSICS:
10699 GetGame().GizmoSelectPhysics(GetPhysics());
10700 return true;
10701 }
10702 }
10703
10704 if (GetGame().IsServer())
10705 {
10706 switch (action_id)
10707 {
10708 case EActions.DELETE:
10709 Delete();
10710 return true;
10711 }
10712 }
10713
10714 if (action_id >= EActions.RECIPES_RANGE_START && action_id < EActions.RECIPES_RANGE_END)
10715 {
10716 PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast(GetPlugin(PluginRecipesManager));
10717 int idWithoutOffset = action_id - EActions.RECIPES_RANGE_START;
10718 PlayerBase p = PlayerBase.Cast(player);
10719 if (EActions.RECIPES_RANGE_START < 1000)
10720 {
10721 float anim_length = plugin_recipes_manager.GetRecipeLengthInSecs(idWithoutOffset);
10722 float specialty_weight = plugin_recipes_manager.GetRecipeSpecialty(idWithoutOffset);
10723 }
10724 }
10725 #ifndef SERVER
10726 else if (action_id == EActions.WATCH_PLAYER)
10727 {
10728 PluginDeveloper.SetDeveloperItemClientEx(player);
10729 }
10730 #endif
10731 if (GetGame().IsServer())
10732 {
10733 if (action_id >= EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START && action_id < EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_END)
10734 {
10735 int id = action_id - EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START;
10736 OnDebugButtonPressServer(id + 1);
10737 }
10738
10739 else if (action_id >= EActions.DEBUG_AGENTS_RANGE_INJECT_START && action_id < EActions.DEBUG_AGENTS_RANGE_INJECT_END)
10740 {
10741 int agent_id = action_id - EActions.DEBUG_AGENTS_RANGE_INJECT_START;
10742 InsertAgent(agent_id,100);
10743 }
10744
10745 else if (action_id >= EActions.DEBUG_AGENTS_RANGE_REMOVE_START && action_id < EActions.DEBUG_AGENTS_RANGE_REMOVE_END)
10746 {
10747 int agent_id2 = action_id - EActions.DEBUG_AGENTS_RANGE_REMOVE_START;
10748 RemoveAgent(agent_id2);
10749 }
10750
10751 else if (action_id == EActions.ADD_QUANTITY)
10752 {
10753 if (IsMagazine())
10754 {
10755 Magazine mag = Magazine.Cast(this);
10756 mag.ServerSetAmmoCount(mag.GetAmmoCount() + mag.GetAmmoMax() * 0.2);
10757 }
10758 else
10759 {
10760 AddQuantity(GetQuantityMax() * 0.2);
10761 }
10762
10763 if (m_EM)
10764 {
10765 m_EM.AddEnergy(m_EM.GetEnergyMax() * 0.2);
10766 }
10767 //PrintVariables();
10768 }
10769
10770 else if (action_id == EActions.REMOVE_QUANTITY) //Quantity -20%
10771 {
10772 if (IsMagazine())
10773 {
10774 Magazine mag2 = Magazine.Cast(this);
10775 mag2.ServerSetAmmoCount(mag2.GetAmmoCount() - mag2.GetAmmoMax() * 0.2);
10776 }
10777 else
10778 {
10779 AddQuantity(- GetQuantityMax() * 0.2);
10780 }
10781 if (m_EM)
10782 {
10783 m_EM.AddEnergy(- m_EM.GetEnergyMax() * 0.2);
10784 }
10785 //PrintVariables();
10786 }
10787
10788 else if (action_id == EActions.SET_QUANTITY_0) //SetMaxQuantity
10789 {
10790 SetQuantity(0);
10791
10792 if (m_EM)
10793 {
10794 m_EM.SetEnergy(0);
10795 }
10796 }
10797
10798 else if (action_id == EActions.SET_MAX_QUANTITY) //SetMaxQuantity
10799 {
10801
10802 if (m_EM)
10803 {
10804 m_EM.SetEnergy(m_EM.GetEnergyMax());
10805 }
10806 }
10807
10808 else if (action_id == EActions.ADD_HEALTH)
10809 {
10810 AddHealth("","",GetMaxHealth("","Health")/5);
10811 }
10812 else if (action_id == EActions.REMOVE_HEALTH)
10813 {
10814 AddHealth("","",-GetMaxHealth("","Health")/5);
10815 }
10816 else if (action_id == EActions.DESTROY_HEALTH)
10817 {
10818 SetHealth01("","",0);
10819 }
10820 else if (action_id == EActions.WATCH_ITEM)
10821 {
10823 mid.RegisterDebugItem(ItemBase.Cast(this), PlayerBase.Cast(player));
10824 #ifdef DEVELOPER
10825 SetDebugDeveloper_item(this);
10826 #endif
10827 }
10828
10829 else if (action_id == EActions.ADD_TEMPERATURE)
10830 {
10831 AddTemperature(20);
10832 //PrintVariables();
10833 }
10834
10835 else if (action_id == EActions.REMOVE_TEMPERATURE)
10836 {
10837 AddTemperature(-20);
10838 //PrintVariables();
10839 }
10840
10841 else if (action_id == EActions.FLIP_FROZEN)
10842 {
10843 SetFrozen(!GetIsFrozen());
10844 //PrintVariables();
10845 }
10846
10847 else if (action_id == EActions.ADD_WETNESS)
10848 {
10849 AddWet(GetWetMax()/5);
10850 //PrintVariables();
10851 }
10852
10853 else if (action_id == EActions.REMOVE_WETNESS)
10854 {
10855 AddWet(-GetWetMax()/5);
10856 //PrintVariables();
10857 }
10858
10859 else if (action_id == EActions.LIQUIDTYPE_UP)
10860 {
10861 int curr_type = GetLiquidType();
10862 SetLiquidType(curr_type * 2);
10863 //AddWet(1);
10864 //PrintVariables();
10865 }
10866
10867 else if (action_id == EActions.LIQUIDTYPE_DOWN)
10868 {
10869 int curr_type2 = GetLiquidType();
10870 SetLiquidType(curr_type2 / 2);
10871 }
10872
10873 else if (action_id == EActions.MAKE_SPECIAL)
10874 {
10875 auto debugParams = DebugSpawnParams.WithPlayer(player);
10876 OnDebugSpawnEx(debugParams);
10877 }
10878
10879 }
10880
10881
10882 return false;
10883 }
10884
10885 // -------------------------------------------------------------------------
10886
10887
10890 void OnActivatedByTripWire();
10891
10893 void OnActivatedByItem(notnull ItemBase item);
10894
10895 //----------------------------------------------------------------
10896 //returns true if item is able to explode when put in fire
10897 bool CanExplodeInFire()
10898 {
10899 return false;
10900 }
10901
10902 //----------------------------------------------------------------
10903 bool CanEat()
10904 {
10905 return true;
10906 }
10907
10908 //----------------------------------------------------------------
10909 override bool IsIgnoredByConstruction()
10910 {
10911 return true;
10912 }
10913
10914 //----------------------------------------------------------------
10915 //has FoodStages in config?
10916 bool HasFoodStage()
10917 {
10918 string config_path = string.Format("CfgVehicles %1 Food FoodStages", GetType());
10919 return GetGame().ConfigIsExisting(config_path);
10920 }
10921
10923 FoodStage GetFoodStage()
10924 {
10925 return null;
10926 }
10927
10928 bool CanBeCooked()
10929 {
10930 return false;
10931 }
10932
10933 bool CanBeCookedOnStick()
10934 {
10935 return false;
10936 }
10937
10939 void RefreshAudioVisualsOnClient( CookingMethodType cooking_method, bool is_done, bool is_empty, bool is_burned );
10941
10942 //----------------------------------------------------------------
10943 bool CanRepair(ItemBase item_repair_kit)
10944 {
10945 PluginRepairing module_repairing = PluginRepairing.Cast(GetPlugin(PluginRepairing));
10946 return module_repairing.CanRepair(this, item_repair_kit);
10947 }
10948
10949 //----------------------------------------------------------------
10950 bool Repair(PlayerBase player, ItemBase item_repair_kit, float specialty_weight)
10951 {
10952 PluginRepairing module_repairing = PluginRepairing.Cast(GetPlugin(PluginRepairing));
10953 return module_repairing.Repair(player, this, item_repair_kit, specialty_weight);
10954 }
10955
10956 //----------------------------------------------------------------
10957 int GetItemSize()
10958 {
10959 /*
10960 vector v_size = this.ConfigGetVector("itemSize");
10961 int v_size_x = v_size[0];
10962 int v_size_y = v_size[1];
10963 int size = v_size_x * v_size_y;
10964 return size;
10965 */
10966
10967 return 1;
10968 }
10969
10970 //----------------------------------------------------------------
10971 //Override for allowing seemingly unallowed moves when two clients send a conflicting message simultaneously
10972 bool CanBeMovedOverride()
10973 {
10974 return m_CanBeMovedOverride;
10975 }
10976
10977 //----------------------------------------------------------------
10978 //Override for allowing seemingly unallowed moves when two clients send a conflicting message simultaneously
10979 void SetCanBeMovedOverride(bool setting)
10980 {
10981 m_CanBeMovedOverride = setting;
10982 }
10983
10984 //----------------------------------------------------------------
10992 void MessageToOwnerStatus(string text)
10993 {
10994 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
10995
10996 if (player)
10997 {
10998 player.MessageStatus(text);
10999 }
11000 }
11001
11002 //----------------------------------------------------------------
11010 void MessageToOwnerAction(string text)
11011 {
11012 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
11013
11014 if (player)
11015 {
11016 player.MessageAction(text);
11017 }
11018 }
11019
11020 //----------------------------------------------------------------
11028 void MessageToOwnerFriendly(string text)
11029 {
11030 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
11031
11032 if (player)
11033 {
11034 player.MessageFriendly(text);
11035 }
11036 }
11037
11038 //----------------------------------------------------------------
11046 void MessageToOwnerImportant(string text)
11047 {
11048 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
11049
11050 if (player)
11051 {
11052 player.MessageImportant(text);
11053 }
11054 }
11055
11056 override bool IsItemBase()
11057 {
11058 return true;
11059 }
11060
11061 // Checks if item is of questioned kind
11062 override bool KindOf(string tag)
11063 {
11064 bool found = false;
11065 string item_name = this.GetType();
11066 ref TStringArray item_tag_array = new TStringArray;
11067 GetGame().ConfigGetTextArray("cfgVehicles " + item_name + " itemInfo", item_tag_array);
11068
11069 int array_size = item_tag_array.Count();
11070 for (int i = 0; i < array_size; i++)
11071 {
11072 if (item_tag_array.Get(i) == tag)
11073 {
11074 found = true;
11075 break;
11076 }
11077 }
11078 return found;
11079 }
11080
11081
11082 override void OnRPC(PlayerIdentity sender, int rpc_type,ParamsReadContext ctx)
11083 {
11084 //Debug.Log("OnRPC called");
11085 super.OnRPC(sender, rpc_type,ctx);
11086
11087 //Play soundset for attachment locking (ActionLockAttachment.c)
11088 switch (rpc_type)
11089 {
11090 #ifndef SERVER
11091 case ERPCs.RPC_SOUND_LOCK_ATTACH:
11092 Param2<bool, string> p = new Param2<bool, string>(false, "");
11093
11094 if (!ctx.Read(p))
11095 return;
11096
11097 bool play = p.param1;
11098 string soundSet = p.param2;
11099
11100 if (play)
11101 {
11102 if (m_LockingSound)
11103 {
11105 {
11106 m_LockingSound = SEffectManager.PlaySound(soundSet, GetPosition(), 0, 0, true);
11107 }
11108 }
11109 else
11110 {
11111 m_LockingSound = SEffectManager.PlaySound(soundSet, GetPosition(), 0, 0, true);
11112 }
11113 }
11114 else
11115 {
11116 SEffectManager.DestroyEffect(m_LockingSound);
11117 }
11118
11119 break;
11120 #endif
11121
11122 }
11123
11124 if (GetWrittenNoteData())
11125 {
11126 GetWrittenNoteData().OnRPC(sender, rpc_type,ctx);
11127 }
11128 }
11129
11130 //-----------------------------
11131 // VARIABLE MANIPULATION SYSTEM
11132 //-----------------------------
11133 int NameToID(string name)
11134 {
11135 PluginVariables plugin = PluginVariables.Cast(GetPlugin(PluginVariables));
11136 return plugin.GetID(name);
11137 }
11138
11139 string IDToName(int id)
11140 {
11141 PluginVariables plugin = PluginVariables.Cast(GetPlugin(PluginVariables));
11142 return plugin.GetName(id);
11143 }
11144
11146 void OnSyncVariables(ParamsReadContext ctx)//with ID optimization
11147 {
11148 //Debug.Log("OnSyncVariables called for item: "+ ToString(this.GetType()),"varSync");
11149 //read the flags
11150 int varFlags;
11151 if (!ctx.Read(varFlags))
11152 return;
11153
11154 if (varFlags & ItemVariableFlags.FLOAT)
11155 {
11156 ReadVarsFromCTX(ctx);
11157 }
11158 }
11159
11160 override void SerializeNumericalVars(array<float> floats_out)
11161 {
11162 //some variables handled on EntityAI level already!
11163 super.SerializeNumericalVars(floats_out);
11164
11165 // the order of serialization must be the same as the order of de-serialization
11166 //--------------------------------------------
11167 if (IsVariableSet(VARIABLE_QUANTITY))
11168 {
11169 floats_out.Insert(m_VarQuantity);
11170 }
11171 //--------------------------------------------
11172 if (IsVariableSet(VARIABLE_WET))
11173 {
11174 floats_out.Insert(m_VarWet);
11175 }
11176 //--------------------------------------------
11177 if (IsVariableSet(VARIABLE_LIQUIDTYPE))
11178 {
11179 floats_out.Insert(m_VarLiquidType);
11180 }
11181 //--------------------------------------------
11182 if (IsVariableSet(VARIABLE_COLOR))
11183 {
11184 floats_out.Insert(m_ColorComponentR);
11185 floats_out.Insert(m_ColorComponentG);
11186 floats_out.Insert(m_ColorComponentB);
11187 floats_out.Insert(m_ColorComponentA);
11188 }
11189 //--------------------------------------------
11190 if (IsVariableSet(VARIABLE_CLEANNESS))
11191 {
11192 floats_out.Insert(m_Cleanness);
11193 }
11194 }
11195
11196 override void DeSerializeNumericalVars(array<float> floats)
11197 {
11198 //some variables handled on EntityAI level already!
11199 super.DeSerializeNumericalVars(floats);
11200
11201 // the order of serialization must be the same as the order of de-serialization
11202 int index = 0;
11203 int mask = Math.Round(floats.Get(index));
11204
11205 index++;
11206 //--------------------------------------------
11207 if (mask & VARIABLE_QUANTITY)
11208 {
11209 if (m_IsStoreLoad)
11210 {
11211 SetStoreLoadedQuantity(floats.Get(index));
11212 }
11213 else
11214 {
11215 float quantity = floats.Get(index);
11216 SetQuantity(quantity, true, false, false, false);
11217 }
11218 index++;
11219 }
11220 //--------------------------------------------
11221 if (mask & VARIABLE_WET)
11222 {
11223 float wet = floats.Get(index);
11224 SetWet(wet);
11225 index++;
11226 }
11227 //--------------------------------------------
11228 if (mask & VARIABLE_LIQUIDTYPE)
11229 {
11230 int liquidtype = Math.Round(floats.Get(index));
11231 SetLiquidType(liquidtype);
11232 index++;
11233 }
11234 //--------------------------------------------
11235 if (mask & VARIABLE_COLOR)
11236 {
11237 m_ColorComponentR = Math.Round(floats.Get(index));
11238 index++;
11239 m_ColorComponentG = Math.Round(floats.Get(index));
11240 index++;
11241 m_ColorComponentB = Math.Round(floats.Get(index));
11242 index++;
11243 m_ColorComponentA = Math.Round(floats.Get(index));
11244 index++;
11245 }
11246 //--------------------------------------------
11247 if (mask & VARIABLE_CLEANNESS)
11248 {
11249 int cleanness = Math.Round(floats.Get(index));
11250 SetCleanness(cleanness);
11251 index++;
11252 }
11253 }
11254
11255 override void WriteVarsToCTX(ParamsWriteContext ctx)
11256 {
11257 super.WriteVarsToCTX(ctx);
11258
11259 //--------------------------------------------
11260 if (IsVariableSet(VARIABLE_QUANTITY))
11261 {
11262 ctx.Write(GetQuantity());
11263 }
11264 //--------------------------------------------
11265 if (IsVariableSet(VARIABLE_WET))
11266 {
11267 ctx.Write(GetWet());
11268 }
11269 //--------------------------------------------
11270 if (IsVariableSet(VARIABLE_LIQUIDTYPE))
11271 {
11272 ctx.Write(GetLiquidType());
11273 }
11274 //--------------------------------------------
11275 if (IsVariableSet(VARIABLE_COLOR))
11276 {
11277 int r,g,b,a;
11278 GetColor(r,g,b,a);
11279 ctx.Write(r);
11280 ctx.Write(g);
11281 ctx.Write(b);
11282 ctx.Write(a);
11283 }
11284 //--------------------------------------------
11285 if (IsVariableSet(VARIABLE_CLEANNESS))
11286 {
11287 ctx.Write(GetCleanness());
11288 }
11289 }
11290
11291 override bool ReadVarsFromCTX(ParamsReadContext ctx, int version = -1)//with ID optimization
11292 {
11293 if (!super.ReadVarsFromCTX(ctx,version))
11294 return false;
11295
11296 int intValue;
11297 float value;
11298
11299 if (version < 140)
11300 {
11301 if (!ctx.Read(intValue))
11302 return false;
11303
11304 m_VariablesMask = intValue;
11305 }
11306
11307 if (m_VariablesMask & VARIABLE_QUANTITY)
11308 {
11309 if (!ctx.Read(value))
11310 return false;
11311
11312 if (IsStoreLoad())
11313 {
11315 }
11316 else
11317 {
11318 SetQuantity(value, true, false, false, false);
11319 }
11320 }
11321 //--------------------------------------------
11322 if (version < 140)
11323 {
11324 if (m_VariablesMask & VARIABLE_TEMPERATURE)
11325 {
11326 if (!ctx.Read(value))
11327 return false;
11328 SetTemperatureDirect(value);
11329 }
11330 }
11331 //--------------------------------------------
11332 if (m_VariablesMask & VARIABLE_WET)
11333 {
11334 if (!ctx.Read(value))
11335 return false;
11336 SetWet(value);
11337 }
11338 //--------------------------------------------
11339 if (m_VariablesMask & VARIABLE_LIQUIDTYPE)
11340 {
11341 if (!ctx.Read(intValue))
11342 return false;
11343 SetLiquidType(intValue);
11344 }
11345 //--------------------------------------------
11346 if (m_VariablesMask & VARIABLE_COLOR)
11347 {
11348 int r,g,b,a;
11349 if (!ctx.Read(r))
11350 return false;
11351 if (!ctx.Read(g))
11352 return false;
11353 if (!ctx.Read(b))
11354 return false;
11355 if (!ctx.Read(a))
11356 return false;
11357
11358 SetColor(r,g,b,a);
11359 }
11360 //--------------------------------------------
11361 if (m_VariablesMask & VARIABLE_CLEANNESS)
11362 {
11363 if (!ctx.Read(intValue))
11364 return false;
11365 SetCleanness(intValue);
11366 }
11367 //--------------------------------------------
11368 if (version >= 138 && version < 140)
11369 {
11370 if (m_VariablesMask & VARIABLE_TEMPERATURE)
11371 {
11372 if (!ctx.Read(intValue))
11373 return false;
11374 SetFrozen(intValue);
11375 }
11376 }
11377
11378 return true;
11379 }
11380
11381 //----------------------------------------------------------------
11382 override bool OnStoreLoad(ParamsReadContext ctx, int version)
11383 {
11384 m_IsStoreLoad = true;
11386 {
11387 m_FixDamageSystemInit = true;
11388 }
11389
11390 if (!super.OnStoreLoad(ctx, version))
11391 {
11392 m_IsStoreLoad = false;
11393 return false;
11394 }
11395
11396 if (version >= 114)
11397 {
11398 bool hasQuickBarIndexSaved;
11399
11400 if (!ctx.Read(hasQuickBarIndexSaved))
11401 {
11402 m_IsStoreLoad = false;
11403 return false;
11404 }
11405
11406 if (hasQuickBarIndexSaved)
11407 {
11408 int itmQBIndex;
11409
11410 //Load quickbar item bind
11411 if (!ctx.Read(itmQBIndex))
11412 {
11413 m_IsStoreLoad = false;
11414 return false;
11415 }
11416
11417 PlayerBase parentPlayer = PlayerBase.Cast(GetHierarchyRootPlayer());
11418 if (itmQBIndex != -1 && parentPlayer)
11419 parentPlayer.SetLoadedQuickBarItemBind(this, itmQBIndex);
11420 }
11421 }
11422 else
11423 {
11424 // Backup of how it used to be
11425 PlayerBase player;
11426 int itemQBIndex;
11427 if (version == int.MAX)
11428 {
11429 if (!ctx.Read(itemQBIndex))
11430 {
11431 m_IsStoreLoad = false;
11432 return false;
11433 }
11434 }
11435 else if (Class.CastTo(player, GetHierarchyRootPlayer()))
11436 {
11437 //Load quickbar item bind
11438 if (!ctx.Read(itemQBIndex))
11439 {
11440 m_IsStoreLoad = false;
11441 return false;
11442 }
11443 if (itemQBIndex != -1 && player)
11444 player.SetLoadedQuickBarItemBind(this,itemQBIndex);
11445 }
11446 }
11447
11448 if (version < 140)
11449 {
11450 // variable management system
11451 if (!LoadVariables(ctx, version))
11452 {
11453 m_IsStoreLoad = false;
11454 return false;
11455 }
11456 }
11457
11458 //agent trasmission system
11459 if (!LoadAgents(ctx, version))
11460 {
11461 m_IsStoreLoad = false;
11462 return false;
11463 }
11464 if (version >= 132)
11465 {
11466 RemotelyActivatedItemBehaviour raib = GetRemotelyActivatedItemBehaviour();
11467 if (raib)
11468 {
11469 if (!raib.OnStoreLoad(ctx,version))
11470 {
11471 m_IsStoreLoad = false;
11472 return false;
11473 }
11474 }
11475 }
11476
11477 m_IsStoreLoad = false;
11478 return true;
11479 }
11480
11481 //----------------------------------------------------------------
11482
11483 override void OnStoreSave(ParamsWriteContext ctx)
11484 {
11485 super.OnStoreSave(ctx);
11486
11487 PlayerBase player;
11488 if (PlayerBase.CastTo(player,GetHierarchyRootPlayer()))
11489 {
11490 ctx.Write(true); // Keep track of if we should actually read this in or not
11491 //Save quickbar item bind
11492 int itemQBIndex = -1;
11493 itemQBIndex = player.FindQuickBarEntityIndex(this);
11494 ctx.Write(itemQBIndex);
11495 }
11496 else
11497 {
11498 ctx.Write(false); // Keep track of if we should actually read this in or not
11499 }
11500
11501 SaveAgents(ctx);//agent trasmission system
11502
11503 RemotelyActivatedItemBehaviour raib = GetRemotelyActivatedItemBehaviour();
11504 if (raib)
11505 {
11506 raib.OnStoreSave(ctx);
11507 }
11508 }
11509 //----------------------------------------------------------------
11510
11511 override void AfterStoreLoad()
11512 {
11513 super.AfterStoreLoad();
11514
11516 {
11518 }
11519
11520 if (GetStoreLoadedQuantity() != float.LOWEST)
11521 {
11523 SetStoreLoadedQuantity(float.LOWEST);//IMPORTANT to do this !! we use 'm_StoreLoadedQuantity' inside SetQuantity to distinguish between initial quantity setting and the consequent(normal gameplay) calls
11524 }
11525 }
11526
11527 override void EEOnAfterLoad()
11528 {
11529 super.EEOnAfterLoad();
11530
11532 {
11533 m_FixDamageSystemInit = false;
11534 }
11535
11538 }
11539
11540 bool CanBeDisinfected()
11541 {
11542 return false;
11543 }
11544
11545
11546 //----------------------------------------------------------------
11547 override void OnVariablesSynchronized()
11548 {
11549 if (m_Initialized)
11550 {
11551 #ifdef PLATFORM_CONSOLE
11552 //bruteforce it is
11553 if (IsSplitable())
11554 {
11555 UIScriptedMenu menu = GetGame().GetUIManager().FindMenu(MENU_INVENTORY);
11556 if (menu)
11557 {
11558 menu.Refresh();
11559 }
11560 }
11561 #endif
11562 }
11563
11565 {
11566 PlayImpactSound(m_ConfigWeight, m_ImpactSpeed, m_ImpactSoundSurfaceHash);
11567 m_WantPlayImpactSound = false;
11568 }
11569
11571 {
11572 SetWeightDirty();
11574 }
11575 if (m_VarWet != m_VarWetPrev)
11576 {
11579 }
11580
11581 if (m_SoundSyncPlay != 0)
11582 {
11583 m_ItemSoundHandler.PlayItemSoundClient(m_SoundSyncPlay);
11584 m_SoundSyncPlay = 0;
11585 }
11586 if (m_SoundSyncStop != 0)
11587 {
11588 m_ItemSoundHandler.StopItemSoundClient(m_SoundSyncStop);
11589 m_SoundSyncStop = 0;
11590 }
11591
11592 super.OnVariablesSynchronized();
11593 }
11594
11595 //------------------------- Quantity
11596 //----------------------------------------------------------------
11598 override bool SetQuantity(float value, bool destroy_config = true, bool destroy_forced = false, bool allow_client = false, bool clamp_to_stack_max = true)
11599 {
11600 if (!IsServerCheck(allow_client))
11601 return false;
11602
11603 if (!HasQuantity())
11604 return false;
11605
11606 float min = GetQuantityMin();
11607 float max = GetQuantityMax();
11608
11609 if (value <= (min + 0.001))
11610 value = min;
11611
11612 if (value == min)
11613 {
11614 if (destroy_config)
11615 {
11616 bool dstr = ConfigGetBool("varQuantityDestroyOnMin");
11617 if (dstr)
11618 {
11619 m_VarQuantity = Math.Clamp(value, min, max);
11620 this.Delete();
11621 return true;
11622 }
11623 }
11624 else if (destroy_forced)
11625 {
11626 m_VarQuantity = Math.Clamp(value, min, max);
11627 this.Delete();
11628 return true;
11629 }
11630 // we get here if destroy_config IS true AND dstr(config destroy param) IS false;
11631 RemoveAllAgents();//we remove all agents when we got to the min value, but the item is not getting deleted
11632 }
11633
11634 float delta = m_VarQuantity;
11635 m_VarQuantity = Math.Clamp(value, min, max);
11636
11637 if (GetStoreLoadedQuantity() == float.LOWEST)//any other value means we are setting quantity from storage
11638 {
11639 delta = m_VarQuantity - delta;
11640
11641 if (delta)
11642 OnQuantityChanged(delta);
11643 }
11644
11645 SetVariableMask(VARIABLE_QUANTITY);
11646
11647 return false;
11648 }
11649
11650 //----------------------------------------------------------------
11652 bool AddQuantity(float value, bool destroy_config = true, bool destroy_forced = false)
11653 {
11654 return SetQuantity(GetQuantity() + value, destroy_config, destroy_forced);
11655 }
11656 //----------------------------------------------------------------
11657 void SetQuantityMax()
11658 {
11659 float max = GetQuantityMax();
11660 SetQuantity(max);
11661 }
11662
11663 override void SetQuantityToMinimum()
11664 {
11665 float min = GetQuantityMin();
11666 SetQuantity(min);
11667 }
11668 //----------------------------------------------------------------
11670 override void SetQuantityNormalized(float value, bool destroy_config = true, bool destroy_forced = false)
11671 {
11672 float value_clamped = Math.Clamp(value, 0, 1);//just to make sure
11673 int result = Math.Round(Math.Lerp(GetQuantityMin(), GetQuantityMax(), value_clamped));
11674 SetQuantity(result, destroy_config, destroy_forced);
11675 }
11676
11677 //----------------------------------------------------------------
11679 override float GetQuantityNormalized()
11680 {
11681 return Math.InverseLerp(GetQuantityMin(), GetQuantityMax(),m_VarQuantity);
11682 }
11683
11685 {
11686 return GetQuantityNormalized();
11687 }
11688
11689 /*void SetAmmoNormalized(float value)
11690 {
11691 float value_clamped = Math.Clamp(value, 0, 1);
11692 Magazine this_mag = Magazine.Cast(this);
11693 int max_rounds = this_mag.GetAmmoMax();
11694 int result = value * max_rounds;//can the rounded if higher precision is required
11695 this_mag.SetAmmoCount(result);
11696 }*/
11697 //----------------------------------------------------------------
11698 override int GetQuantityMax()
11699 {
11700 int slot = -1;
11701 if (GetInventory())
11702 {
11703 InventoryLocation il = new InventoryLocation;
11704 GetInventory().GetCurrentInventoryLocation(il);
11705 slot = il.GetSlot();
11706 }
11707
11708 return GetTargetQuantityMax(slot);
11709 }
11710
11711 override int GetTargetQuantityMax(int attSlotID = -1)
11712 {
11713 float quantity_max = 0;
11714
11715 if (IsSplitable()) //only stackable/splitable items can check for stack size
11716 {
11717 if (attSlotID != -1)
11718 quantity_max = InventorySlots.GetStackMaxForSlotId(attSlotID);
11719
11720 if (quantity_max <= 0)
11721 quantity_max = m_VarStackMax;
11722 }
11723
11724 if (quantity_max <= 0)
11725 quantity_max = m_VarQuantityMax;
11726
11727 return quantity_max;
11728 }
11729 //----------------------------------------------------------------
11730 override int GetQuantityMin()
11731 {
11732 return m_VarQuantityMin;
11733 }
11734 //----------------------------------------------------------------
11735 int GetQuantityInit()
11736 {
11737 return m_VarQuantityInit;
11738 }
11739
11740 //----------------------------------------------------------------
11741 override bool HasQuantity()
11742 {
11743 return !(GetQuantityMax() - GetQuantityMin() == 0);
11744 }
11745
11746 override float GetQuantity()
11747 {
11748 return m_VarQuantity;
11749 }
11750
11751 bool IsFullQuantity()
11752 {
11753 return GetQuantity() >= GetQuantityMax();
11754 }
11755
11756 //Calculates weight of single item without attachments and cargo
11757 override float GetSingleInventoryItemWeightEx()
11758 {
11759 //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
11760 float weightEx = GetWeightEx();//overall weight of the item
11761 float special = GetInventoryAndCargoWeight();//cargo and attachment weight
11762 return weightEx - special;
11763 }
11764
11765 // Obsolete, use GetSingleInventoryItemWeightEx() instead
11767 {
11769 }
11770
11771 override protected float GetWeightSpecialized(bool forceRecalc = false)
11772 {
11773 if (IsSplitable()) //quantity determines size of the stack
11774 {
11775 #ifdef DEVELOPER
11776 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
11777 {
11778 WeightDebugData data1 = WeightDebug.GetWeightDebug(this);
11779 data1.SetCalcDetails("TIB1: " + GetConfigWeightModifiedDebugText() +" * " + GetQuantity()+"(quantity)");
11780 }
11781 #endif
11782
11783 return GetQuantity() * GetConfigWeightModified();
11784 }
11785 else if (HasEnergyManager())// items with energy manager
11786 {
11787 #ifdef DEVELOPER
11788 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
11789 {
11790 WeightDebugData data2 = WeightDebug.GetWeightDebug(this);
11791 data2.SetCalcDetails("TIB2: "+super.GetWeightSpecialized(forceRecalc)+"(contents weight) + " + GetConfigWeightModifiedDebugText() +" + " + GetCompEM().GetEnergy()+"(energy) * " + ConfigGetFloat("weightPerQuantityUnit") +"(weightPerQuantityUnit)");
11792 }
11793 #endif
11794 return super.GetWeightSpecialized(forceRecalc) + (GetCompEM().GetEnergy() * ConfigGetFloat("weightPerQuantityUnit")) + GetConfigWeightModified();
11795 }
11796 else//everything else
11797 {
11798 #ifdef DEVELOPER
11799 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
11800 {
11801 WeightDebugData data3 = WeightDebug.GetWeightDebug(this);
11802 data3.SetCalcDetails("TIB3: "+super.GetWeightSpecialized(forceRecalc)+"(contents weight) + " + GetConfigWeightModifiedDebugText() +" + " + GetQuantity()+"(quantity) * " + ConfigGetFloat("weightPerQuantityUnit") +"(weightPerQuantityUnit))");
11803 }
11804 #endif
11805 return super.GetWeightSpecialized(forceRecalc) + (GetQuantity() * ConfigGetFloat("weightPerQuantityUnit")) + GetConfigWeightModified();
11806 }
11807 }
11808
11810 int GetNumberOfItems()
11811 {
11812 int item_count = 0;
11813 ItemBase item;
11814
11815 if (GetInventory().GetCargo() != NULL)
11816 {
11817 item_count = GetInventory().GetCargo().GetItemCount();
11818 }
11819
11820 for (int i = 0; i < GetInventory().AttachmentCount(); i++)
11821 {
11822 Class.CastTo(item,GetInventory().GetAttachmentFromIndex(i));
11823 if (item)
11824 item_count += item.GetNumberOfItems();
11825 }
11826 return item_count;
11827 }
11828
11830 float GetUnitWeight(bool include_wetness = true)
11831 {
11832 float weight = 0;
11833 float wetness = 1;
11834 if (include_wetness)
11835 wetness += GetWet();
11836 if (IsSplitable()) //quantity determines size of the stack
11837 {
11838 weight = wetness * m_ConfigWeight;
11839 }
11840 else if (IsLiquidContainer()) //is a liquid container, default liquid weight is set to 1. May revisit later?
11841 {
11842 weight = 1;
11843 }
11844 return weight;
11845 }
11846
11847 //-----------------------------------------------------------------
11848
11849 override void ClearInventory()
11850 {
11851 if ((GetGame().IsServer() || !GetGame().IsMultiplayer()) && GetInventory())
11852 {
11853 GameInventory inv = GetInventory();
11854 array<EntityAI> items = new array<EntityAI>;
11855 inv.EnumerateInventory(InventoryTraversalType.INORDER, items);
11856 for (int i = 0; i < items.Count(); i++)
11857 {
11858 ItemBase item = ItemBase.Cast(items.Get(i));
11859 if (item)
11860 {
11861 GetGame().ObjectDelete(item);
11862 }
11863 }
11864 }
11865 }
11866
11867 //------------------------- Energy
11868
11869 //----------------------------------------------------------------
11870 float GetEnergy()
11871 {
11872 float energy = 0;
11873 if (HasEnergyManager())
11874 {
11875 energy = GetCompEM().GetEnergy();
11876 }
11877 return energy;
11878 }
11879
11880
11881 override void OnEnergyConsumed()
11882 {
11883 super.OnEnergyConsumed();
11884
11886 }
11887
11888 override void OnEnergyAdded()
11889 {
11890 super.OnEnergyAdded();
11891
11893 }
11894
11895 // Converts energy (from Energy Manager) to quantity, if enabled.
11897 {
11898 if (GetGame().IsServer() && HasEnergyManager() && GetCompEM().HasConversionOfEnergyToQuantity())
11899 {
11900 if (HasQuantity())
11901 {
11902 float energy_0to1 = GetCompEM().GetEnergy0To1();
11903 SetQuantityNormalized(energy_0to1);
11904 }
11905 }
11906 }
11907
11908 //----------------------------------------------------------------
11909 float GetHeatIsolationInit()
11910 {
11911 return ConfigGetFloat("heatIsolation");
11912 }
11913
11914 float GetHeatIsolation()
11915 {
11916 return m_HeatIsolation;
11917 }
11918
11919 float GetDryingIncrement(string pIncrementName)
11920 {
11921 string paramPath = string.Format("CfgVehicles %1 EnvironmentWetnessIncrements Drying %2", GetType(), pIncrementName);
11922 if (GetGame().ConfigIsExisting(paramPath))
11923 return GetGame().ConfigGetFloat(paramPath);
11924
11925 return 0.0;
11926 }
11927
11928 float GetSoakingIncrement(string pIncrementName)
11929 {
11930 string paramPath = string.Format("CfgVehicles %1 EnvironmentWetnessIncrements Soaking %2", GetType(), pIncrementName);
11931 if (GetGame().ConfigIsExisting(paramPath))
11932 return GetGame().ConfigGetFloat(paramPath);
11933
11934 return 0.0;
11935 }
11936 //----------------------------------------------------------------
11937 override void SetWet(float value, bool allow_client = false)
11938 {
11939 if (!IsServerCheck(allow_client))
11940 return;
11941
11942 float min = GetWetMin();
11943 float max = GetWetMax();
11944
11945 float previousValue = m_VarWet;
11946
11947 m_VarWet = Math.Clamp(value, min, max);
11948
11949 if (previousValue != m_VarWet)
11950 {
11951 SetVariableMask(VARIABLE_WET);
11952 OnWetChanged(m_VarWet, previousValue);
11953 }
11954 }
11955 //----------------------------------------------------------------
11956 override void AddWet(float value)
11957 {
11958 SetWet(GetWet() + value);
11959 }
11960 //----------------------------------------------------------------
11961 override void SetWetMax()
11962 {
11964 }
11965 //----------------------------------------------------------------
11966 override float GetWet()
11967 {
11968 return m_VarWet;
11969 }
11970 //----------------------------------------------------------------
11971 override float GetWetMax()
11972 {
11973 return m_VarWetMax;
11974 }
11975 //----------------------------------------------------------------
11976 override float GetWetMin()
11977 {
11978 return m_VarWetMin;
11979 }
11980 //----------------------------------------------------------------
11981 override float GetWetInit()
11982 {
11983 return m_VarWetInit;
11984 }
11985 //----------------------------------------------------------------
11986 override void OnWetChanged(float newVal, float oldVal)
11987 {
11988 EWetnessLevel newLevel = GetWetLevelInternal(newVal);
11989 EWetnessLevel oldLevel = GetWetLevelInternal(oldVal);
11990 if (newLevel != oldLevel)
11991 {
11992 OnWetLevelChanged(newLevel,oldLevel);
11993 }
11994 }
11995
11996 override void OnWetLevelChanged(EWetnessLevel newLevel, EWetnessLevel oldLevel)
11997 {
11998 SetWeightDirty();
11999 }
12000
12001 override EWetnessLevel GetWetLevel()
12002 {
12003 return GetWetLevelInternal(m_VarWet);
12004 }
12005
12006 //----------------------------------------------------------------
12007
12008 override void SetStoreLoad(bool value)
12009 {
12010 m_IsStoreLoad = value;
12011 }
12012
12013 override bool IsStoreLoad()
12014 {
12015 return m_IsStoreLoad;
12016 }
12017
12018 override void SetStoreLoadedQuantity(float value)
12019 {
12020 m_StoreLoadedQuantity = value;
12021 }
12022
12023 override float GetStoreLoadedQuantity()
12024 {
12025 return m_StoreLoadedQuantity;
12026 }
12027
12028 //----------------------------------------------------------------
12029
12030 float GetItemModelLength()
12031 {
12032 if (ConfigIsExisting("itemModelLength"))
12033 {
12034 return ConfigGetFloat("itemModelLength");
12035 }
12036 return 0;
12037 }
12038
12039 float GetItemAttachOffset()
12040 {
12041 if (ConfigIsExisting("itemAttachOffset"))
12042 {
12043 return ConfigGetFloat("itemAttachOffset");
12044 }
12045 return 0;
12046 }
12047
12048 override void SetCleanness(int value, bool allow_client = false)
12049 {
12050 if (!IsServerCheck(allow_client))
12051 return;
12052
12053 int previousValue = m_Cleanness;
12054
12055 m_Cleanness = Math.Clamp(value, m_CleannessMin, m_CleannessMax);
12056
12057 if (previousValue != m_Cleanness)
12058 SetVariableMask(VARIABLE_CLEANNESS);
12059 }
12060
12061 override int GetCleanness()
12062 {
12063 return m_Cleanness;
12064 }
12065
12067 {
12068 return true;
12069 }
12070
12071 //----------------------------------------------------------------
12072 // ATTACHMENT LOCKING
12073 // Getters relevant to generic ActionLockAttachment
12074 int GetLockType()
12075 {
12076 return m_LockType;
12077 }
12078
12079 string GetLockSoundSet()
12080 {
12081 return m_LockSoundSet;
12082 }
12083
12084 //----------------------------------------------------------------
12085 //------------------------- Color
12086 // sets items color variable given color components
12087 override void SetColor(int r, int g, int b, int a)
12088 {
12093 SetVariableMask(VARIABLE_COLOR);
12094 }
12096 override void GetColor(out int r,out int g,out int b,out int a)
12097 {
12102 }
12103
12104 bool IsColorSet()
12105 {
12106 return IsVariableSet(VARIABLE_COLOR);
12107 }
12108
12110 string GetColorString()
12111 {
12112 int r,g,b,a;
12113 GetColor(r,g,b,a);
12114 r = r/255;
12115 g = g/255;
12116 b = b/255;
12117 a = a/255;
12118 return MiscGameplayFunctions.GetColorString(r, g, b, a);
12119 }
12120 //----------------------------------------------------------------
12121 //------------------------- LiquidType
12122
12123 override void SetLiquidType(int value, bool allow_client = false)
12124 {
12125 if (!IsServerCheck(allow_client))
12126 return;
12127
12128 int old = m_VarLiquidType;
12129 m_VarLiquidType = value;
12130 OnLiquidTypeChanged(old,value);
12131 SetVariableMask(VARIABLE_LIQUIDTYPE);
12132 }
12133
12134 int GetLiquidTypeInit()
12135 {
12136 return ConfigGetInt("varLiquidTypeInit");
12137 }
12138
12139 override int GetLiquidType()
12140 {
12141 return m_VarLiquidType;
12142 }
12143
12144 protected void OnLiquidTypeChanged(int oldType, int newType)
12145 {
12146 if (newType == LIQUID_NONE && GetIsFrozen())
12147 SetFrozen(false);
12148 }
12149
12151 void UpdateQuickbarShortcutVisibility(PlayerBase player)
12152 {
12153 player.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
12154 }
12155
12156 // -------------------------------------------------------------------------
12158 void OnInventoryEnter(Man player)
12159 {
12160 PlayerBase nplayer;
12161 if (PlayerBase.CastTo(nplayer, player))
12162 {
12163 m_CanPlayImpactSound = true;
12164 //nplayer.OnItemInventoryEnter(this);
12165 nplayer.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
12166 }
12167 }
12168
12169 // -------------------------------------------------------------------------
12171 void OnInventoryExit(Man player)
12172 {
12173 PlayerBase nplayer;
12174 if (PlayerBase.CastTo(nplayer,player))
12175 {
12176 //nplayer.OnItemInventoryExit(this);
12177 nplayer.SetEnableQuickBarEntityShortcut(this,false);
12178
12179 }
12180
12181 //if (!GetGame().IsDedicatedServer())
12182 player.GetHumanInventory().ClearUserReservedLocationForContainer(this);
12183
12184
12185 if (HasEnergyManager())
12186 {
12187 GetCompEM().UpdatePlugState(); // Unplug the el. device if it's necesarry.
12188 }
12189 }
12190
12191 // ADVANCED PLACEMENT EVENTS
12192 override void OnPlacementStarted(Man player)
12193 {
12194 super.OnPlacementStarted(player);
12195
12196 SetTakeable(false);
12197 }
12198
12199 override void OnPlacementComplete(Man player, vector position = "0 0 0", vector orientation = "0 0 0")
12200 {
12201 if (m_AdminLog)
12202 {
12203 m_AdminLog.OnPlacementComplete(player, this);
12204 }
12205
12206 super.OnPlacementComplete(player, position, orientation);
12207 }
12208
12209 //-----------------------------
12210 // AGENT SYSTEM
12211 //-----------------------------
12212 //--------------------------------------------------------------------------
12213 bool ContainsAgent(int agent_id)
12214 {
12215 if (agent_id & m_AttachedAgents)
12216 {
12217 return true;
12218 }
12219 else
12220 {
12221 return false;
12222 }
12223 }
12224
12225 //--------------------------------------------------------------------------
12226 override void RemoveAgent(int agent_id)
12227 {
12228 if (ContainsAgent(agent_id))
12229 {
12230 m_AttachedAgents = ~agent_id & m_AttachedAgents;
12231 }
12232 }
12233
12234 //--------------------------------------------------------------------------
12235 override void RemoveAllAgents()
12236 {
12237 m_AttachedAgents = 0;
12238 }
12239 //--------------------------------------------------------------------------
12240 override void RemoveAllAgentsExcept(int agent_to_keep)
12241 {
12242 m_AttachedAgents = m_AttachedAgents & agent_to_keep;
12243 }
12244 // -------------------------------------------------------------------------
12245 override void InsertAgent(int agent, float count = 1)
12246 {
12247 if (count < 1)
12248 return;
12249 //Debug.Log("Inserting Agent on item: " + agent.ToString() +" count: " + count.ToString());
12251 }
12252
12254 void TransferAgents(int agents)
12255 {
12257 }
12258
12259 // -------------------------------------------------------------------------
12260 override int GetAgents()
12261 {
12262 return m_AttachedAgents;
12263 }
12264 //----------------------------------------------------------------------
12265
12266 /*int GetContaminationType()
12267 {
12268 int contamination_type;
12269
12270 const int CONTAMINATED_MASK = eAgents.CHOLERA | eAgents.INFLUENZA | eAgents.SALMONELLA | eAgents.BRAIN;
12271 const int POISONED_MASK = eAgents.FOOD_POISON | eAgents.CHEMICAL_POISON;
12272 const int NERVE_GAS_MASK = eAgents.CHEMICAL_POISON;
12273 const int DIRTY_MASK = eAgents.WOUND_AGENT;
12274
12275 Edible_Base edible = Edible_Base.Cast(this);
12276 int agents = GetAgents();
12277 if (edible)
12278 {
12279 NutritionalProfile profile = Edible_Base.GetNutritionalProfile(edible);
12280 if (profile)
12281 {
12282 agents = agents | profile.GetAgents();//merge item's agents with nutritional agents
12283 }
12284 }
12285 if (agents & CONTAMINATED_MASK)
12286 {
12287 contamination_type = contamination_type | EContaminationTypes.ITEM_BADGE_CONTAMINATED;
12288 }
12289 if (agents & POISONED_MASK)
12290 {
12291 contamination_type = contamination_type | EContaminationTypes.ITEM_BADGE_POISONED;
12292 }
12293 if (agents & NERVE_GAS_MASK)
12294 {
12295 contamination_type = contamination_type | EContaminationTypes.ITEM_BADGE_NERVE_GAS;
12296 }
12297 if (agents & DIRTY_MASK)
12298 {
12299 contamination_type = contamination_type | EContaminationTypes.ITEM_BADGE_DIRTY;
12300 }
12301
12302 return agents;
12303 }*/
12304
12305 // -------------------------------------------------------------------------
12306 bool LoadAgents(ParamsReadContext ctx, int version)
12307 {
12308 if (!ctx.Read(m_AttachedAgents))
12309 return false;
12310 return true;
12311 }
12312 // -------------------------------------------------------------------------
12314 {
12315
12317 }
12318 // -------------------------------------------------------------------------
12319
12321 override void CheckForRoofLimited(float timeTresholdMS = 3000)
12322 {
12323 super.CheckForRoofLimited(timeTresholdMS);
12324
12325 float time = GetGame().GetTime();
12326 if ((time - m_PreviousRoofTestTime) >= timeTresholdMS)
12327 {
12328 m_PreviousRoofTestTime = time;
12329 SetRoofAbove(MiscGameplayFunctions.IsUnderRoof(this));
12330 }
12331 }
12332
12333 // returns item's protection level against enviromental hazard, for masks with filters, returns the filters protection for valid filter, otherwise 0
12334 float GetProtectionLevel(int type, bool consider_filter = false, int system = 0)
12335 {
12336 if (IsDamageDestroyed() || (HasQuantity() && GetQuantity() <= 0))
12337 {
12338 return 0;
12339 }
12340
12341 if (GetInventory().GetAttachmentSlotsCount() != 0)//is it an item with attachable filter ?
12342 {
12343 ItemBase filter = ItemBase.Cast(FindAttachmentBySlotName("GasMaskFilter"));
12344 if (filter)
12345 return filter.GetProtectionLevel(type, false, system);//it's a valid filter, return the protection
12346 else
12347 return 0;//otherwise return 0 when no filter attached
12348 }
12349
12350 string subclassPath, entryName;
12351
12352 switch (type)
12353 {
12354 case DEF_BIOLOGICAL:
12355 entryName = "biological";
12356 break;
12357 case DEF_CHEMICAL:
12358 entryName = "chemical";
12359 break;
12360 default:
12361 entryName = "biological";
12362 break;
12363 }
12364
12365 subclassPath = "CfgVehicles " + this.GetType() + " Protection ";
12366
12367 return GetGame().ConfigGetFloat(subclassPath + entryName);
12368 }
12369
12370
12371
12373 override void EEOnCECreate()
12374 {
12375 if (!IsMagazine())
12377
12379 }
12380
12381
12382 //-------------------------
12383 // OPEN/CLOSE USER ACTIONS
12384 //-------------------------
12386 void Open();
12387 void Close();
12388 bool IsOpen()
12389 {
12390 return true;
12391 }
12392
12393 override bool CanDisplayCargo()
12394 {
12395 return IsOpen();
12396 }
12397
12398
12399 // ------------------------------------------------------------
12400 // CONDITIONS
12401 // ------------------------------------------------------------
12402 override bool CanPutInCargo(EntityAI parent)
12403 {
12404 if (parent)
12405 {
12406 if (parent.IsInherited(DayZInfected))
12407 return true;
12408
12409 if (!parent.IsRuined())
12410 return true;
12411 }
12412
12413 return true;
12414 }
12415
12416 override bool CanPutAsAttachment(EntityAI parent)
12417 {
12418 if (!super.CanPutAsAttachment(parent))
12419 {
12420 return false;
12421 }
12422
12423 if (!IsRuined() && !parent.IsRuined())
12424 {
12425 return true;
12426 }
12427
12428 return false;
12429 }
12430
12431 override bool CanReceiveItemIntoCargo(EntityAI item)
12432 {
12433 //removed 15.06. coz of loading from storage -> after load items in cargo was lost -> waiting for proper solution
12434 //if (GetHealthLevel() == GameConstants.STATE_RUINED)
12435 // return false;
12436
12437 return super.CanReceiveItemIntoCargo(item);
12438 }
12439
12440 override bool CanReceiveAttachment(EntityAI attachment, int slotId)
12441 {
12442 //removed 15.06. coz of loading from storage -> after load items in cargo was lost -> waiting for proper solution
12443 //if (GetHealthLevel() == GameConstants.STATE_RUINED)
12444 // return false;
12445
12446 GameInventory attachmentInv = attachment.GetInventory();
12447 if (attachmentInv && attachmentInv.GetCargo() && attachmentInv.GetCargo().GetItemCount() > 0)
12448 {
12449 if (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase))
12450 return false;
12451 }
12452
12453 InventoryLocation loc = new InventoryLocation();
12454 attachment.GetInventory().GetCurrentInventoryLocation(loc);
12455 if (loc && loc.IsValid() && !GetInventory().AreChildrenAccessible())
12456 return false;
12457
12458 return super.CanReceiveAttachment(attachment, slotId);
12459 }
12460
12461 override bool CanReleaseAttachment(EntityAI attachment)
12462 {
12463 if (!super.CanReleaseAttachment(attachment))
12464 return false;
12465
12466 return GetInventory().AreChildrenAccessible();
12467 }
12468
12469 /*override bool CanLoadAttachment(EntityAI attachment)
12470 {
12471 //removed 15.06. coz of loading from storage -> after load items in cargo was lost -> waiting for proper solution
12472 //if (GetHealthLevel() == GameConstants.STATE_RUINED)
12473 // return false;
12474
12475 GameInventory attachmentInv = attachment.GetInventory();
12476 if (attachmentInv && attachmentInv.GetCargo() && attachmentInv.GetCargo().GetItemCount() > 0)
12477 {
12478 bool boo = (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase));
12479 ErrorEx("CanLoadAttachment | this: " + this + " | attachment: " + attachment + " | boo: " + boo,ErrorExSeverity.INFO);
12480
12481 if (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase))
12482 return false;
12483 }
12484
12485 return super.CanLoadAttachment(attachment);
12486 }*/
12487
12488 // Plays muzzle flash particle effects
12489 static void PlayFireParticles(ItemBase weapon, int muzzle_index, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
12490 {
12491 int id = muzzle_owner.GetMuzzleID();
12492 array<ref WeaponParticlesOnFire> WPOF_array = m_OnFireEffect.Get(id);
12493
12494 if (WPOF_array)
12495 {
12496 for (int i = 0; i < WPOF_array.Count(); i++)
12497 {
12498 WeaponParticlesOnFire WPOF = WPOF_array.Get(i);
12499
12500 if (WPOF)
12501 {
12502 WPOF.OnActivate(weapon, muzzle_index, ammoType, muzzle_owner, suppressor, config_to_search);
12503 }
12504 }
12505 }
12506 }
12507
12508 // Plays bullet eject particle effects (usually just smoke, the bullet itself is a 3D model and is not part of this function)
12509 static void PlayBulletCasingEjectParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
12510 {
12511 int id = muzzle_owner.GetMuzzleID();
12512 array<ref WeaponParticlesOnBulletCasingEject> WPOBE_array = m_OnBulletCasingEjectEffect.Get(id);
12513
12514 if (WPOBE_array)
12515 {
12516 for (int i = 0; i < WPOBE_array.Count(); i++)
12517 {
12518 WeaponParticlesOnBulletCasingEject WPOBE = WPOBE_array.Get(i);
12519
12520 if (WPOBE)
12521 {
12522 WPOBE.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
12523 }
12524 }
12525 }
12526 }
12527
12528 // Plays all weapon overheating particles
12529 static void PlayOverheatingParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
12530 {
12531 int id = muzzle_owner.GetMuzzleID();
12532 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
12533
12534 if (WPOOH_array)
12535 {
12536 for (int i = 0; i < WPOOH_array.Count(); i++)
12537 {
12538 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
12539
12540 if (WPOOH)
12541 {
12542 WPOOH.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
12543 }
12544 }
12545 }
12546 }
12547
12548 // Updates all weapon overheating particles
12549 static void UpdateOverheatingParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
12550 {
12551 int id = muzzle_owner.GetMuzzleID();
12552 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
12553
12554 if (WPOOH_array)
12555 {
12556 for (int i = 0; i < WPOOH_array.Count(); i++)
12557 {
12558 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
12559
12560 if (WPOOH)
12561 {
12562 WPOOH.OnUpdate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
12563 }
12564 }
12565 }
12566 }
12567
12568 // Stops overheating particles
12569 static void StopOverheatingParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
12570 {
12571 int id = muzzle_owner.GetMuzzleID();
12572 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
12573
12574 if (WPOOH_array)
12575 {
12576 for (int i = 0; i < WPOOH_array.Count(); i++)
12577 {
12578 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
12579
12580 if (WPOOH)
12581 {
12582 WPOOH.OnDeactivate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
12583 }
12584 }
12585 }
12586 }
12587
12588 //----------------------------------------------------------------
12589 //Item Behaviour - unified approach
12590 override bool IsHeavyBehaviour()
12591 {
12592 if (m_ItemBehaviour == 0)
12593 {
12594 return true;
12595 }
12596
12597 return false;
12598 }
12599
12600 override bool IsOneHandedBehaviour()
12601 {
12602 if (m_ItemBehaviour == 1)
12603 {
12604 return true;
12605 }
12606
12607 return false;
12608 }
12609
12610 override bool IsTwoHandedBehaviour()
12611 {
12612 if (m_ItemBehaviour == 2)
12613 {
12614 return true;
12615 }
12616
12617 return false;
12618 }
12619
12620 bool IsDeployable()
12621 {
12622 return false;
12623 }
12624
12626 float GetDeployTime()
12627 {
12628 return UATimeSpent.DEFAULT_DEPLOY;
12629 }
12630
12631
12632 //----------------------------------------------------------------
12633 // Item Targeting (User Actions)
12634 override void SetTakeable(bool pState)
12635 {
12636 m_IsTakeable = pState;
12637 SetSynchDirty();
12638 }
12639
12640 override bool IsTakeable()
12641 {
12642 return m_IsTakeable;
12643 }
12644
12645 // For cases where we want to show object widget which cant be taken to hands
12647 {
12648 return false;
12649 }
12650
12652 protected void PreLoadSoundAttachmentType()
12653 {
12654 string att_type = "None";
12655
12656 if (ConfigIsExisting("soundAttType"))
12657 {
12658 att_type = ConfigGetString("soundAttType");
12659 }
12660
12661 m_SoundAttType = att_type;
12662 }
12663
12664 override string GetAttachmentSoundType()
12665 {
12666 return m_SoundAttType;
12667 }
12668
12669 //----------------------------------------------------------------
12670 //SOUNDS - ItemSoundHandler
12671 //----------------------------------------------------------------
12672
12673 string GetPlaceSoundset(); // played when deploy starts
12674 string GetLoopDeploySoundset(); // played when deploy starts and stopped when it finishes
12675 string GetDeploySoundset(); // played when deploy sucessfully finishes
12676 string GetLoopFoldSoundset(); // played when fold starts and stopped when it finishes
12677 string GetFoldSoundset(); // played when fold sucessfully finishes
12678
12680 {
12681 if (!m_ItemSoundHandler)
12683
12684 return m_ItemSoundHandler;
12685 }
12686
12687 // override to initialize sounds
12688 protected void InitItemSounds()
12689 {
12690 if (GetPlaceSoundset() == string.Empty && GetDeploySoundset() == string.Empty && GetLoopDeploySoundset() == string.Empty)
12691 return;
12692
12694
12695 if (GetPlaceSoundset() != string.Empty)
12696 handler.AddSound(SoundConstants.ITEM_PLACE, GetPlaceSoundset());
12697
12698 if (GetDeploySoundset() != string.Empty)
12699 handler.AddSound(SoundConstants.ITEM_DEPLOY, GetDeploySoundset());
12700
12701 SoundParameters params = new SoundParameters();
12702 params.m_Loop = true;
12703 if (GetLoopDeploySoundset() != string.Empty)
12704 handler.AddSound(SoundConstants.ITEM_DEPLOY_LOOP, GetLoopDeploySoundset(), params);
12705 }
12706
12707 // Start sound using ItemSoundHandler
12708 void StartItemSoundServer(int id)
12709 {
12710 if (!GetGame().IsServer())
12711 return;
12712
12713 m_SoundSyncPlay = id;
12714 SetSynchDirty();
12715
12716 GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).Remove(ClearStartItemSoundServer); // in case one is queued already
12718 }
12719
12720 // Stop sound using ItemSoundHandler
12721 void StopItemSoundServer(int id)
12722 {
12723 if (!GetGame().IsServer())
12724 return;
12725
12726 m_SoundSyncStop = id;
12727 SetSynchDirty();
12728
12729 GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).Remove(ClearStopItemSoundServer); // in case one is queued already
12731 }
12732
12733 protected void ClearStartItemSoundServer()
12734 {
12735 m_SoundSyncPlay = 0;
12736 }
12737
12738 protected void ClearStopItemSoundServer()
12739 {
12740 m_SoundSyncStop = 0;
12741 }
12742
12744 void PlayAttachSound(string slot_type)
12745 {
12746 if (!GetGame().IsDedicatedServer())
12747 {
12748 if (ConfigIsExisting("attachSoundSet"))
12749 {
12750 string cfg_path = "";
12751 string soundset = "";
12752 string type_name = GetType();
12753
12754 TStringArray cfg_soundset_array = new TStringArray;
12755 TStringArray cfg_slot_array = new TStringArray;
12756 ConfigGetTextArray("attachSoundSet",cfg_soundset_array);
12757 ConfigGetTextArray("attachSoundSlot",cfg_slot_array);
12758
12759 if (cfg_soundset_array.Count() > 0 && cfg_soundset_array.Count() == cfg_slot_array.Count())
12760 {
12761 for (int i = 0; i < cfg_soundset_array.Count(); i++)
12762 {
12763 if (cfg_slot_array[i] == slot_type)
12764 {
12765 soundset = cfg_soundset_array[i];
12766 break;
12767 }
12768 }
12769 }
12770
12771 if (soundset != "")
12772 {
12773 EffectSound sound = SEffectManager.PlaySound(soundset, GetPosition());
12774 sound.SetAutodestroy(true);
12775 }
12776 }
12777 }
12778 }
12779
12780 void PlayDetachSound(string slot_type)
12781 {
12782 //TODO - evaluate if needed and devise universal config structure if so
12783 }
12784
12785 void OnApply(PlayerBase player);
12786
12788 {
12789 return 1.0;
12790 };
12791 //returns applicable selection
12792 array<string> GetHeadHidingSelection()
12793 {
12795 }
12796
12798 {
12800 }
12801
12802 WrittenNoteData GetWrittenNoteData() {};
12803
12805 {
12806 SetDynamicPhysicsLifeTime(0.01);
12807 m_ItemBeingDroppedPhys = false;
12808 }
12809
12811 {
12812 array<string> zone_names = new array<string>;
12813 GetDamageZones(zone_names);
12814 for (int i = 0; i < zone_names.Count(); i++)
12815 {
12816 SetHealthMax(zone_names.Get(i),"Health");
12817 }
12818 SetHealthMax("","Health");
12819 }
12820
12822 void SetZoneDamageCEInit()
12823 {
12824 float global_health = GetHealth01("","Health");
12825 array<string> zones = new array<string>;
12826 GetDamageZones(zones);
12827 //set damage of all zones to match global health level
12828 for (int i = 0; i < zones.Count(); i++)
12829 {
12830 SetHealth01(zones.Get(i),"Health",global_health);
12831 }
12832 }
12833
12835 bool IsCoverFaceForShave(string slot_name)
12836 {
12837 return IsExclusionFlagPresent(PlayerBase.GetFaceCoverageShaveValues());
12838 }
12839
12840 void ProcessItemWetness(float delta, bool hasParent, bool hasRootAsPlayer, ItemBase refParentIB)
12841 {
12842 if (!hasRootAsPlayer)
12843 {
12844 if (refParentIB)
12845 {
12846 // parent is wet
12847 if ((refParentIB.GetWet() >= GameConstants.STATE_SOAKING_WET) && (m_VarWet < m_VarWetMax))
12848 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_INSIDE);
12849 // parent has liquid inside
12850 else if ((refParentIB.GetLiquidType() != 0) && (refParentIB.GetQuantity() > 0) && (m_VarWet < m_VarWetMax))
12851 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_LIQUID);
12852 // drying
12853 else if (m_VarWet > m_VarWetMin)
12854 AddWet(-1 * delta * GetDryingIncrement("ground") * 2);
12855 }
12856 else
12857 {
12858 // drying on ground or inside non-itembase (car, ...)
12859 if (m_VarWet > m_VarWetMin)
12860 AddWet(-1 * delta * GetDryingIncrement("ground"));
12861 }
12862 }
12863 }
12864
12865 void ProcessItemTemperature(float delta, bool hasParent, bool hasRootAsPlayer, ItemBase refParentIB)
12866 {
12868 {
12869 float target = g_Game.GetMission().GetWorldData().GetBaseEnvTemperatureAtObject(this);
12870 if (GetTemperature() != target || !IsFreezeThawProgressFinished())
12871 {
12872 float heatPermCoef = 1.0;
12873 EntityAI ent = this;
12874 while (ent)
12875 {
12876 heatPermCoef *= ent.GetHeatPermeabilityCoef();
12877 ent = ent.GetHierarchyParent();
12878 }
12879
12880 SetTemperatureEx(new TemperatureDataInterpolated(target,ETemperatureAccessTypes.ACCESS_WORLD,delta,GameConstants.TEMP_COEF_WORLD,heatPermCoef));
12881 }
12882 }
12883 }
12884
12885 void HierarchyCheck(out bool hasParent, out bool hasRootAsPlayer, out ItemBase refParentIB)
12886 {
12887 // hierarchy check for an item to decide whether it has some parent and it is in some player inventory
12888 EntityAI parent = GetHierarchyParent();
12889 if (!parent)
12890 {
12891 hasParent = false;
12892 hasRootAsPlayer = false;
12893 }
12894 else
12895 {
12896 hasParent = true;
12897 hasRootAsPlayer = (GetHierarchyRootPlayer() != null);
12898 refParentIB = ItemBase.Cast(parent);
12899 }
12900 }
12901
12902 protected void ProcessDecay(float delta, bool hasRootAsPlayer)
12903 {
12904 // this is stub, implemented on Edible_Base
12905 }
12906
12907 bool CanDecay()
12908 {
12909 // return true used on selected food clases so they can decay
12910 return false;
12911 }
12912
12913 protected bool CanProcessDecay()
12914 {
12915 // this is stub, implemented on Edible_Base class
12916 // used to determine whether it is still necessary for the food to decay
12917 return false;
12918 }
12919
12920 protected bool CanHaveWetness()
12921 {
12922 // return true used on selected items that have a wetness effect
12923 return false;
12924 }
12925
12927 bool CanBeConsumed(ConsumeConditionData data = null)
12928 {
12929 return !GetIsFrozen() && IsOpen();
12930 }
12931
12932 override void ProcessVariables()
12933 {
12934 bool hasParent = false, hasRootAsPlayer = false;
12935 ItemBase refParentIB;
12936
12937 bool wwtu = g_Game.IsWorldWetTempUpdateEnabled();
12938 bool foodDecay = g_Game.IsFoodDecayEnabled();
12939
12940 if (wwtu || foodDecay)
12941 {
12942 bool processWetness = wwtu && CanHaveWetness();
12943 bool processTemperature = wwtu && CanHaveTemperature();
12944 bool processDecay = foodDecay && CanDecay() && CanProcessDecay();
12945
12946 if (processWetness || processTemperature || processDecay)
12947 {
12948 HierarchyCheck(hasParent, hasRootAsPlayer, refParentIB);
12949
12950 if (processWetness)
12951 ProcessItemWetness(m_ElapsedSinceLastUpdate, hasParent, hasRootAsPlayer, refParentIB);
12952
12953 if (processTemperature)
12954 ProcessItemTemperature(m_ElapsedSinceLastUpdate, hasParent, hasRootAsPlayer, refParentIB);
12955
12956 if (processDecay)
12957 ProcessDecay(m_ElapsedSinceLastUpdate, hasRootAsPlayer);
12958 }
12959 }
12960 }
12961
12964 {
12965 return m_TemperaturePerQuantityWeight * GameConstants.ITEM_TEMPERATURE_QUANTITY_WEIGHT_MULTIPLIER;
12966 }
12967
12968 override float GetTemperatureFreezeThreshold()
12969 {
12971 return Liquid.GetFreezeThreshold(GetLiquidType());
12972
12973 return super.GetTemperatureFreezeThreshold();
12974 }
12975
12976 override float GetTemperatureThawThreshold()
12977 {
12979 return Liquid.GetThawThreshold(GetLiquidType());
12980
12981 return super.GetTemperatureThawThreshold();
12982 }
12983
12984 override float GetItemOverheatThreshold()
12985 {
12987 return Liquid.GetBoilThreshold(GetLiquidType());
12988
12989 return super.GetItemOverheatThreshold();
12990 }
12991
12992 override float GetTemperatureFreezeTime()
12993 {
12994 if (HasQuantity())
12995 return Math.Lerp(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureFreezeTime()),GetQuantityNormalized());
12996
12997 return super.GetTemperatureFreezeTime();
12998 }
12999
13000 override float GetTemperatureThawTime()
13001 {
13002 if (HasQuantity())
13003 return Math.Lerp(GameConstants.TEMPERATURE_TIME_THAW_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureThawTime()),GetQuantityNormalized());
13004
13005 return super.GetTemperatureThawTime();
13006 }
13007
13009 void AffectLiquidContainerOnFill(int liquid_type, float amount);
13011 void AffectLiquidContainerOnTransfer(int liquidType, float amount, float sourceLiquidTemperature);
13012
13013 bool IsCargoException4x3(EntityAI item)
13014 {
13015 return (item.IsKindOf("Cauldron") || item.IsKindOf("Pot") || item.IsKindOf("FryingPan") || item.IsKindOf("SmallProtectorCase") || (item.IsKindOf("PortableGasStove") && item.FindAttachmentBySlotName("CookingEquipment")));
13016 }
13017
13019 {
13020 MiscGameplayFunctions.TransferItemProperties(oldItem, this);
13021 }
13022
13024 void AddLightSourceItem(ItemBase lightsource)
13025 {
13026 m_LightSourceItem = lightsource;
13027 }
13028
13030 {
13031 m_LightSourceItem = null;
13032 }
13033
13035 {
13036 return m_LightSourceItem;
13037 }
13038
13040 array<int> GetValidFinishers()
13041 {
13042 return null;
13043 }
13044
13046 bool GetActionWidgetOverride(out typename name)
13047 {
13048 return false;
13049 }
13050
13051 bool PairWithDevice(notnull ItemBase otherDevice)
13052 {
13053 if (GetGame().IsServer())
13054 {
13055 ItemBase explosive = otherDevice;
13057 if (!trg)
13058 {
13059 trg = RemoteDetonatorTrigger.Cast(otherDevice);
13060 explosive = this;
13061 }
13062
13063 explosive.PairRemote(trg);
13064 trg.SetControlledDevice(explosive);
13065
13066 int persistentID = RemotelyActivatedItemBehaviour.GeneratePersistentID();
13067 trg.SetPersistentPairID(persistentID);
13068 explosive.SetPersistentPairID(persistentID);
13069
13070 return true;
13071 }
13072 return false;
13073 }
13074
13076 float GetBaitEffectivity()
13077 {
13078 float ret = 1.0;
13079 if (HasQuantity())
13080 ret *= GetQuantityNormalized();
13081 ret *= GetHealth01();
13082
13083 return ret;
13084 }
13085
13086 #ifdef DEVELOPER
13087 override void SetDebugItem()
13088 {
13089 super.SetDebugItem();
13090 _itemBase = this;
13091 }
13092
13093 override string GetDebugText()
13094 {
13095 string text = super.GetDebugText();
13096
13097 text += string.Format("Heat isolation(raw): %1\n", GetHeatIsolation());
13098 text += string.Format("Heat isolation(modified): %1\n", MiscGameplayFunctions.GetCurrentItemHeatIsolation(this));
13099
13100 return text;
13101 }
13102 #endif
13103
13104 bool CanBeUsedForSuicide()
13105 {
13106 return true;
13107 }
13108
13110 //DEPRECATED BELOW
13112 // Backwards compatibility
13113 void ProcessItemWetnessAndTemperature(float delta, bool hasParent, bool hasRootAsPlayer, ItemBase refParentIB)
13114 {
13115 ProcessItemWetness(delta, hasParent, hasRootAsPlayer, refParentIB);
13116 ProcessItemTemperature(delta, hasParent, hasRootAsPlayer, refParentIB);
13117 }
13118
13119 // replaced by ItemSoundHandler
13120 protected EffectSound m_SoundDeployFinish;
13121 protected EffectSound m_SoundPlace;
13122 protected EffectSound m_DeployLoopSoundEx;
13123 protected EffectSound m_SoundDeploy;
13124 bool m_IsPlaceSound;
13125 bool m_IsDeploySound;
13127
13128 string GetDeployFinishSoundset();
13129 void PlayDeploySound();
13130 void PlayDeployFinishSound();
13131 void PlayPlaceSound();
13132 void PlayDeployLoopSoundEx();
13133 void StopDeployLoopSoundEx();
13134 void SoundSynchRemoteReset();
13135 void SoundSynchRemote();
13136 bool UsesGlobalDeploy(){return false;}
13137 bool CanPlayDeployLoopSound(){return false;}
13139 bool IsPlaceSound(){return m_IsPlaceSound;}
13140 bool IsDeploySound(){return m_IsDeploySound;}
13141 void SetIsPlaceSound(bool is_place_sound);
13142 void SetIsDeploySound(bool is_deploy_sound);
13143}
13144
13145EntityAI SpawnItemOnLocation(string object_name, notnull InventoryLocation loc, bool full_quantity)
13146{
13147 EntityAI entity = SpawnEntity(object_name, loc, ECE_IN_INVENTORY, RF_DEFAULT);
13148 if (entity)
13149 {
13150 bool is_item = entity.IsInherited(ItemBase);
13151 if (is_item && full_quantity)
13152 {
13153 ItemBase item = ItemBase.Cast(entity);
13154 item.SetQuantity(item.GetQuantityInit());
13155 }
13156 }
13157 else
13158 {
13159 ErrorEx("Cannot spawn entity: " + object_name,ErrorExSeverity.INFO);
13160 return NULL;
13161 }
13162 return entity;
13163}
13164
13165void SetupSpawnedItem(ItemBase item, float health, float quantity)
13166{
13167 if (item)
13168 {
13169 if (health > 0)
13170 item.SetHealth("", "", health);
13171
13172 if (item.CanHaveTemperature())
13173 {
13174 item.SetTemperatureDirect(GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_MIDDLE);
13175 if (item.CanFreeze())
13176 item.SetFrozen(false);
13177 }
13178
13179 if (item.HasEnergyManager())
13180 {
13181 if (quantity >= 0)
13182 {
13183 item.GetCompEM().SetEnergy0To1(quantity);
13184 }
13185 else
13186 {
13187 item.GetCompEM().SetEnergy(Math.AbsFloat(quantity));
13188 }
13189 }
13190 else if (item.IsMagazine())
13191 {
13192 Magazine mag = Magazine.Cast(item);
13193 if (quantity >= 0)
13194 {
13195 mag.ServerSetAmmoCount(mag.GetAmmoMax() * quantity);
13196 }
13197 else
13198 {
13199 mag.ServerSetAmmoCount(Math.AbsFloat(quantity));
13200 }
13201
13202 }
13203 else
13204 {
13205 if (quantity >= 0)
13206 {
13207 item.SetQuantityNormalized(quantity, false);
13208 }
13209 else
13210 {
13211 item.SetQuantity(Math.AbsFloat(quantity));
13212 }
13213
13214 }
13215 }
13216}
13217
13218#ifdef DEVELOPER
13219ItemBase _itemBase;//watched item goes here(LCTRL+RMB->Watch)
13220#endif
Param4< int, int, string, int > TSelectableActionInfoWithColor
Определения 3_Game/Entities/EntityAI.c:97
Param3 TSelectableActionInfo
EWetnessLevel
Определения 3_Game/Entities/EntityAI.c:2
InventoryMode
NOTE: PREDICTIVE is not to be used at all in multiplayer.
const int INPUT_UDT_ITEM_MANIPULATION
class LogManager EntityAI
eBleedingSourceType GetType()
ItemSuppressor SuppressorBase
void ActionDropItem()
Определения ActionDropItem.c:14
void ActionManagerBase(PlayerBase player)
Определения ActionManagerBase.c:63
map< typename, ref array< ActionBase_Basic > > TInputActionMap
Определения ActionManagerClient.c:1
void AddAction(typename actionName)
Определения AdvancedCommunication.c:220
void RemoveAction(typename actionName)
Определения AdvancedCommunication.c:252
TInputActionMap m_InputActionMap
Определения AdvancedCommunication.c:137
bool m_ActionsInitialize
Определения AdvancedCommunication.c:138
override void GetActions(typename action_input_type, out array< ActionBase_Basic > actions)
Определения AdvancedCommunication.c:202
void InitializeActions()
Определения AdvancedCommunication.c:190
int GetLiquidType()
Определения CCTWaterSurface.c:129
const int ECE_PLACE_ON_SURFACE
Определения CentralEconomy.c:37
proto native void SpawnEntity(string sClassName, vector vPos, float fRange, int iCount)
Spawn an entity through CE.
const int ECE_IN_INVENTORY
Определения CentralEconomy.c:36
const int RF_DEFAULT
Определения CentralEconomy.c:65
PlayerSpawnPresetDiscreteItemSetSlotData name
one set for cargo
PlayerSpawnPreset slotName
Open
Implementations only.
override void EEOnCECreate()
Определения ContaminatedArea_Dynamic.c:42
map
Определения ControlsXboxNew.c:4
CookingMethodType
Определения Cooking.c:2
DamageType
exposed from C++ (do not change)
Определения DamageSystem.c:11
DayZGame g_Game
Определения DayZGame.c:3868
DayZGame GetDayZGame()
Определения DayZGame.c:3870
EActions
Определения EActions.c:2
ERPCs
Определения ERPCs.c:2
PluginAdminLog m_AdminLog
Определения EmoteManager.c:142
const int MAX
Определения EnConvert.c:27
float GetTemperature()
Определения Environment.c:497
override bool IsExplosive()
Определения ExplosivesBase.c:59
override bool CanHaveTemperature()
Определения FireplaceBase.c:559
class GP5GasMask extends MaskBase ItemBase
Empty
Определения Hand_States.c:14
FindInventoryLocationType
flags for searching locations in inventory
Определения InventoryLocation.c:17
InventoryLocationType
types of Inventory Location
Определения InventoryLocation.c:4
class BoxCollidingParams component
ComponentInfo for BoxCollidingResult.
bool DamageItemInCargo(float damage)
Определения ItemBase.c:6380
static bool HasDebugActionsMask(int mask)
Определения ItemBase.c:5620
bool HidesSelectionBySlot()
Определения ItemBase.c:9347
float m_VarWetMin
Определения ItemBase.c:4881
void SplitItem(PlayerBase player)
Определения ItemBase.c:6831
void CopyScriptPropertiesFrom(EntityAI oldItem)
Определения ItemBase.c:9568
override void InsertAgent(int agent, float count=1)
Определения ItemBase.c:8795
override float GetQuantityNormalized()
Gets quantity in normalized 0..1 form between the item's Min a Max values as defined by item's config...
Определения ItemBase.c:8229
static void SetDebugActionsMask(int mask)
Определения ItemBase.c:5625
void SetIsDeploySound(bool is_deploy_sound)
bool IsOpen()
Определения ItemBase.c:8938
void SplitItemToInventoryLocation(notnull InventoryLocation dst)
Определения ItemBase.c:6798
override bool IsHeavyBehaviour()
Определения ItemBase.c:9140
override void SetWetMax()
Определения ItemBase.c:8511
bool IsCoverFaceForShave(string slot_name)
DEPRECATED in use, but returns correct values nontheless. Check performed elsewhere.
Определения ItemBase.c:9385
void ClearStartItemSoundServer()
Определения ItemBase.c:9283
float m_VarWet
Определения ItemBase.c:4878
void ProcessItemTemperature(float delta, bool hasParent, bool hasRootAsPlayer, ItemBase refParentIB)
Определения ItemBase.c:9415
map< typename, ref ActionOverrideData > TActionAnimOverrideMap
Определения ItemBase.c:2
override void RemoveAllAgentsExcept(int agent_to_keep)
Определения ItemBase.c:8790
static ref map< int, ref array< ref WeaponParticlesOnBulletCasingEject > > m_OnBulletCasingEjectEffect
Определения ItemBase.c:4941
bool CanBeMovedOverride()
Определения ItemBase.c:7522
override void SetWet(float value, bool allow_client=false)
Определения ItemBase.c:8487
ref TIntArray m_SingleUseActions
Определения ItemBase.c:4927
override void ProcessVariables()
Определения ItemBase.c:9482
ref TStringArray m_HeadHidingSelections
Определения ItemBase.c:4955
float GetWeightSpecialized(bool forceRecalc=false)
Определения ItemBase.c:8321
bool LoadAgents(ParamsReadContext ctx, int version)
Определения ItemBase.c:8856
void UpdateQuickbarShortcutVisibility(PlayerBase player)
To be called on moving item within character's inventory; 'player' should never be null.
Определения ItemBase.c:8701
void OverrideActionAnimation(typename action, int commandUID, int stanceMask=-1, int commandUIDProne=-1)
Определения ItemBase.c:5211
ref array< ref OverheatingParticle > m_OverheatingParticles
Определения ItemBase.c:4953
override float GetTemperatureFreezeThreshold()
Определения ItemBase.c:9518
bool m_IsSoundSynchRemote
Определения ItemBase.c:9676
float m_OverheatingShots
Определения ItemBase.c:4948
void StopItemSoundServer(int id)
Определения ItemBase.c:9271
static void ToggleDebugActionsMask(int mask)
Определения ItemBase.c:5640
void IncreaseOverheating(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
Определения ItemBase.c:5364
override float GetTemperatureFreezeTime()
Определения ItemBase.c:9542
ref array< int > m_CompatibleLocks
Определения ItemBase.c:4965
bool CanBeCooked()
Определения ItemBase.c:7478
override void CombineItemsClient(EntityAI entity2, bool use_stack_max=true)
Определения ItemBase.c:5707
float m_TemperaturePerQuantityWeight
Определения ItemBase.c:4977
bool m_RecipesInitialized
Определения ItemBase.c:4863
void SplitIntoStackMax(EntityAI destination_entity, int slot_id, PlayerBase player)
Определения ItemBase.c:6471
override float GetTemperatureThawThreshold()
Определения ItemBase.c:9526
override void OnEnergyConsumed()
Определения ItemBase.c:8431
void RefreshAudioVisualsOnClient(CookingMethodType cooking_method, bool is_done, bool is_empty, bool is_burned)
cooking-related effect methods
Определения Bottle_Base.c:158
int GetNumberOfItems()
Returns the number of items in cargo, otherwise returns 0(non-cargo objects). Recursive.
Определения ItemBase.c:8360
override EWetnessLevel GetWetLevel()
Определения ItemBase.c:8551
float GetSingleInventoryItemWeight()
Определения ItemBase.c:8316
ref TIntArray m_InteractActions
Определения ItemBase.c:4929
void MessageToOwnerStatus(string text)
Send message to owner player in grey color.
Определения ItemBase.c:7542
float m_VarQuantity
Определения ItemBase.c:4869
bool CanPlayDeployLoopSound()
Определения ItemBase.c:9687
override float GetWetMax()
Определения ItemBase.c:8521
bool CanBeUsedForSuicide()
Определения ItemBase.c:9654
override void CombineItemsEx(EntityAI entity2, bool use_stack_max=true)
Определения ItemBase.c:7117
void OnItemInHandsPlayerSwimStart(PlayerBase player)
void SetIsHologram(bool is_hologram)
Определения ItemBase.c:5845
void OnSyncVariables(ParamsReadContext ctx)
DEPRECATED (most likely)
Определения ItemBase.c:7696
void StartItemSoundServer(int id)
Определения ItemBase.c:9258
void DoAmmoExplosion()
Определения ItemBase.c:6315
static ref map< int, ref array< ref WeaponParticlesOnFire > > m_OnFireEffect
Определения ItemBase.c:4940
void SplitIntoStackMaxCargoClient(EntityAI destination_entity, int idx, int row, int col)
Определения ItemBase.c:6655
int GetItemSize()
Определения ItemBase.c:7507
bool m_CanBeMovedOverride
Определения ItemBase.c:4906
override string ChangeIntoOnAttach(string slot)
Определения ItemBase.c:6239
void UpdateOverheating(ItemBase weapon=null, string ammoType="", ItemBase muzzle_owner=null, ItemBase suppressor=null, string config_to_search="")
Определения ItemBase.c:5432
bool CanDecay()
Определения ItemBase.c:9457
ScriptedLightBase GetLight()
string GetPlaceSoundset()
bool AddQuantity(float value, bool destroy_config=true, bool destroy_forced=false)
add item quantity[related to varQuantity... config entry], destroy_config = true > if the quantity re...
Определения ItemBase.c:8202
void SetQuantityMax()
Определения ItemBase.c:8207
override float GetQuantity()
Определения ItemBase.c:8296
int m_ColorComponentR
Определения ItemBase.c:4918
int m_ShotsToStartOverheating
Определения ItemBase.c:4950
override void OnWetChanged(float newVal, float oldVal)
Определения ItemBase.c:8536
void StopOverheating(ItemBase weapon=null, string ammoType="", ItemBase muzzle_owner=null, ItemBase suppressor=null, string config_to_search="")
Определения ItemBase.c:5439
static void PlayFireParticles(ItemBase weapon, int muzzle_index, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
Определения ItemBase.c:9039
void OnOverheatingDecay()
Определения ItemBase.c:5402
float GetDryingIncrement(string pIncrementName)
Определения ItemBase.c:8469
void SoundSynchRemoteReset()
int m_Cleanness
Определения ItemBase.c:4884
bool HasMuzzle()
Returns true if this item has a muzzle (weapons, suppressors)
Определения ItemBase.c:5540
bool UsesGlobalDeploy()
Определения ItemBase.c:9686
int m_ItemBehaviour
Определения ItemBase.c:4899
override bool CanReleaseAttachment(EntityAI attachment)
Определения ItemBase.c:9011
float m_HeatIsolation
Определения ItemBase.c:4894
float m_VarWetInit
Определения ItemBase.c:4880
override void OnMovedInsideCargo(EntityAI container)
Определения ItemBase.c:5885
void SetCEBasedQuantity()
Определения ItemBase.c:5653
bool m_CanPlayImpactSound
Определения ItemBase.c:4890
override string GetAttachmentSoundType()
Определения ItemBase.c:9214
float GetOverheatingCoef()
Определения ItemBase.c:5459
array< string > GetHeadHidingSelection()
Определения ItemBase.c:9342
void PlayAttachSound(string slot_type)
Plays sound on item attach. Be advised, the config structure may slightly change in 1....
Определения ItemBase.c:9294
override bool IsStoreLoad()
Определения ItemBase.c:8563
int ComputeQuantityUsed(ItemBase other_item, bool use_stack_max=true)
Определения ItemBase.c:7093
bool IsLightSource()
Определения ItemBase.c:5781
bool m_HasQuantityBar
Определения ItemBase.c:4912
void SetResultOfSplit(bool value)
Определения ItemBase.c:7088
void SplitIntoStackMaxCargo(EntityAI destination_entity, int idx, int row, int col)
Определения ItemBase.c:6719
void OnAttachmentQuantityChanged(ItemBase item)
Called on server side when some attachment's quantity is changed. Call super.OnAttachmentQuantityChan...
Определения ItemBase.c:6889
void UpdateAllOverheatingParticles()
Определения ItemBase.c:5467
float GetSoakingIncrement(string pIncrementName)
Определения ItemBase.c:8478
static void StopOverheatingParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
Определения ItemBase.c:9119
override float GetStoreLoadedQuantity()
Определения ItemBase.c:8573
int m_LockType
Определения ItemBase.c:4966
const int ITEM_SOUNDS_MAX
Определения ItemBase.c:4971
bool m_CanBeDigged
Определения ItemBase.c:4913
float m_ItemAttachOffset
Определения ItemBase.c:4896
float GetItemModelLength()
Определения ItemBase.c:8580
bool m_ThrowItemOnDrop
Определения ItemBase.c:4904
override bool ReadVarsFromCTX(ParamsReadContext ctx, int version=-1)
Определения ItemBase.c:7841
override void CheckForRoofLimited(float timeTresholdMS=3000)
Roof check for entity, limited by time (anti-spam solution)
Определения ItemBase.c:8871
void Close()
float GetHeatIsolation()
Определения ItemBase.c:8464
void CombineItems(ItemBase other_item, bool use_stack_max=true)
Определения ItemBase.c:7122
void TransferModifiers(PlayerBase reciever)
appears to be deprecated, legacy code
float GetTemperaturePerQuantityWeight()
Used in heat comfort calculations only!
Определения ItemBase.c:9513
bool CanHaveWetness()
Определения ItemBase.c:9470
int m_CleannessMin
Определения ItemBase.c:4886
void TransferAgents(int agents)
transfer agents from another item
Определения ItemBase.c:8804
string IDToName(int id)
Определения ItemBase.c:7689
bool CanBeConsumed(ConsumeConditionData data=null)
Items cannot be consumed if frozen by default. Override for exceptions.
Определения ItemBase.c:9477
float GetHeatIsolationInit()
Определения ItemBase.c:8459
void PlayPlaceSound()
void SetCanBeMovedOverride(bool setting)
Определения ItemBase.c:7529
override bool HasQuantity()
Определения ItemBase.c:8291
float m_VarWetPrev
Определения ItemBase.c:4879
int m_SoundSyncStop
Определения ItemBase.c:4973
bool IsCargoException4x3(EntityAI item)
Определения ItemBase.c:9563
ref TIntArray m_ContinuousActions
Определения ItemBase.c:4928
int GetMuzzleID()
Returns global muzzle ID. If not found, then it gets automatically registered.
Определения ItemBase.c:5549
void LoadParticleConfigOnFire(int id)
Определения ItemBase.c:5234
int m_VarLiquidType
Определения ItemBase.c:4898
int m_QuickBarBonus
Определения ItemBase.c:4900
void PreLoadSoundAttachmentType()
Attachment Sound Type getting from config file.
Определения ItemBase.c:9202
override float GetWetInit()
Определения ItemBase.c:8531
int m_ImpactSoundSurfaceHash
Определения ItemBase.c:4892
int m_SoundSyncPlay
Определения ItemBase.c:4972
int m_MaxOverheatingValue
Определения ItemBase.c:4951
void SetupSpawnedItem(ItemBase item, float health, float quantity)
Определения ItemBase.c:4875
bool m_IsTakeable
Определения ItemBase.c:4903
bool ShouldSplitQuantity(float quantity)
Определения ItemBase.c:6428
static ref map< string, int > m_WeaponTypeToID
Определения ItemBase.c:4943
string GetLockSoundSet()
Определения ItemBase.c:8629
string GetColorString()
Returns item's PROCEDURAL color as formated string, i.e. "#(argb,8,8,3)color(0.15,...
Определения ItemBase.c:8660
array< int > GetValidFinishers()
returns an array of possible finishers
Определения ItemBase.c:9590
void OnAttachmentQuantityChangedEx(ItemBase item, float delta)
Called on server side when some attachment's quantity is changed. Call super.OnAttachmentQuantityChan...
Определения ItemBase.c:6895
class ItemBase extends InventoryItem SpawnItemOnLocation(string object_name, notnull InventoryLocation loc, bool full_quantity)
Определения ItemBase.c:4855
ItemSoundHandler GetItemSoundHandler()
Определения ItemBase.c:9229
override int GetQuantityMin()
Определения ItemBase.c:8280
void SplitIntoStackMaxToInventoryLocationClient(notnull InventoryLocation dst)
Определения ItemBase.c:6634
override int GetQuickBarBonus()
Определения ItemBase.c:5119
override void SetTakeable(bool pState)
Определения ItemBase.c:9184
float m_OverheatingDecayInterval
Определения ItemBase.c:4952
void SetIsPlaceSound(bool is_place_sound)
override void SplitIntoStackMaxClient(EntityAI destination_entity, int slot_id)
Определения ItemBase.c:6448
void HierarchyCheck(out bool hasParent, out bool hasRootAsPlayer, out ItemBase refParentIB)
Определения ItemBase.c:9435
bool CanProcessDecay()
Определения ItemBase.c:9463
void RemoveAudioVisualsOnClient()
Определения Bottle_Base.c:151
void SoundSynchRemote()
static void AddDebugActionsMask(int mask)
Определения ItemBase.c:5630
void PlayDeployLoopSoundEx()
void RemoveLightSourceItem()
Определения ItemBase.c:9579
bool CanRepair(ItemBase item_repair_kit)
Определения ItemBase.c:7493
bool can_this_be_combined
Определения ItemBase.c:4908
EffectSound m_SoundDeploy
Определения ItemBase.c:9673
int m_Count
Определения ItemBase.c:4874
float GetBaitEffectivity()
generic effectivity as a bait for animal catching
Определения ItemBase.c:9626
float GetDeployTime()
how long it takes to deploy this item in seconds
Определения ItemBase.c:9176
override bool IsSplitable()
Определения ItemBase.c:6415
bool DamageItemAttachments(float damage)
Определения ItemBase.c:6399
override void WriteVarsToCTX(ParamsWriteContext ctx)
Определения ItemBase.c:7805
void ConvertEnergyToQuantity()
Определения ItemBase.c:8446
override void RemoveAllAgents()
Определения ItemBase.c:8785
override void SetQuantityToMinimum()
Определения ItemBase.c:8213
bool m_WantPlayImpactSound
Определения ItemBase.c:4889
override float GetTemperatureThawTime()
Определения ItemBase.c:9550
ref map< int, ref array< ref WeaponParticlesOnOverheating > > m_OnOverheatingEffect
Определения ItemBase.c:4942
int m_ColorComponentG
Определения ItemBase.c:4919
float m_StoreLoadedQuantity
Определения ItemBase.c:4876
void MessageToOwnerAction(string text)
Send message to owner player in yellow color.
Определения ItemBase.c:7560
int m_ColorComponentA
Определения ItemBase.c:4921
int m_VarQuantityInit
Определения ItemBase.c:4871
float GetFilterDamageRatio()
Определения ItemBase.c:5534
override void SetLiquidType(int value, bool allow_client=false)
Определения ItemBase.c:8673
void OnQuantityChanged(float delta)
Called on server side when this item's quantity is changed. Call super.OnQuantityChanged(); first whe...
Определения ItemBase.c:6865
void OnApply(PlayerBase player)
override void SetQuantityNormalized(float value, bool destroy_config=true, bool destroy_forced=false)
Sets quantity in normalized 0..1 form between the item's Min a Max values as defined by item's config...
Определения ItemBase.c:8220
bool m_HideSelectionsBySlot
Определения ItemBase.c:4956
bool IsOverheatingEffectActive()
Определения ItemBase.c:5397
void SetIsBeingPlaced(bool is_being_placed)
Определения ItemBase.c:5814
int GetLiquidContainerMask()
Определения ItemBase.c:5751
void SetInventoryLocationToVicinityOrCurrent(EntityAI root, inout InventoryLocation dst)
Определения ItemBase.c:7002
ref Timer m_CheckOverheating
Определения ItemBase.c:4949
void RegisterOverheatingParticle(Particle p, float min_heat_coef, float max_heat_coef, int particle_id, Object parent, vector local_pos, vector local_ori)
Определения ItemBase.c:5445
float GetEnergy()
Определения ItemBase.c:8420
bool CanBeDigged()
Определения ItemBase.c:5830
bool GetActionWidgetOverride(out typename name)
If we need a different (handheld)item action widget displayed, the logic goes in here.
Определения ItemBase.c:9596
bool IsNVG()
Определения ItemBase.c:5762
float GetUnitWeight(bool include_wetness=true)
Obsolete, use GetWeightEx instead.
Определения ItemBase.c:8380
void SetZoneDamageCEInit()
Sets zone damages to match randomized global health set by CE (CE spawn only)
Определения ItemBase.c:9372
bool m_IsDeploySound
Определения ItemBase.c:9675
bool CanEat()
Определения ItemBase.c:7453
static void PlayOverheatingParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
Определения ItemBase.c:9079
override bool IsOneHandedBehaviour()
Определения ItemBase.c:9150
void AddLightSourceItem(ItemBase lightsource)
Adds a light source child.
Определения ItemBase.c:9574
bool IsLiquidContainer()
Определения ItemBase.c:5746
FoodStage GetFoodStage()
overridden on Edible_Base; so we don't have to parse configs all the time
Определения ItemBase.c:7473
override float GetSingleInventoryItemWeightEx()
Определения ItemBase.c:8307
void SaveAgents(ParamsWriteContext ctx)
Определения ItemBase.c:8863
override int GetTargetQuantityMax(int attSlotID=-1)
Определения ItemBase.c:8261
int m_CleannessInit
Определения ItemBase.c:4885
float GetDisinfectQuantity(int system=0, Param param1=null)
Определения ItemBase.c:5529
override int GetAgents()
Определения ItemBase.c:8810
int m_VarQuantityMax
Определения ItemBase.c:4873
override bool IsHologram()
Определения ItemBase.c:5825
float GetItemAttachOffset()
Определения ItemBase.c:8589
bool IsPlaceSound()
Определения ItemBase.c:9689
static int GetDebugActionsMask()
Определения ItemBase.c:5615
void ProcessDecay(float delta, bool hasRootAsPlayer)
Определения ItemBase.c:9452
override bool IsItemBase()
Определения ItemBase.c:7606
void PlayDeploySound()
override bool IsTwoHandedBehaviour()
Определения ItemBase.c:9160
void ExplodeAmmo()
Определения ItemBase.c:6302
bool IsCombineAll(ItemBase other_item, bool use_stack_max=false)
Определения ItemBase.c:7078
float GetProtectionLevel(int type, bool consider_filter=false, int system=0)
Определения ItemBase.c:8884
static void PlayBulletCasingEjectParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
Определения ItemBase.c:9059
override void OnEnergyAdded()
Определения ItemBase.c:8438
void AffectLiquidContainerOnFill(int liquid_type, float amount)
from enviro source
void AffectLiquidContainerOnTransfer(int liquidType, float amount, float sourceLiquidTemperature)
from other liquid container source
string GetExplosiveTriggerSlotName()
Определения ItemBase.c:5774
EffectSound m_DeployLoopSoundEx
Определения ItemBase.c:9672
override void DeSerializeNumericalVars(array< float > floats)
Определения ItemBase.c:7746
void StopItemDynamicPhysics()
Определения ItemBase.c:9354
bool HasFoodStage()
Определения ItemBase.c:7466
override void SetStoreLoad(bool value)
Определения ItemBase.c:8558
float GetOverheatingValue()
Определения ItemBase.c:5359
bool ContainsAgent(int agent_id)
Определения ItemBase.c:8763
override void AddWet(float value)
Определения ItemBase.c:8506
bool IsLiquidPresent()
Определения ItemBase.c:5741
bool IsFullQuantity()
Определения ItemBase.c:8301
override void EOnContact(IEntity other, Contact extra)
Определения ItemBase.c:6015
void SplitIntoStackMaxHands(PlayerBase player)
Определения ItemBase.c:6770
void SplitIntoStackMaxHandsClient(PlayerBase player)
Определения ItemBase.c:6746
int m_CleannessMax
Определения ItemBase.c:4887
float m_VarStackMax
Определения ItemBase.c:4875
ref Timer m_PhysDropTimer
Определения ItemBase.c:4962
void MessageToOwnerFriendly(string text)
Send message to owner player in green color.
Определения ItemBase.c:7578
override void SetStoreLoadedQuantity(float value)
Определения ItemBase.c:8568
bool m_IsResultOfSplit string m_SoundAttType
distinguish if item has been created as new or it came from splitting (server only flag)
Определения ItemBase.c:4916
void CheckOverheating(ItemBase weapon=null, string ammoType="", ItemBase muzzle_owner=null, ItemBase suppressor=null, string config_to_search="")
Определения ItemBase.c:5380
void UnlockFromParent()
Unlocks this item from its attachment slot of its parent.
Определения ItemBase.c:5695
bool Repair(PlayerBase player, ItemBase item_repair_kit, float specialty_weight)
Определения ItemBase.c:7500
void OnLiquidTypeChanged(int oldType, int newType)
Определения ItemBase.c:8694
void StartOverheating(ItemBase weapon=null, string ammoType="", ItemBase muzzle_owner=null, ItemBase suppressor=null, string config_to_search="")
Определения ItemBase.c:5426
void PlayDeployFinishSound()
bool AllowFoodConsumption()
Определения ItemBase.c:8616
bool m_IsOverheatingEffectActive
Определения ItemBase.c:4947
int m_LiquidContainerMask
Определения ItemBase.c:4897
void ProcessItemWetness(float delta, bool hasParent, bool hasRootAsPlayer, ItemBase refParentIB)
Определения ItemBase.c:9390
override int GetCleanness()
Определения ItemBase.c:8611
bool PairWithDevice(notnull ItemBase otherDevice)
Определения ItemBase.c:9601
bool IsDeploySound()
Определения ItemBase.c:9690
static void RemoveDebugActionsMask(int mask)
Определения ItemBase.c:5635
static void UpdateOverheatingParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
Определения ItemBase.c:9099
int m_VarQuantityMin
Определения ItemBase.c:4872
void PerformDamageSystemReinit()
Определения ItemBase.c:9360
override void ClearInventory()
Определения ItemBase.c:8399
static int m_LastRegisteredWeaponID
Определения ItemBase.c:4944
ItemBase GetLightSourceItem()
Определения ItemBase.c:9584
void MessageToOwnerImportant(string text)
Send message to owner player in red color.
Определения ItemBase.c:7596
override float GetItemOverheatThreshold()
Определения ItemBase.c:9534
void StopDeployLoopSoundEx()
bool m_CanThisBeSplit
Определения ItemBase.c:4909
override void SerializeNumericalVars(array< float > floats_out)
Определения ItemBase.c:7710
ItemBase SplitIntoStackMaxToInventoryLocationEx(notnull InventoryLocation dst)
Определения ItemBase.c:6685
float m_ItemModelLength
Определения ItemBase.c:4895
bool m_IsHologram
Определения ItemBase.c:4902
static int m_DebugActionsMask
Определения ItemBase.c:4862
void KillAllOverheatingParticles()
Определения ItemBase.c:5495
bool CanBeCookedOnStick()
Определения ItemBase.c:7483
override int GetQuantityMax()
Определения ItemBase.c:8248
void GetRecipesActions(Man player, out TSelectableActionInfoArray outputList)
Определения ItemBase.c:7156
void OnActivatedByTripWire()
bool IsColorSet()
Определения ItemBase.c:8654
override void RemoveAgent(int agent_id)
Определения ItemBase.c:8776
bool m_ItemBeingDroppedPhys
Определения ItemBase.c:4905
override bool CanPutAsAttachment(EntityAI parent)
Определения ItemBase.c:8966
void PlayDetachSound(string slot_type)
Определения ItemBase.c:9330
static ref map< typename, ref TInputActionMap > m_ItemTypeActionsMap
Определения ItemBase.c:4856
void ProcessItemWetnessAndTemperature(float delta, bool hasParent, bool hasRootAsPlayer, ItemBase refParentIB)
Определения ItemBase.c:9663
override bool IsBeingPlaced()
Определения ItemBase.c:5809
int GetQuantityInit()
Определения ItemBase.c:8285
float ComputeQuantityUsedEx(ItemBase other_item, bool use_stack_max=true)
Определения ItemBase.c:7098
bool IsResultOfSplit()
Определения ItemBase.c:7083
bool m_FixDamageSystemInit
Определения ItemBase.c:4907
float m_ImpactSpeed
Определения ItemBase.c:4891
bool m_IsStoreLoad
Определения ItemBase.c:4910
int GetLiquidTypeInit()
Определения ItemBase.c:8684
string GetDeployFinishSoundset()
ItemBase m_LightSourceItem
Определения ItemBase.c:4925
void LockToParent()
Locks this item in it's current attachment slot of its parent. This makes the "locked" icon visible i...
Определения ItemBase.c:5682
override void SplitIntoStackMaxEx(EntityAI destination_entity, int slot_id)
Определения ItemBase.c:6557
int m_AttachedAgents
Определения ItemBase.c:4933
string m_LockSoundSet
Определения ItemBase.c:4968
void LoadParticleConfigOnOverheating(int id)
Определения ItemBase.c:5303
float m_VarQuantityPrev
Определения ItemBase.c:4870
bool IsSoundSynchRemote()
Определения ItemBase.c:9688
bool m_CanShowQuantity
Определения ItemBase.c:4911
override void OnRightClick()
Определения ItemBase.c:6938
int m_ColorComponentB
Определения ItemBase.c:4920
static ref map< typename, ref TActionAnimOverrideMap > m_ItemActionOverrides
Определения ItemBase.c:4858
bool IsActionTargetVisible()
Определения ItemBase.c:9196
override void OnItemAttachmentSlotChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
Определения ItemBase.c:6050
override void EEHitBy(TotalDamageResult damageResult, int damageType, EntityAI source, int component, string dmgZone, string ammo, vector modelPos, float speedCoef)
Определения ItemBase.c:6339
bool m_IsBeingPlaced
Определения ItemBase.c:4901
int NameToID(string name)
Определения ItemBase.c:7683
void ~ItemBase()
Определения ItemBase.c:5580
override void OnWetLevelChanged(EWetnessLevel newLevel, EWetnessLevel oldLevel)
Определения ItemBase.c:8546
void ClearStopItemSoundServer()
Определения ItemBase.c:9288
override string ChangeIntoOnDetach()
Определения ItemBase.c:6263
float m_VarWetMax
Определения ItemBase.c:4882
void SplitIntoStackMaxToInventoryLocation(notnull InventoryLocation dst)
Определения ItemBase.c:6680
int GetLockType()
Определения ItemBase.c:8624
EffectSound m_SoundDeployFinish
Определения ItemBase.c:9670
override float GetWet()
Определения ItemBase.c:8516
EffectSound m_SoundPlace
Определения ItemBase.c:9671
float GetQuantityNormalizedScripted()
Определения ItemBase.c:8234
override void SetCleanness(int value, bool allow_client=false)
Определения ItemBase.c:8598
bool m_IsPlaceSound
Определения ItemBase.c:9674
override float GetWetMin()
Определения ItemBase.c:8526
ref ItemSoundHandler m_ItemSoundHandler
Определения ItemBase.c:4974
override bool KindOf(string tag)
Определения ItemBase.c:7612
void ItemSoundHandler(ItemBase parent)
Определения ItemSoundHandler.c:31
string Type
Определения JsonDataContaminatedArea.c:11
EffectSound m_LockingSound
Определения Land_Underground_Entrance.c:321
string GetDebugText()
Определения ModifierBase.c:71
PlayerBase GetPlayer()
Определения ModifierBase.c:51
@ LOWEST
Определения PPEConstants.c:54
void PluginItemDiagnostic()
Определения PluginItemDiagnostic.c:74
PluginBase GetPlugin(typename plugin_type)
Определения PluginManager.c:316
EntityAI GetItem()
Определения RadialQuickbarMenu.c:37
override RemotelyActivatedItemBehaviour GetRemotelyActivatedItemBehaviour()
Определения RemoteDetonator.c:272
void RemoteDetonatorTrigger()
Определения RemoteDetonator.c:233
override void OnActivatedByItem(notnull ItemBase item)
Called when this item is activated by other.
Определения RemoteDetonator.c:305
int particle_id
Определения SmokeSimulation.c:28
ETemperatureAccessTypes
Определения TemperatureAccessConstants.c:2
override void Explode(int damageType, string ammoType="")
Определения Trap_LandMine.c:220
bool m_Initialized
Определения UiHintPanel.c:317
void Debug()
Определения UniversalTemperatureSource.c:349
int GetID()
Определения ActionBase.c:1360
void OnItemLocationChanged(ItemBase item)
Определения ActionBase.c:998
GetInputType()
Определения ActionBase.c:215
int m_StanceMask
Определения ActionBase.c:25
int m_CommandUIDProne
Определения ActionBase.c:24
int m_CommandUID
Определения ActionBase.c:23
void OnItemAttachedAtPlayer(EntityAI item, string slot_name)
Определения AnalyticsManagerClient.c:77
proto native UIManager GetUIManager()
proto bool ConfigGetChildName(string path, int index, out string name)
Get name of subclass in config class on path.
proto native float ConfigGetFloat(string path)
Get float value from config on path.
override ScriptCallQueue GetCallQueue(int call_category)
Определения DayZGame.c:1187
proto native void GizmoSelectObject(Object object)
proto native bool ConfigIsExisting(string path)
proto native void ConfigGetTextArray(string path, out TStringArray values)
Get array of strings from config on path.
proto native DayZPlayer GetPlayer()
proto native void GizmoSelectPhysics(Physics physics)
proto int GetTime()
returns mission time in milliseconds
proto native int ConfigGetType(string path)
Returns type of config value.
AnalyticsManagerClient GetAnalyticsClient()
Определения Global/game.c:1568
proto native int ConfigGetChildrenCount(string path)
Get count of subclasses in config class on path.
proto native SoundOnVehicle CreateSoundOnObject(Object source, string sound_name, float distance, bool looped, bool create_local=false)
proto native void ObjectDelete(Object obj)
proto native int GetItemCount()
proto native EntityAI GetItem(int index)
float GetEnergyAtSpawn()
Определения ComponentEnergyManager.c:1280
void SetEnergy0To1(float energy01)
Energy manager: Sets stored energy for this device between 0 and MAX based on relative input value be...
Определения ComponentEnergyManager.c:541
float GetEnergyMaxPristine()
Energy manager: Returns the maximum amount of energy this device can store. It's damage is NOT taken ...
Определения ComponentEnergyManager.c:1275
override void SetAutodestroy(bool auto_destroy)
Sets whether Effect automatically cleans up when it stops.
Определения EffectSound.c:603
bool IsSoundPlaying()
Get whether EffectSound is currently playing.
Определения EffectSound.c:274
override bool IsMan()
Определения 3_Game/Entities/Man.c:44
proto native bool EnumerateInventory(InventoryTraversalType tt, out array< EntityAI > items)
enumerate inventory using traversal type and filling items array
proto native CargoBase GetCargo()
cargo
Определения ItemBase.c:15
proto native bool IsValid()
verify current set inventory location
proto native EntityAI GetParent()
returns parent of current inventory location
proto native int GetSlot()
returns slot id if current type is Attachment
proto native int GetCol()
returns column of cargo if current type is Cargo / ProxyCargo
proto native int GetRow()
returns row of cargo if current type is Cargo / ProxyCargo
bool WriteToContext(ParamsWriteContext ctx)
Определения InventoryLocation.c:469
proto native int GetType()
returns type of InventoryLocation
proto native int GetIdx()
returns index of cargo if current type is Cargo / ProxyCargo
proto native void SetCargo(notnull EntityAI parent, EntityAI e, int idx, int row, int col, bool flip)
sets current inventory location type to Cargo with coordinates (idx, row, col)
proto native bool GetFlip()
returns flip status of cargo
proto native EntityAI GetItem()
returns item of current inventory location
InventoryLocation.
Определения InventoryLocation.c:29
override bool CanDisplayCargo()
Определения UndergroundStash.c:24
override void OnInventoryEnter(Man player)
Определения BarbedWire.c:203
override string GetFoldSoundset()
Определения BaseBuildingBase.c:108
override bool CanPutAsAttachment(EntityAI parent)
Определения ItemBase.c:6
override bool CanReceiveItemIntoCargo(EntityAI item)
Определения TentBase.c:913
override bool OnStoreLoad(ParamsReadContext ctx, int version)
Определения GardenBase.c:199
override void OnWasDetached(EntityAI parent, int slot_id)
override void EEOnAfterLoad()
Определения GardenBase.c:242
override void EEDelete(EntityAI parent)
Определения BaseBuildingBase.c:68
override bool CanBeRepairedByCrafting()
Определения TentBase.c:86
override void OnPlacementStarted(Man player)
Определения BatteryCharger.c:376
override void OnItemLocationChanged(EntityAI old_owner, EntityAI new_owner)
Определения BarbedWire.c:357
override bool IsElectricAppliance()
Определения BatteryCharger.c:43
override bool IsItemTent()
Определения TentBase.c:81
override void SetActions()
override string GetLoopFoldSoundset()
Определения BaseBuildingBase.c:113
override bool CanMakeGardenplot()
Определения FieldShovel.c:3
override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
Определения PowerGenerator.c:412
override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
Определения HandcuffsLocked.c:12
override WrittenNoteData GetWrittenNoteData()
Определения Paper.c:30
override int GetDamageSystemVersionChange()
Определения BaseBuildingBase.c:1238
override bool SetQuantity(float value, bool destroy_config=true, bool destroy_forced=false, bool allow_client=false, bool clamp_to_stack_max=true)
Определения PileOfWoodenPlanks.c:88
override void InitItemVariables()
Определения Matchbox.c:3
override void SetActionAnimOverrides()
Определения PickAxe.c:28
override void OnCreatePhysics()
Определения BaseBuildingBase.c:489
override string GetDeploySoundset()
Определения BarbedWire.c:392
override float GetBandagingEffectivity()
Определения BandageDressing.c:49
override bool OnAction(int action_id, Man player, ParamsReadContext ctx)
Определения PowerGenerator.c:424
override void EEHealthLevelChanged(int oldLevel, int newLevel, string zone)
Определения BaseBuildingBase.c:496
override void OnStoreSave(ParamsWriteContext ctx)
Определения GardenBase.c:266
override void AfterStoreLoad()
Определения BarbedWire.c:155
override int GetOnDigWormsAmount()
Определения FieldShovel.c:27
override bool IsSelfAdjustingTemperature()
Определения PortableGasStove.c:287
override bool IsPlayerInside(PlayerBase player, string selection)
Определения BaseBuildingBase.c:1037
override void OnVariablesSynchronized()
Определения GardenBase.c:97
override void RefreshPhysics()
Определения BatteryCharger.c:359
override bool CanObstruct()
Определения BaseBuildingBase.c:84
override void OnWasAttached(EntityAI parent, int slot_id)
override bool CanReceiveAttachment(EntityAI attachment, int slotId)
Определения BaseBuildingBase.c:982
override bool CanPutInCargo(EntityAI parent)
Определения GardenBase.c:331
override string GetLoopDeploySoundset()
Определения BarbedWire.c:397
override void OnPlacementComplete(Man player, vector position="0 0 0", vector orientation="0 0 0")
Определения BarbedWire.c:372
override void OnInventoryExit(Man player)
Определения BatteryCharger.c:341
override bool IsTakeable()
Определения BaseBuildingBase.c:1008
override bool IsIgnoredByConstruction()
Определения BaseBuildingBase.c:1170
override void InitItemSounds()
Определения BaseBuildingBase.c:94
override void EEKilled(Object killer)
Определения HandcuffsLocked.c:70
override void OnCombine(ItemBase other_item)
Определения BandageDressing.c:71
override bool CanExplodeInFire()
Определения LargeGasCannister.c:3
override bool IsFacingPlayer(PlayerBase player, string selection)
Определения BaseBuildingBase.c:1032
override bool CanBeCombined(EntityAI other_item, bool reservation_check=true, bool stack_max_limit=false)
Определения Rag.c:61
override bool IsBloodContainer()
Определения BloodContainerBase.c:10
override bool IsClothing()
override bool CanBeSplit()
Определения Rag.c:34
override bool IsDeployable()
Определения BaseBuildingBase.c:365
override void OnRPC(PlayerIdentity sender, int rpc_type, ParamsReadContext ctx)
Определения ToolBase.c:24
override bool CanBeDisinfected()
Определения BandageDressing.c:54
override float GetInfectionChance(int system=0, Param param=null)
Определения BandageDressing.c:59
override void OnEndPlacement()
Определения KitBase.c:65
Определения EnMath.c:7
float GetOverheatingLimitMax()
Определения WeaponParticles.c:417
void SetOverheatingLimitMax(float max)
Определения WeaponParticles.c:407
void SetParticleParams(int particle_id, Object parent, vector local_pos, vector local_ori)
Определения WeaponParticles.c:422
float GetOverheatingLimitMin()
Определения WeaponParticles.c:412
Particle GetParticle()
Определения WeaponParticles.c:397
void SetOverheatingLimitMin(float min)
Определения WeaponParticles.c:402
void RegisterParticle(Particle p)
Определения WeaponParticles.c:392
void Stop()
Legacy function for backwards compatibility with 1.14 and below.
Определения Particle.c:266
void SetControlledDevice(EntityAI pDevice)
Определения RemoteDetonator.c:140
bool OnStoreLoad(ParamsReadContext ctx, int version)
void OnStoreSave(ParamsWriteContext ctx)
proto void Remove(func fn)
remove specific call from queue
proto void CallLater(func fn, int delay=0, bool repeat=false, void param1=NULL, void param2=NULL, void param3=NULL, void param4=NULL, void param5=NULL, void param6=NULL, void param7=NULL, void param8=NULL, void param9=NULL)
adds call into the queue with given parameters and arguments (arguments are held in memory until the ...
proto native void Send()
proto bool Write(void value_out)
proto bool Read(void value_in)
bool m_Loop
Определения ItemSoundHandler.c:5
override void Stop()
Определения DayZPlayerImplement.c:64
proto native float GetDamage(string zoneName, string healthType)
UIScriptedMenu FindMenu(int id)
Returns menu with specific ID if it is open (see MenuID)
Определения UIManager.c:160
override void Refresh()
Определения ChatInputMenu.c:70
void SetCalcDetails(string details)
Определения 3_Game/tools/Debug.c:816
void OnRPC(PlayerIdentity sender, int rpc_type, ParamsReadContext ctx)
Определения WrittenNoteData.c:13
const float LOWEST
Определения EnConvert.c:100
Serializer ParamsReadContext
Определения gameplay.c:15
class LOD Object
InventoryTraversalType
tree traversal type, for more see http://en.wikipedia.org/wiki/Tree_traversal
Определения gameplay.c:6
proto native CGame GetGame()
Serializer ParamsWriteContext
Определения gameplay.c:16
const int DEF_BIOLOGICAL
Определения 3_Game/constants.c:512
const int DEF_CHEMICAL
Определения 3_Game/constants.c:513
const int COMP_TYPE_ENERGY_MANAGER
Определения Component.c:9
ErrorExSeverity
Определения EnDebug.c:62
void Error(string err)
Messagebox with error message.
Определения EnDebug.c:90
enum ShapeType ErrorEx
proto native void SetColor(int color)
array< string > TStringArray
Определения EnScript.c:709
array< int > TIntArray
Определения EnScript.c:711
EntityEvent
Entity events for event-mask, or throwing event from code.
Определения EnEntity.c:45
static const float ITEM_TEMPERATURE_NEUTRAL_ZONE_MIDDLE
Определения 3_Game/constants.c:808
const int VARIABLE_LIQUIDTYPE
Определения 3_Game/constants.c:632
const int VARIABLE_CLEANNESS
Определения 3_Game/constants.c:635
const int VARIABLE_COLOR
Определения 3_Game/constants.c:634
const int VARIABLE_TEMPERATURE
Определения 3_Game/constants.c:630
const int VARIABLE_QUANTITY
Определения 3_Game/constants.c:628
const int VARIABLE_WET
Определения 3_Game/constants.c:631
const int LIQUID_NONE
Определения 3_Game/constants.c:529
static proto float AbsFloat(float f)
Returns absolute value.
const int MENU_INVENTORY
Определения 3_Game/constants.c:180
proto native bool dBodyIsDynamic(notnull IEntity ent)
const int SAT_CRAFTING
Определения 3_Game/constants.c:453
const int SAT_DEBUG_ACTION
Определения 3_Game/constants.c:454
class JsonUndergroundAreaTriggerData GetPosition
Определения UndergroundAreaLoader.c:9
static proto string Format(string fmt, void param1=NULL, void param2=NULL, void param3=NULL, void param4=NULL, void param5=NULL, void param6=NULL, void param7=NULL, void param8=NULL, void param9=NULL)
Gets n-th character from string.
const int CALL_CATEGORY_GAMEPLAY
Определения 3_Game/tools/tools.c:10
const int CALL_CATEGORY_SYSTEM
Определения 3_Game/tools/tools.c:8
proto native int GetColor()

Используется в Mask_Base::ConsumeQuantity(), InventoryItem::ConvertEnergyToQuantity(), CAContinuousMineWood::CreatePrimaryItems(), InventoryItem::GetBaitEffectivity(), Mask_Base::GetFilterQuantityMax(), InventoryItem::GetProtectionLevel(), InventoryItem::GetTemperatureFreezeTime(), InventoryItem::GetTemperatureThawTime(), Mask_Base::HasIntegratedFilter(), InventoryItem::InitItemVariables(), InventoryItem::IsLiquidPresent(), InventoryItem::OnWasAttached(), InventoryItem::OnWasDetached(), InventoryItem::SetCEBasedQuantity() и InventoryItem::SetQuantity().