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

◆ GetWetMax()

override float SpawnItemOnLocation::GetWetMax ( )
protected

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

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

Используется в Entity::HasWetness(), InventoryItem::InitItemVariables(), InventoryItem::OnAction() и InventoryItem::SetWet().