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

◆ GetNumberOfItems()

int SpawnItemOnLocation::GetNumberOfItems ( )
protected

Returns the number of items in cargo, otherwise returns 0(non-cargo objects). Recursive.

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

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

Используется в Barrel_ColorBase::CanDetachAttachment(), FireplaceBase::CanDetachAttachment(), ClothingBase::CanPutAsAttachment(), Barrel_ColorBase::CanPutInCargo(), Clothing::CanPutInCargo(), Clothing_Base::CanPutInCargoClothingConditions() и Barrel_ColorBase::CanPutIntoHands().