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

◆ EEOnAfterLoad()

override void SpawnItemOnLocation::EEOnAfterLoad ( )
protected

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

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