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

◆ SetResultOfSplit()

void SpawnItemOnLocation::SetResultOfSplit ( bool value)
protected

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

7092{
7093 override bool CanPutAsAttachment(EntityAI parent)
7094 {
7095 return true;
7096 }
7097};
7098
7099//const bool QUANTITY_DEBUG_REMOVE_ME = false;
7100
7101class ItemBase extends InventoryItem
7102{
7106
7108
7109 static int m_DebugActionsMask;
7111 // ============================================
7112 // Variable Manipulation System
7113 // ============================================
7114 // Quantity
7115
7116 float m_VarQuantity;
7117 float m_VarQuantityPrev;//for client to know quantity changed during synchronization
7119 int m_VarQuantityMin;
7120 int m_VarQuantityMax;
7121 int m_Count;
7122 float m_VarStackMax;
7123 float m_StoreLoadedQuantity = float.LOWEST;
7124 // Wet
7125 float m_VarWet;
7126 float m_VarWetPrev;//for client to know wetness changed during synchronization
7127 float m_VarWetInit;
7128 float m_VarWetMin;
7129 float m_VarWetMax;
7130 // Cleanness
7131 int m_Cleanness;
7132 int m_CleannessInit;
7133 int m_CleannessMin;
7134 int m_CleannessMax;
7135 // impact sounds
7137 bool m_CanPlayImpactSound = true;
7138 float m_ImpactSpeed;
7140 //
7141 float m_HeatIsolation;
7142 float m_ItemModelLength;
7143 float m_ItemAttachOffset; // Offset length for when the item is attached e.g. to weapon
7145 int m_VarLiquidType;
7146 int m_ItemBehaviour; // -1 = not specified; 0 = heavy item; 1= onehanded item; 2 = twohanded item
7147 int m_QuickBarBonus;
7148 bool m_IsBeingPlaced;
7149 bool m_IsHologram;
7150 bool m_IsTakeable;
7151 bool m_ThrowItemOnDrop;
7154 bool m_FixDamageSystemInit = false; //can be changed on storage version check
7155 bool can_this_be_combined; //Check if item can be combined
7156 bool m_CanThisBeSplit; //Check if item can be split
7157 bool m_IsStoreLoad = false;
7158 bool m_CanShowQuantity;
7159 bool m_HasQuantityBar;
7160 protected bool m_CanBeDigged;
7161 protected bool m_IsResultOfSplit
7162
7163 string m_SoundAttType;
7164 // items color variables
7169 //-------------------------------------------------------
7170
7171 // light source managing
7173
7177
7178 //==============================================
7179 // agent system
7180 private int m_AttachedAgents;
7181
7183 void TransferModifiers(PlayerBase reciever);
7184
7185
7186 // Weapons & suppressors particle effects
7191 static int m_LastRegisteredWeaponID = 0;
7192
7193 // Overheating effects
7195 float m_OverheatingShots;
7196 ref Timer m_CheckOverheating;
7197 int m_ShotsToStartOverheating = 0; // After these many shots, the overheating effect begins
7198 int m_MaxOverheatingValue = 0; // Limits the number of shots that will be tracked
7199 float m_OverheatingDecayInterval = 1; // Timer's interval for decrementing overheat effect's lifespan
7200 ref array <ref OverheatingParticle> m_OverheatingParticles;
7201
7203 protected bool m_HideSelectionsBySlot;
7204
7205 // Admin Log
7206 PluginAdminLog m_AdminLog;
7207
7208 // misc
7209 ref Timer m_PhysDropTimer;
7210
7211 // Attachment Locking variables
7212 ref array<int> m_CompatibleLocks;
7213 protected int m_LockType;
7214 protected ref EffectSound m_LockingSound;
7215 protected string m_LockSoundSet;
7216
7217 // ItemSoundHandler
7218 protected const int ITEM_SOUNDS_MAX = 63; // optimize network synch
7219 protected int m_SoundSyncPlay; // id for sound to play
7220 protected int m_SoundSyncStop; // id for sound to stop
7222
7223 //temperature
7224 private float m_TemperaturePerQuantityWeight;
7225
7226 // -------------------------------------------------------------------------
7227 void ItemBase()
7228 {
7229 SetEventMask(EntityEvent.INIT); // Enable EOnInit event
7233
7234 if (!GetGame().IsDedicatedServer())
7235 {
7236 if (HasMuzzle())
7237 {
7239
7241 {
7243 }
7244 }
7245
7247 m_ActionsInitialize = false;
7248 }
7249
7250 m_OldLocation = null;
7251
7252 if (GetGame().IsServer())
7253 {
7254 m_AdminLog = PluginAdminLog.Cast(GetPlugin(PluginAdminLog));
7255 }
7256
7257 if (ConfigIsExisting("headSelectionsToHide"))
7258 {
7260 ConfigGetTextArray("headSelectionsToHide",m_HeadHidingSelections);
7261 }
7262
7263 m_HideSelectionsBySlot = false;
7264 if (ConfigIsExisting("hideSelectionsByinventorySlot"))
7265 {
7266 m_HideSelectionsBySlot = ConfigGetBool("hideSelectionsByinventorySlot");
7267 }
7268
7269 m_QuickBarBonus = Math.Max(0, ConfigGetInt("quickBarBonus"));
7270
7271 m_IsResultOfSplit = false;
7272
7274 }
7275
7276 override void InitItemVariables()
7277 {
7278 super.InitItemVariables();
7279
7280 m_VarQuantityInit = ConfigGetInt("varQuantityInit");
7281 m_VarQuantity = m_VarQuantityInit;//should be by the CE, this is just a precaution
7282 m_VarQuantityMin = ConfigGetInt("varQuantityMin");
7283 m_VarQuantityMax = ConfigGetInt("varQuantityMax");
7284 m_VarStackMax = ConfigGetFloat("varStackMax");
7285 m_Count = ConfigGetInt("count");
7286
7287 m_CanShowQuantity = ConfigGetBool("quantityShow");
7288 m_HasQuantityBar = ConfigGetBool("quantityBar");
7289
7290 m_CleannessInit = ConfigGetInt("varCleannessInit");
7292 m_CleannessMin = ConfigGetInt("varCleannessMin");
7293 m_CleannessMax = ConfigGetInt("varCleannessMax");
7294
7295 m_WantPlayImpactSound = false;
7296 m_ImpactSpeed = 0.0;
7297
7298 m_VarWetInit = ConfigGetFloat("varWetInit");
7300 m_VarWetMin = ConfigGetFloat("varWetMin");
7301 m_VarWetMax = ConfigGetFloat("varWetMax");
7302
7303 m_LiquidContainerMask = ConfigGetInt("liquidContainerType");
7304 if (IsLiquidContainer() && GetQuantity() != 0)
7306 m_IsBeingPlaced = false;
7307 m_IsHologram = false;
7308 m_IsTakeable = true;
7309 m_CanBeMovedOverride = false;
7313 m_CanBeDigged = ConfigGetBool("canBeDigged");
7314
7315 m_CompatibleLocks = new array<int>();
7316 ConfigGetIntArray("compatibleLocks", m_CompatibleLocks);
7317 m_LockType = ConfigGetInt("lockType");
7318
7319 //Define if item can be split and set ability to be combined accordingly
7320 m_CanThisBeSplit = false;
7321 can_this_be_combined = false;
7322 if (ConfigIsExisting("canBeSplit"))
7323 {
7324 can_this_be_combined = ConfigGetBool("canBeSplit");
7326 }
7327
7328 m_ItemBehaviour = -1;
7329 if (ConfigIsExisting("itemBehaviour"))
7330 m_ItemBehaviour = ConfigGetInt("itemBehaviour");
7331
7332 //RegisterNetSyncVariableInt("m_VariablesMask");
7333 if (HasQuantity()) RegisterNetSyncVariableFloat("m_VarQuantity", GetQuantityMin(), m_VarQuantityMax);
7334 RegisterNetSyncVariableFloat("m_VarWet", GetWetMin(), GetWetMax(), 2);
7335 RegisterNetSyncVariableInt("m_VarLiquidType");
7336 RegisterNetSyncVariableInt("m_Cleanness",0,1);
7337
7338 RegisterNetSyncVariableBoolSignal("m_WantPlayImpactSound");
7339 RegisterNetSyncVariableFloat("m_ImpactSpeed");
7340 RegisterNetSyncVariableInt("m_ImpactSoundSurfaceHash");
7341
7342 RegisterNetSyncVariableInt("m_ColorComponentR", 0, 255);
7343 RegisterNetSyncVariableInt("m_ColorComponentG", 0, 255);
7344 RegisterNetSyncVariableInt("m_ColorComponentB", 0, 255);
7345 RegisterNetSyncVariableInt("m_ColorComponentA", 0, 255);
7346
7347 RegisterNetSyncVariableBool("m_IsBeingPlaced");
7348 RegisterNetSyncVariableBool("m_IsTakeable");
7349 RegisterNetSyncVariableBool("m_IsHologram");
7350
7351 InitItemSounds();
7353 {
7354 RegisterNetSyncVariableInt("m_SoundSyncPlay", 0, ITEM_SOUNDS_MAX);
7355 RegisterNetSyncVariableInt("m_SoundSyncStop", 0, ITEM_SOUNDS_MAX);
7356 }
7357
7358 m_LockSoundSet = ConfigGetString("lockSoundSet");
7359
7361 if (ConfigIsExisting("temperaturePerQuantityWeight"))
7362 m_TemperaturePerQuantityWeight = ConfigGetFloat("temperaturePerQuantityWeight");
7363
7364 }
7365
7366 override int GetQuickBarBonus()
7367 {
7368 return m_QuickBarBonus;
7369 }
7370
7371 void InitializeActions()
7372 {
7374 if (!m_InputActionMap)
7375 {
7377 m_InputActionMap = iam;
7378 SetActions();
7380 }
7381 }
7382
7383 override void GetActions(typename action_input_type, out array<ActionBase_Basic> actions)
7384 {
7386 {
7387 m_ActionsInitialize = true;
7389 }
7390
7391 actions = m_InputActionMap.Get(action_input_type);
7392 }
7393
7394 void SetActions()
7395 {
7396 AddAction(ActionTakeItem);
7397 AddAction(ActionTakeItemToHands);
7398 AddAction(ActionWorldCraft);
7400 AddAction(ActionAttachWithSwitch);
7401 }
7402
7403 void SetActionAnimOverrides(); // Override action animation for specific item
7404
7405 void AddAction(typename actionName)
7406 {
7407 ActionBase action = ActionManagerBase.GetAction(actionName);
7408
7409 if (!action)
7410 {
7411 Debug.LogError("Action " + actionName + " dosn't exist!");
7412 return;
7413 }
7414
7415 typename ai = action.GetInputType();
7416 if (!ai)
7417 {
7418 m_ActionsInitialize = false;
7419 return;
7420 }
7421
7422 array<ActionBase_Basic> action_array = m_InputActionMap.Get(ai);
7423 if (!action_array)
7424 {
7425 action_array = new array<ActionBase_Basic>;
7426 m_InputActionMap.Insert(ai, action_array);
7427 }
7428 if (LogManager.IsActionLogEnable())
7429 {
7430 Debug.ActionLog(action.ToString() + " -> " + ai, this.ToString() , "n/a", "Add action");
7431 }
7432
7433 if (action_array.Find(action) != -1)
7434 {
7435 Debug.Log("Action " + action.Type() + " already added to " + this + ", skipping!");
7436 }
7437 else
7438 {
7439 action_array.Insert(action);
7440 }
7441 }
7442
7443 void RemoveAction(typename actionName)
7444 {
7445 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
7446 ActionBase action = player.GetActionManager().GetAction(actionName);
7447 typename ai = action.GetInputType();
7448 array<ActionBase_Basic> action_array = m_InputActionMap.Get(ai);
7449
7450 if (action_array)
7451 {
7452 action_array.RemoveItem(action);
7453 }
7454 }
7455
7456 // Allows override of default action command per item, defined in the SetActionAnimOverrides() of the item's class
7457 // Set -1 for params which should stay in default state
7458 void OverrideActionAnimation(typename action, int commandUID, int stanceMask = -1, int commandUIDProne = -1)
7459 {
7460 ActionOverrideData overrideData = new ActionOverrideData();
7461 overrideData.m_CommandUID = commandUID;
7462 overrideData.m_CommandUIDProne = commandUIDProne;
7463 overrideData.m_StanceMask = stanceMask;
7464
7465 TActionAnimOverrideMap actionMap = m_ItemActionOverrides.Get(action);
7466 if (!actionMap) // create new map of action > overidables map
7467 {
7468 actionMap = new TActionAnimOverrideMap();
7469 m_ItemActionOverrides.Insert(action, actionMap);
7470 }
7471
7472 actionMap.Insert(this.Type(), overrideData); // insert item -> overrides
7473
7474 }
7475
7476 void OnItemInHandsPlayerSwimStart(PlayerBase player);
7477
7478 ScriptedLightBase GetLight();
7479
7480 // Loads muzzle flash particle configuration from config and saves it to a map for faster access
7481 void LoadParticleConfigOnFire(int id)
7482 {
7483 if (!m_OnFireEffect)
7485
7488
7489 string config_to_search = "CfgVehicles";
7490 string muzzle_owner_config;
7491
7492 if (!m_OnFireEffect.Contains(id))
7493 {
7494 if (IsInherited(Weapon))
7495 config_to_search = "CfgWeapons";
7496
7497 muzzle_owner_config = config_to_search + " " + GetType() + " ";
7498
7499 string config_OnFire_class = muzzle_owner_config + "Particles " + "OnFire ";
7500
7501 int config_OnFire_subclass_count = GetGame().ConfigGetChildrenCount(config_OnFire_class);
7502
7503 if (config_OnFire_subclass_count > 0)
7504 {
7505 array<ref WeaponParticlesOnFire> WPOF_array = new array<ref WeaponParticlesOnFire>;
7506
7507 for (int i = 0; i < config_OnFire_subclass_count; i++)
7508 {
7509 string particle_class = "";
7510 GetGame().ConfigGetChildName(config_OnFire_class, i, particle_class);
7511 string config_OnFire_entry = config_OnFire_class + particle_class;
7512 WeaponParticlesOnFire WPOF = new WeaponParticlesOnFire(this, config_OnFire_entry);
7513 WPOF_array.Insert(WPOF);
7514 }
7515
7516
7517 m_OnFireEffect.Insert(id, WPOF_array);
7518 }
7519 }
7520
7521 if (!m_OnBulletCasingEjectEffect.Contains(id))
7522 {
7523 config_to_search = "CfgWeapons"; // Bullet Eject efect is supported on weapons only.
7524 muzzle_owner_config = config_to_search + " " + GetType() + " ";
7525
7526 string config_OnBulletCasingEject_class = muzzle_owner_config + "Particles " + "OnBulletCasingEject ";
7527
7528 int config_OnBulletCasingEject_count = GetGame().ConfigGetChildrenCount(config_OnBulletCasingEject_class);
7529
7530 if (config_OnBulletCasingEject_count > 0 && IsInherited(Weapon))
7531 {
7532 array<ref WeaponParticlesOnBulletCasingEject> WPOBE_array = new array<ref WeaponParticlesOnBulletCasingEject>;
7533
7534 for (i = 0; i < config_OnBulletCasingEject_count; i++)
7535 {
7536 string particle_class2 = "";
7537 GetGame().ConfigGetChildName(config_OnBulletCasingEject_class, i, particle_class2);
7538 string config_OnBulletCasingEject_entry = config_OnBulletCasingEject_class + particle_class2;
7539 WeaponParticlesOnBulletCasingEject WPOBE = new WeaponParticlesOnBulletCasingEject(this, config_OnBulletCasingEject_entry);
7540 WPOBE_array.Insert(WPOBE);
7541 }
7542
7543
7544 m_OnBulletCasingEjectEffect.Insert(id, WPOBE_array);
7545 }
7546 }
7547 }
7548
7549 // Loads muzzle flash particle configuration from config and saves it to a map for faster access
7551 {
7554
7555 if (!m_OnOverheatingEffect.Contains(id))
7556 {
7557 string config_to_search = "CfgVehicles";
7558
7559 if (IsInherited(Weapon))
7560 config_to_search = "CfgWeapons";
7561
7562 string muzzle_owner_config = config_to_search + " " + GetType() + " ";
7563 string config_OnOverheating_class = muzzle_owner_config + "Particles " + "OnOverheating ";
7564
7565 if (GetGame().ConfigIsExisting(config_OnOverheating_class))
7566 {
7567
7568 m_ShotsToStartOverheating = GetGame().ConfigGetFloat(config_OnOverheating_class + "shotsToStartOverheating");
7569
7571 {
7572 m_ShotsToStartOverheating = -1; // This prevents futher readings from config for future creations of this item
7573 string error = "Error reading config " + GetType() + ">Particles>OnOverheating - Parameter shotsToStartOverheating is configured wrong or is missing! Its value must be 1 or higher!";
7574 Error(error);
7575 return;
7576 }
7577
7578 m_OverheatingDecayInterval = GetGame().ConfigGetFloat(config_OnOverheating_class + "overheatingDecayInterval");
7579 m_MaxOverheatingValue = GetGame().ConfigGetFloat(config_OnOverheating_class + "maxOverheatingValue");
7580
7581
7582
7583 int config_OnOverheating_subclass_count = GetGame().ConfigGetChildrenCount(config_OnOverheating_class);
7584 array<ref WeaponParticlesOnOverheating> WPOOH_array = new array<ref WeaponParticlesOnOverheating>;
7585
7586 for (int i = 0; i < config_OnOverheating_subclass_count; i++)
7587 {
7588 string particle_class = "";
7589 GetGame().ConfigGetChildName(config_OnOverheating_class, i, particle_class);
7590 string config_OnOverheating_entry = config_OnOverheating_class + particle_class;
7591 int entry_type = GetGame().ConfigGetType(config_OnOverheating_entry);
7592
7593 if (entry_type == CT_CLASS)
7594 {
7595 WeaponParticlesOnOverheating WPOF = new WeaponParticlesOnOverheating(this, config_OnOverheating_entry);
7596 WPOOH_array.Insert(WPOF);
7597 }
7598 }
7599
7600
7601 m_OnOverheatingEffect.Insert(id, WPOOH_array);
7602 }
7603 }
7604 }
7605
7606 float GetOverheatingValue()
7607 {
7608 return m_OverheatingShots;
7609 }
7610
7611 void IncreaseOverheating(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
7612 {
7613 if (m_MaxOverheatingValue > 0)
7614 {
7616
7617 if (!m_CheckOverheating)
7619
7621 m_CheckOverheating.Run(m_OverheatingDecayInterval, this, "OnOverheatingDecay");
7622
7623 CheckOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
7624 }
7625 }
7626
7627 void CheckOverheating(ItemBase weapon = null, string ammoType = "", ItemBase muzzle_owner = null, ItemBase suppressor = null, string config_to_search = "")
7628 {
7630 UpdateOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
7631
7633 StartOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
7634
7636 StopOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
7637
7639 {
7641 }
7642 }
7643
7645 {
7647 }
7648
7649 void OnOverheatingDecay()
7650 {
7651 if (m_MaxOverheatingValue > 0)
7652 m_OverheatingShots -= 1 + m_OverheatingShots / m_MaxOverheatingValue; // The hotter a barrel is, the faster it needs to cool down.
7653 else
7655
7656 if (m_OverheatingShots <= 0)
7657 {
7660 }
7661 else
7662 {
7663 if (!m_CheckOverheating)
7665
7667 m_CheckOverheating.Run(m_OverheatingDecayInterval, this, "OnOverheatingDecay");
7668 }
7669
7670 CheckOverheating(this, "", this);
7671 }
7672
7673 void StartOverheating(ItemBase weapon = null, string ammoType = "", ItemBase muzzle_owner = null, ItemBase suppressor = null, string config_to_search = "")
7674 {
7676 ItemBase.PlayOverheatingParticles(this, ammoType, this, suppressor, "CfgWeapons");
7677 }
7678
7679 void UpdateOverheating(ItemBase weapon = null, string ammoType = "", ItemBase muzzle_owner = null, ItemBase suppressor = null, string config_to_search = "")
7680 {
7682 ItemBase.UpdateOverheatingParticles(this, ammoType, this, suppressor, "CfgWeapons");
7684 }
7685
7686 void StopOverheating(ItemBase weapon = null, string ammoType = "", ItemBase muzzle_owner = null, ItemBase suppressor = null, string config_to_search = "")
7687 {
7689 ItemBase.StopOverheatingParticles(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
7690 }
7691
7692 void RegisterOverheatingParticle(Particle p, float min_heat_coef, float max_heat_coef, int particle_id, Object parent, vector local_pos, vector local_ori)
7693 {
7695 m_OverheatingParticles = new array<ref OverheatingParticle>;
7696
7697 OverheatingParticle OP = new OverheatingParticle();
7698 OP.RegisterParticle(p);
7699 OP.SetOverheatingLimitMin(min_heat_coef);
7700 OP.SetOverheatingLimitMax(max_heat_coef);
7701 OP.SetParticleParams(particle_id, parent, local_pos, local_ori);
7702
7703 m_OverheatingParticles.Insert(OP);
7704 }
7705
7706 float GetOverheatingCoef()
7707 {
7708 if (m_MaxOverheatingValue > 0)
7710
7711 return -1;
7712 }
7713
7715 {
7717 {
7718 float overheat_coef = GetOverheatingCoef();
7719 int count = m_OverheatingParticles.Count();
7720
7721 for (int i = count; i > 0; --i)
7722 {
7723 int id = i - 1;
7724 OverheatingParticle OP = m_OverheatingParticles.Get(id);
7725 Particle p = OP.GetParticle();
7726
7727 float overheat_min = OP.GetOverheatingLimitMin();
7728 float overheat_max = OP.GetOverheatingLimitMax();
7729
7730 if (overheat_coef < overheat_min && overheat_coef >= overheat_max)
7731 {
7732 if (p)
7733 {
7734 p.Stop();
7735 OP.RegisterParticle(null);
7736 }
7737 }
7738 }
7739 }
7740 }
7741
7743 {
7745 {
7746 for (int i = m_OverheatingParticles.Count(); i > 0; i--)
7747 {
7748 int id = i - 1;
7749 OverheatingParticle OP = m_OverheatingParticles.Get(id);
7750
7751 if (OP)
7752 {
7753 Particle p = OP.GetParticle();
7754
7755 if (p)
7756 {
7757 p.Stop();
7758 }
7759
7760 delete OP;
7761 }
7762 }
7763
7764 m_OverheatingParticles.Clear();
7766 }
7767 }
7768
7770 float GetInfectionChance(int system = 0, Param param = null)
7771 {
7772 return 0.0;
7773 }
7774
7775
7776 float GetDisinfectQuantity(int system = 0, Param param1 = null)
7777 {
7778 return 250;//default value
7779 }
7780
7781 float GetFilterDamageRatio()
7782 {
7783 return 0;
7784 }
7785
7787 bool HasMuzzle()
7788 {
7789 if (IsInherited(Weapon) || IsInherited(SuppressorBase))
7790 return true;
7791
7792 return false;
7793 }
7794
7796 int GetMuzzleID()
7797 {
7798 if (!m_WeaponTypeToID)
7800
7801 if (m_WeaponTypeToID.Contains(GetType()))
7802 {
7803 return m_WeaponTypeToID.Get(GetType());
7804 }
7805 else
7806 {
7807 // Register new weapon ID
7809 }
7810
7812 }
7813
7820 {
7821 return -1;
7822 }
7823
7824
7825
7826 // -------------------------------------------------------------------------
7827 void ~ItemBase()
7828 {
7829 if (GetGame() && GetGame().GetPlayer() && (!GetGame().IsDedicatedServer()))
7830 {
7831 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
7832 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
7833
7834 if (r_index >= 0)
7835 {
7836 InventoryLocation r_il = new InventoryLocation;
7837 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
7838
7839 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
7840 int r_type = r_il.GetType();
7841 if (r_type == InventoryLocationType.CARGO || r_type == InventoryLocationType.PROXYCARGO)
7842 {
7843 r_il.GetParent().GetOnReleaseLock().Invoke(this);
7844 }
7845 else if (r_type == InventoryLocationType.ATTACHMENT)
7846 {
7847 r_il.GetParent().GetOnAttachmentReleaseLock().Invoke(this, r_il.GetSlot());
7848 }
7849
7850 }
7851
7852 player.GetHumanInventory().ClearUserReservedLocation(this);
7853 }
7854
7855 if (m_LockingSound)
7856 SEffectManager.DestroyEffect(m_LockingSound);
7857 }
7858
7859
7860
7861 // -------------------------------------------------------------------------
7862 static int GetDebugActionsMask()
7863 {
7864 return ItemBase.m_DebugActionsMask;
7865 }
7866
7867 static bool HasDebugActionsMask(int mask)
7868 {
7869 return ItemBase.m_DebugActionsMask & mask;
7870 }
7871
7872 static void SetDebugActionsMask(int mask)
7873 {
7874 ItemBase.m_DebugActionsMask = mask;
7875 }
7876
7877 static void AddDebugActionsMask(int mask)
7878 {
7879 ItemBase.m_DebugActionsMask |= mask;
7880 }
7881
7882 static void RemoveDebugActionsMask(int mask)
7883 {
7884 ItemBase.m_DebugActionsMask &= ~mask;
7885 }
7886
7887 static void ToggleDebugActionsMask(int mask)
7888 {
7889 if (HasDebugActionsMask(mask))
7890 {
7892 }
7893 else
7894 {
7895 AddDebugActionsMask(mask);
7896 }
7897 }
7898
7899 // -------------------------------------------------------------------------
7900 void SetCEBasedQuantity()
7901 {
7902 if (GetEconomyProfile())
7903 {
7904 float q_max = GetEconomyProfile().GetQuantityMax();
7905 if (q_max > 0)
7906 {
7907 float q_min = GetEconomyProfile().GetQuantityMin();
7908 float quantity_randomized = Math.RandomFloatInclusive(q_min, q_max);
7909
7910 if (HasComponent(COMP_TYPE_ENERGY_MANAGER))//more direct access for speed
7911 {
7912 ComponentEnergyManager comp = GetCompEM();
7913 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
7914 {
7915 comp.SetEnergy0To1(quantity_randomized);
7916 }
7917 }
7918 else if (HasQuantity())
7919 {
7920 SetQuantityNormalized(quantity_randomized, false);
7921 //PrintString("<==> Normalized quantity for item: "+ GetType()+", qmin:"+q_min.ToString()+"; qmax:"+q_max.ToString()+";quantity:" +quantity_randomized.ToString());
7922 }
7923
7924 }
7925 }
7926 }
7927
7929 void LockToParent()
7930 {
7931 EntityAI parent = GetHierarchyParent();
7932
7933 if (parent)
7934 {
7935 InventoryLocation inventory_location_to_lock = new InventoryLocation;
7936 GetInventory().GetCurrentInventoryLocation(inventory_location_to_lock);
7937 parent.GetInventory().SetSlotLock(inventory_location_to_lock.GetSlot(), true);
7938 }
7939 }
7940
7942 void UnlockFromParent()
7943 {
7944 EntityAI parent = GetHierarchyParent();
7945
7946 if (parent)
7947 {
7948 InventoryLocation inventory_location_to_unlock = new InventoryLocation;
7949 GetInventory().GetCurrentInventoryLocation(inventory_location_to_unlock);
7950 parent.GetInventory().SetSlotLock(inventory_location_to_unlock.GetSlot(), false);
7951 }
7952 }
7953
7954 override void CombineItemsClient(EntityAI entity2, bool use_stack_max = true)
7955 {
7956 /*
7957 ref Param1<EntityAI> item = new Param1<EntityAI>(entity2);
7958 RPCSingleParam(ERPCs.RPC_ITEM_COMBINE, item, GetGame().GetPlayer());
7959 */
7960 ItemBase item2 = ItemBase.Cast(entity2);
7961
7962 if (GetGame().IsClient())
7963 {
7964 if (ScriptInputUserData.CanStoreInputUserData())
7965 {
7966 ScriptInputUserData ctx = new ScriptInputUserData;
7968 ctx.Write(-1);
7969 ItemBase i1 = this; // @NOTE: workaround for correct serialization
7970 ctx.Write(i1);
7971 ctx.Write(item2);
7972 ctx.Write(use_stack_max);
7973 ctx.Write(-1);
7974 ctx.Send();
7975
7976 if (IsCombineAll(item2, use_stack_max))
7977 {
7978 GetGame().GetPlayer().GetInventory().AddInventoryReservationEx(item2,null,GameInventory.c_InventoryReservationTimeoutShortMS);
7979 }
7980 }
7981 }
7982 else if (!GetGame().IsMultiplayer())
7983 {
7984 CombineItems(item2, use_stack_max);
7985 }
7986 }
7987
7988 bool IsLiquidPresent()
7989 {
7990 return (GetLiquidType() != 0 && HasQuantity());
7991 }
7992
7993 bool IsLiquidContainer()
7994 {
7995 return m_LiquidContainerMask != 0;
7996 }
7997
7999 {
8000 return m_LiquidContainerMask;
8001 }
8002
8003 bool IsBloodContainer()
8004 {
8005 //m_LiquidContainerMask & GROUP_LIQUID_BLOOD ???
8006 return false;
8007 }
8008
8009 bool IsNVG()
8010 {
8011 return false;
8012 }
8013
8016 bool IsExplosive()
8017 {
8018 return false;
8019 }
8020
8022 {
8023 return "";
8024 }
8025
8027
8028 bool IsLightSource()
8029 {
8030 return false;
8031 }
8032
8034 {
8035 return true;
8036 }
8037
8038 //--- ACTION CONDITIONS
8039 //direction
8040 bool IsFacingPlayer(PlayerBase player, string selection)
8041 {
8042 return true;
8043 }
8044
8045 bool IsPlayerInside(PlayerBase player, string selection)
8046 {
8047 return true;
8048 }
8049
8050 override bool CanObstruct()
8051 {
8052 PlayerBase player = PlayerBase.Cast(g_Game.GetPlayer());
8053 return !player || !IsPlayerInside(player, "");
8054 }
8055
8056 override bool IsBeingPlaced()
8057 {
8058 return m_IsBeingPlaced;
8059 }
8060
8061 void SetIsBeingPlaced(bool is_being_placed)
8062 {
8063 m_IsBeingPlaced = is_being_placed;
8064 if (!is_being_placed)
8066 SetSynchDirty();
8067 }
8068
8069 //server-side
8070 void OnEndPlacement() {}
8071
8072 override bool IsHologram()
8073 {
8074 return m_IsHologram;
8075 }
8076
8077 bool CanBeDigged()
8078 {
8079 return m_CanBeDigged;
8080 }
8081
8083 {
8084 return 1;
8085 }
8086
8087 bool CanMakeGardenplot()
8088 {
8089 return false;
8090 }
8091
8092 void SetIsHologram(bool is_hologram)
8093 {
8094 m_IsHologram = is_hologram;
8095 SetSynchDirty();
8096 }
8097 /*
8098 protected float GetNutritionalEnergy()
8099 {
8100 Edible_Base edible = Edible_Base.Cast(this);
8101 return edible.GetFoodEnergy();
8102 }
8103
8104 protected float GetNutritionalWaterContent()
8105 {
8106 Edible_Base edible = Edible_Base.Cast(this);
8107 return edible.GetFoodWater();
8108 }
8109
8110 protected float GetNutritionalIndex()
8111 {
8112 Edible_Base edible = Edible_Base.Cast(this);
8113 return edible.GetFoodNutritionalIndex();
8114 }
8115
8116 protected float GetNutritionalFullnessIndex()
8117 {
8118 Edible_Base edible = Edible_Base.Cast(this);
8119 return edible.GetFoodTotalVolume();
8120 }
8121
8122 protected float GetNutritionalToxicity()
8123 {
8124 Edible_Base edible = Edible_Base.Cast(this);
8125 return edible.GetFoodToxicity();
8126
8127 }
8128 */
8129
8130
8131 // -------------------------------------------------------------------------
8132 override void OnMovedInsideCargo(EntityAI container)
8133 {
8134 super.OnMovedInsideCargo(container);
8135
8136 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
8137 }
8138
8139 override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
8140 {
8141 super.EEItemLocationChanged(oldLoc,newLoc);
8142
8143 PlayerBase new_player = null;
8144 PlayerBase old_player = null;
8145
8146 if (newLoc.GetParent())
8147 new_player = PlayerBase.Cast(newLoc.GetParent().GetHierarchyRootPlayer());
8148
8149 if (oldLoc.GetParent())
8150 old_player = PlayerBase.Cast(oldLoc.GetParent().GetHierarchyRootPlayer());
8151
8152 if (old_player && oldLoc.GetType() == InventoryLocationType.HANDS)
8153 {
8154 int r_index = old_player.GetHumanInventory().FindUserReservedLocationIndex(this);
8155
8156 if (r_index >= 0)
8157 {
8158 InventoryLocation r_il = new InventoryLocation;
8159 old_player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
8160
8161 old_player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
8162 int r_type = r_il.GetType();
8163 if (r_type == InventoryLocationType.CARGO || r_type == InventoryLocationType.PROXYCARGO)
8164 {
8165 r_il.GetParent().GetOnReleaseLock().Invoke(this);
8166 }
8167 else if (r_type == InventoryLocationType.ATTACHMENT)
8168 {
8169 r_il.GetParent().GetOnAttachmentReleaseLock().Invoke(this, r_il.GetSlot());
8170 }
8171
8172 }
8173 }
8174
8175 if (newLoc.GetType() == InventoryLocationType.HANDS)
8176 {
8177 if (new_player)
8178 new_player.ForceStandUpForHeavyItems(newLoc.GetItem());
8179
8180 if (new_player == old_player)
8181 {
8182
8183 if (oldLoc.GetParent() && new_player.GetHumanInventory().LocationGetEntity(oldLoc) == NULL)
8184 {
8185 if (oldLoc.GetType() == InventoryLocationType.CARGO)
8186 {
8187 if (oldLoc.GetParent().GetInventory().TestAddEntityInCargoExLoc(oldLoc, false, false, false, true, false, false))
8188 {
8189 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
8190 }
8191 }
8192 else
8193 {
8194 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
8195 }
8196 }
8197
8198 if (new_player.GetHumanInventory().FindUserReservedLocationIndex(this) >= 0)
8199 {
8200 int type = oldLoc.GetType();
8201 if (type == InventoryLocationType.CARGO || type == InventoryLocationType.PROXYCARGO)
8202 {
8203 oldLoc.GetParent().GetOnSetLock().Invoke(this);
8204 }
8205 else if (type == InventoryLocationType.ATTACHMENT)
8206 {
8207 oldLoc.GetParent().GetOnAttachmentSetLock().Invoke(this, oldLoc.GetSlot());
8208 }
8209 }
8210 if (!m_OldLocation)
8211 {
8212 m_OldLocation = new InventoryLocation;
8213 }
8214 m_OldLocation.Copy(oldLoc);
8215 }
8216 else
8217 {
8218 if (m_OldLocation)
8219 {
8220 m_OldLocation.Reset();
8221 }
8222 }
8223
8225 }
8226 else
8227 {
8228 if (new_player)
8229 {
8230 int res_index = new_player.GetHumanInventory().FindCollidingUserReservedLocationIndex(this, newLoc);
8231 if (res_index >= 0)
8232 {
8233 InventoryLocation il = new InventoryLocation;
8234 new_player.GetHumanInventory().GetUserReservedLocation(res_index,il);
8235 ItemBase it = ItemBase.Cast(il.GetItem());
8236 new_player.GetHumanInventory().ClearUserReservedLocationAtIndex(res_index);
8237 int rel_type = il.GetType();
8238 if (rel_type == InventoryLocationType.CARGO || rel_type == InventoryLocationType.PROXYCARGO)
8239 {
8240 il.GetParent().GetOnReleaseLock().Invoke(it);
8241 }
8242 else if (rel_type == InventoryLocationType.ATTACHMENT)
8243 {
8244 il.GetParent().GetOnAttachmentReleaseLock().Invoke(it, il.GetSlot());
8245 }
8246 //it.GetOnReleaseLock().Invoke(it);
8247 }
8248 }
8249 else if (old_player && newLoc.GetType() == InventoryLocationType.GROUND && m_ThrowItemOnDrop)
8250 {
8251 //ThrowPhysically(old_player, vector.Zero);
8252 m_ThrowItemOnDrop = false;
8253 }
8254
8255 if (m_OldLocation)
8256 {
8257 m_OldLocation.Reset();
8258 }
8259 }
8260 }
8261
8262 override void EOnContact(IEntity other, Contact extra)
8263 {
8265 {
8266 int liquidType = -1;
8267 float impactSpeed = ProcessImpactSoundEx(other, extra, m_ConfigWeight, m_ImpactSoundSurfaceHash, liquidType);
8268 if (impactSpeed > 0.0)
8269 {
8270 m_ImpactSpeed = impactSpeed;
8271 #ifndef SERVER
8272 PlayImpactSound(m_ConfigWeight, m_ImpactSpeed, m_ImpactSoundSurfaceHash);
8273 #else
8274 m_WantPlayImpactSound = true;
8275 SetSynchDirty();
8276 #endif
8277 m_CanPlayImpactSound = (liquidType == -1);// prevents further playing of the sound when the surface is a liquid type
8278 }
8279 }
8280
8281 #ifdef SERVER
8282 if (GetCompEM() && GetCompEM().IsPlugged())
8283 {
8284 if (GetCompEM().GetCordLength() < vector.Distance(GetPosition(), GetCompEM().GetEnergySource().GetPosition()))
8285 GetCompEM().UnplugThis();
8286 }
8287 #endif
8288 }
8289
8290 void RefreshPhysics();
8291
8292 override void OnCreatePhysics()
8293 {
8295 }
8296
8297 override void OnItemAttachmentSlotChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
8298 {
8299
8300 }
8301 // -------------------------------------------------------------------------
8302 override void OnItemLocationChanged(EntityAI old_owner, EntityAI new_owner)
8303 {
8304 super.OnItemLocationChanged(old_owner, new_owner);
8305
8306 PlayerBase relatedPlayer = PlayerBase.Cast(old_owner);
8307 PlayerBase playerNew = PlayerBase.Cast(new_owner);
8308
8309 if (!relatedPlayer && playerNew)
8310 relatedPlayer = playerNew;
8311
8312 if (relatedPlayer && relatedPlayer.GetPerformedActionID() != -1)
8313 {
8314 ActionManagerBase actionMgr = relatedPlayer.GetActionManager();
8315 if (actionMgr)
8316 {
8317 ActionBase currentAction = actionMgr.GetRunningAction();
8318 if (currentAction)
8319 currentAction.OnItemLocationChanged(this);
8320 }
8321 }
8322
8323 Man ownerPlayerOld = null;
8324 Man ownerPlayerNew = null;
8325
8326 if (old_owner)
8327 {
8328 if (old_owner.IsMan())
8329 {
8330 ownerPlayerOld = Man.Cast(old_owner);
8331 }
8332 else
8333 {
8334 ownerPlayerOld = Man.Cast(old_owner.GetHierarchyRootPlayer());
8335 }
8336 }
8337 else
8338 {
8339 if (new_owner && IsElectricAppliance() && GetCompEM() && GetCompEM().IsPlugged())
8340 {
8341 ActionBase action = ActionManagerBase.GetAction(ActionRepositionPluggedItem);
8342
8343 if (!action || !playerNew || playerNew.GetPerformedActionID() != action.GetID())
8344 {
8345 GetCompEM().UnplugThis();
8346 }
8347 }
8348 }
8349
8350 if (new_owner)
8351 {
8352 if (new_owner.IsMan())
8353 {
8354 ownerPlayerNew = Man.Cast(new_owner);
8355 }
8356 else
8357 {
8358 ownerPlayerNew = Man.Cast(new_owner.GetHierarchyRootPlayer());
8359 }
8360 }
8361
8362 if (ownerPlayerOld != ownerPlayerNew)
8363 {
8364 if (ownerPlayerOld)
8365 {
8366 array<EntityAI> subItemsExit = new array<EntityAI>;
8367 GetInventory().EnumerateInventory(InventoryTraversalType.PREORDER,subItemsExit);
8368 for (int i = 0; i < subItemsExit.Count(); i++)
8369 {
8370 ItemBase itemExit = ItemBase.Cast(subItemsExit.Get(i));
8371 itemExit.OnInventoryExit(ownerPlayerOld);
8372 }
8373 }
8374
8375 if (ownerPlayerNew)
8376 {
8377 array<EntityAI> subItemsEnter = new array<EntityAI>;
8378 GetInventory().EnumerateInventory(InventoryTraversalType.PREORDER,subItemsEnter);
8379 for (int j = 0; j < subItemsEnter.Count(); j++)
8380 {
8381 ItemBase itemEnter = ItemBase.Cast(subItemsEnter.Get(j));
8382 itemEnter.OnInventoryEnter(ownerPlayerNew);
8383 }
8384 }
8385 }
8386 else if (ownerPlayerNew != null)
8387 {
8388 PlayerBase nplayer;
8389 if (PlayerBase.CastTo(nplayer, ownerPlayerNew))
8390 {
8391 array<EntityAI> subItemsUpdate = new array<EntityAI>;
8392 GetInventory().EnumerateInventory(InventoryTraversalType.PREORDER,subItemsUpdate);
8393 for (int k = 0; k < subItemsUpdate.Count(); k++)
8394 {
8395 ItemBase itemUpdate = ItemBase.Cast(subItemsUpdate.Get(k));
8396 itemUpdate.UpdateQuickbarShortcutVisibility(nplayer);
8397 }
8398 }
8399 }
8400
8401 if (old_owner)
8402 old_owner.OnChildItemRemoved(this);
8403 if (new_owner)
8404 new_owner.OnChildItemReceived(this);
8405 }
8406
8407 // -------------------------------------------------------------------------------
8408 override void EEDelete(EntityAI parent)
8409 {
8410 super.EEDelete(parent);
8411 PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
8412 if (player)
8413 {
8414 OnInventoryExit(player);
8415
8416 if (player.IsAlive())
8417 {
8418 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
8419 if (r_index >= 0)
8420 {
8421 InventoryLocation r_il = new InventoryLocation;
8422 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
8423
8424 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
8425 int r_type = r_il.GetType();
8426 if (r_type == InventoryLocationType.CARGO || r_type == InventoryLocationType.PROXYCARGO)
8427 {
8428 r_il.GetParent().GetOnReleaseLock().Invoke(this);
8429 }
8430 else if (r_type == InventoryLocationType.ATTACHMENT)
8431 {
8432 r_il.GetParent().GetOnAttachmentReleaseLock().Invoke(this, r_il.GetSlot());
8433 }
8434
8435 }
8436
8437 player.RemoveQuickBarEntityShortcut(this);
8438 }
8439 }
8440 }
8441 // -------------------------------------------------------------------------------
8442 override void EEKilled(Object killer)
8443 {
8444 super.EEKilled(killer);
8445
8447 if (killer && killer.IsFireplace() && CanExplodeInFire())
8448 {
8449 if (GetTemperature() >= GameConstants.ITEM_TEMPERATURE_TO_EXPLODE_MIN)
8450 {
8451 if (IsMagazine())
8452 {
8453 if (Magazine.Cast(this).GetAmmoCount() > 0)
8454 {
8455 ExplodeAmmo();
8456 }
8457 }
8458 else
8459 {
8460 Explode(DamageType.EXPLOSION);
8461 }
8462 }
8463 }
8464 }
8465
8466 override void OnWasAttached(EntityAI parent, int slot_id)
8467 {
8468 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
8469
8470 super.OnWasAttached(parent, slot_id);
8471
8472 if (HasQuantity())
8473 UpdateNetSyncVariableFloat("m_VarQuantity", GetQuantityMin(), m_VarQuantityMax);
8474
8475 PlayAttachSound(InventorySlots.GetSlotName(slot_id));
8476 }
8477
8478 override void OnWasDetached(EntityAI parent, int slot_id)
8479 {
8480 super.OnWasDetached(parent, slot_id);
8481
8482 if (HasQuantity())
8483 UpdateNetSyncVariableFloat("m_VarQuantity", GetQuantityMin(), m_VarQuantityMax);
8484 }
8485
8486 override string ChangeIntoOnAttach(string slot)
8487 {
8488 int idx;
8489 TStringArray inventory_slots = new TStringArray;
8490 TStringArray attach_types = new TStringArray;
8491
8492 ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
8493 if (inventory_slots.Count() < 1) //is string
8494 {
8495 inventory_slots.Insert(ConfigGetString("ChangeInventorySlot"));
8496 attach_types.Insert(ConfigGetString("ChangeIntoOnAttach"));
8497 }
8498 else //is array
8499 {
8500 ConfigGetTextArray("ChangeIntoOnAttach",attach_types);
8501 }
8502
8503 idx = inventory_slots.Find(slot);
8504 if (idx < 0)
8505 return "";
8506
8507 return attach_types.Get(idx);
8508 }
8509
8510 override string ChangeIntoOnDetach()
8511 {
8512 int idx = -1;
8513 string slot;
8514
8515 TStringArray inventory_slots = new TStringArray;
8516 TStringArray detach_types = new TStringArray;
8517
8518 this.ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
8519 if (inventory_slots.Count() < 1) //is string
8520 {
8521 inventory_slots.Insert(this.ConfigGetString("ChangeInventorySlot"));
8522 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
8523 }
8524 else //is array
8525 {
8526 this.ConfigGetTextArray("ChangeIntoOnDetach",detach_types);
8527 if (detach_types.Count() < 1)
8528 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
8529 }
8530
8531 for (int i = 0; i < inventory_slots.Count(); i++)
8532 {
8533 slot = inventory_slots.Get(i);
8534 }
8535
8536 if (slot != "")
8537 {
8538 if (detach_types.Count() == 1)
8539 idx = 0;
8540 else
8541 idx = inventory_slots.Find(slot);
8542 }
8543 if (idx < 0)
8544 return "";
8545
8546 return detach_types.Get(idx);
8547 }
8548
8549 void ExplodeAmmo()
8550 {
8551 //timer
8552 ref Timer explode_timer = new Timer(CALL_CATEGORY_SYSTEM);
8553
8554 //min/max time
8555 float min_time = 1;
8556 float max_time = 3;
8557 float delay = Math.RandomFloat(min_time, max_time);
8558
8559 explode_timer.Run(delay, this, "DoAmmoExplosion");
8560 }
8561
8562 void DoAmmoExplosion()
8563 {
8564 Magazine magazine = Magazine.Cast(this);
8565 int pop_sounds_count = 6;
8566 string pop_sounds[ 6 ] = { "ammopops_1","ammopops_2","ammopops_3","ammopops_4","ammopops_5","ammopops_6" };
8567
8568 //play sound
8569 int sound_idx = Math.RandomInt(0, pop_sounds_count - 1);
8570 string sound_name = pop_sounds[ sound_idx ];
8571 GetGame().CreateSoundOnObject(this, sound_name, 20, false);
8572
8573 //remove ammo count
8574 magazine.ServerAddAmmoCount(-1);
8575
8576 //if condition then repeat -> ExplodeAmmo
8577 float min_temp_to_explode = 100; //min temperature for item to explode
8578
8579 if (magazine.GetAmmoCount() > 0 && GetTemperature() >= min_temp_to_explode) //TODO ? add check for parent -> fireplace
8580 {
8581 ExplodeAmmo();
8582 }
8583 }
8584
8585 // -------------------------------------------------------------------------------
8586 override void EEHitBy(TotalDamageResult damageResult, int damageType, EntityAI source, int component, string dmgZone, string ammo, vector modelPos, float speedCoef)
8587 {
8588 super.EEHitBy(damageResult, damageType, source, component, dmgZone, ammo, modelPos, speedCoef);
8589
8590 const int CHANCE_DAMAGE_CARGO = 4;
8591 const int CHANCE_DAMAGE_ATTACHMENT = 1;
8592 const int CHANCE_DAMAGE_NOTHING = 2;
8593
8594 if (IsClothing() || IsContainer() || IsItemTent())
8595 {
8596 float dmg = damageResult.GetDamage("","Health") * -0.5;
8597 int chances;
8598 int rnd;
8599
8600 if (GetInventory().GetCargo())
8601 {
8602 chances = CHANCE_DAMAGE_CARGO + CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
8603 rnd = Math.RandomInt(0,chances);
8604
8605 if (rnd < CHANCE_DAMAGE_CARGO)
8606 {
8607 DamageItemInCargo(dmg);
8608 }
8609 else if (rnd < (chances - CHANCE_DAMAGE_NOTHING))
8610 {
8612 }
8613 }
8614 else
8615 {
8616 chances = CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
8617 rnd = Math.RandomInt(0,chances);
8618
8619 if (rnd < CHANCE_DAMAGE_ATTACHMENT)
8620 {
8622 }
8623 }
8624 }
8625 }
8626
8627 bool DamageItemInCargo(float damage)
8628 {
8629 if (GetInventory().GetCargo())
8630 {
8631 int item_count = GetInventory().GetCargo().GetItemCount();
8632 if (item_count > 0)
8633 {
8634 int random_pick = Math.RandomInt(0, item_count);
8635 ItemBase item = ItemBase.Cast(GetInventory().GetCargo().GetItem(random_pick));
8636 if (!item.IsExplosive())
8637 {
8638 item.AddHealth("","",damage);
8639 return true;
8640 }
8641 }
8642 }
8643 return false;
8644 }
8645
8646 bool DamageItemAttachments(float damage)
8647 {
8648 int attachment_count = GetInventory().AttachmentCount();
8649 if (attachment_count > 0)
8650 {
8651 int random_pick = Math.RandomInt(0, attachment_count);
8652 ItemBase attachment = ItemBase.Cast(GetInventory().GetAttachmentFromIndex(random_pick));
8653 if (!attachment.IsExplosive())
8654 {
8655 attachment.AddHealth("","",damage);
8656 return true;
8657 }
8658 }
8659 return false;
8660 }
8661
8662 override bool IsSplitable()
8663 {
8664 return m_CanThisBeSplit;
8665 }
8666 //----------------
8667 override bool CanBeSplit()
8668 {
8669 if (IsSplitable() && (GetQuantity() > 1))
8670 return GetInventory().CanRemoveEntity();
8671
8672 return false;
8673 }
8674
8675 protected bool ShouldSplitQuantity(float quantity)
8676 {
8677 // don't call 'CanBeSplit' here, too strict and will introduce a freeze-crash when dismantling fence with a fireplace nearby
8678 if (!IsSplitable())
8679 return false;
8680
8681 // nothing to split?
8682 if (GetQuantity() <= 1)
8683 return false;
8684
8685 // check if we should re-use the item instead of creating a new copy?
8686 // implicit cast to int, if 'IsSplitable' returns true, these values are assumed ints
8687 int delta = GetQuantity() - quantity;
8688 if (delta == 0)
8689 return false;
8690
8691 // valid to split
8692 return true;
8693 }
8694
8695 override void SplitIntoStackMaxClient(EntityAI destination_entity, int slot_id )
8696 {
8697 if (GetGame().IsClient())
8698 {
8699 if (ScriptInputUserData.CanStoreInputUserData())
8700 {
8701 ScriptInputUserData ctx = new ScriptInputUserData;
8703 ctx.Write(1);
8704 ItemBase i1 = this; // @NOTE: workaround for correct serialization
8705 ctx.Write(i1);
8706 ctx.Write(destination_entity);
8707 ctx.Write(true);
8708 ctx.Write(slot_id);
8709 ctx.Send();
8710 }
8711 }
8712 else if (!GetGame().IsMultiplayer())
8713 {
8714 SplitIntoStackMax(destination_entity, slot_id, PlayerBase.Cast(GetGame().GetPlayer()));
8715 }
8716 }
8717
8718 void SplitIntoStackMax(EntityAI destination_entity, int slot_id, PlayerBase player)
8719 {
8720 float split_quantity_new;
8721 ItemBase new_item;
8722 float quantity = GetQuantity();
8723 float stack_max = GetTargetQuantityMax(slot_id);
8724 InventoryLocation loc = new InventoryLocation;
8725
8726 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
8727 {
8728 if (stack_max <= GetQuantity())
8729 split_quantity_new = stack_max;
8730 else
8731 split_quantity_new = GetQuantity();
8732
8733 if (ShouldSplitQuantity(split_quantity_new))
8734 {
8735 new_item = ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(this.GetType(), slot_id));
8736 if (new_item)
8737 {
8738 new_item.SetResultOfSplit(true);
8739 MiscGameplayFunctions.TransferItemProperties(this, new_item);
8740 AddQuantity(-split_quantity_new, false, true);
8741 new_item.SetQuantity(split_quantity_new, false, true);
8742 }
8743 }
8744 }
8745 else if (destination_entity && slot_id == -1)
8746 {
8747 if (quantity > stack_max)
8748 split_quantity_new = stack_max;
8749 else
8750 split_quantity_new = quantity;
8751
8752 if (ShouldSplitQuantity(split_quantity_new))
8753 {
8754 if (destination_entity.GetInventory().FindFreeLocationFor(this, FindInventoryLocationType.ANY, loc))
8755 {
8756 Object o = destination_entity.GetInventory().LocationCreateEntity(loc, GetType(), ECE_IN_INVENTORY, RF_DEFAULT);
8757 new_item = ItemBase.Cast(o);
8758 }
8759
8760 if (new_item)
8761 {
8762 new_item.SetResultOfSplit(true);
8763 MiscGameplayFunctions.TransferItemProperties(this, new_item);
8764 AddQuantity(-split_quantity_new, false, true);
8765 new_item.SetQuantity(split_quantity_new, false, true);
8766 }
8767 }
8768 }
8769 else
8770 {
8771 if (stack_max != 0)
8772 {
8773 if (stack_max < GetQuantity())
8774 {
8775 split_quantity_new = GetQuantity() - stack_max;
8776 }
8777
8778 if (split_quantity_new == 0)
8779 {
8780 if (!GetGame().IsMultiplayer())
8781 player.PhysicalPredictiveDropItem(this);
8782 else
8783 player.ServerDropEntity(this);
8784 return;
8785 }
8786
8787 if (ShouldSplitQuantity(split_quantity_new))
8788 {
8789 new_item = ItemBase.Cast(GetGame().CreateObjectEx(GetType(), player.GetWorldPosition(), ECE_PLACE_ON_SURFACE));
8790
8791 if (new_item)
8792 {
8793 new_item.SetResultOfSplit(true);
8794 MiscGameplayFunctions.TransferItemProperties(this, new_item);
8795 SetQuantity(split_quantity_new, false, true);
8796 new_item.SetQuantity(stack_max, false, true);
8797 new_item.PlaceOnSurface();
8798 }
8799 }
8800 }
8801 }
8802 }
8803
8804 override void SplitIntoStackMaxEx(EntityAI destination_entity, int slot_id)
8805 {
8806 float split_quantity_new;
8807 ItemBase new_item;
8808 float quantity = GetQuantity();
8809 float stack_max = GetTargetQuantityMax(slot_id);
8810 InventoryLocation loc = new InventoryLocation;
8811
8812 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
8813 {
8814 if (stack_max <= GetQuantity())
8815 split_quantity_new = stack_max;
8816 else
8817 split_quantity_new = GetQuantity();
8818
8819 if (ShouldSplitQuantity(split_quantity_new))
8820 {
8821 new_item = ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(this.GetType(), slot_id));
8822 if (new_item)
8823 {
8824 new_item.SetResultOfSplit(true);
8825 MiscGameplayFunctions.TransferItemProperties(this, new_item);
8826 AddQuantity(-split_quantity_new, false, true);
8827 new_item.SetQuantity(split_quantity_new, false, true);
8828 }
8829 }
8830 }
8831 else if (destination_entity && slot_id == -1)
8832 {
8833 if (quantity > stack_max)
8834 split_quantity_new = stack_max;
8835 else
8836 split_quantity_new = quantity;
8837
8838 if (ShouldSplitQuantity(split_quantity_new))
8839 {
8840 if (destination_entity.GetInventory().FindFreeLocationFor(this, FindInventoryLocationType.ANY, loc))
8841 {
8842 Object o = destination_entity.GetInventory().LocationCreateEntity(loc, GetType(), ECE_IN_INVENTORY, RF_DEFAULT);
8843 new_item = ItemBase.Cast(o);
8844 }
8845
8846 if (new_item)
8847 {
8848 new_item.SetResultOfSplit(true);
8849 MiscGameplayFunctions.TransferItemProperties(this, new_item);
8850 AddQuantity(-split_quantity_new, false, true);
8851 new_item.SetQuantity(split_quantity_new, false, true);
8852 }
8853 }
8854 }
8855 else
8856 {
8857 if (stack_max != 0)
8858 {
8859 if (stack_max < GetQuantity())
8860 {
8861 split_quantity_new = GetQuantity() - stack_max;
8862 }
8863
8864 if (ShouldSplitQuantity(split_quantity_new))
8865 {
8866 new_item = ItemBase.Cast(GetGame().CreateObjectEx(GetType(),GetWorldPosition(), ECE_PLACE_ON_SURFACE));
8867
8868 if (new_item)
8869 {
8870 new_item.SetResultOfSplit(true);
8871 MiscGameplayFunctions.TransferItemProperties(this, new_item);
8872 SetQuantity(split_quantity_new, false, true);
8873 new_item.SetQuantity(stack_max, false, true);
8874 new_item.PlaceOnSurface();
8875 }
8876 }
8877 }
8878 }
8879 }
8880
8881 void SplitIntoStackMaxToInventoryLocationClient(notnull InventoryLocation dst)
8882 {
8883 if (GetGame().IsClient())
8884 {
8885 if (ScriptInputUserData.CanStoreInputUserData())
8886 {
8887 ScriptInputUserData ctx = new ScriptInputUserData;
8889 ctx.Write(4);
8890 ItemBase thiz = this; // @NOTE: workaround for correct serialization
8891 ctx.Write(thiz);
8892 dst.WriteToContext(ctx);
8893 ctx.Send();
8894 }
8895 }
8896 else if (!GetGame().IsMultiplayer())
8897 {
8899 }
8900 }
8901
8902 void SplitIntoStackMaxCargoClient(EntityAI destination_entity, int idx, int row, int col)
8903 {
8904 if (GetGame().IsClient())
8905 {
8906 if (ScriptInputUserData.CanStoreInputUserData())
8907 {
8908 ScriptInputUserData ctx = new ScriptInputUserData;
8910 ctx.Write(2);
8911 ItemBase dummy = this; // @NOTE: workaround for correct serialization
8912 ctx.Write(dummy);
8913 ctx.Write(destination_entity);
8914 ctx.Write(true);
8915 ctx.Write(idx);
8916 ctx.Write(row);
8917 ctx.Write(col);
8918 ctx.Send();
8919 }
8920 }
8921 else if (!GetGame().IsMultiplayer())
8922 {
8923 SplitIntoStackMaxCargo(destination_entity, idx, row, col);
8924 }
8925 }
8926
8927 void SplitIntoStackMaxToInventoryLocation(notnull InventoryLocation dst)
8928 {
8930 }
8931
8932 ItemBase SplitIntoStackMaxToInventoryLocationEx(notnull InventoryLocation dst)
8933 {
8934 float quantity = GetQuantity();
8935 float split_quantity_new;
8936 ItemBase new_item;
8937 if (dst.IsValid())
8938 {
8939 int slot_id = dst.GetSlot();
8940 float stack_max = GetTargetQuantityMax(slot_id);
8941
8942 if (quantity > stack_max)
8943 split_quantity_new = stack_max;
8944 else
8945 split_quantity_new = quantity;
8946
8947 if (ShouldSplitQuantity(split_quantity_new))
8948 {
8949 new_item = ItemBase.Cast(GameInventory.LocationCreateEntity(dst, this.GetType(), ECE_IN_INVENTORY, RF_DEFAULT));
8950
8951 if (new_item)
8952 {
8953 new_item.SetResultOfSplit(true);
8954 MiscGameplayFunctions.TransferItemProperties(this,new_item);
8955 AddQuantity(-split_quantity_new, false, true);
8956 new_item.SetQuantity(split_quantity_new, false, true);
8957 }
8958
8959 return new_item;
8960 }
8961 }
8962
8963 return null;
8964 }
8965
8966 void SplitIntoStackMaxCargo(EntityAI destination_entity, int idx, int row, int col)
8967 {
8968 float quantity = GetQuantity();
8969 float split_quantity_new;
8970 ItemBase new_item;
8971 if (destination_entity)
8972 {
8973 float stackable = GetTargetQuantityMax();
8974 if (quantity > stackable)
8975 split_quantity_new = stackable;
8976 else
8977 split_quantity_new = quantity;
8978
8979 if (ShouldSplitQuantity(split_quantity_new))
8980 {
8981 new_item = ItemBase.Cast(destination_entity.GetInventory().CreateEntityInCargoEx(this.GetType(), idx, row, col, false));
8982 if (new_item)
8983 {
8984 new_item.SetResultOfSplit(true);
8985 MiscGameplayFunctions.TransferItemProperties(this,new_item);
8986 AddQuantity(-split_quantity_new, false, true);
8987 new_item.SetQuantity(split_quantity_new, false, true);
8988 }
8989 }
8990 }
8991 }
8992
8993 void SplitIntoStackMaxHandsClient(PlayerBase player)
8994 {
8995 if (GetGame().IsClient())
8996 {
8997 if (ScriptInputUserData.CanStoreInputUserData())
8998 {
8999 ScriptInputUserData ctx = new ScriptInputUserData;
9001 ctx.Write(3);
9002 ItemBase i1 = this; // @NOTE: workaround for correct serialization
9003 ctx.Write(i1);
9004 ItemBase destination_entity = this;
9005 ctx.Write(destination_entity);
9006 ctx.Write(true);
9007 ctx.Write(0);
9008 ctx.Send();
9009 }
9010 }
9011 else if (!GetGame().IsMultiplayer())
9012 {
9013 SplitIntoStackMaxHands(player);
9014 }
9015 }
9016
9017 void SplitIntoStackMaxHands(PlayerBase player)
9018 {
9019 float quantity = GetQuantity();
9020 float split_quantity_new;
9021 ref ItemBase new_item;
9022 if (player)
9023 {
9024 float stackable = GetTargetQuantityMax();
9025 if (quantity > stackable)
9026 split_quantity_new = stackable;
9027 else
9028 split_quantity_new = quantity;
9029
9030 if (ShouldSplitQuantity(split_quantity_new))
9031 {
9032 EntityAI in_hands = player.GetHumanInventory().CreateInHands(this.GetType());
9033 new_item = ItemBase.Cast(in_hands);
9034 if (new_item)
9035 {
9036 new_item.SetResultOfSplit(true);
9037 MiscGameplayFunctions.TransferItemProperties(this,new_item);
9038 AddQuantity(-split_quantity_new, false, true);
9039 new_item.SetQuantity(split_quantity_new, false, true);
9040 }
9041 }
9042 }
9043 }
9044
9045 void SplitItemToInventoryLocation(notnull InventoryLocation dst)
9046 {
9047 float quantity = GetQuantity();
9048 float split_quantity_new = Math.Floor(quantity * 0.5);
9049
9050 if (!ShouldSplitQuantity(split_quantity_new))
9051 return;
9052
9053 ItemBase new_item = ItemBase.Cast(GameInventory.LocationCreateEntity(dst, GetType(), ECE_IN_INVENTORY, RF_DEFAULT));
9054
9055 if (new_item)
9056 {
9057 if (new_item.GetQuantityMax() < split_quantity_new)
9058 {
9059 split_quantity_new = new_item.GetQuantityMax();
9060 }
9061
9062 new_item.SetResultOfSplit(true);
9063 MiscGameplayFunctions.TransferItemProperties(this, new_item);
9064
9065 if (dst.IsValid() && dst.GetType() == InventoryLocationType.ATTACHMENT && split_quantity_new > 1)
9066 {
9067 AddQuantity(-1, false, true);
9068 new_item.SetQuantity(1, false, true);
9069 }
9070 else
9071 {
9072 AddQuantity(-split_quantity_new, false, true);
9073 new_item.SetQuantity(split_quantity_new, false, true);
9074 }
9075 }
9076 }
9077
9078 void SplitItem(PlayerBase player)
9079 {
9080 float quantity = GetQuantity();
9081 float split_quantity_new = Math.Floor(quantity / 2);
9082
9083 if (!ShouldSplitQuantity(split_quantity_new))
9084 return;
9085
9086 InventoryLocation invloc = new InventoryLocation;
9087 bool found = player.GetInventory().FindFirstFreeLocationForNewEntity(GetType(), FindInventoryLocationType.ATTACHMENT, invloc);
9088
9089 ItemBase new_item;
9090 new_item = player.CreateCopyOfItemInInventoryOrGroundEx(this, true);
9091
9092 if (new_item)
9093 {
9094 if (new_item.GetQuantityMax() < split_quantity_new)
9095 {
9096 split_quantity_new = new_item.GetQuantityMax();
9097 }
9098 if (found && invloc.IsValid() && invloc.GetType() == InventoryLocationType.ATTACHMENT && split_quantity_new > 1)
9099 {
9100 AddQuantity(-1, false, true);
9101 new_item.SetQuantity(1, false, true);
9102 }
9103 else if (split_quantity_new > 1)
9104 {
9105 AddQuantity(-split_quantity_new, false, true);
9106 new_item.SetQuantity(split_quantity_new, false, true);
9107 }
9108 }
9109 }
9110
9112 void OnQuantityChanged(float delta)
9113 {
9114 SetWeightDirty();
9115 ItemBase parent = ItemBase.Cast(GetHierarchyParent());
9116
9117 if (parent)
9118 parent.OnAttachmentQuantityChangedEx(this, delta);
9119
9120 if (IsLiquidContainer())
9121 {
9122 if (GetQuantityNormalized() <= 0.0)
9123 {
9125 }
9126 else if (GetLiquidType() == LIQUID_NONE)
9127 {
9128 ErrorEx("Undefined liquid type quantity changed, please define liquid type first! Using init value.",ErrorExSeverity.INFO);
9130 }
9131 }
9132
9133 }
9134
9137 {
9138 // insert code here
9139 }
9140
9142 void OnAttachmentQuantityChangedEx(ItemBase item , float delta)
9143 {
9145 }
9146
9147 override void EEHealthLevelChanged(int oldLevel, int newLevel, string zone)
9148 {
9149 super.EEHealthLevelChanged(oldLevel,newLevel,zone);
9150
9151 if (GetGame().IsServer())
9152 {
9153 if (newLevel == GameConstants.STATE_RUINED)
9154 {
9156 EntityAI parent = GetHierarchyParent();
9157 if (parent && parent.IsFireplace())
9158 {
9159 CargoBase cargo = GetInventory().GetCargo();
9160 if (cargo)
9161 {
9162 for (int i = 0; i < cargo.GetItemCount(); ++i)
9163 {
9164 parent.GetInventory().TakeEntityToInventory(InventoryMode.SERVER, FindInventoryLocationType.CARGO, cargo.GetItem(i));
9165 }
9166 }
9167 }
9168 }
9169
9170 if (IsResultOfSplit())
9171 {
9172 // reset the splitting result flag, return to normal item behavior
9173 SetResultOfSplit(false);
9174 return;
9175 }
9176
9177 if (m_Cleanness != 0 && oldLevel < newLevel && newLevel != 0)
9178 {
9179 SetCleanness(0);//unclean the item upon damage dealt
9180 }
9181 }
9182 }
9183
9184 // just the split? TODO: verify
9185 override void OnRightClick()
9186 {
9187 super.OnRightClick();
9188
9189 if (CanBeSplit() && !GetDayZGame().IsLeftCtrlDown() && !GetGame().GetPlayer().GetInventory().HasInventoryReservation(this,null))
9190 {
9191 if (GetGame().IsClient())
9192 {
9193 if (ScriptInputUserData.CanStoreInputUserData())
9194 {
9195 EntityAI root = GetHierarchyRoot();
9196 Man playerOwner = GetHierarchyRootPlayer();
9197 InventoryLocation dst = new InventoryLocation;
9198
9199 // 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
9200 if (!playerOwner && root && root == this)
9201 {
9203 }
9204 else
9205 {
9206 // 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
9207 GetInventory().GetCurrentInventoryLocation(dst);
9208 if (!dst.GetParent() || dst.GetParent() && !dst.GetParent().GetInventory().FindFreeLocationFor(this, FindInventoryLocationType.CARGO, dst))
9209 {
9210 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
9211 if (!player.GetInventory().FindFreeLocationFor(this, FindInventoryLocationType.CARGO, dst) || !playerOwner)
9212 {
9214 }
9215 else
9216 {
9217 dst.SetCargo(dst.GetParent(), this, dst.GetIdx(), dst.GetRow(), dst.GetCol(), dst.GetFlip());
9218 /* hacky solution to check reservation of "this" item instead of null since the gamecode is checking null against null and returning reservation=true incorrectly
9219 this shouldnt cause issues within this scope*/
9220 if (GetGame().GetPlayer().GetInventory().HasInventoryReservation(this, dst))
9221 {
9223 }
9224 else
9225 {
9226 GetGame().GetPlayer().GetInventory().AddInventoryReservationEx(null, dst, GameInventory.c_InventoryReservationTimeoutShortMS);
9227 }
9228 }
9229 }
9230 }
9231
9232 ScriptInputUserData ctx = new ScriptInputUserData;
9234 ctx.Write(4);
9235 ItemBase thiz = this; // @NOTE: workaround for correct serialization
9236 ctx.Write(thiz);
9237 dst.WriteToContext(ctx);
9238 ctx.Write(true); // dummy
9239 ctx.Send();
9240 }
9241 }
9242 else if (!GetGame().IsMultiplayer())
9243 {
9244 SplitItem(PlayerBase.Cast(GetGame().GetPlayer()));
9245 }
9246 }
9247 }
9248
9249 protected void SetInventoryLocationToVicinityOrCurrent(EntityAI root, inout InventoryLocation dst)
9250 {
9251 if (root)
9252 {
9253 vector m4[4];
9254 root.GetTransform(m4);
9255 dst.SetGround(this, m4);
9256 }
9257 else
9258 {
9259 GetInventory().GetCurrentInventoryLocation(dst);
9260 }
9261 }
9262
9263 override bool CanBeCombined(EntityAI other_item, bool reservation_check = true, bool stack_max_limit = false)
9264 {
9265 //TODO: delete check zero quantity check after fix double posts hands fsm events
9266 if (!other_item || GetType() != other_item.GetType() || (IsFullQuantity() && other_item.GetQuantity() > 0) || other_item == this)
9267 return false;
9268
9269 if (GetHealthLevel() == GameConstants.STATE_RUINED || other_item.GetHealthLevel() == GameConstants.STATE_RUINED)
9270 return false;
9271
9272 //can_this_be_combined = ConfigGetBool("canBeSplit");
9274 return false;
9275
9276
9277 Magazine mag = Magazine.Cast(this);
9278 if (mag)
9279 {
9280 if (mag.GetAmmoCount() >= mag.GetAmmoMax())
9281 return false;
9282
9283 if (stack_max_limit)
9284 {
9285 Magazine other_mag = Magazine.Cast(other_item);
9286 if (other_item)
9287 {
9288 if (mag.GetAmmoCount() + other_mag.GetAmmoCount() > mag.GetAmmoMax())
9289 return false;
9290 }
9291
9292 }
9293 }
9294 else
9295 {
9296 //TODO: delete check zero quantity check after fix double posts hands fsm events
9297 if (GetQuantity() >= GetQuantityMax() && other_item.GetQuantity() > 0 )
9298 return false;
9299
9300 if (stack_max_limit && (GetQuantity() + other_item.GetQuantity() > GetQuantityMax()))
9301 return false;
9302 }
9303
9304 PlayerBase player = null;
9305 if (CastTo(player, GetHierarchyRootPlayer())) //false when attached to player's attachment slot
9306 {
9307 if (player.GetInventory().HasAttachment(this))
9308 return false;
9309
9310 if (player.IsItemsToDelete())
9311 return false;
9312 }
9313
9314 if (reservation_check && (GetInventory().HasInventoryReservation(this, null) || other_item.GetInventory().HasInventoryReservation(other_item, null)))
9315 return false;
9316
9317 int slotID;
9318 string slotName;
9319 if (GetInventory().GetCurrentAttachmentSlotInfo(slotID,slotName) && GetHierarchyParent().GetInventory().GetSlotLock(slotID))
9320 return false;
9321
9322 return true;
9323 }
9324
9325 bool IsCombineAll(ItemBase other_item, bool use_stack_max = false)
9326 {
9327 return ComputeQuantityUsed(other_item, use_stack_max) == other_item.GetQuantity();
9328 }
9329
9330 bool IsResultOfSplit()
9331 {
9332 return m_IsResultOfSplit;
9333 }
9334
9335 void SetResultOfSplit(bool value)
9336 {
9337 m_IsResultOfSplit = value;
9338 }
9339
9340 int ComputeQuantityUsed(ItemBase other_item, bool use_stack_max = true)
9341 {
9342 return ComputeQuantityUsedEx(other_item, use_stack_max);
9343 }
9344
9345 float ComputeQuantityUsedEx(ItemBase other_item, bool use_stack_max = true)
9346 {
9347 float other_item_quantity = other_item.GetQuantity();
9348 float this_free_space;
9349
9350 float stack_max = GetQuantityMax();
9351
9352 this_free_space = stack_max - GetQuantity();
9353
9354 if (other_item_quantity > this_free_space)
9355 {
9356 return this_free_space;
9357 }
9358 else
9359 {
9360 return other_item_quantity;
9361 }
9362 }
9363
9364 override void CombineItemsEx(EntityAI entity2, bool use_stack_max = true)
9365 {
9366 CombineItems(ItemBase.Cast(entity2),use_stack_max);
9367 }
9368
9369 void CombineItems(ItemBase other_item, bool use_stack_max = true)
9370 {
9371 if (!CanBeCombined(other_item, false))
9372 return;
9373
9374 if (!IsMagazine() && other_item)
9375 {
9376 float quantity_used = ComputeQuantityUsedEx(other_item,use_stack_max);
9377 if (quantity_used != 0)
9378 {
9379 float hp1 = GetHealth01("","");
9380 float hp2 = other_item.GetHealth01("","");
9381 float hpResult = ((hp1*GetQuantity()) + (hp2*quantity_used));
9382 hpResult = hpResult / (GetQuantity() + quantity_used);
9383
9384 hpResult *= GetMaxHealth();
9385 Math.Round(hpResult);
9386 SetHealth("", "Health", hpResult);
9387
9388 AddQuantity(quantity_used);
9389 other_item.AddQuantity(-quantity_used);
9390 }
9391 }
9392 OnCombine(other_item);
9393 }
9394
9395 void OnCombine(ItemBase other_item)
9396 {
9397 #ifdef SERVER
9398 if (!GetHierarchyRootPlayer() && GetHierarchyParent())
9399 GetHierarchyParent().IncreaseLifetimeUp();
9400 #endif
9401 };
9402
9403 void GetRecipesActions(Man player, out TSelectableActionInfoArray outputList)
9404 {
9405 PlayerBase p = PlayerBase.Cast(player);
9406
9407 array<int> recipesIds = p.m_Recipes;
9408 PluginRecipesManager moduleRecipesManager = PluginRecipesManager.Cast(GetPlugin(PluginRecipesManager));
9409 if (moduleRecipesManager)
9410 {
9411 EntityAI itemInHands = player.GetHumanInventory().GetEntityInHands();
9412 moduleRecipesManager.GetValidRecipes(ItemBase.Cast(this), ItemBase.Cast(itemInHands), recipesIds, p);
9413 }
9414
9415 for (int i = 0;i < recipesIds.Count(); i++)
9416 {
9417 int key = recipesIds.Get(i);
9418 string recipeName = moduleRecipesManager.GetRecipeName(key);
9419 outputList.Insert(new TSelectableActionInfo(SAT_CRAFTING, key, recipeName));
9420 }
9421 }
9422
9423 // -------------------------------------------------------------------------
9424 override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
9425 {
9426 super.GetDebugActions(outputList);
9427
9428 //quantity
9429 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.ADD_QUANTITY, "Quantity +20%", FadeColors.LIGHT_GREY));
9430 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.REMOVE_QUANTITY, "Quantity -20%", FadeColors.LIGHT_GREY));
9431 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SET_QUANTITY_0, "Set Quantity 0", FadeColors.LIGHT_GREY));
9432 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SET_MAX_QUANTITY, "Set Quantity Max", FadeColors.LIGHT_GREY));
9433 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
9434
9435 //health
9436 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.ADD_HEALTH, "Health +20%", FadeColors.LIGHT_GREY));
9437 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.REMOVE_HEALTH, "Health -20%", FadeColors.LIGHT_GREY));
9438 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.DESTROY_HEALTH, "Health 0", FadeColors.LIGHT_GREY));
9439 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
9440 //temperature
9441 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.ADD_TEMPERATURE, "Temperature +20", FadeColors.LIGHT_GREY));
9442 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.REMOVE_TEMPERATURE, "Temperature -20", FadeColors.LIGHT_GREY));
9443 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.FLIP_FROZEN, "Toggle Frozen", FadeColors.LIGHT_GREY));
9444 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
9445
9446 //wet
9447 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.ADD_WETNESS, "Wetness +20", FadeColors.LIGHT_GREY));
9448 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.REMOVE_WETNESS, "Wetness -20", FadeColors.LIGHT_GREY));
9449 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
9450
9451 //liquidtype
9452 if (IsLiquidContainer())
9453 {
9454 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.LIQUIDTYPE_UP, "LiquidType Next", FadeColors.LIGHT_GREY));
9455 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.LIQUIDTYPE_DOWN, "LiquidType Previous", FadeColors.LIGHT_GREY));
9456 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
9457 }
9458
9459 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.MAKE_SPECIAL, "Make Special", FadeColors.LIGHT_GREY));
9460 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
9461
9462 // watch
9463 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.WATCH_ITEM, "Watch (CTRL-Z)", FadeColors.LIGHT_GREY));
9464 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.WATCH_PLAYER, "Watch Player", FadeColors.LIGHT_GREY));
9465 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
9466
9467 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.DELETE, "Delete", FadeColors.RED));
9468
9469 InventoryLocation loc = new InventoryLocation();
9470 GetInventory().GetCurrentInventoryLocation(loc);
9471 if (!loc || loc.GetType() == InventoryLocationType.GROUND)
9472 {
9473 if (Gizmo_IsSupported())
9474 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.GIZMO_OBJECT, "Gizmo Object", FadeColors.LIGHT_GREY));
9475 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.GIZMO_PHYSICS, "Gizmo Physics (SP Only)", FadeColors.LIGHT_GREY)); // intentionally allowed for testing physics desync
9476 }
9477
9478 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
9479 }
9480
9481 // -------------------------------------------------------------------------
9482 // -------------------------------------------------------------------------
9483 // -------------------------------------------------------------------------
9484 override bool OnAction(int action_id, Man player, ParamsReadContext ctx)
9485 {
9486 super.OnAction(action_id, player, ctx);
9487
9488 if (GetGame().IsClient() || !GetGame().IsMultiplayer())
9489 {
9490 switch (action_id)
9491 {
9492 case EActions.GIZMO_OBJECT:
9493 GetGame().GizmoSelectObject(this);
9494 return true;
9495 case EActions.GIZMO_PHYSICS:
9496 GetGame().GizmoSelectPhysics(GetPhysics());
9497 return true;
9498 }
9499 }
9500
9501 if (GetGame().IsServer())
9502 {
9503 switch (action_id)
9504 {
9505 case EActions.DELETE:
9506 Delete();
9507 return true;
9508 }
9509 }
9510
9511 if (action_id >= EActions.RECIPES_RANGE_START && action_id < EActions.RECIPES_RANGE_END)
9512 {
9513 PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast(GetPlugin(PluginRecipesManager));
9514 int idWithoutOffset = action_id - EActions.RECIPES_RANGE_START;
9515 PlayerBase p = PlayerBase.Cast(player);
9516 if (EActions.RECIPES_RANGE_START < 1000)
9517 {
9518 float anim_length = plugin_recipes_manager.GetRecipeLengthInSecs(idWithoutOffset);
9519 float specialty_weight = plugin_recipes_manager.GetRecipeSpecialty(idWithoutOffset);
9520 }
9521 }
9522 #ifndef SERVER
9523 else if (action_id == EActions.WATCH_PLAYER)
9524 {
9525 PluginDeveloper.SetDeveloperItemClientEx(player);
9526 }
9527 #endif
9528 if (GetGame().IsServer())
9529 {
9530 if (action_id >= EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START && action_id < EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_END)
9531 {
9532 int id = action_id - EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START;
9533 OnDebugButtonPressServer(id + 1);
9534 }
9535
9536 else if (action_id >= EActions.DEBUG_AGENTS_RANGE_INJECT_START && action_id < EActions.DEBUG_AGENTS_RANGE_INJECT_END)
9537 {
9538 int agent_id = action_id - EActions.DEBUG_AGENTS_RANGE_INJECT_START;
9539 InsertAgent(agent_id,100);
9540 }
9541
9542 else if (action_id >= EActions.DEBUG_AGENTS_RANGE_REMOVE_START && action_id < EActions.DEBUG_AGENTS_RANGE_REMOVE_END)
9543 {
9544 int agent_id2 = action_id - EActions.DEBUG_AGENTS_RANGE_REMOVE_START;
9545 RemoveAgent(agent_id2);
9546 }
9547
9548 else if (action_id == EActions.ADD_QUANTITY)
9549 {
9550 if (IsMagazine())
9551 {
9552 Magazine mag = Magazine.Cast(this);
9553 mag.ServerSetAmmoCount(mag.GetAmmoCount() + mag.GetAmmoMax() * 0.2);
9554 }
9555 else
9556 {
9557 AddQuantity(GetQuantityMax() * 0.2);
9558 }
9559
9560 if (m_EM)
9561 {
9562 m_EM.AddEnergy(m_EM.GetEnergyMax() * 0.2);
9563 }
9564 //PrintVariables();
9565 }
9566
9567 else if (action_id == EActions.REMOVE_QUANTITY) //Quantity -20%
9568 {
9569 if (IsMagazine())
9570 {
9571 Magazine mag2 = Magazine.Cast(this);
9572 mag2.ServerSetAmmoCount(mag2.GetAmmoCount() - mag2.GetAmmoMax() * 0.2);
9573 }
9574 else
9575 {
9576 AddQuantity(- GetQuantityMax() * 0.2);
9577 }
9578 if (m_EM)
9579 {
9580 m_EM.AddEnergy(- m_EM.GetEnergyMax() * 0.2);
9581 }
9582 //PrintVariables();
9583 }
9584
9585 else if (action_id == EActions.SET_QUANTITY_0) //SetMaxQuantity
9586 {
9587 SetQuantity(0);
9588
9589 if (m_EM)
9590 {
9591 m_EM.SetEnergy(0);
9592 }
9593 }
9594
9595 else if (action_id == EActions.SET_MAX_QUANTITY) //SetMaxQuantity
9596 {
9598
9599 if (m_EM)
9600 {
9601 m_EM.SetEnergy(m_EM.GetEnergyMax());
9602 }
9603 }
9604
9605 else if (action_id == EActions.ADD_HEALTH)
9606 {
9607 AddHealth("","",GetMaxHealth("","Health")/5);
9608 }
9609 else if (action_id == EActions.REMOVE_HEALTH)
9610 {
9611 AddHealth("","",-GetMaxHealth("","Health")/5);
9612 }
9613 else if (action_id == EActions.DESTROY_HEALTH)
9614 {
9615 SetHealth01("","",0);
9616 }
9617 else if (action_id == EActions.WATCH_ITEM)
9618 {
9620 mid.RegisterDebugItem(ItemBase.Cast(this), PlayerBase.Cast(player));
9621 #ifdef DEVELOPER
9622 SetDebugDeveloper_item(this);
9623 #endif
9624 }
9625
9626 else if (action_id == EActions.ADD_TEMPERATURE)
9627 {
9628 AddTemperature(20);
9629 //PrintVariables();
9630 }
9631
9632 else if (action_id == EActions.REMOVE_TEMPERATURE)
9633 {
9634 AddTemperature(-20);
9635 //PrintVariables();
9636 }
9637
9638 else if (action_id == EActions.FLIP_FROZEN)
9639 {
9640 SetFrozen(!GetIsFrozen());
9641 //PrintVariables();
9642 }
9643
9644 else if (action_id == EActions.ADD_WETNESS)
9645 {
9646 AddWet(GetWetMax()/5);
9647 //PrintVariables();
9648 }
9649
9650 else if (action_id == EActions.REMOVE_WETNESS)
9651 {
9652 AddWet(-GetWetMax()/5);
9653 //PrintVariables();
9654 }
9655
9656 else if (action_id == EActions.LIQUIDTYPE_UP)
9657 {
9658 int curr_type = GetLiquidType();
9659 SetLiquidType(curr_type * 2);
9660 //AddWet(1);
9661 //PrintVariables();
9662 }
9663
9664 else if (action_id == EActions.LIQUIDTYPE_DOWN)
9665 {
9666 int curr_type2 = GetLiquidType();
9667 SetLiquidType(curr_type2 / 2);
9668 }
9669
9670 else if (action_id == EActions.MAKE_SPECIAL)
9671 {
9672 auto debugParams = DebugSpawnParams.WithPlayer(player);
9673 OnDebugSpawnEx(debugParams);
9674 }
9675
9676 }
9677
9678
9679 return false;
9680 }
9681
9682 // -------------------------------------------------------------------------
9683
9684
9687 void OnActivatedByTripWire();
9688
9690 void OnActivatedByItem(notnull ItemBase item);
9691
9692 //----------------------------------------------------------------
9693 //returns true if item is able to explode when put in fire
9694 bool CanExplodeInFire()
9695 {
9696 return false;
9697 }
9698
9699 //----------------------------------------------------------------
9700 bool CanEat()
9701 {
9702 return true;
9703 }
9704
9705 //----------------------------------------------------------------
9706 override bool IsIgnoredByConstruction()
9707 {
9708 return true;
9709 }
9710
9711 //----------------------------------------------------------------
9712 //has FoodStages in config?
9713 bool HasFoodStage()
9714 {
9715 string config_path = string.Format("CfgVehicles %1 Food FoodStages", GetType());
9716 return GetGame().ConfigIsExisting(config_path);
9717 }
9718
9720 FoodStage GetFoodStage()
9721 {
9722 return null;
9723 }
9724
9725 bool CanBeCooked()
9726 {
9727 return false;
9728 }
9729
9730 bool CanBeCookedOnStick()
9731 {
9732 return false;
9733 }
9734
9736 void RefreshAudioVisualsOnClient( CookingMethodType cooking_method, bool is_done, bool is_empty, bool is_burned );
9738
9739 //----------------------------------------------------------------
9740 bool CanRepair(ItemBase item_repair_kit)
9741 {
9742 PluginRepairing module_repairing = PluginRepairing.Cast(GetPlugin(PluginRepairing));
9743 return module_repairing.CanRepair(this, item_repair_kit);
9744 }
9745
9746 //----------------------------------------------------------------
9747 bool Repair(PlayerBase player, ItemBase item_repair_kit, float specialty_weight)
9748 {
9749 PluginRepairing module_repairing = PluginRepairing.Cast(GetPlugin(PluginRepairing));
9750 return module_repairing.Repair(player, this, item_repair_kit, specialty_weight);
9751 }
9752
9753 //----------------------------------------------------------------
9754 int GetItemSize()
9755 {
9756 /*
9757 vector v_size = this.ConfigGetVector("itemSize");
9758 int v_size_x = v_size[0];
9759 int v_size_y = v_size[1];
9760 int size = v_size_x * v_size_y;
9761 return size;
9762 */
9763
9764 return 1;
9765 }
9766
9767 //----------------------------------------------------------------
9768 //Override for allowing seemingly unallowed moves when two clients send a conflicting message simultaneously
9769 bool CanBeMovedOverride()
9770 {
9771 return m_CanBeMovedOverride;
9772 }
9773
9774 //----------------------------------------------------------------
9775 //Override for allowing seemingly unallowed moves when two clients send a conflicting message simultaneously
9776 void SetCanBeMovedOverride(bool setting)
9777 {
9778 m_CanBeMovedOverride = setting;
9779 }
9780
9781 //----------------------------------------------------------------
9789 void MessageToOwnerStatus(string text)
9790 {
9791 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
9792
9793 if (player)
9794 {
9795 player.MessageStatus(text);
9796 }
9797 }
9798
9799 //----------------------------------------------------------------
9807 void MessageToOwnerAction(string text)
9808 {
9809 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
9810
9811 if (player)
9812 {
9813 player.MessageAction(text);
9814 }
9815 }
9816
9817 //----------------------------------------------------------------
9825 void MessageToOwnerFriendly(string text)
9826 {
9827 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
9828
9829 if (player)
9830 {
9831 player.MessageFriendly(text);
9832 }
9833 }
9834
9835 //----------------------------------------------------------------
9843 void MessageToOwnerImportant(string text)
9844 {
9845 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
9846
9847 if (player)
9848 {
9849 player.MessageImportant(text);
9850 }
9851 }
9852
9853 override bool IsItemBase()
9854 {
9855 return true;
9856 }
9857
9858 // Checks if item is of questioned kind
9859 override bool KindOf(string tag)
9860 {
9861 bool found = false;
9862 string item_name = this.GetType();
9863 ref TStringArray item_tag_array = new TStringArray;
9864 GetGame().ConfigGetTextArray("cfgVehicles " + item_name + " itemInfo", item_tag_array);
9865
9866 int array_size = item_tag_array.Count();
9867 for (int i = 0; i < array_size; i++)
9868 {
9869 if (item_tag_array.Get(i) == tag)
9870 {
9871 found = true;
9872 break;
9873 }
9874 }
9875 return found;
9876 }
9877
9878
9879 override void OnRPC(PlayerIdentity sender, int rpc_type,ParamsReadContext ctx)
9880 {
9881 //Debug.Log("OnRPC called");
9882 super.OnRPC(sender, rpc_type,ctx);
9883
9884 //Play soundset for attachment locking (ActionLockAttachment.c)
9885 switch (rpc_type)
9886 {
9887 #ifndef SERVER
9888 case ERPCs.RPC_SOUND_LOCK_ATTACH:
9889 Param2<bool, string> p = new Param2<bool, string>(false, "");
9890
9891 if (!ctx.Read(p))
9892 return;
9893
9894 bool play = p.param1;
9895 string soundSet = p.param2;
9896
9897 if (play)
9898 {
9899 if (m_LockingSound)
9900 {
9902 {
9903 m_LockingSound = SEffectManager.PlaySound(soundSet, GetPosition(), 0, 0, true);
9904 }
9905 }
9906 else
9907 {
9908 m_LockingSound = SEffectManager.PlaySound(soundSet, GetPosition(), 0, 0, true);
9909 }
9910 }
9911 else
9912 {
9913 SEffectManager.DestroyEffect(m_LockingSound);
9914 }
9915
9916 break;
9917 #endif
9918
9919 }
9920
9921 if (GetWrittenNoteData())
9922 {
9923 GetWrittenNoteData().OnRPC(sender, rpc_type,ctx);
9924 }
9925 }
9926
9927 //-----------------------------
9928 // VARIABLE MANIPULATION SYSTEM
9929 //-----------------------------
9930 int NameToID(string name)
9931 {
9932 PluginVariables plugin = PluginVariables.Cast(GetPlugin(PluginVariables));
9933 return plugin.GetID(name);
9934 }
9935
9936 string IDToName(int id)
9937 {
9938 PluginVariables plugin = PluginVariables.Cast(GetPlugin(PluginVariables));
9939 return plugin.GetName(id);
9940 }
9941
9943 void OnSyncVariables(ParamsReadContext ctx)//with ID optimization
9944 {
9945 //Debug.Log("OnSyncVariables called for item: "+ ToString(this.GetType()),"varSync");
9946 //read the flags
9947 int varFlags;
9948 if (!ctx.Read(varFlags))
9949 return;
9950
9951 if (varFlags & ItemVariableFlags.FLOAT)
9952 {
9953 ReadVarsFromCTX(ctx);
9954 }
9955 }
9956
9957 override void SerializeNumericalVars(array<float> floats_out)
9958 {
9959 //some variables handled on EntityAI level already!
9960 super.SerializeNumericalVars(floats_out);
9961
9962 // the order of serialization must be the same as the order of de-serialization
9963 //--------------------------------------------
9964 if (IsVariableSet(VARIABLE_QUANTITY))
9965 {
9966 floats_out.Insert(m_VarQuantity);
9967 }
9968 //--------------------------------------------
9969 if (IsVariableSet(VARIABLE_WET))
9970 {
9971 floats_out.Insert(m_VarWet);
9972 }
9973 //--------------------------------------------
9974 if (IsVariableSet(VARIABLE_LIQUIDTYPE))
9975 {
9976 floats_out.Insert(m_VarLiquidType);
9977 }
9978 //--------------------------------------------
9979 if (IsVariableSet(VARIABLE_COLOR))
9980 {
9981 floats_out.Insert(m_ColorComponentR);
9982 floats_out.Insert(m_ColorComponentG);
9983 floats_out.Insert(m_ColorComponentB);
9984 floats_out.Insert(m_ColorComponentA);
9985 }
9986 //--------------------------------------------
9987 if (IsVariableSet(VARIABLE_CLEANNESS))
9988 {
9989 floats_out.Insert(m_Cleanness);
9990 }
9991 }
9992
9993 override void DeSerializeNumericalVars(array<float> floats)
9994 {
9995 //some variables handled on EntityAI level already!
9996 super.DeSerializeNumericalVars(floats);
9997
9998 // the order of serialization must be the same as the order of de-serialization
9999 int index = 0;
10000 int mask = Math.Round(floats.Get(index));
10001
10002 index++;
10003 //--------------------------------------------
10004 if (mask & VARIABLE_QUANTITY)
10005 {
10006 if (m_IsStoreLoad)
10007 {
10008 SetStoreLoadedQuantity(floats.Get(index));
10009 }
10010 else
10011 {
10012 float quantity = floats.Get(index);
10013 SetQuantity(quantity, true, false, false, false);
10014 }
10015 index++;
10016 }
10017 //--------------------------------------------
10018 if (mask & VARIABLE_WET)
10019 {
10020 float wet = floats.Get(index);
10021 SetWet(wet);
10022 index++;
10023 }
10024 //--------------------------------------------
10025 if (mask & VARIABLE_LIQUIDTYPE)
10026 {
10027 int liquidtype = Math.Round(floats.Get(index));
10028 SetLiquidType(liquidtype);
10029 index++;
10030 }
10031 //--------------------------------------------
10032 if (mask & VARIABLE_COLOR)
10033 {
10034 m_ColorComponentR = Math.Round(floats.Get(index));
10035 index++;
10036 m_ColorComponentG = Math.Round(floats.Get(index));
10037 index++;
10038 m_ColorComponentB = Math.Round(floats.Get(index));
10039 index++;
10040 m_ColorComponentA = Math.Round(floats.Get(index));
10041 index++;
10042 }
10043 //--------------------------------------------
10044 if (mask & VARIABLE_CLEANNESS)
10045 {
10046 int cleanness = Math.Round(floats.Get(index));
10047 SetCleanness(cleanness);
10048 index++;
10049 }
10050 }
10051
10052 override void WriteVarsToCTX(ParamsWriteContext ctx)
10053 {
10054 super.WriteVarsToCTX(ctx);
10055
10056 //--------------------------------------------
10057 if (IsVariableSet(VARIABLE_QUANTITY))
10058 {
10059 ctx.Write(GetQuantity());
10060 }
10061 //--------------------------------------------
10062 if (IsVariableSet(VARIABLE_WET))
10063 {
10064 ctx.Write(GetWet());
10065 }
10066 //--------------------------------------------
10067 if (IsVariableSet(VARIABLE_LIQUIDTYPE))
10068 {
10069 ctx.Write(GetLiquidType());
10070 }
10071 //--------------------------------------------
10072 if (IsVariableSet(VARIABLE_COLOR))
10073 {
10074 int r,g,b,a;
10075 GetColor(r,g,b,a);
10076 ctx.Write(r);
10077 ctx.Write(g);
10078 ctx.Write(b);
10079 ctx.Write(a);
10080 }
10081 //--------------------------------------------
10082 if (IsVariableSet(VARIABLE_CLEANNESS))
10083 {
10084 ctx.Write(GetCleanness());
10085 }
10086 }
10087
10088 override bool ReadVarsFromCTX(ParamsReadContext ctx, int version = -1)//with ID optimization
10089 {
10090 if (!super.ReadVarsFromCTX(ctx,version))
10091 return false;
10092
10093 int intValue;
10094 float value;
10095
10096 if (version < 140)
10097 {
10098 if (!ctx.Read(intValue))
10099 return false;
10100
10101 m_VariablesMask = intValue;
10102 }
10103
10104 if (m_VariablesMask & VARIABLE_QUANTITY)
10105 {
10106 if (!ctx.Read(value))
10107 return false;
10108
10109 if (IsStoreLoad())
10110 {
10112 }
10113 else
10114 {
10115 SetQuantity(value, true, false, false, false);
10116 }
10117 }
10118 //--------------------------------------------
10119 if (version < 140)
10120 {
10121 if (m_VariablesMask & VARIABLE_TEMPERATURE)
10122 {
10123 if (!ctx.Read(value))
10124 return false;
10125 SetTemperatureDirect(value);
10126 }
10127 }
10128 //--------------------------------------------
10129 if (m_VariablesMask & VARIABLE_WET)
10130 {
10131 if (!ctx.Read(value))
10132 return false;
10133 SetWet(value);
10134 }
10135 //--------------------------------------------
10136 if (m_VariablesMask & VARIABLE_LIQUIDTYPE)
10137 {
10138 if (!ctx.Read(intValue))
10139 return false;
10140 SetLiquidType(intValue);
10141 }
10142 //--------------------------------------------
10143 if (m_VariablesMask & VARIABLE_COLOR)
10144 {
10145 int r,g,b,a;
10146 if (!ctx.Read(r))
10147 return false;
10148 if (!ctx.Read(g))
10149 return false;
10150 if (!ctx.Read(b))
10151 return false;
10152 if (!ctx.Read(a))
10153 return false;
10154
10155 SetColor(r,g,b,a);
10156 }
10157 //--------------------------------------------
10158 if (m_VariablesMask & VARIABLE_CLEANNESS)
10159 {
10160 if (!ctx.Read(intValue))
10161 return false;
10162 SetCleanness(intValue);
10163 }
10164 //--------------------------------------------
10165 if (version >= 138 && version < 140)
10166 {
10167 if (m_VariablesMask & VARIABLE_TEMPERATURE)
10168 {
10169 if (!ctx.Read(intValue))
10170 return false;
10171 SetFrozen(intValue);
10172 }
10173 }
10174
10175 return true;
10176 }
10177
10178 //----------------------------------------------------------------
10179 override bool OnStoreLoad(ParamsReadContext ctx, int version)
10180 {
10181 m_IsStoreLoad = true;
10183 {
10184 m_FixDamageSystemInit = true;
10185 }
10186
10187 if (!super.OnStoreLoad(ctx, version))
10188 {
10189 m_IsStoreLoad = false;
10190 return false;
10191 }
10192
10193 if (version >= 114)
10194 {
10195 bool hasQuickBarIndexSaved;
10196
10197 if (!ctx.Read(hasQuickBarIndexSaved))
10198 {
10199 m_IsStoreLoad = false;
10200 return false;
10201 }
10202
10203 if (hasQuickBarIndexSaved)
10204 {
10205 int itmQBIndex;
10206
10207 //Load quickbar item bind
10208 if (!ctx.Read(itmQBIndex))
10209 {
10210 m_IsStoreLoad = false;
10211 return false;
10212 }
10213
10214 PlayerBase parentPlayer = PlayerBase.Cast(GetHierarchyRootPlayer());
10215 if (itmQBIndex != -1 && parentPlayer)
10216 parentPlayer.SetLoadedQuickBarItemBind(this, itmQBIndex);
10217 }
10218 }
10219 else
10220 {
10221 // Backup of how it used to be
10222 PlayerBase player;
10223 int itemQBIndex;
10224 if (version == int.MAX)
10225 {
10226 if (!ctx.Read(itemQBIndex))
10227 {
10228 m_IsStoreLoad = false;
10229 return false;
10230 }
10231 }
10232 else if (Class.CastTo(player, GetHierarchyRootPlayer()))
10233 {
10234 //Load quickbar item bind
10235 if (!ctx.Read(itemQBIndex))
10236 {
10237 m_IsStoreLoad = false;
10238 return false;
10239 }
10240 if (itemQBIndex != -1 && player)
10241 player.SetLoadedQuickBarItemBind(this,itemQBIndex);
10242 }
10243 }
10244
10245 if (version < 140)
10246 {
10247 // variable management system
10248 if (!LoadVariables(ctx, version))
10249 {
10250 m_IsStoreLoad = false;
10251 return false;
10252 }
10253 }
10254
10255 //agent trasmission system
10256 if (!LoadAgents(ctx, version))
10257 {
10258 m_IsStoreLoad = false;
10259 return false;
10260 }
10261 if (version >= 132)
10262 {
10263 RemotelyActivatedItemBehaviour raib = GetRemotelyActivatedItemBehaviour();
10264 if (raib)
10265 {
10266 if (!raib.OnStoreLoad(ctx,version))
10267 {
10268 m_IsStoreLoad = false;
10269 return false;
10270 }
10271 }
10272 }
10273
10274 m_IsStoreLoad = false;
10275 return true;
10276 }
10277
10278 //----------------------------------------------------------------
10279
10280 override void OnStoreSave(ParamsWriteContext ctx)
10281 {
10282 super.OnStoreSave(ctx);
10283
10284 PlayerBase player;
10285 if (PlayerBase.CastTo(player,GetHierarchyRootPlayer()))
10286 {
10287 ctx.Write(true); // Keep track of if we should actually read this in or not
10288 //Save quickbar item bind
10289 int itemQBIndex = -1;
10290 itemQBIndex = player.FindQuickBarEntityIndex(this);
10291 ctx.Write(itemQBIndex);
10292 }
10293 else
10294 {
10295 ctx.Write(false); // Keep track of if we should actually read this in or not
10296 }
10297
10298 SaveAgents(ctx);//agent trasmission system
10299
10300 RemotelyActivatedItemBehaviour raib = GetRemotelyActivatedItemBehaviour();
10301 if (raib)
10302 {
10303 raib.OnStoreSave(ctx);
10304 }
10305 }
10306 //----------------------------------------------------------------
10307
10308 override void AfterStoreLoad()
10309 {
10310 super.AfterStoreLoad();
10311
10313 {
10315 }
10316
10317 if (GetStoreLoadedQuantity() != float.LOWEST)
10318 {
10320 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
10321 }
10322 }
10323
10324 override void EEOnAfterLoad()
10325 {
10326 super.EEOnAfterLoad();
10327
10329 {
10330 m_FixDamageSystemInit = false;
10331 }
10332
10335 }
10336
10337 bool CanBeDisinfected()
10338 {
10339 return false;
10340 }
10341
10342
10343 //----------------------------------------------------------------
10344 override void OnVariablesSynchronized()
10345 {
10346 if (m_Initialized)
10347 {
10348 #ifdef PLATFORM_CONSOLE
10349 //bruteforce it is
10350 if (IsSplitable())
10351 {
10352 UIScriptedMenu menu = GetGame().GetUIManager().FindMenu(MENU_INVENTORY);
10353 if (menu)
10354 {
10355 menu.Refresh();
10356 }
10357 }
10358 #endif
10359 }
10360
10362 {
10363 PlayImpactSound(m_ConfigWeight, m_ImpactSpeed, m_ImpactSoundSurfaceHash);
10364 m_WantPlayImpactSound = false;
10365 }
10366
10368 {
10369 SetWeightDirty();
10371 }
10372 if (m_VarWet != m_VarWetPrev)
10373 {
10376 }
10377
10378 if (m_SoundSyncPlay != 0)
10379 {
10380 m_ItemSoundHandler.PlayItemSoundClient(m_SoundSyncPlay);
10381 m_SoundSyncPlay = 0;
10382 }
10383 if (m_SoundSyncStop != 0)
10384 {
10385 m_ItemSoundHandler.StopItemSoundClient(m_SoundSyncStop);
10386 m_SoundSyncStop = 0;
10387 }
10388
10389 super.OnVariablesSynchronized();
10390 }
10391
10392 //------------------------- Quantity
10393 //----------------------------------------------------------------
10395 override bool SetQuantity(float value, bool destroy_config = true, bool destroy_forced = false, bool allow_client = false, bool clamp_to_stack_max = true)
10396 {
10397 if (!IsServerCheck(allow_client))
10398 return false;
10399
10400 if (!HasQuantity())
10401 return false;
10402
10403 float min = GetQuantityMin();
10404 float max = GetQuantityMax();
10405
10406 if (value <= (min + 0.001))
10407 value = min;
10408
10409 if (value == min)
10410 {
10411 if (destroy_config)
10412 {
10413 bool dstr = ConfigGetBool("varQuantityDestroyOnMin");
10414 if (dstr)
10415 {
10416 m_VarQuantity = Math.Clamp(value, min, max);
10417 this.Delete();
10418 return true;
10419 }
10420 }
10421 else if (destroy_forced)
10422 {
10423 m_VarQuantity = Math.Clamp(value, min, max);
10424 this.Delete();
10425 return true;
10426 }
10427 // we get here if destroy_config IS true AND dstr(config destroy param) IS false;
10428 RemoveAllAgents();//we remove all agents when we got to the min value, but the item is not getting deleted
10429 }
10430
10431 float delta = m_VarQuantity;
10432 m_VarQuantity = Math.Clamp(value, min, max);
10433
10434 if (GetStoreLoadedQuantity() == float.LOWEST)//any other value means we are setting quantity from storage
10435 {
10436 delta = m_VarQuantity - delta;
10437
10438 if (delta)
10439 OnQuantityChanged(delta);
10440 }
10441
10442 SetVariableMask(VARIABLE_QUANTITY);
10443
10444 return false;
10445 }
10446
10447 //----------------------------------------------------------------
10449 bool AddQuantity(float value, bool destroy_config = true, bool destroy_forced = false)
10450 {
10451 return SetQuantity(GetQuantity() + value, destroy_config, destroy_forced);
10452 }
10453 //----------------------------------------------------------------
10454 void SetQuantityMax()
10455 {
10456 float max = GetQuantityMax();
10457 SetQuantity(max);
10458 }
10459
10460 override void SetQuantityToMinimum()
10461 {
10462 float min = GetQuantityMin();
10463 SetQuantity(min);
10464 }
10465 //----------------------------------------------------------------
10467 override void SetQuantityNormalized(float value, bool destroy_config = true, bool destroy_forced = false)
10468 {
10469 float value_clamped = Math.Clamp(value, 0, 1);//just to make sure
10470 int result = Math.Round(Math.Lerp(GetQuantityMin(), GetQuantityMax(), value_clamped));
10471 SetQuantity(result, destroy_config, destroy_forced);
10472 }
10473
10474 //----------------------------------------------------------------
10476 override float GetQuantityNormalized()
10477 {
10478 return Math.InverseLerp(GetQuantityMin(), GetQuantityMax(),m_VarQuantity);
10479 }
10480
10482 {
10483 return GetQuantityNormalized();
10484 }
10485
10486 /*void SetAmmoNormalized(float value)
10487 {
10488 float value_clamped = Math.Clamp(value, 0, 1);
10489 Magazine this_mag = Magazine.Cast(this);
10490 int max_rounds = this_mag.GetAmmoMax();
10491 int result = value * max_rounds;//can the rounded if higher precision is required
10492 this_mag.SetAmmoCount(result);
10493 }*/
10494 //----------------------------------------------------------------
10495 override int GetQuantityMax()
10496 {
10497 int slot = -1;
10498 if (GetInventory())
10499 {
10500 InventoryLocation il = new InventoryLocation;
10501 GetInventory().GetCurrentInventoryLocation(il);
10502 slot = il.GetSlot();
10503 }
10504
10505 return GetTargetQuantityMax(slot);
10506 }
10507
10508 override int GetTargetQuantityMax(int attSlotID = -1)
10509 {
10510 float quantity_max = 0;
10511
10512 if (IsSplitable()) //only stackable/splitable items can check for stack size
10513 {
10514 if (attSlotID != -1)
10515 quantity_max = InventorySlots.GetStackMaxForSlotId(attSlotID);
10516
10517 if (quantity_max <= 0)
10518 quantity_max = m_VarStackMax;
10519 }
10520
10521 if (quantity_max <= 0)
10522 quantity_max = m_VarQuantityMax;
10523
10524 return quantity_max;
10525 }
10526 //----------------------------------------------------------------
10527 override int GetQuantityMin()
10528 {
10529 return m_VarQuantityMin;
10530 }
10531 //----------------------------------------------------------------
10532 int GetQuantityInit()
10533 {
10534 return m_VarQuantityInit;
10535 }
10536
10537 //----------------------------------------------------------------
10538 override bool HasQuantity()
10539 {
10540 return !(GetQuantityMax() - GetQuantityMin() == 0);
10541 }
10542
10543 override float GetQuantity()
10544 {
10545 return m_VarQuantity;
10546 }
10547
10548 bool IsFullQuantity()
10549 {
10550 return GetQuantity() >= GetQuantityMax();
10551 }
10552
10553 //Calculates weight of single item without attachments and cargo
10554 override float GetSingleInventoryItemWeightEx()
10555 {
10556 //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
10557 float weightEx = GetWeightEx();//overall weight of the item
10558 float special = GetInventoryAndCargoWeight();//cargo and attachment weight
10559 return weightEx - special;
10560 }
10561
10562 // Obsolete, use GetSingleInventoryItemWeightEx() instead
10564 {
10566 }
10567
10568 override protected float GetWeightSpecialized(bool forceRecalc = false)
10569 {
10570 if (IsSplitable()) //quantity determines size of the stack
10571 {
10572 #ifdef DEVELOPER
10573 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
10574 {
10575 WeightDebugData data1 = WeightDebug.GetWeightDebug(this);
10576 data1.SetCalcDetails("TIB1: " + GetConfigWeightModifiedDebugText() +" * " + GetQuantity()+"(quantity)");
10577 }
10578 #endif
10579
10580 return GetQuantity() * GetConfigWeightModified();
10581 }
10582 else if (HasEnergyManager())// items with energy manager
10583 {
10584 #ifdef DEVELOPER
10585 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
10586 {
10587 WeightDebugData data2 = WeightDebug.GetWeightDebug(this);
10588 data2.SetCalcDetails("TIB2: "+super.GetWeightSpecialized(forceRecalc)+"(contents weight) + " + GetConfigWeightModifiedDebugText() +" + " + GetCompEM().GetEnergy()+"(energy) * " + ConfigGetFloat("weightPerQuantityUnit") +"(weightPerQuantityUnit)");
10589 }
10590 #endif
10591 return super.GetWeightSpecialized(forceRecalc) + (GetCompEM().GetEnergy() * ConfigGetFloat("weightPerQuantityUnit")) + GetConfigWeightModified();
10592 }
10593 else//everything else
10594 {
10595 #ifdef DEVELOPER
10596 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
10597 {
10598 WeightDebugData data3 = WeightDebug.GetWeightDebug(this);
10599 data3.SetCalcDetails("TIB3: "+super.GetWeightSpecialized(forceRecalc)+"(contents weight) + " + GetConfigWeightModifiedDebugText() +" + " + GetQuantity()+"(quantity) * " + ConfigGetFloat("weightPerQuantityUnit") +"(weightPerQuantityUnit))");
10600 }
10601 #endif
10602 return super.GetWeightSpecialized(forceRecalc) + (GetQuantity() * ConfigGetFloat("weightPerQuantityUnit")) + GetConfigWeightModified();
10603 }
10604 }
10605
10607 int GetNumberOfItems()
10608 {
10609 int item_count = 0;
10610 ItemBase item;
10611
10612 if (GetInventory().GetCargo() != NULL)
10613 {
10614 item_count = GetInventory().GetCargo().GetItemCount();
10615 }
10616
10617 for (int i = 0; i < GetInventory().AttachmentCount(); i++)
10618 {
10619 Class.CastTo(item,GetInventory().GetAttachmentFromIndex(i));
10620 if (item)
10621 item_count += item.GetNumberOfItems();
10622 }
10623 return item_count;
10624 }
10625
10627 float GetUnitWeight(bool include_wetness = true)
10628 {
10629 float weight = 0;
10630 float wetness = 1;
10631 if (include_wetness)
10632 wetness += GetWet();
10633 if (IsSplitable()) //quantity determines size of the stack
10634 {
10635 weight = wetness * m_ConfigWeight;
10636 }
10637 else if (IsLiquidContainer()) //is a liquid container, default liquid weight is set to 1. May revisit later?
10638 {
10639 weight = 1;
10640 }
10641 return weight;
10642 }
10643
10644 //-----------------------------------------------------------------
10645
10646 override void ClearInventory()
10647 {
10648 if ((GetGame().IsServer() || !GetGame().IsMultiplayer()) && GetInventory())
10649 {
10650 GameInventory inv = GetInventory();
10651 array<EntityAI> items = new array<EntityAI>;
10652 inv.EnumerateInventory(InventoryTraversalType.INORDER, items);
10653 for (int i = 0; i < items.Count(); i++)
10654 {
10655 ItemBase item = ItemBase.Cast(items.Get(i));
10656 if (item)
10657 {
10658 GetGame().ObjectDelete(item);
10659 }
10660 }
10661 }
10662 }
10663
10664 //------------------------- Energy
10665
10666 //----------------------------------------------------------------
10667 float GetEnergy()
10668 {
10669 float energy = 0;
10670 if (HasEnergyManager())
10671 {
10672 energy = GetCompEM().GetEnergy();
10673 }
10674 return energy;
10675 }
10676
10677
10678 override void OnEnergyConsumed()
10679 {
10680 super.OnEnergyConsumed();
10681
10683 }
10684
10685 override void OnEnergyAdded()
10686 {
10687 super.OnEnergyAdded();
10688
10690 }
10691
10692 // Converts energy (from Energy Manager) to quantity, if enabled.
10694 {
10695 if (GetGame().IsServer() && HasEnergyManager() && GetCompEM().HasConversionOfEnergyToQuantity())
10696 {
10697 if (HasQuantity())
10698 {
10699 float energy_0to1 = GetCompEM().GetEnergy0To1();
10700 SetQuantityNormalized(energy_0to1);
10701 }
10702 }
10703 }
10704
10705 //----------------------------------------------------------------
10706 float GetHeatIsolationInit()
10707 {
10708 return ConfigGetFloat("heatIsolation");
10709 }
10710
10711 float GetHeatIsolation()
10712 {
10713 return m_HeatIsolation;
10714 }
10715
10716 float GetDryingIncrement(string pIncrementName)
10717 {
10718 string paramPath = string.Format("CfgVehicles %1 EnvironmentWetnessIncrements Drying %2", GetType(), pIncrementName);
10719 if (GetGame().ConfigIsExisting(paramPath))
10720 return GetGame().ConfigGetFloat(paramPath);
10721
10722 return 0.0;
10723 }
10724
10725 float GetSoakingIncrement(string pIncrementName)
10726 {
10727 string paramPath = string.Format("CfgVehicles %1 EnvironmentWetnessIncrements Soaking %2", GetType(), pIncrementName);
10728 if (GetGame().ConfigIsExisting(paramPath))
10729 return GetGame().ConfigGetFloat(paramPath);
10730
10731 return 0.0;
10732 }
10733 //----------------------------------------------------------------
10734 override void SetWet(float value, bool allow_client = false)
10735 {
10736 if (!IsServerCheck(allow_client))
10737 return;
10738
10739 float min = GetWetMin();
10740 float max = GetWetMax();
10741
10742 float previousValue = m_VarWet;
10743
10744 m_VarWet = Math.Clamp(value, min, max);
10745
10746 if (previousValue != m_VarWet)
10747 {
10748 SetVariableMask(VARIABLE_WET);
10749 OnWetChanged(m_VarWet, previousValue);
10750 }
10751 }
10752 //----------------------------------------------------------------
10753 override void AddWet(float value)
10754 {
10755 SetWet(GetWet() + value);
10756 }
10757 //----------------------------------------------------------------
10758 override void SetWetMax()
10759 {
10761 }
10762 //----------------------------------------------------------------
10763 override float GetWet()
10764 {
10765 return m_VarWet;
10766 }
10767 //----------------------------------------------------------------
10768 override float GetWetMax()
10769 {
10770 return m_VarWetMax;
10771 }
10772 //----------------------------------------------------------------
10773 override float GetWetMin()
10774 {
10775 return m_VarWetMin;
10776 }
10777 //----------------------------------------------------------------
10778 override float GetWetInit()
10779 {
10780 return m_VarWetInit;
10781 }
10782 //----------------------------------------------------------------
10783 override void OnWetChanged(float newVal, float oldVal)
10784 {
10785 EWetnessLevel newLevel = GetWetLevelInternal(newVal);
10786 EWetnessLevel oldLevel = GetWetLevelInternal(oldVal);
10787 if (newLevel != oldLevel)
10788 {
10789 OnWetLevelChanged(newLevel,oldLevel);
10790 }
10791 }
10792
10793 override void OnWetLevelChanged(EWetnessLevel newLevel, EWetnessLevel oldLevel)
10794 {
10795 SetWeightDirty();
10796 }
10797
10798 override EWetnessLevel GetWetLevel()
10799 {
10800 return GetWetLevelInternal(m_VarWet);
10801 }
10802
10803 //----------------------------------------------------------------
10804
10805 override void SetStoreLoad(bool value)
10806 {
10807 m_IsStoreLoad = value;
10808 }
10809
10810 override bool IsStoreLoad()
10811 {
10812 return m_IsStoreLoad;
10813 }
10814
10815 override void SetStoreLoadedQuantity(float value)
10816 {
10817 m_StoreLoadedQuantity = value;
10818 }
10819
10820 override float GetStoreLoadedQuantity()
10821 {
10822 return m_StoreLoadedQuantity;
10823 }
10824
10825 //----------------------------------------------------------------
10826
10827 float GetItemModelLength()
10828 {
10829 if (ConfigIsExisting("itemModelLength"))
10830 {
10831 return ConfigGetFloat("itemModelLength");
10832 }
10833 return 0;
10834 }
10835
10836 float GetItemAttachOffset()
10837 {
10838 if (ConfigIsExisting("itemAttachOffset"))
10839 {
10840 return ConfigGetFloat("itemAttachOffset");
10841 }
10842 return 0;
10843 }
10844
10845 override void SetCleanness(int value, bool allow_client = false)
10846 {
10847 if (!IsServerCheck(allow_client))
10848 return;
10849
10850 int previousValue = m_Cleanness;
10851
10852 m_Cleanness = Math.Clamp(value, m_CleannessMin, m_CleannessMax);
10853
10854 if (previousValue != m_Cleanness)
10855 SetVariableMask(VARIABLE_CLEANNESS);
10856 }
10857
10858 override int GetCleanness()
10859 {
10860 return m_Cleanness;
10861 }
10862
10864 {
10865 return true;
10866 }
10867
10868 //----------------------------------------------------------------
10869 // ATTACHMENT LOCKING
10870 // Getters relevant to generic ActionLockAttachment
10871 int GetLockType()
10872 {
10873 return m_LockType;
10874 }
10875
10876 string GetLockSoundSet()
10877 {
10878 return m_LockSoundSet;
10879 }
10880
10881 //----------------------------------------------------------------
10882 //------------------------- Color
10883 // sets items color variable given color components
10884 override void SetColor(int r, int g, int b, int a)
10885 {
10890 SetVariableMask(VARIABLE_COLOR);
10891 }
10893 override void GetColor(out int r,out int g,out int b,out int a)
10894 {
10899 }
10900
10901 bool IsColorSet()
10902 {
10903 return IsVariableSet(VARIABLE_COLOR);
10904 }
10905
10907 string GetColorString()
10908 {
10909 int r,g,b,a;
10910 GetColor(r,g,b,a);
10911 r = r/255;
10912 g = g/255;
10913 b = b/255;
10914 a = a/255;
10915 return MiscGameplayFunctions.GetColorString(r, g, b, a);
10916 }
10917 //----------------------------------------------------------------
10918 //------------------------- LiquidType
10919
10920 override void SetLiquidType(int value, bool allow_client = false)
10921 {
10922 if (!IsServerCheck(allow_client))
10923 return;
10924
10925 int old = m_VarLiquidType;
10926 m_VarLiquidType = value;
10927 OnLiquidTypeChanged(old,value);
10928 SetVariableMask(VARIABLE_LIQUIDTYPE);
10929 }
10930
10931 int GetLiquidTypeInit()
10932 {
10933 return ConfigGetInt("varLiquidTypeInit");
10934 }
10935
10936 override int GetLiquidType()
10937 {
10938 return m_VarLiquidType;
10939 }
10940
10941 protected void OnLiquidTypeChanged(int oldType, int newType)
10942 {
10943 if (newType == LIQUID_NONE && GetIsFrozen())
10944 SetFrozen(false);
10945 }
10946
10948 void UpdateQuickbarShortcutVisibility(PlayerBase player)
10949 {
10950 player.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
10951 }
10952
10953 // -------------------------------------------------------------------------
10955 void OnInventoryEnter(Man player)
10956 {
10957 PlayerBase nplayer;
10958 if (PlayerBase.CastTo(nplayer, player))
10959 {
10960 m_CanPlayImpactSound = true;
10961 //nplayer.OnItemInventoryEnter(this);
10962 nplayer.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
10963 }
10964 }
10965
10966 // -------------------------------------------------------------------------
10968 void OnInventoryExit(Man player)
10969 {
10970 PlayerBase nplayer;
10971 if (PlayerBase.CastTo(nplayer,player))
10972 {
10973 //nplayer.OnItemInventoryExit(this);
10974 nplayer.SetEnableQuickBarEntityShortcut(this,false);
10975
10976 }
10977
10978 //if (!GetGame().IsDedicatedServer())
10979 player.GetHumanInventory().ClearUserReservedLocationForContainer(this);
10980
10981
10982 if (HasEnergyManager())
10983 {
10984 GetCompEM().UpdatePlugState(); // Unplug the el. device if it's necesarry.
10985 }
10986 }
10987
10988 // ADVANCED PLACEMENT EVENTS
10989 override void OnPlacementStarted(Man player)
10990 {
10991 super.OnPlacementStarted(player);
10992
10993 SetTakeable(false);
10994 }
10995
10996 override void OnPlacementComplete(Man player, vector position = "0 0 0", vector orientation = "0 0 0")
10997 {
10998 if (m_AdminLog)
10999 {
11000 m_AdminLog.OnPlacementComplete(player, this);
11001 }
11002
11003 super.OnPlacementComplete(player, position, orientation);
11004 }
11005
11006 //-----------------------------
11007 // AGENT SYSTEM
11008 //-----------------------------
11009 //--------------------------------------------------------------------------
11010 bool ContainsAgent(int agent_id)
11011 {
11012 if (agent_id & m_AttachedAgents)
11013 {
11014 return true;
11015 }
11016 else
11017 {
11018 return false;
11019 }
11020 }
11021
11022 //--------------------------------------------------------------------------
11023 override void RemoveAgent(int agent_id)
11024 {
11025 if (ContainsAgent(agent_id))
11026 {
11027 m_AttachedAgents = ~agent_id & m_AttachedAgents;
11028 }
11029 }
11030
11031 //--------------------------------------------------------------------------
11032 override void RemoveAllAgents()
11033 {
11034 m_AttachedAgents = 0;
11035 }
11036 //--------------------------------------------------------------------------
11037 override void RemoveAllAgentsExcept(int agent_to_keep)
11038 {
11039 m_AttachedAgents = m_AttachedAgents & agent_to_keep;
11040 }
11041 // -------------------------------------------------------------------------
11042 override void InsertAgent(int agent, float count = 1)
11043 {
11044 if (count < 1)
11045 return;
11046 //Debug.Log("Inserting Agent on item: " + agent.ToString() +" count: " + count.ToString());
11048 }
11049
11051 void TransferAgents(int agents)
11052 {
11054 }
11055
11056 // -------------------------------------------------------------------------
11057 override int GetAgents()
11058 {
11059 return m_AttachedAgents;
11060 }
11061 //----------------------------------------------------------------------
11062
11063 /*int GetContaminationType()
11064 {
11065 int contamination_type;
11066
11067 const int CONTAMINATED_MASK = eAgents.CHOLERA | eAgents.INFLUENZA | eAgents.SALMONELLA | eAgents.BRAIN;
11068 const int POISONED_MASK = eAgents.FOOD_POISON | eAgents.CHEMICAL_POISON;
11069 const int NERVE_GAS_MASK = eAgents.CHEMICAL_POISON;
11070 const int DIRTY_MASK = eAgents.WOUND_AGENT;
11071
11072 Edible_Base edible = Edible_Base.Cast(this);
11073 int agents = GetAgents();
11074 if (edible)
11075 {
11076 NutritionalProfile profile = Edible_Base.GetNutritionalProfile(edible);
11077 if (profile)
11078 {
11079 agents = agents | profile.GetAgents();//merge item's agents with nutritional agents
11080 }
11081 }
11082 if (agents & CONTAMINATED_MASK)
11083 {
11084 contamination_type = contamination_type | EContaminationTypes.ITEM_BADGE_CONTAMINATED;
11085 }
11086 if (agents & POISONED_MASK)
11087 {
11088 contamination_type = contamination_type | EContaminationTypes.ITEM_BADGE_POISONED;
11089 }
11090 if (agents & NERVE_GAS_MASK)
11091 {
11092 contamination_type = contamination_type | EContaminationTypes.ITEM_BADGE_NERVE_GAS;
11093 }
11094 if (agents & DIRTY_MASK)
11095 {
11096 contamination_type = contamination_type | EContaminationTypes.ITEM_BADGE_DIRTY;
11097 }
11098
11099 return agents;
11100 }*/
11101
11102 // -------------------------------------------------------------------------
11103 bool LoadAgents(ParamsReadContext ctx, int version)
11104 {
11105 if (!ctx.Read(m_AttachedAgents))
11106 return false;
11107 return true;
11108 }
11109 // -------------------------------------------------------------------------
11111 {
11112
11114 }
11115 // -------------------------------------------------------------------------
11116
11118 override void CheckForRoofLimited(float timeTresholdMS = 3000)
11119 {
11120 super.CheckForRoofLimited(timeTresholdMS);
11121
11122 float time = GetGame().GetTime();
11123 if ((time - m_PreviousRoofTestTime) >= timeTresholdMS)
11124 {
11125 m_PreviousRoofTestTime = time;
11126 SetRoofAbove(MiscGameplayFunctions.IsUnderRoof(this));
11127 }
11128 }
11129
11130 // returns item's protection level against enviromental hazard, for masks with filters, returns the filters protection for valid filter, otherwise 0
11131 float GetProtectionLevel(int type, bool consider_filter = false, int system = 0)
11132 {
11133 if (IsDamageDestroyed() || (HasQuantity() && GetQuantity() <= 0))
11134 {
11135 return 0;
11136 }
11137
11138 if (GetInventory().GetAttachmentSlotsCount() != 0)//is it an item with attachable filter ?
11139 {
11140 ItemBase filter = ItemBase.Cast(FindAttachmentBySlotName("GasMaskFilter"));
11141 if (filter)
11142 return filter.GetProtectionLevel(type, false, system);//it's a valid filter, return the protection
11143 else
11144 return 0;//otherwise return 0 when no filter attached
11145 }
11146
11147 string subclassPath, entryName;
11148
11149 switch (type)
11150 {
11151 case DEF_BIOLOGICAL:
11152 entryName = "biological";
11153 break;
11154 case DEF_CHEMICAL:
11155 entryName = "chemical";
11156 break;
11157 default:
11158 entryName = "biological";
11159 break;
11160 }
11161
11162 subclassPath = "CfgVehicles " + this.GetType() + " Protection ";
11163
11164 return GetGame().ConfigGetFloat(subclassPath + entryName);
11165 }
11166
11167
11168
11170 override void EEOnCECreate()
11171 {
11172 if (!IsMagazine())
11174
11176 }
11177
11178
11179 //-------------------------
11180 // OPEN/CLOSE USER ACTIONS
11181 //-------------------------
11183 void Open();
11184 void Close();
11185 bool IsOpen()
11186 {
11187 return true;
11188 }
11189
11190 override bool CanDisplayCargo()
11191 {
11192 return IsOpen();
11193 }
11194
11195
11196 // ------------------------------------------------------------
11197 // CONDITIONS
11198 // ------------------------------------------------------------
11199 override bool CanPutInCargo(EntityAI parent)
11200 {
11201 if (parent)
11202 {
11203 if (parent.IsInherited(DayZInfected))
11204 return true;
11205
11206 if (!parent.IsRuined())
11207 return true;
11208 }
11209
11210 return true;
11211 }
11212
11213 override bool CanPutAsAttachment(EntityAI parent)
11214 {
11215 if (!super.CanPutAsAttachment(parent))
11216 {
11217 return false;
11218 }
11219
11220 if (!IsRuined() && !parent.IsRuined())
11221 {
11222 return true;
11223 }
11224
11225 return false;
11226 }
11227
11228 override bool CanReceiveItemIntoCargo(EntityAI item)
11229 {
11230 //removed 15.06. coz of loading from storage -> after load items in cargo was lost -> waiting for proper solution
11231 //if (GetHealthLevel() == GameConstants.STATE_RUINED)
11232 // return false;
11233
11234 return super.CanReceiveItemIntoCargo(item);
11235 }
11236
11237 override bool CanReceiveAttachment(EntityAI attachment, int slotId)
11238 {
11239 //removed 15.06. coz of loading from storage -> after load items in cargo was lost -> waiting for proper solution
11240 //if (GetHealthLevel() == GameConstants.STATE_RUINED)
11241 // return false;
11242
11243 GameInventory attachmentInv = attachment.GetInventory();
11244 if (attachmentInv && attachmentInv.GetCargo() && attachmentInv.GetCargo().GetItemCount() > 0)
11245 {
11246 if (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase))
11247 return false;
11248 }
11249
11250 InventoryLocation loc = new InventoryLocation();
11251 attachment.GetInventory().GetCurrentInventoryLocation(loc);
11252 if (loc && loc.IsValid() && !GetInventory().AreChildrenAccessible())
11253 return false;
11254
11255 return super.CanReceiveAttachment(attachment, slotId);
11256 }
11257
11258 override bool CanReleaseAttachment(EntityAI attachment)
11259 {
11260 if (!super.CanReleaseAttachment(attachment))
11261 return false;
11262
11263 return GetInventory().AreChildrenAccessible();
11264 }
11265
11266 /*override bool CanLoadAttachment(EntityAI attachment)
11267 {
11268 //removed 15.06. coz of loading from storage -> after load items in cargo was lost -> waiting for proper solution
11269 //if (GetHealthLevel() == GameConstants.STATE_RUINED)
11270 // return false;
11271
11272 GameInventory attachmentInv = attachment.GetInventory();
11273 if (attachmentInv && attachmentInv.GetCargo() && attachmentInv.GetCargo().GetItemCount() > 0)
11274 {
11275 bool boo = (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase));
11276 ErrorEx("CanLoadAttachment | this: " + this + " | attachment: " + attachment + " | boo: " + boo,ErrorExSeverity.INFO);
11277
11278 if (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase))
11279 return false;
11280 }
11281
11282 return super.CanLoadAttachment(attachment);
11283 }*/
11284
11285 // Plays muzzle flash particle effects
11286 static void PlayFireParticles(ItemBase weapon, int muzzle_index, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
11287 {
11288 int id = muzzle_owner.GetMuzzleID();
11289 array<ref WeaponParticlesOnFire> WPOF_array = m_OnFireEffect.Get(id);
11290
11291 if (WPOF_array)
11292 {
11293 for (int i = 0; i < WPOF_array.Count(); i++)
11294 {
11295 WeaponParticlesOnFire WPOF = WPOF_array.Get(i);
11296
11297 if (WPOF)
11298 {
11299 WPOF.OnActivate(weapon, muzzle_index, ammoType, muzzle_owner, suppressor, config_to_search);
11300 }
11301 }
11302 }
11303 }
11304
11305 // Plays bullet eject particle effects (usually just smoke, the bullet itself is a 3D model and is not part of this function)
11306 static void PlayBulletCasingEjectParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
11307 {
11308 int id = muzzle_owner.GetMuzzleID();
11309 array<ref WeaponParticlesOnBulletCasingEject> WPOBE_array = m_OnBulletCasingEjectEffect.Get(id);
11310
11311 if (WPOBE_array)
11312 {
11313 for (int i = 0; i < WPOBE_array.Count(); i++)
11314 {
11315 WeaponParticlesOnBulletCasingEject WPOBE = WPOBE_array.Get(i);
11316
11317 if (WPOBE)
11318 {
11319 WPOBE.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
11320 }
11321 }
11322 }
11323 }
11324
11325 // Plays all weapon overheating particles
11326 static void PlayOverheatingParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
11327 {
11328 int id = muzzle_owner.GetMuzzleID();
11329 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
11330
11331 if (WPOOH_array)
11332 {
11333 for (int i = 0; i < WPOOH_array.Count(); i++)
11334 {
11335 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
11336
11337 if (WPOOH)
11338 {
11339 WPOOH.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
11340 }
11341 }
11342 }
11343 }
11344
11345 // Updates all weapon overheating particles
11346 static void UpdateOverheatingParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
11347 {
11348 int id = muzzle_owner.GetMuzzleID();
11349 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
11350
11351 if (WPOOH_array)
11352 {
11353 for (int i = 0; i < WPOOH_array.Count(); i++)
11354 {
11355 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
11356
11357 if (WPOOH)
11358 {
11359 WPOOH.OnUpdate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
11360 }
11361 }
11362 }
11363 }
11364
11365 // Stops overheating particles
11366 static void StopOverheatingParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
11367 {
11368 int id = muzzle_owner.GetMuzzleID();
11369 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
11370
11371 if (WPOOH_array)
11372 {
11373 for (int i = 0; i < WPOOH_array.Count(); i++)
11374 {
11375 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
11376
11377 if (WPOOH)
11378 {
11379 WPOOH.OnDeactivate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
11380 }
11381 }
11382 }
11383 }
11384
11385 //----------------------------------------------------------------
11386 //Item Behaviour - unified approach
11387 override bool IsHeavyBehaviour()
11388 {
11389 if (m_ItemBehaviour == 0)
11390 {
11391 return true;
11392 }
11393
11394 return false;
11395 }
11396
11397 override bool IsOneHandedBehaviour()
11398 {
11399 if (m_ItemBehaviour == 1)
11400 {
11401 return true;
11402 }
11403
11404 return false;
11405 }
11406
11407 override bool IsTwoHandedBehaviour()
11408 {
11409 if (m_ItemBehaviour == 2)
11410 {
11411 return true;
11412 }
11413
11414 return false;
11415 }
11416
11417 bool IsDeployable()
11418 {
11419 return false;
11420 }
11421
11423 float GetDeployTime()
11424 {
11425 return UATimeSpent.DEFAULT_DEPLOY;
11426 }
11427
11428
11429 //----------------------------------------------------------------
11430 // Item Targeting (User Actions)
11431 override void SetTakeable(bool pState)
11432 {
11433 m_IsTakeable = pState;
11434 SetSynchDirty();
11435 }
11436
11437 override bool IsTakeable()
11438 {
11439 return m_IsTakeable;
11440 }
11441
11442 // For cases where we want to show object widget which cant be taken to hands
11444 {
11445 return false;
11446 }
11447
11449 protected void PreLoadSoundAttachmentType()
11450 {
11451 string att_type = "None";
11452
11453 if (ConfigIsExisting("soundAttType"))
11454 {
11455 att_type = ConfigGetString("soundAttType");
11456 }
11457
11458 m_SoundAttType = att_type;
11459 }
11460
11461 override string GetAttachmentSoundType()
11462 {
11463 return m_SoundAttType;
11464 }
11465
11466 //----------------------------------------------------------------
11467 //SOUNDS - ItemSoundHandler
11468 //----------------------------------------------------------------
11469
11470 string GetPlaceSoundset(); // played when deploy starts
11471 string GetLoopDeploySoundset(); // played when deploy starts and stopped when it finishes
11472 string GetDeploySoundset(); // played when deploy sucessfully finishes
11473 string GetLoopFoldSoundset(); // played when fold starts and stopped when it finishes
11474 string GetFoldSoundset(); // played when fold sucessfully finishes
11475
11477 {
11478 if (!m_ItemSoundHandler)
11480
11481 return m_ItemSoundHandler;
11482 }
11483
11484 // override to initialize sounds
11485 protected void InitItemSounds()
11486 {
11487 if (GetPlaceSoundset() == string.Empty && GetDeploySoundset() == string.Empty && GetLoopDeploySoundset() == string.Empty)
11488 return;
11489
11491
11492 if (GetPlaceSoundset() != string.Empty)
11493 handler.AddSound(SoundConstants.ITEM_PLACE, GetPlaceSoundset());
11494
11495 if (GetDeploySoundset() != string.Empty)
11496 handler.AddSound(SoundConstants.ITEM_DEPLOY, GetDeploySoundset());
11497
11498 SoundParameters params = new SoundParameters();
11499 params.m_Loop = true;
11500 if (GetLoopDeploySoundset() != string.Empty)
11501 handler.AddSound(SoundConstants.ITEM_DEPLOY_LOOP, GetLoopDeploySoundset(), params);
11502 }
11503
11504 // Start sound using ItemSoundHandler
11505 void StartItemSoundServer(int id)
11506 {
11507 if (!GetGame().IsServer())
11508 return;
11509
11510 m_SoundSyncPlay = id;
11511 SetSynchDirty();
11512
11513 GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).Remove(ClearStartItemSoundServer); // in case one is queued already
11515 }
11516
11517 // Stop sound using ItemSoundHandler
11518 void StopItemSoundServer(int id)
11519 {
11520 if (!GetGame().IsServer())
11521 return;
11522
11523 m_SoundSyncStop = id;
11524 SetSynchDirty();
11525
11526 GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).Remove(ClearStopItemSoundServer); // in case one is queued already
11528 }
11529
11530 protected void ClearStartItemSoundServer()
11531 {
11532 m_SoundSyncPlay = 0;
11533 }
11534
11535 protected void ClearStopItemSoundServer()
11536 {
11537 m_SoundSyncStop = 0;
11538 }
11539
11541 void PlayAttachSound(string slot_type)
11542 {
11543 if (!GetGame().IsDedicatedServer())
11544 {
11545 if (ConfigIsExisting("attachSoundSet"))
11546 {
11547 string cfg_path = "";
11548 string soundset = "";
11549 string type_name = GetType();
11550
11551 TStringArray cfg_soundset_array = new TStringArray;
11552 TStringArray cfg_slot_array = new TStringArray;
11553 ConfigGetTextArray("attachSoundSet",cfg_soundset_array);
11554 ConfigGetTextArray("attachSoundSlot",cfg_slot_array);
11555
11556 if (cfg_soundset_array.Count() > 0 && cfg_soundset_array.Count() == cfg_slot_array.Count())
11557 {
11558 for (int i = 0; i < cfg_soundset_array.Count(); i++)
11559 {
11560 if (cfg_slot_array[i] == slot_type)
11561 {
11562 soundset = cfg_soundset_array[i];
11563 break;
11564 }
11565 }
11566 }
11567
11568 if (soundset != "")
11569 {
11570 EffectSound sound = SEffectManager.PlaySound(soundset, GetPosition());
11571 sound.SetAutodestroy(true);
11572 }
11573 }
11574 }
11575 }
11576
11577 void PlayDetachSound(string slot_type)
11578 {
11579 //TODO - evaluate if needed and devise universal config structure if so
11580 }
11581
11582 void OnApply(PlayerBase player);
11583
11585 {
11586 return 1.0;
11587 };
11588 //returns applicable selection
11589 array<string> GetHeadHidingSelection()
11590 {
11592 }
11593
11595 {
11597 }
11598
11599 WrittenNoteData GetWrittenNoteData() {};
11600
11602 {
11603 SetDynamicPhysicsLifeTime(0.01);
11604 m_ItemBeingDroppedPhys = false;
11605 }
11606
11608 {
11609 array<string> zone_names = new array<string>;
11610 GetDamageZones(zone_names);
11611 for (int i = 0; i < zone_names.Count(); i++)
11612 {
11613 SetHealthMax(zone_names.Get(i),"Health");
11614 }
11615 SetHealthMax("","Health");
11616 }
11617
11619 void SetZoneDamageCEInit()
11620 {
11621 float global_health = GetHealth01("","Health");
11622 array<string> zones = new array<string>;
11623 GetDamageZones(zones);
11624 //set damage of all zones to match global health level
11625 for (int i = 0; i < zones.Count(); i++)
11626 {
11627 SetHealth01(zones.Get(i),"Health",global_health);
11628 }
11629 }
11630
11632 bool IsCoverFaceForShave(string slot_name)
11633 {
11634 return IsExclusionFlagPresent(PlayerBase.GetFaceCoverageShaveValues());
11635 }
11636
11637 void ProcessItemWetness(float delta, bool hasParent, bool hasRootAsPlayer, ItemBase refParentIB)
11638 {
11639 if (!hasRootAsPlayer)
11640 {
11641 if (refParentIB)
11642 {
11643 // parent is wet
11644 if ((refParentIB.GetWet() >= GameConstants.STATE_SOAKING_WET) && (m_VarWet < m_VarWetMax))
11645 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_INSIDE);
11646 // parent has liquid inside
11647 else if ((refParentIB.GetLiquidType() != 0) && (refParentIB.GetQuantity() > 0) && (m_VarWet < m_VarWetMax))
11648 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_LIQUID);
11649 // drying
11650 else if (m_VarWet > m_VarWetMin)
11651 AddWet(-1 * delta * GetDryingIncrement("ground") * 2);
11652 }
11653 else
11654 {
11655 // drying on ground or inside non-itembase (car, ...)
11656 if (m_VarWet > m_VarWetMin)
11657 AddWet(-1 * delta * GetDryingIncrement("ground"));
11658 }
11659 }
11660 }
11661
11662 void ProcessItemTemperature(float delta, bool hasParent, bool hasRootAsPlayer, ItemBase refParentIB)
11663 {
11665 {
11666 float target = g_Game.GetMission().GetWorldData().GetBaseEnvTemperatureAtObject(this);
11667 if (GetTemperature() != target || !IsFreezeThawProgressFinished())
11668 {
11669 float heatPermCoef = 1.0;
11670 EntityAI ent = this;
11671 while (ent)
11672 {
11673 heatPermCoef *= ent.GetHeatPermeabilityCoef();
11674 ent = ent.GetHierarchyParent();
11675 }
11676
11677 SetTemperatureEx(new TemperatureDataInterpolated(target,ETemperatureAccessTypes.ACCESS_WORLD,delta,GameConstants.TEMP_COEF_WORLD,heatPermCoef));
11678 }
11679 }
11680 }
11681
11682 void HierarchyCheck(out bool hasParent, out bool hasRootAsPlayer, out ItemBase refParentIB)
11683 {
11684 // hierarchy check for an item to decide whether it has some parent and it is in some player inventory
11685 EntityAI parent = GetHierarchyParent();
11686 if (!parent)
11687 {
11688 hasParent = false;
11689 hasRootAsPlayer = false;
11690 }
11691 else
11692 {
11693 hasParent = true;
11694 hasRootAsPlayer = (GetHierarchyRootPlayer() != null);
11695 refParentIB = ItemBase.Cast(parent);
11696 }
11697 }
11698
11699 protected void ProcessDecay(float delta, bool hasRootAsPlayer)
11700 {
11701 // this is stub, implemented on Edible_Base
11702 }
11703
11704 bool CanDecay()
11705 {
11706 // return true used on selected food clases so they can decay
11707 return false;
11708 }
11709
11710 protected bool CanProcessDecay()
11711 {
11712 // this is stub, implemented on Edible_Base class
11713 // used to determine whether it is still necessary for the food to decay
11714 return false;
11715 }
11716
11717 protected bool CanHaveWetness()
11718 {
11719 // return true used on selected items that have a wetness effect
11720 return false;
11721 }
11722
11724 bool CanBeConsumed(ConsumeConditionData data = null)
11725 {
11726 return !GetIsFrozen() && IsOpen();
11727 }
11728
11729 override void ProcessVariables()
11730 {
11731 bool hasParent = false, hasRootAsPlayer = false;
11732 ItemBase refParentIB;
11733
11734 bool wwtu = g_Game.IsWorldWetTempUpdateEnabled();
11735 bool foodDecay = g_Game.IsFoodDecayEnabled();
11736
11737 if (wwtu || foodDecay)
11738 {
11739 bool processWetness = wwtu && CanHaveWetness();
11740 bool processTemperature = wwtu && CanHaveTemperature();
11741 bool processDecay = foodDecay && CanDecay() && CanProcessDecay();
11742
11743 if (processWetness || processTemperature || processDecay)
11744 {
11745 HierarchyCheck(hasParent, hasRootAsPlayer, refParentIB);
11746
11747 if (processWetness)
11748 ProcessItemWetness(m_ElapsedSinceLastUpdate, hasParent, hasRootAsPlayer, refParentIB);
11749
11750 if (processTemperature)
11751 ProcessItemTemperature(m_ElapsedSinceLastUpdate, hasParent, hasRootAsPlayer, refParentIB);
11752
11753 if (processDecay)
11754 ProcessDecay(m_ElapsedSinceLastUpdate, hasRootAsPlayer);
11755 }
11756 }
11757 }
11758
11761 {
11762 return m_TemperaturePerQuantityWeight * GameConstants.ITEM_TEMPERATURE_QUANTITY_WEIGHT_MULTIPLIER;
11763 }
11764
11765 override float GetTemperatureFreezeThreshold()
11766 {
11768 return Liquid.GetFreezeThreshold(GetLiquidType());
11769
11770 return super.GetTemperatureFreezeThreshold();
11771 }
11772
11773 override float GetTemperatureThawThreshold()
11774 {
11776 return Liquid.GetThawThreshold(GetLiquidType());
11777
11778 return super.GetTemperatureThawThreshold();
11779 }
11780
11781 override float GetItemOverheatThreshold()
11782 {
11784 return Liquid.GetBoilThreshold(GetLiquidType());
11785
11786 return super.GetItemOverheatThreshold();
11787 }
11788
11789 override float GetTemperatureFreezeTime()
11790 {
11791 if (HasQuantity())
11792 return Math.Lerp(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureFreezeTime()),GetQuantityNormalized());
11793
11794 return super.GetTemperatureFreezeTime();
11795 }
11796
11797 override float GetTemperatureThawTime()
11798 {
11799 if (HasQuantity())
11800 return Math.Lerp(GameConstants.TEMPERATURE_TIME_THAW_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureThawTime()),GetQuantityNormalized());
11801
11802 return super.GetTemperatureThawTime();
11803 }
11804
11806 void AffectLiquidContainerOnFill(int liquid_type, float amount);
11808 void AffectLiquidContainerOnTransfer(int liquidType, float amount, float sourceLiquidTemperature);
11809
11810 bool IsCargoException4x3(EntityAI item)
11811 {
11812 return (item.IsKindOf("Cauldron") || item.IsKindOf("Pot") || item.IsKindOf("FryingPan") || item.IsKindOf("SmallProtectorCase") || (item.IsKindOf("PortableGasStove") && item.FindAttachmentBySlotName("CookingEquipment")));
11813 }
11814
11816 {
11817 MiscGameplayFunctions.TransferItemProperties(oldItem, this);
11818 }
11819
11821 void AddLightSourceItem(ItemBase lightsource)
11822 {
11823 m_LightSourceItem = lightsource;
11824 }
11825
11827 {
11828 m_LightSourceItem = null;
11829 }
11830
11832 {
11833 return m_LightSourceItem;
11834 }
11835
11837 array<int> GetValidFinishers()
11838 {
11839 return null;
11840 }
11841
11843 bool GetActionWidgetOverride(out typename name)
11844 {
11845 return false;
11846 }
11847
11848 bool PairWithDevice(notnull ItemBase otherDevice)
11849 {
11850 if (GetGame().IsServer())
11851 {
11852 ItemBase explosive = otherDevice;
11854 if (!trg)
11855 {
11856 trg = RemoteDetonatorTrigger.Cast(otherDevice);
11857 explosive = this;
11858 }
11859
11860 explosive.PairRemote(trg);
11861 trg.SetControlledDevice(explosive);
11862
11863 int persistentID = RemotelyActivatedItemBehaviour.GeneratePersistentID();
11864 trg.SetPersistentPairID(persistentID);
11865 explosive.SetPersistentPairID(persistentID);
11866
11867 return true;
11868 }
11869 return false;
11870 }
11871
11873 float GetBaitEffectivity()
11874 {
11875 float ret = 1.0;
11876 if (HasQuantity())
11877 ret *= GetQuantityNormalized();
11878 ret *= GetHealth01();
11879
11880 return ret;
11881 }
11882
11883 #ifdef DEVELOPER
11884 override void SetDebugItem()
11885 {
11886 super.SetDebugItem();
11887 _itemBase = this;
11888 }
11889
11890 override string GetDebugText()
11891 {
11892 string text = super.GetDebugText();
11893
11894 text += string.Format("Heat isolation(raw): %1\n", GetHeatIsolation());
11895 text += string.Format("Heat isolation(modified): %1\n", MiscGameplayFunctions.GetCurrentItemHeatIsolation(this));
11896
11897 return text;
11898 }
11899 #endif
11900
11901 bool CanBeUsedForSuicide()
11902 {
11903 return true;
11904 }
11905
11907 //DEPRECATED BELOW
11909 // Backwards compatibility
11910 void ProcessItemWetnessAndTemperature(float delta, bool hasParent, bool hasRootAsPlayer, ItemBase refParentIB)
11911 {
11912 ProcessItemWetness(delta, hasParent, hasRootAsPlayer, refParentIB);
11913 ProcessItemTemperature(delta, hasParent, hasRootAsPlayer, refParentIB);
11914 }
11915
11916 // replaced by ItemSoundHandler
11917 protected EffectSound m_SoundDeployFinish;
11918 protected EffectSound m_SoundPlace;
11919 protected EffectSound m_DeployLoopSoundEx;
11920 protected EffectSound m_SoundDeploy;
11921 bool m_IsPlaceSound;
11922 bool m_IsDeploySound;
11924
11925 string GetDeployFinishSoundset();
11926 void PlayDeploySound();
11927 void PlayDeployFinishSound();
11928 void PlayPlaceSound();
11929 void PlayDeployLoopSoundEx();
11930 void StopDeployLoopSoundEx();
11931 void SoundSynchRemoteReset();
11932 void SoundSynchRemote();
11933 bool UsesGlobalDeploy(){return false;}
11934 bool CanPlayDeployLoopSound(){return false;}
11936 bool IsPlaceSound(){return m_IsPlaceSound;}
11937 bool IsDeploySound(){return m_IsDeploySound;}
11938 void SetIsPlaceSound(bool is_place_sound);
11939 void SetIsDeploySound(bool is_deploy_sound);
11940}
11941
11942EntityAI SpawnItemOnLocation(string object_name, notnull InventoryLocation loc, bool full_quantity)
11943{
11944 EntityAI entity = SpawnEntity(object_name, loc, ECE_IN_INVENTORY, RF_DEFAULT);
11945 if (entity)
11946 {
11947 bool is_item = entity.IsInherited(ItemBase);
11948 if (is_item && full_quantity)
11949 {
11950 ItemBase item = ItemBase.Cast(entity);
11951 item.SetQuantity(item.GetQuantityInit());
11952 }
11953 }
11954 else
11955 {
11956 ErrorEx("Cannot spawn entity: " + object_name,ErrorExSeverity.INFO);
11957 return NULL;
11958 }
11959 return entity;
11960}
11961
11962void SetupSpawnedItem(ItemBase item, float health, float quantity)
11963{
11964 if (item)
11965 {
11966 if (health > 0)
11967 item.SetHealth("", "", health);
11968
11969 if (item.CanHaveTemperature())
11970 {
11971 item.SetTemperatureDirect(GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_MIDDLE);
11972 if (item.CanFreeze())
11973 item.SetFrozen(false);
11974 }
11975
11976 if (item.HasEnergyManager())
11977 {
11978 if (quantity >= 0)
11979 {
11980 item.GetCompEM().SetEnergy0To1(quantity);
11981 }
11982 else
11983 {
11984 item.GetCompEM().SetEnergy(Math.AbsFloat(quantity));
11985 }
11986 }
11987 else if (item.IsMagazine())
11988 {
11989 Magazine mag = Magazine.Cast(item);
11990 if (quantity >= 0)
11991 {
11992 mag.ServerSetAmmoCount(mag.GetAmmoMax() * quantity);
11993 }
11994 else
11995 {
11996 mag.ServerSetAmmoCount(Math.AbsFloat(quantity));
11997 }
11998
11999 }
12000 else
12001 {
12002 if (quantity >= 0)
12003 {
12004 item.SetQuantityNormalized(quantity, false);
12005 }
12006 else
12007 {
12008 item.SetQuantity(Math.AbsFloat(quantity));
12009 }
12010
12011 }
12012 }
12013}
12014
12015#ifdef DEVELOPER
12016ItemBase _itemBase;//watched item goes here(LCTRL+RMB->Watch)
12017#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()

Используется в InventoryItem::EEHealthLevelChanged().