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

◆ AddWet()

override void SpawnItemOnLocation::AddWet ( float value)
protected

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

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

Используется в InventoryItem::OnAction(), FlammableBase::OnWork() и InventoryItem::ProcessItemWetness().