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

◆ GetTargetQuantityMax()

override int SpawnItemOnLocation::GetTargetQuantityMax ( int attSlotID = -1)
protected

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

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