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

◆ GetQuantityNormalizedScripted()

override float GetQuantityNormalizedScripted ( )
protected

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

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