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

◆ SetCleanness()

override void SpawnItemOnLocation::SetCleanness ( int value,
bool allow_client = false )
protected

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

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