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

◆ GetLockType()

int SpawnItemOnLocation::GetLockType ( )
protected

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

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