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

◆ GetStoreLoadedQuantity()

override float SpawnItemOnLocation::GetStoreLoadedQuantity ( )
protected

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

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

Используется в InventoryItem::AfterStoreLoad() и InventoryItem::SetQuantity().