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

◆ SetWetMax()

override void SpawnItemOnLocation::SetWetMax ( )
protected

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

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