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

◆ GetWetInit()

override float SpawnItemOnLocation::GetWetInit ( )
protected

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

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