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

◆ GetLockSoundSet()

string SpawnItemOnLocation::GetLockSoundSet ( )
protected

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

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