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

◆ GetSoakingIncrement()

float SpawnItemOnLocation::GetSoakingIncrement ( string pIncrementName)
protected

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

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