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

◆ GetWetLevel()

override EWetnessLevel SpawnItemOnLocation::GetWetLevel ( )
protected

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

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