6165{
6167 {
6168 return true;
6169 }
6170};
6171
6172
6173
6175{
6179
6181
6184
6185
6186
6187
6188
6197
6203
6208
6213
6234 protected bool m_IsResultOfSplit
6235
6237
6242
6243
6244
6246
6250
6251
6252
6254
6257
6258
6259
6265
6266
6274
6277
6278
6280
6281
6283
6284
6289
6290
6295
6296
6298
6299
6301 {
6306
6307 if (!
GetGame().IsDedicatedServer())
6308 {
6310 {
6312
6314 {
6316 }
6317 }
6318
6321 }
6322
6323 m_OldLocation = null;
6324
6326 {
6328 }
6329
6330 if (ConfigIsExisting("headSelectionsToHide"))
6331 {
6334 }
6335
6337 if (ConfigIsExisting("hideSelectionsByinventorySlot"))
6338 {
6340 }
6341
6343
6344 m_IsResultOfSplit = false;
6345
6347 }
6348
6350 {
6351 super.InitItemVariables();
6352
6358 m_Count = ConfigGetInt(
"count");
6359
6362
6367
6370
6375
6387
6391
6392
6395 if (ConfigIsExisting("canBeSplit"))
6396 {
6399 }
6400
6402 if (ConfigIsExisting("itemBehaviour"))
6404
6405
6408 RegisterNetSyncVariableInt("m_VarLiquidType");
6409 RegisterNetSyncVariableInt("m_Cleanness",0,1);
6410
6411 RegisterNetSyncVariableBoolSignal("m_WantPlayImpactSound");
6412 RegisterNetSyncVariableFloat("m_ImpactSpeed");
6413 RegisterNetSyncVariableInt("m_ImpactSoundSurfaceHash");
6414
6415 RegisterNetSyncVariableInt("m_ColorComponentR", 0, 255);
6416 RegisterNetSyncVariableInt("m_ColorComponentG", 0, 255);
6417 RegisterNetSyncVariableInt("m_ColorComponentB", 0, 255);
6418 RegisterNetSyncVariableInt("m_ColorComponentA", 0, 255);
6419
6420 RegisterNetSyncVariableBool("m_IsBeingPlaced");
6421 RegisterNetSyncVariableBool("m_IsTakeable");
6422 RegisterNetSyncVariableBool("m_IsHologram");
6423
6426 {
6429 }
6430
6432
6434 if (ConfigIsExisting("temperaturePerQuantityWeight"))
6436
6437 }
6438
6440 {
6442 }
6443
6445 {
6448 {
6453 }
6454 }
6455
6456 override void GetActions(
typename action_input_type, out array<ActionBase_Basic> actions)
6457 {
6459 {
6462 }
6463
6465 }
6466
6468 {
6474 }
6475
6477
6479 {
6481
6482 if (!action)
6483 {
6484 Debug.LogError(
"Action " + actionName +
" dosn't exist!");
6485 return;
6486 }
6487
6489 if (!ai)
6490 {
6492 return;
6493 }
6494
6496 if (!action_array)
6497 {
6498 action_array = new array<ActionBase_Basic>;
6500 }
6501 if (LogManager.IsActionLogEnable())
6502 {
6503 Debug.ActionLog(action.ToString() +
" -> " + ai,
this.ToString() ,
"n/a",
"Add action");
6504 }
6505
6506 if (action_array.Find(action) != -1)
6507 {
6508 Debug.Log(
"Action " + action.Type() +
" already added to " +
this +
", skipping!");
6509 }
6510 else
6511 {
6512 action_array.Insert(action);
6513 }
6514 }
6515
6517 {
6519 ActionBase action = player.GetActionManager().GetAction(actionName);
6522
6523 if (action_array)
6524 {
6525 action_array.RemoveItem(action);
6526 }
6527 }
6528
6529
6530
6532 {
6533 ActionOverrideData overrideData = new ActionOverrideData();
6537
6539 if (!actionMap)
6540 {
6543 }
6544
6545 actionMap.Insert(this.
Type(), overrideData);
6546
6547 }
6548
6550
6552
6553
6555 {
6558
6561
6562 string config_to_search = "CfgVehicles";
6563 string muzzle_owner_config;
6564
6566 {
6567 if (IsInherited(Weapon))
6568 config_to_search = "CfgWeapons";
6569
6570 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
6571
6572 string config_OnFire_class = muzzle_owner_config + "Particles " + "OnFire ";
6573
6575
6576 if (config_OnFire_subclass_count > 0)
6577 {
6578 array<ref WeaponParticlesOnFire> WPOF_array = new array<ref WeaponParticlesOnFire>;
6579
6580 for (int i = 0; i < config_OnFire_subclass_count; i++)
6581 {
6582 string particle_class = "";
6584 string config_OnFire_entry = config_OnFire_class + particle_class;
6585 WeaponParticlesOnFire WPOF = new WeaponParticlesOnFire(this, config_OnFire_entry);
6586 WPOF_array.Insert(WPOF);
6587 }
6588
6589
6591 }
6592 }
6593
6595 {
6596 config_to_search = "CfgWeapons";
6597 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
6598
6599 string config_OnBulletCasingEject_class = muzzle_owner_config + "Particles " + "OnBulletCasingEject ";
6600
6602
6603 if (config_OnBulletCasingEject_count > 0 && IsInherited(Weapon))
6604 {
6605 array<ref WeaponParticlesOnBulletCasingEject> WPOBE_array = new array<ref WeaponParticlesOnBulletCasingEject>;
6606
6607 for (i = 0; i < config_OnBulletCasingEject_count; i++)
6608 {
6609 string particle_class2 = "";
6611 string config_OnBulletCasingEject_entry = config_OnBulletCasingEject_class + particle_class2;
6612 WeaponParticlesOnBulletCasingEject WPOBE = new WeaponParticlesOnBulletCasingEject(this, config_OnBulletCasingEject_entry);
6613 WPOBE_array.Insert(WPOBE);
6614 }
6615
6616
6618 }
6619 }
6620 }
6621
6622
6624 {
6627
6629 {
6630 string config_to_search = "CfgVehicles";
6631
6632 if (IsInherited(Weapon))
6633 config_to_search = "CfgWeapons";
6634
6635 string muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
6636 string config_OnOverheating_class = muzzle_owner_config + "Particles " + "OnOverheating ";
6637
6638 if (
GetGame().ConfigIsExisting(config_OnOverheating_class))
6639 {
6640
6642
6644 {
6646 string error =
"Error reading config " +
GetType() +
">Particles>OnOverheating - Parameter shotsToStartOverheating is configured wrong or is missing! Its value must be 1 or higher!";
6648 return;
6649 }
6650
6653
6654
6655
6657 array<ref WeaponParticlesOnOverheating> WPOOH_array = new array<ref WeaponParticlesOnOverheating>;
6658
6659 for (int i = 0; i < config_OnOverheating_subclass_count; i++)
6660 {
6661 string particle_class = "";
6663 string config_OnOverheating_entry = config_OnOverheating_class + particle_class;
6665
6666 if (entry_type == CT_CLASS)
6667 {
6668 WeaponParticlesOnOverheating WPOF = new WeaponParticlesOnOverheating(this, config_OnOverheating_entry);
6669 WPOOH_array.Insert(WPOF);
6670 }
6671 }
6672
6673
6675 }
6676 }
6677 }
6678
6680 {
6682 }
6683
6685 {
6687 {
6689
6692
6695
6696 CheckOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
6697 }
6698 }
6699
6701 {
6703 UpdateOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
6704
6706 StartOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
6707
6709 StopOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
6710
6712 {
6714 }
6715 }
6716
6718 {
6720 }
6721
6723 {
6726 else
6728
6730 {
6733 }
6734 else
6735 {
6738
6741 }
6742
6744 }
6745
6747 {
6749 ItemBase.PlayOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
6750 }
6751
6753 {
6755 ItemBase.UpdateOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
6757 }
6758
6760 {
6762 ItemBase.StopOverheatingParticles(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
6763 }
6764
6766 {
6769
6770 OverheatingParticle OP = new OverheatingParticle();
6775
6777 }
6778
6780 {
6783
6784 return -1;
6785 }
6786
6788 {
6790 {
6793
6794 for (int i = count; i > 0; --i)
6795 {
6796 int id = i - 1;
6799
6802
6803 if (overheat_coef < overheat_min && overheat_coef >= overheat_max)
6804 {
6805 if (p)
6806 {
6809 }
6810 }
6811 }
6812 }
6813 }
6814
6816 {
6818 {
6820 {
6821 int id = i - 1;
6823
6824 if (OP)
6825 {
6827
6828 if (p)
6829 {
6831 }
6832
6833 delete OP;
6834 }
6835 }
6836
6839 }
6840 }
6841
6844 {
6845 return 0.0;
6846 }
6847
6848
6850 {
6851 return 250;
6852 }
6853
6855 {
6856 return 0;
6857 }
6858
6861 {
6863 return true;
6864
6865 return false;
6866 }
6867
6870 {
6873
6875 {
6877 }
6878 else
6879 {
6880
6882 }
6883
6885 }
6886
6893 {
6894 return -1;
6895 }
6896
6897
6898
6899
6901 {
6903 {
6905 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
6906
6907 if (r_index >= 0)
6908 {
6909 InventoryLocation r_il = new InventoryLocation;
6910 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
6911
6912 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
6915 {
6916 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
6917 }
6919 {
6920 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
6921 }
6922
6923 }
6924
6925 player.GetHumanInventory().ClearUserReservedLocation(this);
6926 }
6927
6930 }
6931
6932
6933
6934
6936 {
6937 return ItemBase.m_DebugActionsMask;
6938 }
6939
6941 {
6942 return ItemBase.m_DebugActionsMask & mask;
6943 }
6944
6946 {
6947 ItemBase.m_DebugActionsMask = mask;
6948 }
6949
6951 {
6952 ItemBase.m_DebugActionsMask |= mask;
6953 }
6954
6956 {
6957 ItemBase.m_DebugActionsMask &= ~mask;
6958 }
6959
6961 {
6963 {
6965 }
6966 else
6967 {
6969 }
6970 }
6971
6972
6974 {
6975 if (GetEconomyProfile())
6976 {
6977 float q_max = GetEconomyProfile().GetQuantityMax();
6978 if (q_max > 0)
6979 {
6980 float q_min = GetEconomyProfile().GetQuantityMin();
6981 float quantity_randomized = Math.RandomFloatInclusive(q_min, q_max);
6982
6984 {
6985 ComponentEnergyManager comp = GetCompEM();
6987 {
6989 }
6990 }
6992 {
6994
6995 }
6996
6997 }
6998 }
6999 }
7000
7003 {
7004 EntityAI parent = GetHierarchyParent();
7005
7006 if (parent)
7007 {
7008 InventoryLocation inventory_location_to_lock = new InventoryLocation;
7009 GetInventory().GetCurrentInventoryLocation(inventory_location_to_lock);
7010 parent.GetInventory().SetSlotLock(inventory_location_to_lock.
GetSlot(),
true);
7011 }
7012 }
7013
7016 {
7017 EntityAI parent = GetHierarchyParent();
7018
7019 if (parent)
7020 {
7021 InventoryLocation inventory_location_to_unlock = new InventoryLocation;
7022 GetInventory().GetCurrentInventoryLocation(inventory_location_to_unlock);
7023 parent.GetInventory().SetSlotLock(inventory_location_to_unlock.
GetSlot(),
false);
7024 }
7025 }
7026
7028 {
7029
7030
7031
7032
7034
7036 {
7037 if (ScriptInputUserData.CanStoreInputUserData())
7038 {
7039 ScriptInputUserData ctx = new ScriptInputUserData;
7045 ctx.
Write(use_stack_max);
7048
7050 {
7051 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(item2,null,GameInventory.c_InventoryReservationTimeoutShortMS);
7052 }
7053 }
7054 }
7055 else if (!
GetGame().IsMultiplayer())
7056 {
7058 }
7059 }
7060
7062 {
7064 }
7065
7067 {
7069 }
7070
7072 {
7074 }
7075
7077 {
7078
7079 return false;
7080 }
7081
7083 {
7084 return false;
7085 }
7086
7090 {
7091 return false;
7092 }
7093
7095 {
7096 return "";
7097 }
7098
7100
7102 {
7103 return false;
7104 }
7105
7107 {
7108 return true;
7109 }
7110
7111
7112
7114 {
7115 return true;
7116 }
7117
7119 {
7120 return true;
7121 }
7122
7124 {
7125 PlayerBase player = PlayerBase.Cast(
g_Game.GetPlayer());
7127 }
7128
7130 {
7132 }
7133
7135 {
7137 if (!is_being_placed)
7139 SetSynchDirty();
7140 }
7141
7142
7144
7146 {
7148 }
7149
7151 {
7153 }
7154
7156 {
7157 return 1;
7158 }
7159
7161 {
7162 return false;
7163 }
7164
7166 {
7168 SetSynchDirty();
7169 }
7170
7171
7172
7173
7174
7175
7176
7177
7178
7179
7180
7181
7182
7183
7184
7185
7186
7187
7188
7189
7190
7191
7192
7193
7194
7195
7196
7197
7198
7199
7200
7201
7202
7203
7204
7206 {
7207 super.OnMovedInsideCargo(container);
7208
7209 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
7210 }
7211
7212 override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
7213 {
7214 super.EEItemLocationChanged(oldLoc,newLoc);
7215
7216 PlayerBase new_player = null;
7217 PlayerBase old_player = null;
7218
7219 if (newLoc.GetParent())
7220 new_player = PlayerBase.Cast(newLoc.GetParent().GetHierarchyRootPlayer());
7221
7222 if (oldLoc.GetParent())
7223 old_player = PlayerBase.Cast(oldLoc.GetParent().GetHierarchyRootPlayer());
7224
7226 {
7227 int r_index = old_player.GetHumanInventory().FindUserReservedLocationIndex(this);
7228
7229 if (r_index >= 0)
7230 {
7231 InventoryLocation r_il = new InventoryLocation;
7232 old_player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
7233
7234 old_player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
7237 {
7238 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
7239 }
7241 {
7242 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
7243 }
7244
7245 }
7246 }
7247
7249 {
7250 if (new_player)
7251 new_player.ForceStandUpForHeavyItems(newLoc.GetItem());
7252
7253 if (new_player == old_player)
7254 {
7255
7256 if (oldLoc.GetParent() && new_player.GetHumanInventory().LocationGetEntity(oldLoc) == NULL)
7257 {
7259 {
7260 if (oldLoc.GetParent().GetInventory().TestAddEntityInCargoExLoc(oldLoc, false, false, false, true, false, false))
7261 {
7262 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
7263 }
7264 }
7265 else
7266 {
7267 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
7268 }
7269 }
7270
7271 if (new_player.GetHumanInventory().FindUserReservedLocationIndex(this) >= 0)
7272 {
7273 int type = oldLoc.GetType();
7275 {
7276 oldLoc.GetParent().GetOnSetLock().Invoke(this);
7277 }
7279 {
7280 oldLoc.GetParent().GetOnAttachmentSetLock().Invoke(this, oldLoc.GetSlot());
7281 }
7282 }
7283 if (!m_OldLocation)
7284 {
7285 m_OldLocation = new InventoryLocation;
7286 }
7287 m_OldLocation.Copy(oldLoc);
7288 }
7289 else
7290 {
7291 if (m_OldLocation)
7292 {
7293 m_OldLocation.Reset();
7294 }
7295 }
7296
7298 }
7299 else
7300 {
7301 if (new_player)
7302 {
7303 int res_index = new_player.GetHumanInventory().FindCollidingUserReservedLocationIndex(this, newLoc);
7304 if (res_index >= 0)
7305 {
7306 InventoryLocation il = new InventoryLocation;
7307 new_player.GetHumanInventory().GetUserReservedLocation(res_index,il);
7309 new_player.GetHumanInventory().ClearUserReservedLocationAtIndex(res_index);
7312 {
7313 il.
GetParent().GetOnReleaseLock().Invoke(it);
7314 }
7316 {
7318 }
7319
7320 }
7321 }
7323 {
7324
7326 }
7327
7328 if (m_OldLocation)
7329 {
7330 m_OldLocation.Reset();
7331 }
7332 }
7333 }
7334
7335 override void EOnContact(IEntity other, Contact extra)
7336 {
7338 {
7339 int liquidType = -1;
7341 if (impactSpeed > 0.0)
7342 {
7344 #ifndef SERVER
7346 #else
7348 SetSynchDirty();
7349 #endif
7351 }
7352 }
7353
7354 #ifdef SERVER
7355 if (GetCompEM() && GetCompEM().IsPlugged())
7356 {
7357 if (GetCompEM().GetCordLength() < vector.Distance(
GetPosition(), GetCompEM().GetEnergySource().
GetPosition()))
7358 GetCompEM().UnplugThis();
7359 }
7360 #endif
7361 }
7362
7364
7366 {
7368 }
7369
7371 {
7372
7373 }
7374
7376 {
7377 super.OnItemLocationChanged(old_owner, new_owner);
7378
7379 PlayerBase relatedPlayer = PlayerBase.Cast(old_owner);
7380 PlayerBase playerNew = PlayerBase.Cast(new_owner);
7381
7382 if (!relatedPlayer && playerNew)
7383 relatedPlayer = playerNew;
7384
7385 if (relatedPlayer && relatedPlayer.GetPerformedActionID() != -1)
7386 {
7388 if (actionMgr)
7389 {
7390 ActionBase currentAction = actionMgr.GetRunningAction();
7391 if (currentAction)
7393 }
7394 }
7395
7396 Man ownerPlayerOld = null;
7397 Man ownerPlayerNew = null;
7398
7399 if (old_owner)
7400 {
7401 if (old_owner.
IsMan())
7402 {
7403 ownerPlayerOld = Man.Cast(old_owner);
7404 }
7405 else
7406 {
7407 ownerPlayerOld = Man.Cast(old_owner.GetHierarchyRootPlayer());
7408 }
7409 }
7410 else
7411 {
7413 {
7415
7416 if (!action || !playerNew || playerNew.GetPerformedActionID() != action.
GetID())
7417 {
7418 GetCompEM().UnplugThis();
7419 }
7420 }
7421 }
7422
7423 if (new_owner)
7424 {
7425 if (new_owner.
IsMan())
7426 {
7427 ownerPlayerNew = Man.Cast(new_owner);
7428 }
7429 else
7430 {
7431 ownerPlayerNew = Man.Cast(new_owner.GetHierarchyRootPlayer());
7432 }
7433 }
7434
7435 if (ownerPlayerOld != ownerPlayerNew)
7436 {
7437 if (ownerPlayerOld)
7438 {
7439 array<EntityAI> subItemsExit = new array<EntityAI>;
7441 for (int i = 0; i < subItemsExit.Count(); i++)
7442 {
7445 }
7446 }
7447
7448 if (ownerPlayerNew)
7449 {
7450 array<EntityAI> subItemsEnter = new array<EntityAI>;
7452 for (int j = 0; j < subItemsEnter.Count(); j++)
7453 {
7456 }
7457 }
7458 }
7459 else if (ownerPlayerNew != null)
7460 {
7461 PlayerBase nplayer;
7462 if (PlayerBase.CastTo(nplayer, ownerPlayerNew))
7463 {
7464 array<EntityAI> subItemsUpdate = new array<EntityAI>;
7466 for (int k = 0; k < subItemsUpdate.Count(); k++)
7467 {
7469 itemUpdate.UpdateQuickbarShortcutVisibility(nplayer);
7470 }
7471 }
7472 }
7473
7474 if (old_owner)
7475 old_owner.OnChildItemRemoved(this);
7476 if (new_owner)
7477 new_owner.OnChildItemReceived(this);
7478 }
7479
7480
7482 {
7483 super.EEDelete(parent);
7484 PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
7485 if (player)
7486 {
7488
7489 if (player.IsAlive())
7490 {
7491 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
7492 if (r_index >= 0)
7493 {
7494 InventoryLocation r_il = new InventoryLocation;
7495 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
7496
7497 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
7500 {
7501 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
7502 }
7504 {
7505 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
7506 }
7507
7508 }
7509
7510 player.RemoveQuickBarEntityShortcut(this);
7511 }
7512 }
7513 }
7514
7516 {
7517 super.EEKilled(killer);
7518
7521 {
7522 if (
GetTemperature() >= GameConstants.ITEM_TEMPERATURE_TO_EXPLODE_MIN)
7523 {
7524 if (IsMagazine())
7525 {
7526 if (Magazine.Cast(this).GetAmmoCount() > 0)
7527 {
7529 }
7530 }
7531 else
7532 {
7534 }
7535 }
7536 }
7537 }
7538
7540 {
7541 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
7542
7543 super.OnWasAttached(parent, slot_id);
7544
7547
7549 }
7550
7552 {
7553 super.OnWasDetached(parent, slot_id);
7554
7557 }
7558
7560 {
7561 int idx;
7564
7565 ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
7566 if (inventory_slots.Count() < 1)
7567 {
7568 inventory_slots.Insert(ConfigGetString("ChangeInventorySlot"));
7569 attach_types.Insert(ConfigGetString("ChangeIntoOnAttach"));
7570 }
7571 else
7572 {
7573 ConfigGetTextArray("ChangeIntoOnAttach",attach_types);
7574 }
7575
7576 idx = inventory_slots.Find(slot);
7577 if (idx < 0)
7578 return "";
7579
7580 return attach_types.Get(idx);
7581 }
7582
7584 {
7585 int idx = -1;
7586 string slot;
7587
7590
7591 this.ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
7592 if (inventory_slots.Count() < 1)
7593 {
7594 inventory_slots.Insert(this.ConfigGetString("ChangeInventorySlot"));
7595 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
7596 }
7597 else
7598 {
7599 this.ConfigGetTextArray("ChangeIntoOnDetach",detach_types);
7600 if (detach_types.Count() < 1)
7601 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
7602 }
7603
7604 for (int i = 0; i < inventory_slots.Count(); i++)
7605 {
7606 slot = inventory_slots.Get(i);
7607 }
7608
7609 if (slot != "")
7610 {
7611 if (detach_types.Count() == 1)
7612 idx = 0;
7613 else
7614 idx = inventory_slots.Find(slot);
7615 }
7616 if (idx < 0)
7617 return "";
7618
7619 return detach_types.Get(idx);
7620 }
7621
7623 {
7624
7626
7627
7628 float min_time = 1;
7629 float max_time = 3;
7630 float delay = Math.RandomFloat(min_time, max_time);
7631
7632 explode_timer.Run(delay, this, "DoAmmoExplosion");
7633 }
7634
7636 {
7637 Magazine magazine = Magazine.Cast(this);
7638 int pop_sounds_count = 6;
7639 string pop_sounds[ 6 ] = { "ammopops_1","ammopops_2","ammopops_3","ammopops_4","ammopops_5","ammopops_6" };
7640
7641
7642 int sound_idx = Math.RandomInt(0, pop_sounds_count - 1);
7643 string sound_name = pop_sounds[ sound_idx ];
7645
7646
7647 magazine.ServerAddAmmoCount(-1);
7648
7649
7650 float min_temp_to_explode = 100;
7651
7652 if (magazine.GetAmmoCount() > 0 &&
GetTemperature() >= min_temp_to_explode)
7653 {
7655 }
7656 }
7657
7658
7659 override void EEHitBy(TotalDamageResult damageResult,
int damageType,
EntityAI source,
int component,
string dmgZone,
string ammo, vector modelPos,
float speedCoef)
7660 {
7661 super.EEHitBy(damageResult, damageType, source,
component, dmgZone, ammo, modelPos, speedCoef);
7662
7663 const int CHANCE_DAMAGE_CARGO = 4;
7664 const int CHANCE_DAMAGE_ATTACHMENT = 1;
7665 const int CHANCE_DAMAGE_NOTHING = 2;
7666
7668 {
7669 float dmg = damageResult.
GetDamage(
"",
"Health") * -0.5;
7670 int chances;
7671 int rnd;
7672
7673 if (GetInventory().GetCargo())
7674 {
7675 chances = CHANCE_DAMAGE_CARGO + CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
7676 rnd = Math.RandomInt(0,chances);
7677
7678 if (rnd < CHANCE_DAMAGE_CARGO)
7679 {
7681 }
7682 else if (rnd < (chances - CHANCE_DAMAGE_NOTHING))
7683 {
7685 }
7686 }
7687 else
7688 {
7689 chances = CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
7690 rnd = Math.RandomInt(0,chances);
7691
7692 if (rnd < CHANCE_DAMAGE_ATTACHMENT)
7693 {
7695 }
7696 }
7697 }
7698 }
7699
7701 {
7702 if (GetInventory().GetCargo())
7703 {
7704 int item_count = GetInventory().GetCargo().GetItemCount();
7705 if (item_count > 0)
7706 {
7707 int random_pick = Math.RandomInt(0, item_count);
7709 if (!item.IsExplosive())
7710 {
7711 item.AddHealth("","",damage);
7712 return true;
7713 }
7714 }
7715 }
7716 return false;
7717 }
7718
7720 {
7721 int attachment_count = GetInventory().AttachmentCount();
7722 if (attachment_count > 0)
7723 {
7724 int random_pick = Math.RandomInt(0, attachment_count);
7725 ItemBase attachment =
ItemBase.Cast(GetInventory().GetAttachmentFromIndex(random_pick));
7726 if (!attachment.IsExplosive())
7727 {
7728 attachment.AddHealth("","",damage);
7729 return true;
7730 }
7731 }
7732 return false;
7733 }
7734
7736 {
7738 }
7739
7741 {
7743 return GetInventory().CanRemoveEntity();
7744
7745 return false;
7746 }
7747
7749 {
7750
7752 return false;
7753
7754
7756 return false;
7757
7758
7759
7761 if (delta == 0)
7762 return false;
7763
7764
7765 return true;
7766 }
7767
7769 {
7771 {
7772 if (ScriptInputUserData.CanStoreInputUserData())
7773 {
7774 ScriptInputUserData ctx = new ScriptInputUserData;
7779 ctx.
Write(destination_entity);
7783 }
7784 }
7785 else if (!
GetGame().IsMultiplayer())
7786 {
7788 }
7789 }
7790
7792 {
7793 float split_quantity_new;
7797 InventoryLocation loc = new InventoryLocation;
7798
7799 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
7800 {
7802 split_quantity_new = stack_max;
7803 else
7805
7807 {
7808 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
7809 if (new_item)
7810 {
7811 new_item.SetResultOfSplit(true);
7812 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7814 new_item.
SetQuantity(split_quantity_new,
false,
true);
7815 }
7816 }
7817 }
7818 else if (destination_entity && slot_id == -1)
7819 {
7820 if (quantity > stack_max)
7821 split_quantity_new = stack_max;
7822 else
7823 split_quantity_new = quantity;
7824
7826 {
7828 {
7831 }
7832
7833 if (new_item)
7834 {
7835 new_item.SetResultOfSplit(true);
7836 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7838 new_item.
SetQuantity(split_quantity_new,
false,
true);
7839 }
7840 }
7841 }
7842 else
7843 {
7844 if (stack_max != 0)
7845 {
7847 {
7849 }
7850
7851 if (split_quantity_new == 0)
7852 {
7853 if (!
GetGame().IsMultiplayer())
7854 player.PhysicalPredictiveDropItem(this);
7855 else
7856 player.ServerDropEntity(this);
7857 return;
7858 }
7859
7861 {
7863
7864 if (new_item)
7865 {
7866 new_item.SetResultOfSplit(true);
7867 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7870 new_item.PlaceOnSurface();
7871 }
7872 }
7873 }
7874 }
7875 }
7876
7878 {
7879 float split_quantity_new;
7883 InventoryLocation loc = new InventoryLocation;
7884
7885 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
7886 {
7888 split_quantity_new = stack_max;
7889 else
7891
7893 {
7894 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
7895 if (new_item)
7896 {
7897 new_item.SetResultOfSplit(true);
7898 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7900 new_item.
SetQuantity(split_quantity_new,
false,
true);
7901 }
7902 }
7903 }
7904 else if (destination_entity && slot_id == -1)
7905 {
7906 if (quantity > stack_max)
7907 split_quantity_new = stack_max;
7908 else
7909 split_quantity_new = quantity;
7910
7912 {
7914 {
7917 }
7918
7919 if (new_item)
7920 {
7921 new_item.SetResultOfSplit(true);
7922 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7924 new_item.
SetQuantity(split_quantity_new,
false,
true);
7925 }
7926 }
7927 }
7928 else
7929 {
7930 if (stack_max != 0)
7931 {
7933 {
7935 }
7936
7938 {
7940
7941 if (new_item)
7942 {
7943 new_item.SetResultOfSplit(true);
7944 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7947 new_item.PlaceOnSurface();
7948 }
7949 }
7950 }
7951 }
7952 }
7953
7955 {
7957 {
7958 if (ScriptInputUserData.CanStoreInputUserData())
7959 {
7960 ScriptInputUserData ctx = new ScriptInputUserData;
7965 dst.WriteToContext(ctx);
7967 }
7968 }
7969 else if (!
GetGame().IsMultiplayer())
7970 {
7972 }
7973 }
7974
7976 {
7978 {
7979 if (ScriptInputUserData.CanStoreInputUserData())
7980 {
7981 ScriptInputUserData ctx = new ScriptInputUserData;
7986 ctx.
Write(destination_entity);
7992 }
7993 }
7994 else if (!
GetGame().IsMultiplayer())
7995 {
7997 }
7998 }
7999
8001 {
8003 }
8004
8006 {
8008 float split_quantity_new;
8010 if (dst.IsValid())
8011 {
8012 int slot_id = dst.GetSlot();
8014
8015 if (quantity > stack_max)
8016 split_quantity_new = stack_max;
8017 else
8018 split_quantity_new = quantity;
8019
8021 {
8023
8024 if (new_item)
8025 {
8026 new_item.SetResultOfSplit(true);
8027 MiscGameplayFunctions.TransferItemProperties(this,new_item);
8029 new_item.
SetQuantity(split_quantity_new,
false,
true);
8030 }
8031
8032 return new_item;
8033 }
8034 }
8035
8036 return null;
8037 }
8038
8040 {
8042 float split_quantity_new;
8044 if (destination_entity)
8045 {
8047 if (quantity > stackable)
8048 split_quantity_new = stackable;
8049 else
8050 split_quantity_new = quantity;
8051
8053 {
8054 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateEntityInCargoEx(
this.GetType(), idx, row, col,
false));
8055 if (new_item)
8056 {
8057 new_item.SetResultOfSplit(true);
8058 MiscGameplayFunctions.TransferItemProperties(this,new_item);
8060 new_item.
SetQuantity(split_quantity_new,
false,
true);
8061 }
8062 }
8063 }
8064 }
8065
8067 {
8069 {
8070 if (ScriptInputUserData.CanStoreInputUserData())
8071 {
8072 ScriptInputUserData ctx = new ScriptInputUserData;
8077 ItemBase destination_entity =
this;
8078 ctx.
Write(destination_entity);
8082 }
8083 }
8084 else if (!
GetGame().IsMultiplayer())
8085 {
8087 }
8088 }
8089
8091 {
8093 float split_quantity_new;
8095 if (player)
8096 {
8098 if (quantity > stackable)
8099 split_quantity_new = stackable;
8100 else
8101 split_quantity_new = quantity;
8102
8104 {
8105 EntityAI in_hands = player.GetHumanInventory().CreateInHands(this.
GetType());
8106 new_item =
ItemBase.Cast(in_hands);
8107 if (new_item)
8108 {
8109 new_item.SetResultOfSplit(true);
8110 MiscGameplayFunctions.TransferItemProperties(this,new_item);
8112 new_item.SetQuantity(split_quantity_new, false, true);
8113 }
8114 }
8115 }
8116 }
8117
8119 {
8121 float split_quantity_new = Math.Floor(quantity * 0.5);
8122
8124 return;
8125
8127
8128 if (new_item)
8129 {
8130 if (new_item.GetQuantityMax() < split_quantity_new)
8131 {
8132 split_quantity_new = new_item.GetQuantityMax();
8133 }
8134
8135 new_item.SetResultOfSplit(true);
8136 MiscGameplayFunctions.TransferItemProperties(this, new_item);
8137
8139 {
8142 }
8143 else
8144 {
8146 new_item.
SetQuantity(split_quantity_new,
false,
true);
8147 }
8148 }
8149 }
8150
8152 {
8154 float split_quantity_new = Math.Floor(quantity / 2);
8155
8157 return;
8158
8159 InventoryLocation invloc = new InventoryLocation;
8161
8163 new_item = player.CreateCopyOfItemInInventoryOrGroundEx(this, true);
8164
8165 if (new_item)
8166 {
8167 if (new_item.GetQuantityMax() < split_quantity_new)
8168 {
8169 split_quantity_new = new_item.GetQuantityMax();
8170 }
8172 {
8175 }
8176 else if (split_quantity_new > 1)
8177 {
8179 new_item.
SetQuantity(split_quantity_new,
false,
true);
8180 }
8181 }
8182 }
8183
8186 {
8187 SetWeightDirty();
8189
8190 if (parent)
8191 parent.OnAttachmentQuantityChangedEx(this, delta);
8192
8194 {
8196 {
8198 }
8200 {
8201 ErrorEx(
"Undefined liquid type quantity changed, please define liquid type first! Using init value.",
ErrorExSeverity.INFO);
8203 }
8204 }
8205
8206 }
8207
8210 {
8211
8212 }
8213
8216 {
8218 }
8219
8221 {
8222 super.EEHealthLevelChanged(oldLevel,newLevel,zone);
8223
8225 {
8226 if (newLevel == GameConstants.STATE_RUINED)
8227 {
8229 EntityAI parent = GetHierarchyParent();
8230 if (parent && parent.IsFireplace())
8231 {
8232 CargoBase cargo = GetInventory().GetCargo();
8233 if (cargo)
8234 {
8236 {
8238 }
8239 }
8240 }
8241 }
8242
8244 {
8245
8247 return;
8248 }
8249
8250 if (
m_Cleanness != 0 && oldLevel < newLevel && newLevel != 0)
8251 {
8253 }
8254 }
8255 }
8256
8257
8259 {
8260 super.OnRightClick();
8261
8263 {
8265 {
8266 if (ScriptInputUserData.CanStoreInputUserData())
8267 {
8268 EntityAI root = GetHierarchyRoot();
8269 Man playerOwner = GetHierarchyRootPlayer();
8270 InventoryLocation dst = new InventoryLocation;
8271
8272
8273 if (!playerOwner && root && root == this)
8274 {
8276 }
8277 else
8278 {
8279
8280 GetInventory().GetCurrentInventoryLocation(dst);
8282 {
8285 {
8287 }
8288 else
8289 {
8291
8292
8293 if (
GetGame().
GetPlayer().GetInventory().HasInventoryReservation(
this, dst))
8294 {
8296 }
8297 else
8298 {
8299 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(null, dst, GameInventory.c_InventoryReservationTimeoutShortMS);
8300 }
8301 }
8302 }
8303 }
8304
8305 ScriptInputUserData ctx = new ScriptInputUserData;
8313 }
8314 }
8315 else if (!
GetGame().IsMultiplayer())
8316 {
8318 }
8319 }
8320 }
8321
8323 {
8324 if (root)
8325 {
8326 vector m4[4];
8327 root.GetTransform(m4);
8328 dst.SetGround(this, m4);
8329 }
8330 else
8331 {
8332 GetInventory().GetCurrentInventoryLocation(dst);
8333 }
8334 }
8335
8336 override bool CanBeCombined(
EntityAI other_item,
bool reservation_check =
true,
bool stack_max_limit =
false)
8337 {
8338
8339 if (!other_item ||
GetType() != other_item.GetType() || (
IsFullQuantity() && other_item.GetQuantity() > 0) || other_item ==
this)
8340 return false;
8341
8342 if (GetHealthLevel() == GameConstants.STATE_RUINED || other_item.GetHealthLevel() == GameConstants.STATE_RUINED)
8343 return false;
8344
8345
8347 return false;
8348
8349
8350 Magazine mag = Magazine.Cast(this);
8351 if (mag)
8352 {
8353 if (mag.GetAmmoCount() >= mag.GetAmmoMax())
8354 return false;
8355
8356 if (stack_max_limit)
8357 {
8358 Magazine other_mag = Magazine.Cast(other_item);
8359 if (other_item)
8360 {
8361 if (mag.GetAmmoCount() + other_mag.GetAmmoCount() > mag.GetAmmoMax())
8362 return false;
8363 }
8364
8365 }
8366 }
8367 else
8368 {
8369
8371 return false;
8372
8374 return false;
8375 }
8376
8377 PlayerBase player = null;
8378 if (CastTo(player, GetHierarchyRootPlayer()))
8379 {
8380 if (player.GetInventory().HasAttachment(this))
8381 return false;
8382
8383 if (player.IsItemsToDelete())
8384 return false;
8385 }
8386
8387 if (reservation_check && (GetInventory().HasInventoryReservation(this, null) || other_item.GetInventory().HasInventoryReservation(other_item, null)))
8388 return false;
8389
8390 int slotID;
8392 if (GetInventory().GetCurrentAttachmentSlotInfo(slotID,
slotName) && GetHierarchyParent().GetInventory().GetSlotLock(slotID))
8393 return false;
8394
8395 return true;
8396 }
8397
8399 {
8401 }
8402
8404 {
8405 return m_IsResultOfSplit;
8406 }
8407
8409 {
8410 m_IsResultOfSplit = value;
8411 }
8412
8414 {
8416 }
8417
8419 {
8420 float other_item_quantity = other_item.GetQuantity();
8421 float this_free_space;
8422
8424
8426
8427 if (other_item_quantity > this_free_space)
8428 {
8429 return this_free_space;
8430 }
8431 else
8432 {
8433 return other_item_quantity;
8434 }
8435 }
8436
8438 {
8440 }
8441
8443 {
8445 return;
8446
8447 if (!IsMagazine() && other_item)
8448 {
8450 if (quantity_used != 0)
8451 {
8452 float hp1 = GetHealth01("","");
8453 float hp2 = other_item.GetHealth01("","");
8454 float hpResult = ((hp1*
GetQuantity()) + (hp2*quantity_used));
8455 hpResult = hpResult / (
GetQuantity() + quantity_used);
8456
8457 hpResult *= GetMaxHealth();
8458 Math.Round(hpResult);
8459 SetHealth("", "Health", hpResult);
8460
8462 other_item.AddQuantity(-quantity_used);
8463 }
8464 }
8466 }
8467
8469 {
8470 #ifdef SERVER
8471 if (!GetHierarchyRootPlayer() && GetHierarchyParent())
8472 GetHierarchyParent().IncreaseLifetimeUp();
8473 #endif
8474 };
8475
8477 {
8478 PlayerBase p = PlayerBase.Cast(player);
8479
8480 array<int> recipesIds = p.m_Recipes;
8481 PluginRecipesManager moduleRecipesManager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
8482 if (moduleRecipesManager)
8483 {
8484 EntityAI itemInHands = player.GetHumanInventory().GetEntityInHands();
8485 moduleRecipesManager.GetValidRecipes(
ItemBase.Cast(
this),
ItemBase.Cast(itemInHands), recipesIds, p);
8486 }
8487
8488 for (int i = 0;i < recipesIds.Count(); i++)
8489 {
8490 int key = recipesIds.Get(i);
8491 string recipeName = moduleRecipesManager.GetRecipeName(key);
8493 }
8494 }
8495
8496
8497 override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
8498 {
8499 super.GetDebugActions(outputList);
8500
8501
8507
8508
8513
8518
8519
8523
8524
8526 {
8530 }
8531
8534
8535
8539
8541
8542 InventoryLocation loc = new InventoryLocation();
8543 GetInventory().GetCurrentInventoryLocation(loc);
8545 {
8546 if (Gizmo_IsSupported())
8549 }
8550
8552 }
8553
8554
8555
8556
8558 {
8559 super.OnAction(action_id, player, ctx);
8560
8562 {
8563 switch (action_id)
8564 {
8567 return true;
8570 return true;
8571 }
8572 }
8573
8575 {
8576 switch (action_id)
8577 {
8579 Delete();
8580 return true;
8581 }
8582 }
8583
8584 if (action_id >=
EActions.RECIPES_RANGE_START && action_id <
EActions.RECIPES_RANGE_END)
8585 {
8586 PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
8587 int idWithoutOffset = action_id -
EActions.RECIPES_RANGE_START;
8588 PlayerBase p = PlayerBase.Cast(player);
8589 if (
EActions.RECIPES_RANGE_START < 1000)
8590 {
8591 float anim_length = plugin_recipes_manager.GetRecipeLengthInSecs(idWithoutOffset);
8592 float specialty_weight = plugin_recipes_manager.GetRecipeSpecialty(idWithoutOffset);
8593 }
8594 }
8595 #ifndef SERVER
8596 else if (action_id ==
EActions.WATCH_PLAYER)
8597 {
8598 PluginDeveloper.SetDeveloperItemClientEx(player);
8599 }
8600 #endif
8602 {
8603 if (action_id >=
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START && action_id <
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_END)
8604 {
8605 int id = action_id -
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START;
8606 OnDebugButtonPressServer(id + 1);
8607 }
8608
8609 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_INJECT_START && action_id <
EActions.DEBUG_AGENTS_RANGE_INJECT_END)
8610 {
8611 int agent_id = action_id -
EActions.DEBUG_AGENTS_RANGE_INJECT_START;
8613 }
8614
8615 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_REMOVE_START && action_id <
EActions.DEBUG_AGENTS_RANGE_REMOVE_END)
8616 {
8617 int agent_id2 = action_id -
EActions.DEBUG_AGENTS_RANGE_REMOVE_START;
8619 }
8620
8621 else if (action_id ==
EActions.ADD_QUANTITY)
8622 {
8623 if (IsMagazine())
8624 {
8625 Magazine mag = Magazine.Cast(this);
8626 mag.ServerSetAmmoCount(mag.GetAmmoCount() + mag.GetAmmoMax() * 0.2);
8627 }
8628 else
8629 {
8631 }
8632
8633 if (m_EM)
8634 {
8635 m_EM.AddEnergy(m_EM.GetEnergyMax() * 0.2);
8636 }
8637
8638 }
8639
8640 else if (action_id ==
EActions.REMOVE_QUANTITY)
8641 {
8642 if (IsMagazine())
8643 {
8644 Magazine mag2 = Magazine.Cast(this);
8645 mag2.ServerSetAmmoCount(mag2.GetAmmoCount() - mag2.GetAmmoMax() * 0.2);
8646 }
8647 else
8648 {
8650 }
8651 if (m_EM)
8652 {
8653 m_EM.AddEnergy(- m_EM.GetEnergyMax() * 0.2);
8654 }
8655
8656 }
8657
8658 else if (action_id ==
EActions.SET_QUANTITY_0)
8659 {
8661
8662 if (m_EM)
8663 {
8664 m_EM.SetEnergy(0);
8665 }
8666 }
8667
8668 else if (action_id ==
EActions.SET_MAX_QUANTITY)
8669 {
8671
8672 if (m_EM)
8673 {
8674 m_EM.SetEnergy(m_EM.GetEnergyMax());
8675 }
8676 }
8677
8678 else if (action_id ==
EActions.ADD_HEALTH)
8679 {
8680 AddHealth("","",GetMaxHealth("","Health")/5);
8681 }
8682 else if (action_id ==
EActions.REMOVE_HEALTH)
8683 {
8684 AddHealth("","",-GetMaxHealth("","Health")/5);
8685 }
8686 else if (action_id ==
EActions.DESTROY_HEALTH)
8687 {
8688 SetHealth01("","",0);
8689 }
8690 else if (action_id ==
EActions.WATCH_ITEM)
8691 {
8693 mid.RegisterDebugItem(
ItemBase.Cast(
this), PlayerBase.Cast(player));
8694 #ifdef DEVELOPER
8695 SetDebugDeveloper_item(this);
8696 #endif
8697 }
8698
8699 else if (action_id ==
EActions.ADD_TEMPERATURE)
8700 {
8701 AddTemperature(20);
8702
8703 }
8704
8705 else if (action_id ==
EActions.REMOVE_TEMPERATURE)
8706 {
8707 AddTemperature(-20);
8708
8709 }
8710
8711 else if (action_id ==
EActions.FLIP_FROZEN)
8712 {
8713 SetFrozen(!GetIsFrozen());
8714
8715 }
8716
8717 else if (action_id ==
EActions.ADD_WETNESS)
8718 {
8720
8721 }
8722
8723 else if (action_id ==
EActions.REMOVE_WETNESS)
8724 {
8726
8727 }
8728
8729 else if (action_id ==
EActions.LIQUIDTYPE_UP)
8730 {
8733
8734
8735 }
8736
8737 else if (action_id ==
EActions.LIQUIDTYPE_DOWN)
8738 {
8741 }
8742
8743 else if (action_id ==
EActions.MAKE_SPECIAL)
8744 {
8745 auto debugParams = DebugSpawnParams.WithPlayer(player);
8746 OnDebugSpawnEx(debugParams);
8747 }
8748
8749 }
8750
8751
8752 return false;
8753 }
8754
8755
8756
8757
8761
8764
8765
8766
8768 {
8769 return false;
8770 }
8771
8772
8774 {
8775 return true;
8776 }
8777
8778
8780 {
8781 return true;
8782 }
8783
8784
8785
8787 {
8788 string config_path =
string.Format(
"CfgVehicles %1 Food FoodStages",
GetType());
8790 }
8791
8794 {
8795 return null;
8796 }
8797
8799 {
8800 return false;
8801 }
8802
8804 {
8805 return false;
8806 }
8807
8811
8812
8814 {
8815 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
8816 return module_repairing.CanRepair(this, item_repair_kit);
8817 }
8818
8819
8820 bool Repair(PlayerBase player,
ItemBase item_repair_kit,
float specialty_weight)
8821 {
8822 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
8823 return module_repairing.Repair(player, this, item_repair_kit, specialty_weight);
8824 }
8825
8826
8828 {
8829
8830
8831
8832
8833
8834
8835
8836
8837 return 1;
8838 }
8839
8840
8841
8843 {
8845 }
8846
8847
8848
8850 {
8852 }
8853
8854
8863 {
8864 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8865
8866 if (player)
8867 {
8868 player.MessageStatus(text);
8869 }
8870 }
8871
8872
8881 {
8882 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8883
8884 if (player)
8885 {
8886 player.MessageAction(text);
8887 }
8888 }
8889
8890
8899 {
8900 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8901
8902 if (player)
8903 {
8904 player.MessageFriendly(text);
8905 }
8906 }
8907
8908
8917 {
8918 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8919
8920 if (player)
8921 {
8922 player.MessageImportant(text);
8923 }
8924 }
8925
8927 {
8928 return true;
8929 }
8930
8931
8932 override bool KindOf(
string tag)
8933 {
8934 bool found = false;
8935 string item_name = this.
GetType();
8938
8939 int array_size = item_tag_array.Count();
8940 for (int i = 0; i < array_size; i++)
8941 {
8942 if (item_tag_array.Get(i) == tag)
8943 {
8944 found = true;
8945 break;
8946 }
8947 }
8948 return found;
8949 }
8950
8951
8953 {
8954
8955 super.OnRPC(sender, rpc_type,ctx);
8956
8957
8958 switch (rpc_type)
8959 {
8960 #ifndef SERVER
8961 case ERPCs.RPC_SOUND_LOCK_ATTACH:
8962 Param2<bool, string> p = new Param2<bool, string>(false, "");
8963
8965 return;
8966
8967 bool play = p.param1;
8968 string soundSet = p.param2;
8969
8970 if (play)
8971 {
8973 {
8975 {
8977 }
8978 }
8979 else
8980 {
8982 }
8983 }
8984 else
8985 {
8987 }
8988
8989 break;
8990 #endif
8991
8992 }
8993
8995 {
8997 }
8998 }
8999
9000
9001
9002
9004 {
9005 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
9006 return plugin.GetID(
name);
9007 }
9008
9010 {
9011 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
9012 return plugin.GetName(id);
9013 }
9014
9017 {
9018
9019
9020 int varFlags;
9021 if (!ctx.
Read(varFlags))
9022 return;
9023
9024 if (varFlags & ItemVariableFlags.FLOAT)
9025 {
9027 }
9028 }
9029
9031 {
9032
9033 super.SerializeNumericalVars(floats_out);
9034
9035
9036
9038 {
9040 }
9041
9043 {
9045 }
9046
9048 {
9050 }
9051
9053 {
9058 }
9059
9061 {
9063 }
9064 }
9065
9067 {
9068
9069 super.DeSerializeNumericalVars(floats);
9070
9071
9072 int index = 0;
9073 int mask = Math.Round(floats.Get(index));
9074
9075 index++;
9076
9078 {
9080 {
9082 }
9083 else
9084 {
9085 float quantity = floats.Get(index);
9087 }
9088 index++;
9089 }
9090
9092 {
9093 float wet = floats.Get(index);
9095 index++;
9096 }
9097
9099 {
9100 int liquidtype = Math.Round(floats.Get(index));
9102 index++;
9103 }
9104
9106 {
9108 index++;
9110 index++;
9112 index++;
9114 index++;
9115 }
9116
9118 {
9119 int cleanness = Math.Round(floats.Get(index));
9121 index++;
9122 }
9123 }
9124
9126 {
9127 super.WriteVarsToCTX(ctx);
9128
9129
9131 {
9133 }
9134
9136 {
9138 }
9139
9141 {
9143 }
9144
9146 {
9147 int r,g,b,a;
9153 }
9154
9156 {
9158 }
9159 }
9160
9162 {
9163 if (!super.ReadVarsFromCTX(ctx,version))
9164 return false;
9165
9166 int intValue;
9167 float value;
9168
9169 if (version < 140)
9170 {
9171 if (!ctx.
Read(intValue))
9172 return false;
9173
9174 m_VariablesMask = intValue;
9175 }
9176
9178 {
9179 if (!ctx.
Read(value))
9180 return false;
9181
9183 {
9185 }
9186 else
9187 {
9189 }
9190 }
9191
9192 if (version < 140)
9193 {
9195 {
9196 if (!ctx.
Read(value))
9197 return false;
9198 SetTemperatureDirect(value);
9199 }
9200 }
9201
9203 {
9204 if (!ctx.
Read(value))
9205 return false;
9207 }
9208
9210 {
9211 if (!ctx.
Read(intValue))
9212 return false;
9214 }
9215
9217 {
9218 int r,g,b,a;
9220 return false;
9222 return false;
9224 return false;
9226 return false;
9227
9229 }
9230
9232 {
9233 if (!ctx.
Read(intValue))
9234 return false;
9236 }
9237
9238 if (version >= 138 && version < 140)
9239 {
9241 {
9242 if (!ctx.
Read(intValue))
9243 return false;
9244 SetFrozen(intValue);
9245 }
9246 }
9247
9248 return true;
9249 }
9250
9251
9253 {
9256 {
9258 }
9259
9260 if (!super.OnStoreLoad(ctx, version))
9261 {
9263 return false;
9264 }
9265
9266 if (version >= 114)
9267 {
9268 bool hasQuickBarIndexSaved;
9269
9270 if (!ctx.
Read(hasQuickBarIndexSaved))
9271 {
9273 return false;
9274 }
9275
9276 if (hasQuickBarIndexSaved)
9277 {
9278 int itmQBIndex;
9279
9280
9281 if (!ctx.
Read(itmQBIndex))
9282 {
9284 return false;
9285 }
9286
9287 PlayerBase parentPlayer = PlayerBase.Cast(GetHierarchyRootPlayer());
9288 if (itmQBIndex != -1 && parentPlayer)
9289 parentPlayer.SetLoadedQuickBarItemBind(this, itmQBIndex);
9290 }
9291 }
9292 else
9293 {
9294
9295 PlayerBase player;
9296 int itemQBIndex;
9297 if (version ==
int.
MAX)
9298 {
9299 if (!ctx.
Read(itemQBIndex))
9300 {
9302 return false;
9303 }
9304 }
9305 else if (Class.CastTo(player, GetHierarchyRootPlayer()))
9306 {
9307
9308 if (!ctx.
Read(itemQBIndex))
9309 {
9311 return false;
9312 }
9313 if (itemQBIndex != -1 && player)
9314 player.SetLoadedQuickBarItemBind(this,itemQBIndex);
9315 }
9316 }
9317
9318 if (version < 140)
9319 {
9320
9321 if (!LoadVariables(ctx, version))
9322 {
9324 return false;
9325 }
9326 }
9327
9328
9330 {
9332 return false;
9333 }
9334 if (version >= 132)
9335 {
9337 if (raib)
9338 {
9340 {
9342 return false;
9343 }
9344 }
9345 }
9346
9348 return true;
9349 }
9350
9351
9352
9354 {
9355 super.OnStoreSave(ctx);
9356
9357 PlayerBase player;
9358 if (PlayerBase.CastTo(player,GetHierarchyRootPlayer()))
9359 {
9361
9362 int itemQBIndex = -1;
9363 itemQBIndex = player.FindQuickBarEntityIndex(this);
9364 ctx.
Write(itemQBIndex);
9365 }
9366 else
9367 {
9369 }
9370
9372
9374 if (raib)
9375 {
9377 }
9378 }
9379
9380
9382 {
9383 super.AfterStoreLoad();
9384
9386 {
9388 }
9389
9391 {
9394 }
9395 }
9396
9398 {
9399 super.EEOnAfterLoad();
9400
9402 {
9404 }
9405
9408 }
9409
9411 {
9412 return false;
9413 }
9414
9415
9416
9418 {
9420 {
9421 #ifdef PLATFORM_CONSOLE
9422
9424 {
9426 if (menu)
9427 {
9429 }
9430 }
9431 #endif
9432 }
9433
9435 {
9438 }
9439
9441 {
9442 SetWeightDirty();
9444 }
9446 {
9449 }
9450
9452 {
9455 }
9457 {
9460 }
9461
9462 super.OnVariablesSynchronized();
9463 }
9464
9465
9466
9468 override bool SetQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false,
bool allow_client =
false,
bool clamp_to_stack_max =
true)
9469 {
9470 if (!IsServerCheck(allow_client))
9471 return false;
9472
9474 return false;
9475
9478
9479 if (value <= (min + 0.001))
9480 value = min;
9481
9482 if (value == min)
9483 {
9484 if (destroy_config)
9485 {
9486 bool dstr = ConfigGetBool("varQuantityDestroyOnMin");
9487 if (dstr)
9488 {
9490 this.Delete();
9491 return true;
9492 }
9493 }
9494 else if (destroy_forced)
9495 {
9497 this.Delete();
9498 return true;
9499 }
9500
9502 }
9503
9506
9508 {
9510
9511 if (delta)
9513 }
9514
9516
9517 return false;
9518 }
9519
9520
9522 bool AddQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
9523 {
9525 }
9526
9528 {
9531 }
9532
9534 {
9537 }
9538
9540 override void SetQuantityNormalized(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
9541 {
9542 float value_clamped = Math.Clamp(value, 0, 1);
9544 SetQuantity(result, destroy_config, destroy_forced);
9545 }
9546
9547
9550 {
9552 }
9553
9555 {
9557 }
9558
9559
9560
9561
9562
9563
9564
9565
9566
9567
9569 {
9570 int slot = -1;
9571 if (GetInventory())
9572 {
9573 InventoryLocation il = new InventoryLocation;
9574 GetInventory().GetCurrentInventoryLocation(il);
9576 }
9577
9579 }
9580
9582 {
9583 float quantity_max = 0;
9584
9586 {
9587 if (attSlotID != -1)
9588 quantity_max = InventorySlots.GetStackMaxForSlotId(attSlotID);
9589
9590 if (quantity_max <= 0)
9592 }
9593
9594 if (quantity_max <= 0)
9596
9597 return quantity_max;
9598 }
9599
9601 {
9603 }
9604
9606 {
9608 }
9609
9610
9612 {
9614 }
9615
9617 {
9619 }
9620
9622 {
9624 }
9625
9626
9628 {
9629
9630 float weightEx = GetWeightEx();
9631 float special = GetInventoryAndCargoWeight();
9632 return weightEx - special;
9633 }
9634
9635
9637 {
9639 }
9640
9642 {
9644 {
9645 #ifdef DEVELOPER
9646 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
9647 {
9648 WeightDebugData data1 = WeightDebug.GetWeightDebug(this);
9650 }
9651 #endif
9652
9654 }
9655 else if (HasEnergyManager())
9656 {
9657 #ifdef DEVELOPER
9658 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
9659 {
9660 WeightDebugData data2 = WeightDebug.GetWeightDebug(this);
9661 data2.
SetCalcDetails(
"TIB2: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " + GetCompEM().
GetEnergy()+
"(energy) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit)");
9662 }
9663 #endif
9664 return super.GetWeightSpecialized(forceRecalc) + (GetCompEM().GetEnergy() * ConfigGetFloat("weightPerQuantityUnit")) + GetConfigWeightModified();
9665 }
9666 else
9667 {
9668 #ifdef DEVELOPER
9669 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
9670 {
9671 WeightDebugData data3 = WeightDebug.GetWeightDebug(this);
9672 data3.
SetCalcDetails(
"TIB3: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " +
GetQuantity()+
"(quantity) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit))");
9673 }
9674 #endif
9675 return super.GetWeightSpecialized(forceRecalc) + (
GetQuantity() * ConfigGetFloat(
"weightPerQuantityUnit")) + GetConfigWeightModified();
9676 }
9677 }
9678
9681 {
9682 int item_count = 0;
9684
9685 if (GetInventory().GetCargo() != NULL)
9686 {
9687 item_count = GetInventory().GetCargo().GetItemCount();
9688 }
9689
9690 for (int i = 0; i < GetInventory().AttachmentCount(); i++)
9691 {
9692 Class.CastTo(item,GetInventory().GetAttachmentFromIndex(i));
9693 if (item)
9694 item_count += item.GetNumberOfItems();
9695 }
9696 return item_count;
9697 }
9698
9701 {
9702 float weight = 0;
9703 float wetness = 1;
9704 if (include_wetness)
9707 {
9708 weight = wetness * m_ConfigWeight;
9709 }
9711 {
9712 weight = 1;
9713 }
9714 return weight;
9715 }
9716
9717
9718
9720 {
9721 if ((
GetGame().IsServer() || !
GetGame().IsMultiplayer()) && GetInventory())
9722 {
9723 GameInventory inv = GetInventory();
9724 array<EntityAI> items = new array<EntityAI>;
9726 for (int i = 0; i < items.Count(); i++)
9727 {
9729 if (item)
9730 {
9732 }
9733 }
9734 }
9735 }
9736
9737
9738
9739
9741 {
9742 float energy = 0;
9743 if (HasEnergyManager())
9744 {
9745 energy = GetCompEM().GetEnergy();
9746 }
9747 return energy;
9748 }
9749
9750
9752 {
9753 super.OnEnergyConsumed();
9754
9756 }
9757
9759 {
9760 super.OnEnergyAdded();
9761
9763 }
9764
9765
9767 {
9768 if (
GetGame().IsServer() && HasEnergyManager() && GetCompEM().HasConversionOfEnergyToQuantity())
9769 {
9771 {
9772 float energy_0to1 = GetCompEM().GetEnergy0To1();
9774 }
9775 }
9776 }
9777
9778
9780 {
9781 return ConfigGetFloat("heatIsolation");
9782 }
9783
9785 {
9787 }
9788
9790 {
9791 string paramPath =
string.Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Drying %2",
GetType(), pIncrementName);
9792 if (
GetGame().ConfigIsExisting(paramPath))
9794
9795 return 0.0;
9796 }
9797
9799 {
9800 string paramPath =
string.
Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Soaking %2",
GetType(), pIncrementName);
9801 if (
GetGame().ConfigIsExisting(paramPath))
9803
9804 return 0.0;
9805 }
9806
9807 override void SetWet(
float value,
bool allow_client =
false)
9808 {
9809 if (!IsServerCheck(allow_client))
9810 return;
9811
9814
9816
9817 m_VarWet = Math.Clamp(value, min, max);
9818
9820 {
9823 }
9824 }
9825
9826 override void AddWet(
float value)
9827 {
9829 }
9830
9832 {
9834 }
9835
9837 {
9839 }
9840
9842 {
9844 }
9845
9847 {
9849 }
9850
9852 {
9854 }
9855
9857 {
9860 if (newLevel != oldLevel)
9861 {
9863 }
9864 }
9865
9867 {
9868 SetWeightDirty();
9869 }
9870
9872 {
9873 return GetWetLevelInternal(
m_VarWet);
9874 }
9875
9876
9877
9879 {
9881 }
9882
9884 {
9886 }
9887
9889 {
9891 }
9892
9894 {
9896 }
9897
9898
9899
9901 {
9902 if (ConfigIsExisting("itemModelLength"))
9903 {
9904 return ConfigGetFloat("itemModelLength");
9905 }
9906 return 0;
9907 }
9908
9910 {
9911 if (ConfigIsExisting("itemAttachOffset"))
9912 {
9913 return ConfigGetFloat("itemAttachOffset");
9914 }
9915 return 0;
9916 }
9917
9918 override void SetCleanness(
int value,
bool allow_client =
false)
9919 {
9920 if (!IsServerCheck(allow_client))
9921 return;
9922
9924
9926
9929 }
9930
9932 {
9934 }
9935
9937 {
9938 return true;
9939 }
9940
9941
9942
9943
9945 {
9947 }
9948
9950 {
9952 }
9953
9954
9955
9956
9957 override void SetColor(
int r,
int g,
int b,
int a)
9958 {
9964 }
9966 override void GetColor(out
int r,out
int g,out
int b,out
int a)
9967 {
9972 }
9973
9975 {
9977 }
9978
9981 {
9982 int r,g,b,a;
9984 r = r/255;
9985 g = g/255;
9986 b = b/255;
9987 a = a/255;
9988 return MiscGameplayFunctions.GetColorString(r, g, b, a);
9989 }
9990
9991
9992
9993 override void SetLiquidType(
int value,
bool allow_client =
false)
9994 {
9995 if (!IsServerCheck(allow_client))
9996 return;
9997
10002 }
10003
10005 {
10006 return ConfigGetInt("varLiquidTypeInit");
10007 }
10008
10010 {
10012 }
10013
10015 {
10017 SetFrozen(false);
10018 }
10019
10022 {
10023 player.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
10024 }
10025
10026
10029 {
10030 PlayerBase nplayer;
10031 if (PlayerBase.CastTo(nplayer, player))
10032 {
10034
10035 nplayer.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
10036 }
10037 }
10038
10039
10042 {
10043 PlayerBase nplayer;
10044 if (PlayerBase.CastTo(nplayer,player))
10045 {
10046
10047 nplayer.SetEnableQuickBarEntityShortcut(this,false);
10048
10049 }
10050
10051
10052 player.GetHumanInventory().ClearUserReservedLocationForContainer(this);
10053
10054
10055 if (HasEnergyManager())
10056 {
10057 GetCompEM().UpdatePlugState();
10058 }
10059 }
10060
10061
10063 {
10064 super.OnPlacementStarted(player);
10065
10067 }
10068
10069 override void OnPlacementComplete(Man player, vector position =
"0 0 0", vector orientation =
"0 0 0")
10070 {
10072 {
10073 m_AdminLog.OnPlacementComplete(player,
this);
10074 }
10075
10076 super.OnPlacementComplete(player, position, orientation);
10077 }
10078
10079
10080
10081
10082
10084 {
10086 {
10087 return true;
10088 }
10089 else
10090 {
10091 return false;
10092 }
10093 }
10094
10095
10097 {
10099 {
10101 }
10102 }
10103
10104
10106 {
10108 }
10109
10111 {
10113 }
10114
10115 override void InsertAgent(
int agent,
float count = 1)
10116 {
10117 if (count < 1)
10118 return;
10119
10121 }
10122
10125 {
10127 }
10128
10129
10131 {
10133 }
10134
10135
10136
10137
10138
10139
10140
10141
10142
10143
10144
10145
10146
10147
10148
10149
10150
10151
10152
10153
10154
10155
10156
10157
10158
10159
10160
10161
10162
10163
10164
10165
10166
10167
10168
10169
10170
10171
10172
10173
10174
10175
10177 {
10179 return false;
10180 return true;
10181 }
10182
10184 {
10185
10187 }
10188
10189
10192 {
10193 super.CheckForRoofLimited(timeTresholdMS);
10194
10196 if ((time - m_PreviousRoofTestTime) >= timeTresholdMS)
10197 {
10198 m_PreviousRoofTestTime = time;
10199 SetRoofAbove(MiscGameplayFunctions.IsUnderRoof(this));
10200 }
10201 }
10202
10203
10205 {
10207 {
10208 return 0;
10209 }
10210
10211 if (GetInventory().GetAttachmentSlotsCount() != 0)
10212 {
10213 ItemBase filter =
ItemBase.Cast(FindAttachmentBySlotName(
"GasMaskFilter"));
10214 if (filter)
10215 return filter.GetProtectionLevel(type, false, system);
10216 else
10217 return 0;
10218 }
10219
10220 string subclassPath, entryName;
10221
10222 switch (type)
10223 {
10225 entryName = "biological";
10226 break;
10228 entryName = "chemical";
10229 break;
10230 default:
10231 entryName = "biological";
10232 break;
10233 }
10234
10235 subclassPath =
"CfgVehicles " + this.
GetType() +
" Protection ";
10236
10238 }
10239
10240
10241
10244 {
10245 if (!IsMagazine())
10247
10249 }
10250
10251
10252
10253
10254
10259 {
10260 return true;
10261 }
10262
10264 {
10266 }
10267
10268
10269
10270
10271
10273 {
10274 if (parent)
10275 {
10276 if (parent.IsInherited(DayZInfected))
10277 return true;
10278
10279 if (!parent.IsRuined())
10280 return true;
10281 }
10282
10283 return true;
10284 }
10285
10287 {
10288 if (!super.CanPutAsAttachment(parent))
10289 {
10290 return false;
10291 }
10292
10293 if (!IsRuined() && !parent.IsRuined())
10294 {
10295 return true;
10296 }
10297
10298 return false;
10299 }
10300
10302 {
10303
10304
10305
10306
10307 return super.CanReceiveItemIntoCargo(item);
10308 }
10309
10311 {
10312
10313
10314
10315
10316 GameInventory attachmentInv = attachment.GetInventory();
10318 {
10319 if (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase))
10320 return false;
10321 }
10322
10323 InventoryLocation loc = new InventoryLocation();
10324 attachment.GetInventory().GetCurrentInventoryLocation(loc);
10325 if (loc && loc.
IsValid() && !GetInventory().AreChildrenAccessible())
10326 return false;
10327
10328 return super.CanReceiveAttachment(attachment, slotId);
10329 }
10330
10332 {
10333 if (!super.CanReleaseAttachment(attachment))
10334 return false;
10335
10336 return GetInventory().AreChildrenAccessible();
10337 }
10338
10339
10340
10341
10342
10343
10344
10345
10346
10347
10348
10349
10350
10351
10352
10353
10354
10355
10356
10357
10358
10360 {
10361 int id = muzzle_owner.GetMuzzleID();
10362 array<ref WeaponParticlesOnFire> WPOF_array =
m_OnFireEffect.Get(
id);
10363
10364 if (WPOF_array)
10365 {
10366 for (int i = 0; i < WPOF_array.Count(); i++)
10367 {
10368 WeaponParticlesOnFire WPOF = WPOF_array.Get(i);
10369
10370 if (WPOF)
10371 {
10372 WPOF.OnActivate(weapon, muzzle_index, ammoType, muzzle_owner, suppressor, config_to_search);
10373 }
10374 }
10375 }
10376 }
10377
10378
10380 {
10381 int id = muzzle_owner.GetMuzzleID();
10383
10384 if (WPOBE_array)
10385 {
10386 for (int i = 0; i < WPOBE_array.Count(); i++)
10387 {
10388 WeaponParticlesOnBulletCasingEject WPOBE = WPOBE_array.Get(i);
10389
10390 if (WPOBE)
10391 {
10392 WPOBE.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
10393 }
10394 }
10395 }
10396 }
10397
10398
10400 {
10401 int id = muzzle_owner.GetMuzzleID();
10402 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
10403
10404 if (WPOOH_array)
10405 {
10406 for (int i = 0; i < WPOOH_array.Count(); i++)
10407 {
10408 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
10409
10410 if (WPOOH)
10411 {
10412 WPOOH.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
10413 }
10414 }
10415 }
10416 }
10417
10418
10420 {
10421 int id = muzzle_owner.GetMuzzleID();
10422 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
10423
10424 if (WPOOH_array)
10425 {
10426 for (int i = 0; i < WPOOH_array.Count(); i++)
10427 {
10428 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
10429
10430 if (WPOOH)
10431 {
10432 WPOOH.OnUpdate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
10433 }
10434 }
10435 }
10436 }
10437
10438
10440 {
10441 int id = muzzle_owner.GetMuzzleID();
10442 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
10443
10444 if (WPOOH_array)
10445 {
10446 for (int i = 0; i < WPOOH_array.Count(); i++)
10447 {
10448 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
10449
10450 if (WPOOH)
10451 {
10452 WPOOH.OnDeactivate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
10453 }
10454 }
10455 }
10456 }
10457
10458
10459
10461 {
10463 {
10464 return true;
10465 }
10466
10467 return false;
10468 }
10469
10471 {
10473 {
10474 return true;
10475 }
10476
10477 return false;
10478 }
10479
10481 {
10483 {
10484 return true;
10485 }
10486
10487 return false;
10488 }
10489
10491 {
10492 return false;
10493 }
10494
10497 {
10498 return UATimeSpent.DEFAULT_DEPLOY;
10499 }
10500
10501
10502
10503
10505 {
10507 SetSynchDirty();
10508 }
10509
10511 {
10513 }
10514
10515
10517 {
10518 return false;
10519 }
10520
10523 {
10524 string att_type = "None";
10525
10526 if (ConfigIsExisting("soundAttType"))
10527 {
10528 att_type = ConfigGetString("soundAttType");
10529 }
10530
10532 }
10533
10535 {
10537 }
10538
10539
10540
10541
10542
10548
10550 {
10553
10555 }
10556
10557
10559 {
10561 return;
10562
10564
10567
10570
10571 SoundParameters params = new SoundParameters();
10575 }
10576
10577
10579 {
10581 return;
10582
10584 SetSynchDirty();
10585
10588 }
10589
10590
10592 {
10594 return;
10595
10597 SetSynchDirty();
10598
10601 }
10602
10604 {
10606 }
10607
10609 {
10611 }
10612
10615 {
10616 if (!
GetGame().IsDedicatedServer())
10617 {
10618 if (ConfigIsExisting("attachSoundSet"))
10619 {
10620 string cfg_path = "";
10621 string soundset = "";
10622 string type_name =
GetType();
10623
10626 ConfigGetTextArray("attachSoundSet",cfg_soundset_array);
10627 ConfigGetTextArray("attachSoundSlot",cfg_slot_array);
10628
10629 if (cfg_soundset_array.Count() > 0 && cfg_soundset_array.Count() == cfg_slot_array.Count())
10630 {
10631 for (int i = 0; i < cfg_soundset_array.Count(); i++)
10632 {
10633 if (cfg_slot_array[i] == slot_type)
10634 {
10635 soundset = cfg_soundset_array[i];
10636 break;
10637 }
10638 }
10639 }
10640
10641 if (soundset != "")
10642 {
10643 EffectSound sound = SEffectManager.PlaySound(soundset,
GetPosition());
10645 }
10646 }
10647 }
10648 }
10649
10651 {
10652
10653 }
10654
10655 void OnApply(PlayerBase player);
10656
10658 {
10659 return 1.0;
10660 };
10661
10663 {
10665 }
10666
10668 {
10670 }
10671
10673
10675 {
10676 SetDynamicPhysicsLifeTime(0.01);
10678 }
10679
10681 {
10682 array<string> zone_names = new array<string>;
10683 GetDamageZones(zone_names);
10684 for (int i = 0; i < zone_names.Count(); i++)
10685 {
10686 SetHealthMax(zone_names.Get(i),"Health");
10687 }
10688 SetHealthMax("","Health");
10689 }
10690
10693 {
10694 float global_health = GetHealth01("","Health");
10695 array<string> zones = new array<string>;
10696 GetDamageZones(zones);
10697
10698 for (int i = 0; i < zones.Count(); i++)
10699 {
10700 SetHealth01(zones.Get(i),"Health",global_health);
10701 }
10702 }
10703
10706 {
10707 return IsExclusionFlagPresent(PlayerBase.GetFaceCoverageShaveValues());
10708 }
10709
10711 {
10712 if (!hasRootAsPlayer)
10713 {
10714 if (refParentIB)
10715 {
10716
10717 if ((refParentIB.GetWet() >= GameConstants.STATE_SOAKING_WET) && (
m_VarWet <
m_VarWetMax))
10718 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_INSIDE);
10719
10720 else if ((refParentIB.GetLiquidType() != 0) && (refParentIB.GetQuantity() > 0) && (
m_VarWet <
m_VarWetMax))
10721 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_LIQUID);
10722
10725 }
10726 else
10727 {
10728
10731 }
10732 }
10733 }
10734
10736 {
10738 {
10739 float target =
g_Game.GetMission().GetWorldData().GetBaseEnvTemperatureAtObject(
this);
10740 if (
GetTemperature() != target || !IsFreezeThawProgressFinished())
10741 {
10742 float heatPermCoef = 1.0;
10744 while (ent)
10745 {
10746 heatPermCoef *= ent.GetHeatPermeabilityCoef();
10747 ent = ent.GetHierarchyParent();
10748 }
10749
10750 SetTemperatureEx(
new TemperatureDataInterpolated(target,
ETemperatureAccessTypes.ACCESS_WORLD,delta,GameConstants.TEMP_COEF_WORLD,heatPermCoef));
10751 }
10752 }
10753 }
10754
10756 {
10757
10758 EntityAI parent = GetHierarchyParent();
10759 if (!parent)
10760 {
10761 hasParent = false;
10762 hasRootAsPlayer = false;
10763 }
10764 else
10765 {
10766 hasParent = true;
10767 hasRootAsPlayer = (GetHierarchyRootPlayer() != null);
10768 refParentIB =
ItemBase.Cast(parent);
10769 }
10770 }
10771
10772 protected void ProcessDecay(
float delta,
bool hasRootAsPlayer)
10773 {
10774
10775 }
10776
10778 {
10779
10780 return false;
10781 }
10782
10784 {
10785
10786
10787 return false;
10788 }
10789
10791 {
10792
10793 return false;
10794 }
10795
10798 {
10799 return !GetIsFrozen() &&
IsOpen();
10800 }
10801
10803 {
10804 bool hasParent = false, hasRootAsPlayer = false;
10806
10807 bool wwtu =
g_Game.IsWorldWetTempUpdateEnabled();
10808 bool foodDecay =
g_Game.IsFoodDecayEnabled();
10809
10810 if (wwtu || foodDecay)
10811 {
10815
10816 if (processWetness || processTemperature || processDecay)
10817 {
10819
10820 if (processWetness)
10821 ProcessItemWetness(m_ElapsedSinceLastUpdate, hasParent, hasRootAsPlayer, refParentIB);
10822
10823 if (processTemperature)
10825
10826 if (processDecay)
10827 ProcessDecay(m_ElapsedSinceLastUpdate, hasRootAsPlayer);
10828 }
10829 }
10830 }
10831
10834 {
10836 }
10837
10839 {
10842
10843 return super.GetTemperatureFreezeThreshold();
10844 }
10845
10847 {
10850
10851 return super.GetTemperatureThawThreshold();
10852 }
10853
10855 {
10858
10859 return super.GetItemOverheatThreshold();
10860 }
10861
10863 {
10865 return Math.Lerp(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureFreezeTime()),
GetQuantityNormalized());
10866
10867 return super.GetTemperatureFreezeTime();
10868 }
10869
10871 {
10873 return Math.Lerp(GameConstants.TEMPERATURE_TIME_THAW_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureThawTime()),
GetQuantityNormalized());
10874
10875 return super.GetTemperatureThawTime();
10876 }
10877
10882
10884 {
10885 return (item.IsKindOf("Cauldron") || item.IsKindOf("Pot") || item.IsKindOf("FryingPan") || item.IsKindOf("SmallProtectorCase") || (item.IsKindOf("PortableGasStove") && item.FindAttachmentBySlotName("CookingEquipment")));
10886 }
10887
10889 {
10890 MiscGameplayFunctions.TransferItemProperties(oldItem, this);
10891 }
10892
10895 {
10897 }
10898
10900 {
10902 }
10903
10905 {
10907 }
10908
10911 {
10912 return null;
10913 }
10914
10917 {
10918 return false;
10919 }
10920
10922 {
10924 {
10927 if (!trg)
10928 {
10930 explosive = this;
10931 }
10932
10933 explosive.PairRemote(trg);
10935
10936 int persistentID = RemotelyActivatedItemBehaviour.GeneratePersistentID();
10937 trg.SetPersistentPairID(persistentID);
10938 explosive.SetPersistentPairID(persistentID);
10939
10940 return true;
10941 }
10942 return false;
10943 }
10944
10947 {
10948 float ret = 1.0;
10951 ret *= GetHealth01();
10952
10953 return ret;
10954 }
10955
10956 #ifdef DEVELOPER
10957 override void SetDebugItem()
10958 {
10959 super.SetDebugItem();
10960 _itemBase = this;
10961 }
10962
10964 {
10965 string text = super.GetDebugText();
10966
10968 text +=
string.
Format(
"Heat isolation(modified): %1\n", MiscGameplayFunctions.GetCurrentItemHeatIsolation(
this));
10969
10970 return text;
10971 }
10972 #endif
10973
10975 {
10976 return true;
10977 }
10978
10980
10982
10984 {
10987 }
10988
10989
10997
11013}
11014
11016{
11018 if (entity)
11019 {
11020 bool is_item = entity.IsInherited(
ItemBase);
11021 if (is_item && full_quantity)
11022 {
11025 }
11026 }
11027 else
11028 {
11030 return NULL;
11031 }
11032 return entity;
11033}
11034
11036{
11037 if (item)
11038 {
11039 if (health > 0)
11040 item.SetHealth("", "", health);
11041
11042 if (item.CanHaveTemperature())
11043 {
11045 if (item.CanFreeze())
11046 item.SetFrozen(false);
11047 }
11048
11049 if (item.HasEnergyManager())
11050 {
11051 if (quantity >= 0)
11052 {
11053 item.GetCompEM().SetEnergy0To1(quantity);
11054 }
11055 else
11056 {
11058 }
11059 }
11060 else if (item.IsMagazine())
11061 {
11062 Magazine mag = Magazine.Cast(item);
11063 if (quantity >= 0)
11064 {
11065 mag.ServerSetAmmoCount(mag.GetAmmoMax() * quantity);
11066 }
11067 else
11068 {
11070 }
11071
11072 }
11073 else
11074 {
11075 if (quantity >= 0)
11076 {
11077 item.SetQuantityNormalized(quantity, false);
11078 }
11079 else
11080 {
11082 }
11083
11084 }
11085 }
11086}
11087
11088#ifdef DEVELOPER
11090#endif
Param4< int, int, string, int > TSelectableActionInfoWithColor
Param3 TSelectableActionInfo
InventoryMode
NOTE: PREDICTIVE is not to be used at all in multiplayer.
eBleedingSourceType GetType()
ItemSuppressor SuppressorBase
void ActionManagerBase(PlayerBase player)
map< typename, ref array< ActionBase_Basic > > TInputActionMap
void AddAction(typename actionName)
void RemoveAction(typename actionName)
TInputActionMap m_InputActionMap
override void GetActions(typename action_input_type, out array< ActionBase_Basic > actions)
const int ECE_PLACE_ON_SURFACE
proto native void SpawnEntity(string sClassName, vector vPos, float fRange, int iCount)
Spawn an entity through CE.
const int ECE_IN_INVENTORY
PlayerSpawnPresetDiscreteItemSetSlotData name
one set for cargo
PlayerSpawnPreset slotName
Open
Implementations only.
override void EEOnCECreate()
DamageType
exposed from C++ (do not change)
PluginAdminLog m_AdminLog
override bool IsExplosive()
override bool CanHaveTemperature()
class GP5GasMask extends MaskBase ItemBase
FindInventoryLocationType
flags for searching locations in inventory
InventoryLocationType
types of Inventory Location
class BoxCollidingParams component
ComponentInfo for BoxCollidingResult.
bool DamageItemInCargo(float damage)
static bool HasDebugActionsMask(int mask)
bool HidesSelectionBySlot()
void SplitItem(PlayerBase player)
void CopyScriptPropertiesFrom(EntityAI oldItem)
override void InsertAgent(int agent, float count=1)
override float GetQuantityNormalized()
Gets quantity in normalized 0..1 form between the item's Min a Max values as defined by item's config...
static void SetDebugActionsMask(int mask)
void SetIsDeploySound(bool is_deploy_sound)
void SplitItemToInventoryLocation(notnull InventoryLocation dst)
override bool IsHeavyBehaviour()
override void SetWetMax()
bool IsCoverFaceForShave(string slot_name)
DEPRECATED in use, but returns correct values nontheless. Check performed elsewhere.
void ClearStartItemSoundServer()
void ProcessItemTemperature(float delta, bool hasParent, bool hasRootAsPlayer, ItemBase refParentIB)
map< typename, ref ActionOverrideData > TActionAnimOverrideMap
override void RemoveAllAgentsExcept(int agent_to_keep)
static ref map< int, ref array< ref WeaponParticlesOnBulletCasingEject > > m_OnBulletCasingEjectEffect
bool CanBeMovedOverride()
override void SetWet(float value, bool allow_client=false)
ref TIntArray m_SingleUseActions
override void ProcessVariables()
ref TStringArray m_HeadHidingSelections
float GetWeightSpecialized(bool forceRecalc=false)
bool LoadAgents(ParamsReadContext ctx, int version)
void UpdateQuickbarShortcutVisibility(PlayerBase player)
To be called on moving item within character's inventory; 'player' should never be null.
void OverrideActionAnimation(typename action, int commandUID, int stanceMask=-1, int commandUIDProne=-1)
ref array< ref OverheatingParticle > m_OverheatingParticles
override float GetTemperatureFreezeThreshold()
bool m_IsSoundSynchRemote
void StopItemSoundServer(int id)
static void ToggleDebugActionsMask(int mask)
void IncreaseOverheating(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
override float GetTemperatureFreezeTime()
ref array< int > m_CompatibleLocks
override void CombineItemsClient(EntityAI entity2, bool use_stack_max=true)
float m_TemperaturePerQuantityWeight
bool m_RecipesInitialized
void SplitIntoStackMax(EntityAI destination_entity, int slot_id, PlayerBase player)
override float GetTemperatureThawThreshold()
override void OnEnergyConsumed()
void RefreshAudioVisualsOnClient(CookingMethodType cooking_method, bool is_done, bool is_empty, bool is_burned)
cooking-related effect methods
int GetNumberOfItems()
Returns the number of items in cargo, otherwise returns 0(non-cargo objects). Recursive.
override EWetnessLevel GetWetLevel()
float GetSingleInventoryItemWeight()
ref TIntArray m_InteractActions
void MessageToOwnerStatus(string text)
Send message to owner player in grey color.
bool CanPlayDeployLoopSound()
override float GetWetMax()
bool CanBeUsedForSuicide()
override void CombineItemsEx(EntityAI entity2, bool use_stack_max=true)
void OnItemInHandsPlayerSwimStart(PlayerBase player)
void SetIsHologram(bool is_hologram)
void OnSyncVariables(ParamsReadContext ctx)
DEPRECATED (most likely)
void StartItemSoundServer(int id)
static ref map< int, ref array< ref WeaponParticlesOnFire > > m_OnFireEffect
void SplitIntoStackMaxCargoClient(EntityAI destination_entity, int idx, int row, int col)
bool m_CanBeMovedOverride
override string ChangeIntoOnAttach(string slot)
void UpdateOverheating(ItemBase weapon=null, string ammoType="", ItemBase muzzle_owner=null, ItemBase suppressor=null, string config_to_search="")
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...
override float GetQuantity()
int m_ShotsToStartOverheating
override void OnWetChanged(float newVal, float oldVal)
void StopOverheating(ItemBase weapon=null, string ammoType="", ItemBase muzzle_owner=null, ItemBase suppressor=null, string config_to_search="")
static void PlayFireParticles(ItemBase weapon, int muzzle_index, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
void OnOverheatingDecay()
float GetDryingIncrement(string pIncrementName)
void SoundSynchRemoteReset()
bool HasMuzzle()
Returns true if this item has a muzzle (weapons, suppressors)
override bool CanReleaseAttachment(EntityAI attachment)
override void OnMovedInsideCargo(EntityAI container)
void SetCEBasedQuantity()
bool m_CanPlayImpactSound
override string GetAttachmentSoundType()
float GetOverheatingCoef()
array< string > GetHeadHidingSelection()
void PlayAttachSound(string slot_type)
Plays sound on item attach. Be advised, the config structure may slightly change in 1....
override bool IsStoreLoad()
int ComputeQuantityUsed(ItemBase other_item, bool use_stack_max=true)
void SetResultOfSplit(bool value)
void SplitIntoStackMaxCargo(EntityAI destination_entity, int idx, int row, int col)
void OnAttachmentQuantityChanged(ItemBase item)
Called on server side when some attachment's quantity is changed. Call super.OnAttachmentQuantityChan...
void UpdateAllOverheatingParticles()
float GetSoakingIncrement(string pIncrementName)
static void StopOverheatingParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
override float GetStoreLoadedQuantity()
const int ITEM_SOUNDS_MAX
float GetItemModelLength()
override bool ReadVarsFromCTX(ParamsReadContext ctx, int version=-1)
override void CheckForRoofLimited(float timeTresholdMS=3000)
Roof check for entity, limited by time (anti-spam solution)
void CombineItems(ItemBase other_item, bool use_stack_max=true)
void TransferModifiers(PlayerBase reciever)
appears to be deprecated, legacy code
float GetTemperaturePerQuantityWeight()
Used in heat comfort calculations only!
void TransferAgents(int agents)
transfer agents from another item
bool CanBeConsumed(ConsumeConditionData data=null)
Items cannot be consumed if frozen by default. Override for exceptions.
float GetHeatIsolationInit()
void SetCanBeMovedOverride(bool setting)
override bool HasQuantity()
bool IsCargoException4x3(EntityAI item)
ref TIntArray m_ContinuousActions
int GetMuzzleID()
Returns global muzzle ID. If not found, then it gets automatically registered.
void LoadParticleConfigOnFire(int id)
void PreLoadSoundAttachmentType()
Attachment Sound Type getting from config file.
override float GetWetInit()
int m_ImpactSoundSurfaceHash
int m_MaxOverheatingValue
void SetupSpawnedItem(ItemBase item, float health, float quantity)
bool ShouldSplitQuantity(float quantity)
static ref map< string, int > m_WeaponTypeToID
string GetColorString()
Returns item's PROCEDURAL color as formated string, i.e. "#(argb,8,8,3)color(0.15,...
array< int > GetValidFinishers()
returns an array of possible finishers
void OnAttachmentQuantityChangedEx(ItemBase item, float delta)
Called on server side when some attachment's quantity is changed. Call super.OnAttachmentQuantityChan...
class ItemBase extends InventoryItem SpawnItemOnLocation(string object_name, notnull InventoryLocation loc, bool full_quantity)
ItemSoundHandler GetItemSoundHandler()
override int GetQuantityMin()
void SplitIntoStackMaxToInventoryLocationClient(notnull InventoryLocation dst)
override int GetQuickBarBonus()
override void SetTakeable(bool pState)
float m_OverheatingDecayInterval
void SetIsPlaceSound(bool is_place_sound)
override void SplitIntoStackMaxClient(EntityAI destination_entity, int slot_id)
void HierarchyCheck(out bool hasParent, out bool hasRootAsPlayer, out ItemBase refParentIB)
void RemoveAudioVisualsOnClient()
static void AddDebugActionsMask(int mask)
void PlayDeployLoopSoundEx()
void RemoveLightSourceItem()
bool CanRepair(ItemBase item_repair_kit)
bool can_this_be_combined
EffectSound m_SoundDeploy
float GetBaitEffectivity()
generic effectivity as a bait for animal catching
float GetDeployTime()
how long it takes to deploy this item in seconds
override bool IsSplitable()
bool DamageItemAttachments(float damage)
override void WriteVarsToCTX(ParamsWriteContext ctx)
void ConvertEnergyToQuantity()
override void RemoveAllAgents()
override void SetQuantityToMinimum()
bool m_WantPlayImpactSound
override float GetTemperatureThawTime()
ref map< int, ref array< ref WeaponParticlesOnOverheating > > m_OnOverheatingEffect
float m_StoreLoadedQuantity
void MessageToOwnerAction(string text)
Send message to owner player in yellow color.
float GetFilterDamageRatio()
override void SetLiquidType(int value, bool allow_client=false)
void OnQuantityChanged(float delta)
Called on server side when this item's quantity is changed. Call super.OnQuantityChanged(); first whe...
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...
bool m_HideSelectionsBySlot
bool IsOverheatingEffectActive()
void SetIsBeingPlaced(bool is_being_placed)
int GetLiquidContainerMask()
void SetInventoryLocationToVicinityOrCurrent(EntityAI root, inout InventoryLocation dst)
ref Timer m_CheckOverheating
void RegisterOverheatingParticle(Particle p, float min_heat_coef, float max_heat_coef, int particle_id, Object parent, vector local_pos, vector local_ori)
bool GetActionWidgetOverride(out typename name)
If we need a different (handheld)item action widget displayed, the logic goes in here.
float GetUnitWeight(bool include_wetness=true)
Obsolete, use GetWeightEx instead.
void SetZoneDamageCEInit()
Sets zone damages to match randomized global health set by CE (CE spawn only)
static void PlayOverheatingParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
override bool IsOneHandedBehaviour()
void AddLightSourceItem(ItemBase lightsource)
Adds a light source child.
FoodStage GetFoodStage()
overridden on Edible_Base; so we don't have to parse configs all the time
override float GetSingleInventoryItemWeightEx()
void SaveAgents(ParamsWriteContext ctx)
override int GetTargetQuantityMax(int attSlotID=-1)
float GetDisinfectQuantity(int system=0, Param param1=null)
override bool IsHologram()
float GetItemAttachOffset()
static int GetDebugActionsMask()
void ProcessDecay(float delta, bool hasRootAsPlayer)
override bool IsItemBase()
override bool IsTwoHandedBehaviour()
bool IsCombineAll(ItemBase other_item, bool use_stack_max=false)
float GetProtectionLevel(int type, bool consider_filter=false, int system=0)
static void PlayBulletCasingEjectParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
override void OnEnergyAdded()
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()
EffectSound m_DeployLoopSoundEx
override void DeSerializeNumericalVars(array< float > floats)
void StopItemDynamicPhysics()
override void SetStoreLoad(bool value)
float GetOverheatingValue()
bool ContainsAgent(int agent_id)
override void AddWet(float value)
override void EOnContact(IEntity other, Contact extra)
void SplitIntoStackMaxHands(PlayerBase player)
void SplitIntoStackMaxHandsClient(PlayerBase player)
ref Timer m_PhysDropTimer
void MessageToOwnerFriendly(string text)
Send message to owner player in green color.
override void SetStoreLoadedQuantity(float value)
bool m_IsResultOfSplit string m_SoundAttType
distinguish if item has been created as new or it came from splitting (server only flag)
void CheckOverheating(ItemBase weapon=null, string ammoType="", ItemBase muzzle_owner=null, ItemBase suppressor=null, string config_to_search="")
void UnlockFromParent()
Unlocks this item from its attachment slot of its parent.
bool Repair(PlayerBase player, ItemBase item_repair_kit, float specialty_weight)
void OnLiquidTypeChanged(int oldType, int newType)
void StartOverheating(ItemBase weapon=null, string ammoType="", ItemBase muzzle_owner=null, ItemBase suppressor=null, string config_to_search="")
void PlayDeployFinishSound()
bool AllowFoodConsumption()
bool m_IsOverheatingEffectActive
int m_LiquidContainerMask
void ProcessItemWetness(float delta, bool hasParent, bool hasRootAsPlayer, ItemBase refParentIB)
override int GetCleanness()
bool PairWithDevice(notnull ItemBase otherDevice)
static void RemoveDebugActionsMask(int mask)
static void UpdateOverheatingParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
void PerformDamageSystemReinit()
override void ClearInventory()
static int m_LastRegisteredWeaponID
ItemBase GetLightSourceItem()
void MessageToOwnerImportant(string text)
Send message to owner player in red color.
override float GetItemOverheatThreshold()
void StopDeployLoopSoundEx()
override void SerializeNumericalVars(array< float > floats_out)
ItemBase SplitIntoStackMaxToInventoryLocationEx(notnull InventoryLocation dst)
static int m_DebugActionsMask
void KillAllOverheatingParticles()
bool CanBeCookedOnStick()
override int GetQuantityMax()
void GetRecipesActions(Man player, out TSelectableActionInfoArray outputList)
void OnActivatedByTripWire()
override void RemoveAgent(int agent_id)
bool m_ItemBeingDroppedPhys
override bool CanPutAsAttachment(EntityAI parent)
void PlayDetachSound(string slot_type)
static ref map< typename, ref TInputActionMap > m_ItemTypeActionsMap
void ProcessItemWetnessAndTemperature(float delta, bool hasParent, bool hasRootAsPlayer, ItemBase refParentIB)
override bool IsBeingPlaced()
float ComputeQuantityUsedEx(ItemBase other_item, bool use_stack_max=true)
bool m_FixDamageSystemInit
string GetDeployFinishSoundset()
ItemBase m_LightSourceItem
void LockToParent()
Locks this item in it's current attachment slot of its parent. This makes the "locked" icon visible i...
override void SplitIntoStackMaxEx(EntityAI destination_entity, int slot_id)
void LoadParticleConfigOnOverheating(int id)
bool IsSoundSynchRemote()
override void OnRightClick()
static ref map< typename, ref TActionAnimOverrideMap > m_ItemActionOverrides
bool IsActionTargetVisible()
override void OnItemAttachmentSlotChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
override void EEHitBy(TotalDamageResult damageResult, int damageType, EntityAI source, int component, string dmgZone, string ammo, vector modelPos, float speedCoef)
int NameToID(string name)
override void OnWetLevelChanged(EWetnessLevel newLevel, EWetnessLevel oldLevel)
void ClearStopItemSoundServer()
override string ChangeIntoOnDetach()
void SplitIntoStackMaxToInventoryLocation(notnull InventoryLocation dst)
EffectSound m_SoundDeployFinish
float GetQuantityNormalizedScripted()
override void SetCleanness(int value, bool allow_client=false)
override float GetWetMin()
ref ItemSoundHandler m_ItemSoundHandler
override bool KindOf(string tag)
void ItemSoundHandler(ItemBase parent)
EffectSound m_LockingSound
void PluginItemDiagnostic()
PluginBase GetPlugin(typename plugin_type)
override RemotelyActivatedItemBehaviour GetRemotelyActivatedItemBehaviour()
void RemoteDetonatorTrigger()
override void OnActivatedByItem(notnull ItemBase item)
Called when this item is activated by other.
override void Explode(int damageType, string ammoType="")
void OnItemLocationChanged(ItemBase item)
void OnItemAttachedAtPlayer(EntityAI item, string slot_name)
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)
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()
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)
void SetEnergy0To1(float energy01)
Energy manager: Sets stored energy for this device between 0 and MAX based on relative input value be...
float GetEnergyMaxPristine()
Energy manager: Returns the maximum amount of energy this device can store. It's damage is NOT taken ...
override void SetAutodestroy(bool auto_destroy)
Sets whether Effect automatically cleans up when it stops.
bool IsSoundPlaying()
Get whether EffectSound is currently playing.
proto native bool EnumerateInventory(InventoryTraversalType tt, out array< EntityAI > items)
enumerate inventory using traversal type and filling items array
proto native CargoBase GetCargo()
cargo
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)
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
override bool CanDisplayCargo()
override void OnInventoryEnter(Man player)
override string GetFoldSoundset()
override bool CanPutAsAttachment(EntityAI parent)
override bool CanReceiveItemIntoCargo(EntityAI item)
override bool OnStoreLoad(ParamsReadContext ctx, int version)
override void OnWasDetached(EntityAI parent, int slot_id)
override void EEOnAfterLoad()
override void EEDelete(EntityAI parent)
override bool CanBeRepairedByCrafting()
override void OnPlacementStarted(Man player)
override void OnItemLocationChanged(EntityAI old_owner, EntityAI new_owner)
override bool IsElectricAppliance()
override bool IsItemTent()
override void SetActions()
override string GetLoopFoldSoundset()
override bool CanMakeGardenplot()
override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
override WrittenNoteData GetWrittenNoteData()
override int GetDamageSystemVersionChange()
override bool SetQuantity(float value, bool destroy_config=true, bool destroy_forced=false, bool allow_client=false, bool clamp_to_stack_max=true)
override void InitItemVariables()
override void SetActionAnimOverrides()
override void OnCreatePhysics()
override string GetDeploySoundset()
override float GetBandagingEffectivity()
override bool OnAction(int action_id, Man player, ParamsReadContext ctx)
override void EEHealthLevelChanged(int oldLevel, int newLevel, string zone)
override void OnStoreSave(ParamsWriteContext ctx)
override void AfterStoreLoad()
override int GetOnDigWormsAmount()
override bool IsSelfAdjustingTemperature()
override bool IsPlayerInside(PlayerBase player, string selection)
override void OnVariablesSynchronized()
override void RefreshPhysics()
override bool CanObstruct()
override void OnWasAttached(EntityAI parent, int slot_id)
override bool CanReceiveAttachment(EntityAI attachment, int slotId)
override bool CanPutInCargo(EntityAI parent)
override string GetLoopDeploySoundset()
override void OnPlacementComplete(Man player, vector position="0 0 0", vector orientation="0 0 0")
override void OnInventoryExit(Man player)
override bool IsTakeable()
override bool IsIgnoredByConstruction()
override void InitItemSounds()
override void EEKilled(Object killer)
override void OnCombine(ItemBase other_item)
override bool CanExplodeInFire()
override bool IsFacingPlayer(PlayerBase player, string selection)
override bool CanBeCombined(EntityAI other_item, bool reservation_check=true, bool stack_max_limit=false)
override bool IsBloodContainer()
override bool IsClothing()
override bool CanBeSplit()
override bool IsDeployable()
override void OnRPC(PlayerIdentity sender, int rpc_type, ParamsReadContext ctx)
override bool CanBeDisinfected()
override float GetInfectionChance(int system=0, Param param=null)
override void OnEndPlacement()
float GetOverheatingLimitMax()
void SetOverheatingLimitMax(float max)
void SetParticleParams(int particle_id, Object parent, vector local_pos, vector local_ori)
float GetOverheatingLimitMin()
void SetOverheatingLimitMin(float min)
void RegisterParticle(Particle p)
void Stop()
Legacy function for backwards compatibility with 1.14 and below.
void SetControlledDevice(EntityAI pDevice)
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 bool Write(void value_out)
proto bool Read(void value_in)
proto native float GetDamage(string zoneName, string healthType)
UIScriptedMenu FindMenu(int id)
Returns menu with specific ID if it is open (see MenuID)
void SetCalcDetails(string details)
void OnRPC(PlayerIdentity sender, int rpc_type, ParamsReadContext ctx)
Serializer ParamsReadContext
InventoryTraversalType
tree traversal type, for more see http://en.wikipedia.org/wiki/Tree_traversal
proto native CGame GetGame()
Serializer ParamsWriteContext
const int COMP_TYPE_ENERGY_MANAGER
void Error(string err)
Messagebox with error message.
proto native void SetColor(int color)
array< string > TStringArray
EntityEvent
Entity events for event-mask, or throwing event from code.
static const float ITEM_TEMPERATURE_NEUTRAL_ZONE_MIDDLE
const int VARIABLE_LIQUIDTYPE
const int VARIABLE_CLEANNESS
const int VARIABLE_TEMPERATURE
const int VARIABLE_QUANTITY
static proto float AbsFloat(float f)
Returns absolute value.
proto native bool dBodyIsDynamic(notnull IEntity ent)
const int SAT_DEBUG_ACTION
class JsonUndergroundAreaTriggerData GetPosition
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.