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

◆ OnWetLevelChanged()

override void SpawnItemOnLocation::OnWetLevelChanged ( EWetnessLevel newLevel,
EWetnessLevel oldLevel )
protected

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

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