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

◆ GetItemModelLength()

float SpawnItemOnLocation::GetItemModelLength ( )
protected

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

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

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