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

◆ ClearInventory()

override void SpawnItemOnLocation::ClearInventory ( )
protected

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

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

Используется в PluginBase::OnRPCClearInventory().