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

◆ GetQuantityNormalized()

override float SpawnItemOnLocation::GetQuantityNormalized ( )
protected

Gets quantity in normalized 0..1 form between the item's Min a Max values as defined by item's config(for Min 0 and Max 5000, value 2500 will result in 0.5)

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

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

Используется в InventoryItem::GetBaitEffectivity(), InventoryItem::GetQuantityNormalizedScripted() и InventoryItem::OnQuantityChanged().