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

◆ IsColorSet()

bool SpawnItemOnLocation::IsColorSet ( )
protected

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

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