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

◆ OnStoreSave()

override void SpawnItemOnLocation::OnStoreSave ( ParamsWriteContext ctx)
protected

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

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