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

◆ GetDryingIncrement()

float SpawnItemOnLocation::GetDryingIncrement ( string pIncrementName)
protected

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

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

Используется в InventoryItem::ProcessItemWetness().