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

◆ SetStoreLoad()

override void SpawnItemOnLocation::SetStoreLoad ( bool value)
protected

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

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