5368{
5370 {
5371 return true;
5372 }
5373};
5374
5375
5376
5378{
5382
5384
5387
5388
5389
5390
5391
5400
5406
5411
5416
5437 protected bool m_IsResultOfSplit
5438
5440
5445
5446
5447
5449
5453
5454
5455
5457
5460
5461
5462
5468
5469
5477
5480
5481
5483
5484
5486
5487
5492
5493
5498
5499
5501
5502
5504 {
5509
5510 if (!
GetGame().IsDedicatedServer())
5511 {
5513 {
5515
5517 {
5519 }
5520 }
5521
5524 }
5525
5526 m_OldLocation = null;
5527
5529 {
5531 }
5532
5533 if (ConfigIsExisting("headSelectionsToHide"))
5534 {
5537 }
5538
5540 if (ConfigIsExisting("hideSelectionsByinventorySlot"))
5541 {
5543 }
5544
5546
5547 m_IsResultOfSplit = false;
5548
5550 }
5551
5553 {
5554 super.InitItemVariables();
5555
5561 m_Count = ConfigGetInt(
"count");
5562
5565
5570
5573
5578
5590
5594
5595
5598 if (ConfigIsExisting("canBeSplit"))
5599 {
5602 }
5603
5605 if (ConfigIsExisting("itemBehaviour"))
5607
5608
5611 RegisterNetSyncVariableInt("m_VarLiquidType");
5612 RegisterNetSyncVariableInt("m_Cleanness",0,1);
5613
5614 RegisterNetSyncVariableBoolSignal("m_WantPlayImpactSound");
5615 RegisterNetSyncVariableFloat("m_ImpactSpeed");
5616 RegisterNetSyncVariableInt("m_ImpactSoundSurfaceHash");
5617
5618 RegisterNetSyncVariableInt("m_ColorComponentR", 0, 255);
5619 RegisterNetSyncVariableInt("m_ColorComponentG", 0, 255);
5620 RegisterNetSyncVariableInt("m_ColorComponentB", 0, 255);
5621 RegisterNetSyncVariableInt("m_ColorComponentA", 0, 255);
5622
5623 RegisterNetSyncVariableBool("m_IsBeingPlaced");
5624 RegisterNetSyncVariableBool("m_IsTakeable");
5625 RegisterNetSyncVariableBool("m_IsHologram");
5626
5629 {
5632 }
5633
5635
5637 if (ConfigIsExisting("temperaturePerQuantityWeight"))
5639
5640 }
5641
5643 {
5645 }
5646
5648 {
5651 {
5656 }
5657 }
5658
5659 override void GetActions(
typename action_input_type, out array<ActionBase_Basic> actions)
5660 {
5662 {
5665 }
5666
5668 }
5669
5671 {
5677 }
5678
5680
5682 {
5684
5685 if (!action)
5686 {
5687 Debug.LogError(
"Action " + actionName +
" dosn't exist!");
5688 return;
5689 }
5690
5692 if (!ai)
5693 {
5695 return;
5696 }
5697
5699 if (!action_array)
5700 {
5701 action_array = new array<ActionBase_Basic>;
5703 }
5704 if (LogManager.IsActionLogEnable())
5705 {
5706 Debug.ActionLog(action.ToString() +
" -> " + ai,
this.ToString() ,
"n/a",
"Add action");
5707 }
5708
5709 if (action_array.Find(action) != -1)
5710 {
5711 Debug.Log(
"Action " + action.Type() +
" already added to " +
this +
", skipping!");
5712 }
5713 else
5714 {
5715 action_array.Insert(action);
5716 }
5717 }
5718
5720 {
5722 ActionBase action = player.GetActionManager().GetAction(actionName);
5725
5726 if (action_array)
5727 {
5728 action_array.RemoveItem(action);
5729 }
5730 }
5731
5732
5733
5735 {
5736 ActionOverrideData overrideData = new ActionOverrideData();
5740
5742 if (!actionMap)
5743 {
5746 }
5747
5748 actionMap.Insert(this.
Type(), overrideData);
5749
5750 }
5751
5753
5755
5756
5758 {
5761
5764
5765 string config_to_search = "CfgVehicles";
5766 string muzzle_owner_config;
5767
5769 {
5770 if (IsInherited(Weapon))
5771 config_to_search = "CfgWeapons";
5772
5773 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
5774
5775 string config_OnFire_class = muzzle_owner_config + "Particles " + "OnFire ";
5776
5778
5779 if (config_OnFire_subclass_count > 0)
5780 {
5781 array<ref WeaponParticlesOnFire> WPOF_array = new array<ref WeaponParticlesOnFire>;
5782
5783 for (int i = 0; i < config_OnFire_subclass_count; i++)
5784 {
5785 string particle_class = "";
5787 string config_OnFire_entry = config_OnFire_class + particle_class;
5788 WeaponParticlesOnFire WPOF = new WeaponParticlesOnFire(this, config_OnFire_entry);
5789 WPOF_array.Insert(WPOF);
5790 }
5791
5792
5794 }
5795 }
5796
5798 {
5799 config_to_search = "CfgWeapons";
5800 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
5801
5802 string config_OnBulletCasingEject_class = muzzle_owner_config + "Particles " + "OnBulletCasingEject ";
5803
5805
5806 if (config_OnBulletCasingEject_count > 0 && IsInherited(Weapon))
5807 {
5808 array<ref WeaponParticlesOnBulletCasingEject> WPOBE_array = new array<ref WeaponParticlesOnBulletCasingEject>;
5809
5810 for (i = 0; i < config_OnBulletCasingEject_count; i++)
5811 {
5812 string particle_class2 = "";
5814 string config_OnBulletCasingEject_entry = config_OnBulletCasingEject_class + particle_class2;
5815 WeaponParticlesOnBulletCasingEject WPOBE = new WeaponParticlesOnBulletCasingEject(this, config_OnBulletCasingEject_entry);
5816 WPOBE_array.Insert(WPOBE);
5817 }
5818
5819
5821 }
5822 }
5823 }
5824
5825
5827 {
5830
5832 {
5833 string config_to_search = "CfgVehicles";
5834
5835 if (IsInherited(Weapon))
5836 config_to_search = "CfgWeapons";
5837
5838 string muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
5839 string config_OnOverheating_class = muzzle_owner_config + "Particles " + "OnOverheating ";
5840
5841 if (
GetGame().ConfigIsExisting(config_OnOverheating_class))
5842 {
5843
5845
5847 {
5849 string error =
"Error reading config " +
GetType() +
">Particles>OnOverheating - Parameter shotsToStartOverheating is configured wrong or is missing! Its value must be 1 or higher!";
5851 return;
5852 }
5853
5856
5857
5858
5860 array<ref WeaponParticlesOnOverheating> WPOOH_array = new array<ref WeaponParticlesOnOverheating>;
5861
5862 for (int i = 0; i < config_OnOverheating_subclass_count; i++)
5863 {
5864 string particle_class = "";
5866 string config_OnOverheating_entry = config_OnOverheating_class + particle_class;
5868
5869 if (entry_type == CT_CLASS)
5870 {
5871 WeaponParticlesOnOverheating WPOF = new WeaponParticlesOnOverheating(this, config_OnOverheating_entry);
5872 WPOOH_array.Insert(WPOF);
5873 }
5874 }
5875
5876
5878 }
5879 }
5880 }
5881
5883 {
5885 }
5886
5888 {
5890 {
5892
5895
5898
5899 CheckOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
5900 }
5901 }
5902
5904 {
5906 UpdateOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
5907
5909 StartOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
5910
5912 StopOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
5913
5915 {
5917 }
5918 }
5919
5921 {
5923 }
5924
5926 {
5929 else
5931
5933 {
5936 }
5937 else
5938 {
5941
5944 }
5945
5947 }
5948
5950 {
5952 ItemBase.PlayOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
5953 }
5954
5956 {
5958 ItemBase.UpdateOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
5960 }
5961
5963 {
5965 ItemBase.StopOverheatingParticles(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
5966 }
5967
5969 {
5972
5973 OverheatingParticle OP = new OverheatingParticle();
5978
5980 }
5981
5983 {
5986
5987 return -1;
5988 }
5989
5991 {
5993 {
5996
5997 for (int i = count; i > 0; --i)
5998 {
5999 int id = i - 1;
6002
6005
6006 if (overheat_coef < overheat_min && overheat_coef >= overheat_max)
6007 {
6008 if (p)
6009 {
6012 }
6013 }
6014 }
6015 }
6016 }
6017
6019 {
6021 {
6023 {
6024 int id = i - 1;
6026
6027 if (OP)
6028 {
6030
6031 if (p)
6032 {
6034 }
6035
6036 delete OP;
6037 }
6038 }
6039
6042 }
6043 }
6044
6047 {
6048 return 0.0;
6049 }
6050
6051
6053 {
6054 return 250;
6055 }
6056
6058 {
6059 return 0;
6060 }
6061
6064 {
6066 return true;
6067
6068 return false;
6069 }
6070
6073 {
6076
6078 {
6080 }
6081 else
6082 {
6083
6085 }
6086
6088 }
6089
6096 {
6097 return -1;
6098 }
6099
6100
6101
6102
6104 {
6106 {
6108 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
6109
6110 if (r_index >= 0)
6111 {
6112 InventoryLocation r_il = new InventoryLocation;
6113 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
6114
6115 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
6118 {
6119 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
6120 }
6122 {
6123 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
6124 }
6125
6126 }
6127
6128 player.GetHumanInventory().ClearUserReservedLocation(this);
6129 }
6130
6133 }
6134
6135
6136
6137
6139 {
6140 return ItemBase.m_DebugActionsMask;
6141 }
6142
6144 {
6145 return ItemBase.m_DebugActionsMask & mask;
6146 }
6147
6149 {
6150 ItemBase.m_DebugActionsMask = mask;
6151 }
6152
6154 {
6155 ItemBase.m_DebugActionsMask |= mask;
6156 }
6157
6159 {
6160 ItemBase.m_DebugActionsMask &= ~mask;
6161 }
6162
6164 {
6166 {
6168 }
6169 else
6170 {
6172 }
6173 }
6174
6175
6177 {
6178 if (GetEconomyProfile())
6179 {
6180 float q_max = GetEconomyProfile().GetQuantityMax();
6181 if (q_max > 0)
6182 {
6183 float q_min = GetEconomyProfile().GetQuantityMin();
6184 float quantity_randomized = Math.RandomFloatInclusive(q_min, q_max);
6185
6187 {
6188 ComponentEnergyManager comp = GetCompEM();
6190 {
6192 }
6193 }
6195 {
6197
6198 }
6199
6200 }
6201 }
6202 }
6203
6206 {
6207 EntityAI parent = GetHierarchyParent();
6208
6209 if (parent)
6210 {
6211 InventoryLocation inventory_location_to_lock = new InventoryLocation;
6212 GetInventory().GetCurrentInventoryLocation(inventory_location_to_lock);
6213 parent.GetInventory().SetSlotLock(inventory_location_to_lock.
GetSlot(),
true);
6214 }
6215 }
6216
6219 {
6220 EntityAI parent = GetHierarchyParent();
6221
6222 if (parent)
6223 {
6224 InventoryLocation inventory_location_to_unlock = new InventoryLocation;
6225 GetInventory().GetCurrentInventoryLocation(inventory_location_to_unlock);
6226 parent.GetInventory().SetSlotLock(inventory_location_to_unlock.
GetSlot(),
false);
6227 }
6228 }
6229
6231 {
6232
6233
6234
6235
6237
6239 {
6240 if (ScriptInputUserData.CanStoreInputUserData())
6241 {
6242 ScriptInputUserData ctx = new ScriptInputUserData;
6248 ctx.
Write(use_stack_max);
6251
6253 {
6254 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(item2,null,GameInventory.c_InventoryReservationTimeoutShortMS);
6255 }
6256 }
6257 }
6258 else if (!
GetGame().IsMultiplayer())
6259 {
6261 }
6262 }
6263
6265 {
6267 }
6268
6270 {
6272 }
6273
6275 {
6277 }
6278
6280 {
6281
6282 return false;
6283 }
6284
6286 {
6287 return false;
6288 }
6289
6293 {
6294 return false;
6295 }
6296
6298 {
6299 return "";
6300 }
6301
6303
6305 {
6306 return false;
6307 }
6308
6310 {
6311 return true;
6312 }
6313
6314
6315
6317 {
6318 return true;
6319 }
6320
6322 {
6323 return true;
6324 }
6325
6327 {
6328 PlayerBase player = PlayerBase.Cast(
g_Game.GetPlayer());
6330 }
6331
6333 {
6335 }
6336
6338 {
6340 if (!is_being_placed)
6342 SetSynchDirty();
6343 }
6344
6345
6347
6349 {
6351 }
6352
6354 {
6356 }
6357
6359 {
6360 return 1;
6361 }
6362
6364 {
6365 return false;
6366 }
6367
6369 {
6371 SetSynchDirty();
6372 }
6373
6374
6375
6376
6377
6378
6379
6380
6381
6382
6383
6384
6385
6386
6387
6388
6389
6390
6391
6392
6393
6394
6395
6396
6397
6398
6399
6400
6401
6402
6403
6404
6405
6406
6407
6409 {
6410 super.OnMovedInsideCargo(container);
6411
6412 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
6413 }
6414
6415 override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
6416 {
6417 super.EEItemLocationChanged(oldLoc,newLoc);
6418
6419 PlayerBase new_player = null;
6420 PlayerBase old_player = null;
6421
6422 if (newLoc.GetParent())
6423 new_player = PlayerBase.Cast(newLoc.GetParent().GetHierarchyRootPlayer());
6424
6425 if (oldLoc.GetParent())
6426 old_player = PlayerBase.Cast(oldLoc.GetParent().GetHierarchyRootPlayer());
6427
6429 {
6430 int r_index = old_player.GetHumanInventory().FindUserReservedLocationIndex(this);
6431
6432 if (r_index >= 0)
6433 {
6434 InventoryLocation r_il = new InventoryLocation;
6435 old_player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
6436
6437 old_player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
6440 {
6441 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
6442 }
6444 {
6445 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
6446 }
6447
6448 }
6449 }
6450
6452 {
6453 if (new_player)
6454 new_player.ForceStandUpForHeavyItems(newLoc.GetItem());
6455
6456 if (new_player == old_player)
6457 {
6458
6459 if (oldLoc.GetParent() && new_player.GetHumanInventory().LocationGetEntity(oldLoc) == NULL)
6460 {
6462 {
6463 if (oldLoc.GetParent().GetInventory().TestAddEntityInCargoExLoc(oldLoc, false, false, false, true, false, false))
6464 {
6465 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
6466 }
6467 }
6468 else
6469 {
6470 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
6471 }
6472 }
6473
6474 if (new_player.GetHumanInventory().FindUserReservedLocationIndex(this) >= 0)
6475 {
6476 int type = oldLoc.GetType();
6478 {
6479 oldLoc.GetParent().GetOnSetLock().Invoke(this);
6480 }
6482 {
6483 oldLoc.GetParent().GetOnAttachmentSetLock().Invoke(this, oldLoc.GetSlot());
6484 }
6485 }
6486 if (!m_OldLocation)
6487 {
6488 m_OldLocation = new InventoryLocation;
6489 }
6490 m_OldLocation.Copy(oldLoc);
6491 }
6492 else
6493 {
6494 if (m_OldLocation)
6495 {
6496 m_OldLocation.Reset();
6497 }
6498 }
6499
6501 }
6502 else
6503 {
6504 if (new_player)
6505 {
6506 int res_index = new_player.GetHumanInventory().FindCollidingUserReservedLocationIndex(this, newLoc);
6507 if (res_index >= 0)
6508 {
6509 InventoryLocation il = new InventoryLocation;
6510 new_player.GetHumanInventory().GetUserReservedLocation(res_index,il);
6512 new_player.GetHumanInventory().ClearUserReservedLocationAtIndex(res_index);
6515 {
6516 il.
GetParent().GetOnReleaseLock().Invoke(it);
6517 }
6519 {
6521 }
6522
6523 }
6524 }
6526 {
6527
6529 }
6530
6531 if (m_OldLocation)
6532 {
6533 m_OldLocation.Reset();
6534 }
6535 }
6536 }
6537
6538 override void EOnContact(IEntity other, Contact extra)
6539 {
6541 {
6542 int liquidType = -1;
6544 if (impactSpeed > 0.0)
6545 {
6547 #ifndef SERVER
6549 #else
6551 SetSynchDirty();
6552 #endif
6554 }
6555 }
6556
6557 #ifdef SERVER
6558 if (GetCompEM() && GetCompEM().IsPlugged())
6559 {
6560 if (GetCompEM().GetCordLength() < vector.Distance(
GetPosition(), GetCompEM().GetEnergySource().
GetPosition()))
6561 GetCompEM().UnplugThis();
6562 }
6563 #endif
6564 }
6565
6567
6569 {
6571 }
6572
6574 {
6575
6576 }
6577
6579 {
6580 super.OnItemLocationChanged(old_owner, new_owner);
6581
6582 PlayerBase relatedPlayer = PlayerBase.Cast(old_owner);
6583 PlayerBase playerNew = PlayerBase.Cast(new_owner);
6584
6585 if (!relatedPlayer && playerNew)
6586 relatedPlayer = playerNew;
6587
6588 if (relatedPlayer && relatedPlayer.GetPerformedActionID() != -1)
6589 {
6591 if (actionMgr)
6592 {
6593 ActionBase currentAction = actionMgr.GetRunningAction();
6594 if (currentAction)
6596 }
6597 }
6598
6599 Man ownerPlayerOld = null;
6600 Man ownerPlayerNew = null;
6601
6602 if (old_owner)
6603 {
6604 if (old_owner.
IsMan())
6605 {
6606 ownerPlayerOld = Man.Cast(old_owner);
6607 }
6608 else
6609 {
6610 ownerPlayerOld = Man.Cast(old_owner.GetHierarchyRootPlayer());
6611 }
6612 }
6613 else
6614 {
6616 {
6618
6619 if (!action || !playerNew || playerNew.GetPerformedActionID() != action.
GetID())
6620 {
6621 GetCompEM().UnplugThis();
6622 }
6623 }
6624 }
6625
6626 if (new_owner)
6627 {
6628 if (new_owner.
IsMan())
6629 {
6630 ownerPlayerNew = Man.Cast(new_owner);
6631 }
6632 else
6633 {
6634 ownerPlayerNew = Man.Cast(new_owner.GetHierarchyRootPlayer());
6635 }
6636 }
6637
6638 if (ownerPlayerOld != ownerPlayerNew)
6639 {
6640 if (ownerPlayerOld)
6641 {
6642 array<EntityAI> subItemsExit = new array<EntityAI>;
6644 for (int i = 0; i < subItemsExit.Count(); i++)
6645 {
6648 }
6649 }
6650
6651 if (ownerPlayerNew)
6652 {
6653 array<EntityAI> subItemsEnter = new array<EntityAI>;
6655 for (int j = 0; j < subItemsEnter.Count(); j++)
6656 {
6659 }
6660 }
6661 }
6662 else if (ownerPlayerNew != null)
6663 {
6664 PlayerBase nplayer;
6665 if (PlayerBase.CastTo(nplayer, ownerPlayerNew))
6666 {
6667 array<EntityAI> subItemsUpdate = new array<EntityAI>;
6669 for (int k = 0; k < subItemsUpdate.Count(); k++)
6670 {
6672 itemUpdate.UpdateQuickbarShortcutVisibility(nplayer);
6673 }
6674 }
6675 }
6676
6677 if (old_owner)
6678 old_owner.OnChildItemRemoved(this);
6679 if (new_owner)
6680 new_owner.OnChildItemReceived(this);
6681 }
6682
6683
6685 {
6686 super.EEDelete(parent);
6687 PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
6688 if (player)
6689 {
6691
6692 if (player.IsAlive())
6693 {
6694 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
6695 if (r_index >= 0)
6696 {
6697 InventoryLocation r_il = new InventoryLocation;
6698 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
6699
6700 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
6703 {
6704 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
6705 }
6707 {
6708 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
6709 }
6710
6711 }
6712
6713 player.RemoveQuickBarEntityShortcut(this);
6714 }
6715 }
6716 }
6717
6719 {
6720 super.EEKilled(killer);
6721
6724 {
6725 if (
GetTemperature() >= GameConstants.ITEM_TEMPERATURE_TO_EXPLODE_MIN)
6726 {
6727 if (IsMagazine())
6728 {
6729 if (Magazine.Cast(this).GetAmmoCount() > 0)
6730 {
6732 }
6733 }
6734 else
6735 {
6737 }
6738 }
6739 }
6740 }
6741
6743 {
6744 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
6745
6746 super.OnWasAttached(parent, slot_id);
6747
6750
6752 }
6753
6755 {
6756 super.OnWasDetached(parent, slot_id);
6757
6760 }
6761
6763 {
6764 int idx;
6767
6768 ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
6769 if (inventory_slots.Count() < 1)
6770 {
6771 inventory_slots.Insert(ConfigGetString("ChangeInventorySlot"));
6772 attach_types.Insert(ConfigGetString("ChangeIntoOnAttach"));
6773 }
6774 else
6775 {
6776 ConfigGetTextArray("ChangeIntoOnAttach",attach_types);
6777 }
6778
6779 idx = inventory_slots.Find(slot);
6780 if (idx < 0)
6781 return "";
6782
6783 return attach_types.Get(idx);
6784 }
6785
6787 {
6788 int idx = -1;
6789 string slot;
6790
6793
6794 this.ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
6795 if (inventory_slots.Count() < 1)
6796 {
6797 inventory_slots.Insert(this.ConfigGetString("ChangeInventorySlot"));
6798 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
6799 }
6800 else
6801 {
6802 this.ConfigGetTextArray("ChangeIntoOnDetach",detach_types);
6803 if (detach_types.Count() < 1)
6804 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
6805 }
6806
6807 for (int i = 0; i < inventory_slots.Count(); i++)
6808 {
6809 slot = inventory_slots.Get(i);
6810 }
6811
6812 if (slot != "")
6813 {
6814 if (detach_types.Count() == 1)
6815 idx = 0;
6816 else
6817 idx = inventory_slots.Find(slot);
6818 }
6819 if (idx < 0)
6820 return "";
6821
6822 return detach_types.Get(idx);
6823 }
6824
6826 {
6827
6829
6830
6831 float min_time = 1;
6832 float max_time = 3;
6833 float delay = Math.RandomFloat(min_time, max_time);
6834
6835 explode_timer.Run(delay, this, "DoAmmoExplosion");
6836 }
6837
6839 {
6840 Magazine magazine = Magazine.Cast(this);
6841 int pop_sounds_count = 6;
6842 string pop_sounds[ 6 ] = { "ammopops_1","ammopops_2","ammopops_3","ammopops_4","ammopops_5","ammopops_6" };
6843
6844
6845 int sound_idx = Math.RandomInt(0, pop_sounds_count - 1);
6846 string sound_name = pop_sounds[ sound_idx ];
6848
6849
6850 magazine.ServerAddAmmoCount(-1);
6851
6852
6853 float min_temp_to_explode = 100;
6854
6855 if (magazine.GetAmmoCount() > 0 &&
GetTemperature() >= min_temp_to_explode)
6856 {
6858 }
6859 }
6860
6861
6862 override void EEHitBy(TotalDamageResult damageResult,
int damageType,
EntityAI source,
int component,
string dmgZone,
string ammo, vector modelPos,
float speedCoef)
6863 {
6864 super.EEHitBy(damageResult, damageType, source,
component, dmgZone, ammo, modelPos, speedCoef);
6865
6866 const int CHANCE_DAMAGE_CARGO = 4;
6867 const int CHANCE_DAMAGE_ATTACHMENT = 1;
6868 const int CHANCE_DAMAGE_NOTHING = 2;
6869
6871 {
6872 float dmg = damageResult.
GetDamage(
"",
"Health") * -0.5;
6873 int chances;
6874 int rnd;
6875
6876 if (GetInventory().GetCargo())
6877 {
6878 chances = CHANCE_DAMAGE_CARGO + CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
6879 rnd = Math.RandomInt(0,chances);
6880
6881 if (rnd < CHANCE_DAMAGE_CARGO)
6882 {
6884 }
6885 else if (rnd < (chances - CHANCE_DAMAGE_NOTHING))
6886 {
6888 }
6889 }
6890 else
6891 {
6892 chances = CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
6893 rnd = Math.RandomInt(0,chances);
6894
6895 if (rnd < CHANCE_DAMAGE_ATTACHMENT)
6896 {
6898 }
6899 }
6900 }
6901 }
6902
6904 {
6905 if (GetInventory().GetCargo())
6906 {
6907 int item_count = GetInventory().GetCargo().GetItemCount();
6908 if (item_count > 0)
6909 {
6910 int random_pick = Math.RandomInt(0, item_count);
6912 if (!item.IsExplosive())
6913 {
6914 item.AddHealth("","",damage);
6915 return true;
6916 }
6917 }
6918 }
6919 return false;
6920 }
6921
6923 {
6924 int attachment_count = GetInventory().AttachmentCount();
6925 if (attachment_count > 0)
6926 {
6927 int random_pick = Math.RandomInt(0, attachment_count);
6928 ItemBase attachment =
ItemBase.Cast(GetInventory().GetAttachmentFromIndex(random_pick));
6929 if (!attachment.IsExplosive())
6930 {
6931 attachment.AddHealth("","",damage);
6932 return true;
6933 }
6934 }
6935 return false;
6936 }
6937
6939 {
6941 }
6942
6944 {
6946 return GetInventory().CanRemoveEntity();
6947
6948 return false;
6949 }
6950
6952 {
6953
6955 return false;
6956
6957
6959 return false;
6960
6961
6962
6964 if (delta == 0)
6965 return false;
6966
6967
6968 return true;
6969 }
6970
6972 {
6974 {
6975 if (ScriptInputUserData.CanStoreInputUserData())
6976 {
6977 ScriptInputUserData ctx = new ScriptInputUserData;
6982 ctx.
Write(destination_entity);
6986 }
6987 }
6988 else if (!
GetGame().IsMultiplayer())
6989 {
6991 }
6992 }
6993
6995 {
6996 float split_quantity_new;
7000 InventoryLocation loc = new InventoryLocation;
7001
7002 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
7003 {
7005 split_quantity_new = stack_max;
7006 else
7008
7010 {
7011 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
7012 if (new_item)
7013 {
7014 new_item.SetResultOfSplit(true);
7015 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7017 new_item.
SetQuantity(split_quantity_new,
false,
true);
7018 }
7019 }
7020 }
7021 else if (destination_entity && slot_id == -1)
7022 {
7023 if (quantity > stack_max)
7024 split_quantity_new = stack_max;
7025 else
7026 split_quantity_new = quantity;
7027
7029 {
7031 {
7034 }
7035
7036 if (new_item)
7037 {
7038 new_item.SetResultOfSplit(true);
7039 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7041 new_item.
SetQuantity(split_quantity_new,
false,
true);
7042 }
7043 }
7044 }
7045 else
7046 {
7047 if (stack_max != 0)
7048 {
7050 {
7052 }
7053
7054 if (split_quantity_new == 0)
7055 {
7056 if (!
GetGame().IsMultiplayer())
7057 player.PhysicalPredictiveDropItem(this);
7058 else
7059 player.ServerDropEntity(this);
7060 return;
7061 }
7062
7064 {
7066
7067 if (new_item)
7068 {
7069 new_item.SetResultOfSplit(true);
7070 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7073 new_item.PlaceOnSurface();
7074 }
7075 }
7076 }
7077 }
7078 }
7079
7081 {
7082 float split_quantity_new;
7086 InventoryLocation loc = new InventoryLocation;
7087
7088 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
7089 {
7091 split_quantity_new = stack_max;
7092 else
7094
7096 {
7097 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
7098 if (new_item)
7099 {
7100 new_item.SetResultOfSplit(true);
7101 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7103 new_item.
SetQuantity(split_quantity_new,
false,
true);
7104 }
7105 }
7106 }
7107 else if (destination_entity && slot_id == -1)
7108 {
7109 if (quantity > stack_max)
7110 split_quantity_new = stack_max;
7111 else
7112 split_quantity_new = quantity;
7113
7115 {
7117 {
7120 }
7121
7122 if (new_item)
7123 {
7124 new_item.SetResultOfSplit(true);
7125 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7127 new_item.
SetQuantity(split_quantity_new,
false,
true);
7128 }
7129 }
7130 }
7131 else
7132 {
7133 if (stack_max != 0)
7134 {
7136 {
7138 }
7139
7141 {
7143
7144 if (new_item)
7145 {
7146 new_item.SetResultOfSplit(true);
7147 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7150 new_item.PlaceOnSurface();
7151 }
7152 }
7153 }
7154 }
7155 }
7156
7158 {
7160 {
7161 if (ScriptInputUserData.CanStoreInputUserData())
7162 {
7163 ScriptInputUserData ctx = new ScriptInputUserData;
7168 dst.WriteToContext(ctx);
7170 }
7171 }
7172 else if (!
GetGame().IsMultiplayer())
7173 {
7175 }
7176 }
7177
7179 {
7181 {
7182 if (ScriptInputUserData.CanStoreInputUserData())
7183 {
7184 ScriptInputUserData ctx = new ScriptInputUserData;
7189 ctx.
Write(destination_entity);
7195 }
7196 }
7197 else if (!
GetGame().IsMultiplayer())
7198 {
7200 }
7201 }
7202
7204 {
7206 }
7207
7209 {
7211 float split_quantity_new;
7213 if (dst.IsValid())
7214 {
7215 int slot_id = dst.GetSlot();
7217
7218 if (quantity > stack_max)
7219 split_quantity_new = stack_max;
7220 else
7221 split_quantity_new = quantity;
7222
7224 {
7226
7227 if (new_item)
7228 {
7229 new_item.SetResultOfSplit(true);
7230 MiscGameplayFunctions.TransferItemProperties(this,new_item);
7232 new_item.
SetQuantity(split_quantity_new,
false,
true);
7233 }
7234
7235 return new_item;
7236 }
7237 }
7238
7239 return null;
7240 }
7241
7243 {
7245 float split_quantity_new;
7247 if (destination_entity)
7248 {
7250 if (quantity > stackable)
7251 split_quantity_new = stackable;
7252 else
7253 split_quantity_new = quantity;
7254
7256 {
7257 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateEntityInCargoEx(
this.GetType(), idx, row, col,
false));
7258 if (new_item)
7259 {
7260 new_item.SetResultOfSplit(true);
7261 MiscGameplayFunctions.TransferItemProperties(this,new_item);
7263 new_item.
SetQuantity(split_quantity_new,
false,
true);
7264 }
7265 }
7266 }
7267 }
7268
7270 {
7272 {
7273 if (ScriptInputUserData.CanStoreInputUserData())
7274 {
7275 ScriptInputUserData ctx = new ScriptInputUserData;
7280 ItemBase destination_entity =
this;
7281 ctx.
Write(destination_entity);
7285 }
7286 }
7287 else if (!
GetGame().IsMultiplayer())
7288 {
7290 }
7291 }
7292
7294 {
7296 float split_quantity_new;
7298 if (player)
7299 {
7301 if (quantity > stackable)
7302 split_quantity_new = stackable;
7303 else
7304 split_quantity_new = quantity;
7305
7307 {
7308 EntityAI in_hands = player.GetHumanInventory().CreateInHands(this.
GetType());
7309 new_item =
ItemBase.Cast(in_hands);
7310 if (new_item)
7311 {
7312 new_item.SetResultOfSplit(true);
7313 MiscGameplayFunctions.TransferItemProperties(this,new_item);
7315 new_item.SetQuantity(split_quantity_new, false, true);
7316 }
7317 }
7318 }
7319 }
7320
7322 {
7324 float split_quantity_new = Math.Floor(quantity * 0.5);
7325
7327 return;
7328
7330
7331 if (new_item)
7332 {
7333 if (new_item.GetQuantityMax() < split_quantity_new)
7334 {
7335 split_quantity_new = new_item.GetQuantityMax();
7336 }
7337
7338 new_item.SetResultOfSplit(true);
7339 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7340
7342 {
7345 }
7346 else
7347 {
7349 new_item.
SetQuantity(split_quantity_new,
false,
true);
7350 }
7351 }
7352 }
7353
7355 {
7357 float split_quantity_new = Math.Floor(quantity / 2);
7358
7360 return;
7361
7362 InventoryLocation invloc = new InventoryLocation;
7364
7366 new_item = player.CreateCopyOfItemInInventoryOrGroundEx(this, true);
7367
7368 if (new_item)
7369 {
7370 if (new_item.GetQuantityMax() < split_quantity_new)
7371 {
7372 split_quantity_new = new_item.GetQuantityMax();
7373 }
7375 {
7378 }
7379 else if (split_quantity_new > 1)
7380 {
7382 new_item.
SetQuantity(split_quantity_new,
false,
true);
7383 }
7384 }
7385 }
7386
7389 {
7390 SetWeightDirty();
7392
7393 if (parent)
7394 parent.OnAttachmentQuantityChangedEx(this, delta);
7395
7397 {
7399 {
7401 }
7403 {
7404 ErrorEx(
"Undefined liquid type quantity changed, please define liquid type first! Using init value.",
ErrorExSeverity.INFO);
7406 }
7407 }
7408
7409 }
7410
7413 {
7414
7415 }
7416
7419 {
7421 }
7422
7424 {
7425 super.EEHealthLevelChanged(oldLevel,newLevel,zone);
7426
7428 {
7429 if (newLevel == GameConstants.STATE_RUINED)
7430 {
7432 EntityAI parent = GetHierarchyParent();
7433 if (parent && parent.IsFireplace())
7434 {
7435 CargoBase cargo = GetInventory().GetCargo();
7436 if (cargo)
7437 {
7439 {
7441 }
7442 }
7443 }
7444 }
7445
7447 {
7448
7450 return;
7451 }
7452
7453 if (
m_Cleanness != 0 && oldLevel < newLevel && newLevel != 0)
7454 {
7456 }
7457 }
7458 }
7459
7460
7462 {
7463 super.OnRightClick();
7464
7466 {
7468 {
7469 if (ScriptInputUserData.CanStoreInputUserData())
7470 {
7471 EntityAI root = GetHierarchyRoot();
7472 Man playerOwner = GetHierarchyRootPlayer();
7473 InventoryLocation dst = new InventoryLocation;
7474
7475
7476 if (!playerOwner && root && root == this)
7477 {
7479 }
7480 else
7481 {
7482
7483 GetInventory().GetCurrentInventoryLocation(dst);
7485 {
7488 {
7490 }
7491 else
7492 {
7494
7495
7496 if (
GetGame().
GetPlayer().GetInventory().HasInventoryReservation(
this, dst))
7497 {
7499 }
7500 else
7501 {
7502 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(null, dst, GameInventory.c_InventoryReservationTimeoutShortMS);
7503 }
7504 }
7505 }
7506 }
7507
7508 ScriptInputUserData ctx = new ScriptInputUserData;
7516 }
7517 }
7518 else if (!
GetGame().IsMultiplayer())
7519 {
7521 }
7522 }
7523 }
7524
7526 {
7527 if (root)
7528 {
7529 vector m4[4];
7530 root.GetTransform(m4);
7531 dst.SetGround(this, m4);
7532 }
7533 else
7534 {
7535 GetInventory().GetCurrentInventoryLocation(dst);
7536 }
7537 }
7538
7539 override bool CanBeCombined(
EntityAI other_item,
bool reservation_check =
true,
bool stack_max_limit =
false)
7540 {
7541
7542 if (!other_item ||
GetType() != other_item.GetType() || (
IsFullQuantity() && other_item.GetQuantity() > 0) || other_item ==
this)
7543 return false;
7544
7545 if (GetHealthLevel() == GameConstants.STATE_RUINED || other_item.GetHealthLevel() == GameConstants.STATE_RUINED)
7546 return false;
7547
7548
7550 return false;
7551
7552
7553 Magazine mag = Magazine.Cast(this);
7554 if (mag)
7555 {
7556 if (mag.GetAmmoCount() >= mag.GetAmmoMax())
7557 return false;
7558
7559 if (stack_max_limit)
7560 {
7561 Magazine other_mag = Magazine.Cast(other_item);
7562 if (other_item)
7563 {
7564 if (mag.GetAmmoCount() + other_mag.GetAmmoCount() > mag.GetAmmoMax())
7565 return false;
7566 }
7567
7568 }
7569 }
7570 else
7571 {
7572
7574 return false;
7575
7577 return false;
7578 }
7579
7580 PlayerBase player = null;
7581 if (CastTo(player, GetHierarchyRootPlayer()))
7582 {
7583 if (player.GetInventory().HasAttachment(this))
7584 return false;
7585
7586 if (player.IsItemsToDelete())
7587 return false;
7588 }
7589
7590 if (reservation_check && (GetInventory().HasInventoryReservation(this, null) || other_item.GetInventory().HasInventoryReservation(other_item, null)))
7591 return false;
7592
7593 int slotID;
7595 if (GetInventory().GetCurrentAttachmentSlotInfo(slotID,
slotName) && GetHierarchyParent().GetInventory().GetSlotLock(slotID))
7596 return false;
7597
7598 return true;
7599 }
7600
7602 {
7604 }
7605
7607 {
7608 return m_IsResultOfSplit;
7609 }
7610
7612 {
7613 m_IsResultOfSplit = value;
7614 }
7615
7617 {
7619 }
7620
7622 {
7623 float other_item_quantity = other_item.GetQuantity();
7624 float this_free_space;
7625
7627
7629
7630 if (other_item_quantity > this_free_space)
7631 {
7632 return this_free_space;
7633 }
7634 else
7635 {
7636 return other_item_quantity;
7637 }
7638 }
7639
7641 {
7643 }
7644
7646 {
7648 return;
7649
7650 if (!IsMagazine() && other_item)
7651 {
7653 if (quantity_used != 0)
7654 {
7655 float hp1 = GetHealth01("","");
7656 float hp2 = other_item.GetHealth01("","");
7657 float hpResult = ((hp1*
GetQuantity()) + (hp2*quantity_used));
7658 hpResult = hpResult / (
GetQuantity() + quantity_used);
7659
7660 hpResult *= GetMaxHealth();
7661 Math.Round(hpResult);
7662 SetHealth("", "Health", hpResult);
7663
7665 other_item.AddQuantity(-quantity_used);
7666 }
7667 }
7669 }
7670
7672 {
7673 #ifdef SERVER
7674 if (!GetHierarchyRootPlayer() && GetHierarchyParent())
7675 GetHierarchyParent().IncreaseLifetimeUp();
7676 #endif
7677 };
7678
7680 {
7681 PlayerBase p = PlayerBase.Cast(player);
7682
7683 array<int> recipesIds = p.m_Recipes;
7684 PluginRecipesManager moduleRecipesManager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
7685 if (moduleRecipesManager)
7686 {
7687 EntityAI itemInHands = player.GetHumanInventory().GetEntityInHands();
7688 moduleRecipesManager.GetValidRecipes(
ItemBase.Cast(
this),
ItemBase.Cast(itemInHands), recipesIds, p);
7689 }
7690
7691 for (int i = 0;i < recipesIds.Count(); i++)
7692 {
7693 int key = recipesIds.Get(i);
7694 string recipeName = moduleRecipesManager.GetRecipeName(key);
7696 }
7697 }
7698
7699
7700 override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
7701 {
7702 super.GetDebugActions(outputList);
7703
7704
7710
7711
7716
7721
7722
7726
7727
7729 {
7733 }
7734
7737
7738
7742
7744
7745 InventoryLocation loc = new InventoryLocation();
7746 GetInventory().GetCurrentInventoryLocation(loc);
7748 {
7749 if (Gizmo_IsSupported())
7752 }
7753
7755 }
7756
7757
7758
7759
7761 {
7762 super.OnAction(action_id, player, ctx);
7763
7765 {
7766 switch (action_id)
7767 {
7770 return true;
7773 return true;
7774 }
7775 }
7776
7778 {
7779 switch (action_id)
7780 {
7782 Delete();
7783 return true;
7784 }
7785 }
7786
7787 if (action_id >=
EActions.RECIPES_RANGE_START && action_id <
EActions.RECIPES_RANGE_END)
7788 {
7789 PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
7790 int idWithoutOffset = action_id -
EActions.RECIPES_RANGE_START;
7791 PlayerBase p = PlayerBase.Cast(player);
7792 if (
EActions.RECIPES_RANGE_START < 1000)
7793 {
7794 float anim_length = plugin_recipes_manager.GetRecipeLengthInSecs(idWithoutOffset);
7795 float specialty_weight = plugin_recipes_manager.GetRecipeSpecialty(idWithoutOffset);
7796 }
7797 }
7798 #ifndef SERVER
7799 else if (action_id ==
EActions.WATCH_PLAYER)
7800 {
7801 PluginDeveloper.SetDeveloperItemClientEx(player);
7802 }
7803 #endif
7805 {
7806 if (action_id >=
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START && action_id <
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_END)
7807 {
7808 int id = action_id -
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START;
7809 OnDebugButtonPressServer(id + 1);
7810 }
7811
7812 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_INJECT_START && action_id <
EActions.DEBUG_AGENTS_RANGE_INJECT_END)
7813 {
7814 int agent_id = action_id -
EActions.DEBUG_AGENTS_RANGE_INJECT_START;
7816 }
7817
7818 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_REMOVE_START && action_id <
EActions.DEBUG_AGENTS_RANGE_REMOVE_END)
7819 {
7820 int agent_id2 = action_id -
EActions.DEBUG_AGENTS_RANGE_REMOVE_START;
7822 }
7823
7824 else if (action_id ==
EActions.ADD_QUANTITY)
7825 {
7826 if (IsMagazine())
7827 {
7828 Magazine mag = Magazine.Cast(this);
7829 mag.ServerSetAmmoCount(mag.GetAmmoCount() + mag.GetAmmoMax() * 0.2);
7830 }
7831 else
7832 {
7834 }
7835
7836 if (m_EM)
7837 {
7838 m_EM.AddEnergy(m_EM.GetEnergyMax() * 0.2);
7839 }
7840
7841 }
7842
7843 else if (action_id ==
EActions.REMOVE_QUANTITY)
7844 {
7845 if (IsMagazine())
7846 {
7847 Magazine mag2 = Magazine.Cast(this);
7848 mag2.ServerSetAmmoCount(mag2.GetAmmoCount() - mag2.GetAmmoMax() * 0.2);
7849 }
7850 else
7851 {
7853 }
7854 if (m_EM)
7855 {
7856 m_EM.AddEnergy(- m_EM.GetEnergyMax() * 0.2);
7857 }
7858
7859 }
7860
7861 else if (action_id ==
EActions.SET_QUANTITY_0)
7862 {
7864
7865 if (m_EM)
7866 {
7867 m_EM.SetEnergy(0);
7868 }
7869 }
7870
7871 else if (action_id ==
EActions.SET_MAX_QUANTITY)
7872 {
7874
7875 if (m_EM)
7876 {
7877 m_EM.SetEnergy(m_EM.GetEnergyMax());
7878 }
7879 }
7880
7881 else if (action_id ==
EActions.ADD_HEALTH)
7882 {
7883 AddHealth("","",GetMaxHealth("","Health")/5);
7884 }
7885 else if (action_id ==
EActions.REMOVE_HEALTH)
7886 {
7887 AddHealth("","",-GetMaxHealth("","Health")/5);
7888 }
7889 else if (action_id ==
EActions.DESTROY_HEALTH)
7890 {
7891 SetHealth01("","",0);
7892 }
7893 else if (action_id ==
EActions.WATCH_ITEM)
7894 {
7896 mid.RegisterDebugItem(
ItemBase.Cast(
this), PlayerBase.Cast(player));
7897 #ifdef DEVELOPER
7898 SetDebugDeveloper_item(this);
7899 #endif
7900 }
7901
7902 else if (action_id ==
EActions.ADD_TEMPERATURE)
7903 {
7904 AddTemperature(20);
7905
7906 }
7907
7908 else if (action_id ==
EActions.REMOVE_TEMPERATURE)
7909 {
7910 AddTemperature(-20);
7911
7912 }
7913
7914 else if (action_id ==
EActions.FLIP_FROZEN)
7915 {
7916 SetFrozen(!GetIsFrozen());
7917
7918 }
7919
7920 else if (action_id ==
EActions.ADD_WETNESS)
7921 {
7923
7924 }
7925
7926 else if (action_id ==
EActions.REMOVE_WETNESS)
7927 {
7929
7930 }
7931
7932 else if (action_id ==
EActions.LIQUIDTYPE_UP)
7933 {
7936
7937
7938 }
7939
7940 else if (action_id ==
EActions.LIQUIDTYPE_DOWN)
7941 {
7944 }
7945
7946 else if (action_id ==
EActions.MAKE_SPECIAL)
7947 {
7948 auto debugParams = DebugSpawnParams.WithPlayer(player);
7949 OnDebugSpawnEx(debugParams);
7950 }
7951
7952 }
7953
7954
7955 return false;
7956 }
7957
7958
7959
7960
7964
7967
7968
7969
7971 {
7972 return false;
7973 }
7974
7975
7977 {
7978 return true;
7979 }
7980
7981
7983 {
7984 return true;
7985 }
7986
7987
7988
7990 {
7991 string config_path =
string.Format(
"CfgVehicles %1 Food FoodStages",
GetType());
7993 }
7994
7997 {
7998 return null;
7999 }
8000
8002 {
8003 return false;
8004 }
8005
8007 {
8008 return false;
8009 }
8010
8014
8015
8017 {
8018 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
8019 return module_repairing.CanRepair(this, item_repair_kit);
8020 }
8021
8022
8023 bool Repair(PlayerBase player,
ItemBase item_repair_kit,
float specialty_weight)
8024 {
8025 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
8026 return module_repairing.Repair(player, this, item_repair_kit, specialty_weight);
8027 }
8028
8029
8031 {
8032
8033
8034
8035
8036
8037
8038
8039
8040 return 1;
8041 }
8042
8043
8044
8046 {
8048 }
8049
8050
8051
8053 {
8055 }
8056
8057
8066 {
8067 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8068
8069 if (player)
8070 {
8071 player.MessageStatus(text);
8072 }
8073 }
8074
8075
8084 {
8085 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8086
8087 if (player)
8088 {
8089 player.MessageAction(text);
8090 }
8091 }
8092
8093
8102 {
8103 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8104
8105 if (player)
8106 {
8107 player.MessageFriendly(text);
8108 }
8109 }
8110
8111
8120 {
8121 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8122
8123 if (player)
8124 {
8125 player.MessageImportant(text);
8126 }
8127 }
8128
8130 {
8131 return true;
8132 }
8133
8134
8135 override bool KindOf(
string tag)
8136 {
8137 bool found = false;
8138 string item_name = this.
GetType();
8141
8142 int array_size = item_tag_array.Count();
8143 for (int i = 0; i < array_size; i++)
8144 {
8145 if (item_tag_array.Get(i) == tag)
8146 {
8147 found = true;
8148 break;
8149 }
8150 }
8151 return found;
8152 }
8153
8154
8156 {
8157
8158 super.OnRPC(sender, rpc_type,ctx);
8159
8160
8161 switch (rpc_type)
8162 {
8163 #ifndef SERVER
8164 case ERPCs.RPC_SOUND_LOCK_ATTACH:
8165 Param2<bool, string> p = new Param2<bool, string>(false, "");
8166
8168 return;
8169
8170 bool play = p.param1;
8171 string soundSet = p.param2;
8172
8173 if (play)
8174 {
8176 {
8178 {
8180 }
8181 }
8182 else
8183 {
8185 }
8186 }
8187 else
8188 {
8190 }
8191
8192 break;
8193 #endif
8194
8195 }
8196
8198 {
8200 }
8201 }
8202
8203
8204
8205
8207 {
8208 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
8209 return plugin.GetID(
name);
8210 }
8211
8213 {
8214 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
8215 return plugin.GetName(id);
8216 }
8217
8220 {
8221
8222
8223 int varFlags;
8224 if (!ctx.
Read(varFlags))
8225 return;
8226
8227 if (varFlags & ItemVariableFlags.FLOAT)
8228 {
8230 }
8231 }
8232
8234 {
8235
8236 super.SerializeNumericalVars(floats_out);
8237
8238
8239
8241 {
8243 }
8244
8246 {
8248 }
8249
8251 {
8253 }
8254
8256 {
8261 }
8262
8264 {
8266 }
8267 }
8268
8270 {
8271
8272 super.DeSerializeNumericalVars(floats);
8273
8274
8275 int index = 0;
8276 int mask = Math.Round(floats.Get(index));
8277
8278 index++;
8279
8281 {
8283 {
8285 }
8286 else
8287 {
8288 float quantity = floats.Get(index);
8290 }
8291 index++;
8292 }
8293
8295 {
8296 float wet = floats.Get(index);
8298 index++;
8299 }
8300
8302 {
8303 int liquidtype = Math.Round(floats.Get(index));
8305 index++;
8306 }
8307
8309 {
8311 index++;
8313 index++;
8315 index++;
8317 index++;
8318 }
8319
8321 {
8322 int cleanness = Math.Round(floats.Get(index));
8324 index++;
8325 }
8326 }
8327
8329 {
8330 super.WriteVarsToCTX(ctx);
8331
8332
8334 {
8336 }
8337
8339 {
8341 }
8342
8344 {
8346 }
8347
8349 {
8350 int r,g,b,a;
8356 }
8357
8359 {
8361 }
8362 }
8363
8365 {
8366 if (!super.ReadVarsFromCTX(ctx,version))
8367 return false;
8368
8369 int intValue;
8370 float value;
8371
8372 if (version < 140)
8373 {
8374 if (!ctx.
Read(intValue))
8375 return false;
8376
8377 m_VariablesMask = intValue;
8378 }
8379
8381 {
8382 if (!ctx.
Read(value))
8383 return false;
8384
8386 {
8388 }
8389 else
8390 {
8392 }
8393 }
8394
8395 if (version < 140)
8396 {
8398 {
8399 if (!ctx.
Read(value))
8400 return false;
8401 SetTemperatureDirect(value);
8402 }
8403 }
8404
8406 {
8407 if (!ctx.
Read(value))
8408 return false;
8410 }
8411
8413 {
8414 if (!ctx.
Read(intValue))
8415 return false;
8417 }
8418
8420 {
8421 int r,g,b,a;
8423 return false;
8425 return false;
8427 return false;
8429 return false;
8430
8432 }
8433
8435 {
8436 if (!ctx.
Read(intValue))
8437 return false;
8439 }
8440
8441 if (version >= 138 && version < 140)
8442 {
8444 {
8445 if (!ctx.
Read(intValue))
8446 return false;
8447 SetFrozen(intValue);
8448 }
8449 }
8450
8451 return true;
8452 }
8453
8454
8456 {
8459 {
8461 }
8462
8463 if (!super.OnStoreLoad(ctx, version))
8464 {
8466 return false;
8467 }
8468
8469 if (version >= 114)
8470 {
8471 bool hasQuickBarIndexSaved;
8472
8473 if (!ctx.
Read(hasQuickBarIndexSaved))
8474 {
8476 return false;
8477 }
8478
8479 if (hasQuickBarIndexSaved)
8480 {
8481 int itmQBIndex;
8482
8483
8484 if (!ctx.
Read(itmQBIndex))
8485 {
8487 return false;
8488 }
8489
8490 PlayerBase parentPlayer = PlayerBase.Cast(GetHierarchyRootPlayer());
8491 if (itmQBIndex != -1 && parentPlayer)
8492 parentPlayer.SetLoadedQuickBarItemBind(this, itmQBIndex);
8493 }
8494 }
8495 else
8496 {
8497
8498 PlayerBase player;
8499 int itemQBIndex;
8500 if (version ==
int.
MAX)
8501 {
8502 if (!ctx.
Read(itemQBIndex))
8503 {
8505 return false;
8506 }
8507 }
8508 else if (Class.CastTo(player, GetHierarchyRootPlayer()))
8509 {
8510
8511 if (!ctx.
Read(itemQBIndex))
8512 {
8514 return false;
8515 }
8516 if (itemQBIndex != -1 && player)
8517 player.SetLoadedQuickBarItemBind(this,itemQBIndex);
8518 }
8519 }
8520
8521 if (version < 140)
8522 {
8523
8524 if (!LoadVariables(ctx, version))
8525 {
8527 return false;
8528 }
8529 }
8530
8531
8533 {
8535 return false;
8536 }
8537 if (version >= 132)
8538 {
8540 if (raib)
8541 {
8543 {
8545 return false;
8546 }
8547 }
8548 }
8549
8551 return true;
8552 }
8553
8554
8555
8557 {
8558 super.OnStoreSave(ctx);
8559
8560 PlayerBase player;
8561 if (PlayerBase.CastTo(player,GetHierarchyRootPlayer()))
8562 {
8564
8565 int itemQBIndex = -1;
8566 itemQBIndex = player.FindQuickBarEntityIndex(this);
8567 ctx.
Write(itemQBIndex);
8568 }
8569 else
8570 {
8572 }
8573
8575
8577 if (raib)
8578 {
8580 }
8581 }
8582
8583
8585 {
8586 super.AfterStoreLoad();
8587
8589 {
8591 }
8592
8594 {
8597 }
8598 }
8599
8601 {
8602 super.EEOnAfterLoad();
8603
8605 {
8607 }
8608
8611 }
8612
8614 {
8615 return false;
8616 }
8617
8618
8619
8621 {
8623 {
8624 #ifdef PLATFORM_CONSOLE
8625
8627 {
8629 if (menu)
8630 {
8632 }
8633 }
8634 #endif
8635 }
8636
8638 {
8641 }
8642
8644 {
8645 SetWeightDirty();
8647 }
8649 {
8652 }
8653
8655 {
8658 }
8660 {
8663 }
8664
8665 super.OnVariablesSynchronized();
8666 }
8667
8668
8669
8671 override bool SetQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false,
bool allow_client =
false,
bool clamp_to_stack_max =
true)
8672 {
8673 if (!IsServerCheck(allow_client))
8674 return false;
8675
8677 return false;
8678
8681
8682 if (value <= (min + 0.001))
8683 value = min;
8684
8685 if (value == min)
8686 {
8687 if (destroy_config)
8688 {
8689 bool dstr = ConfigGetBool("varQuantityDestroyOnMin");
8690 if (dstr)
8691 {
8693 this.Delete();
8694 return true;
8695 }
8696 }
8697 else if (destroy_forced)
8698 {
8700 this.Delete();
8701 return true;
8702 }
8703
8705 }
8706
8709
8711 {
8713
8714 if (delta)
8716 }
8717
8719
8720 return false;
8721 }
8722
8723
8725 bool AddQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
8726 {
8728 }
8729
8731 {
8734 }
8735
8737 {
8740 }
8741
8743 override void SetQuantityNormalized(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
8744 {
8745 float value_clamped = Math.Clamp(value, 0, 1);
8747 SetQuantity(result, destroy_config, destroy_forced);
8748 }
8749
8750
8753 {
8755 }
8756
8758 {
8760 }
8761
8762
8763
8764
8765
8766
8767
8768
8769
8770
8772 {
8773 int slot = -1;
8774 if (GetInventory())
8775 {
8776 InventoryLocation il = new InventoryLocation;
8777 GetInventory().GetCurrentInventoryLocation(il);
8779 }
8780
8782 }
8783
8785 {
8786 float quantity_max = 0;
8787
8789 {
8790 if (attSlotID != -1)
8791 quantity_max = InventorySlots.GetStackMaxForSlotId(attSlotID);
8792
8793 if (quantity_max <= 0)
8795 }
8796
8797 if (quantity_max <= 0)
8799
8800 return quantity_max;
8801 }
8802
8804 {
8806 }
8807
8809 {
8811 }
8812
8813
8815 {
8817 }
8818
8820 {
8822 }
8823
8825 {
8827 }
8828
8829
8831 {
8832
8833 float weightEx = GetWeightEx();
8834 float special = GetInventoryAndCargoWeight();
8835 return weightEx - special;
8836 }
8837
8838
8840 {
8842 }
8843
8845 {
8847 {
8848 #ifdef DEVELOPER
8849 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
8850 {
8851 WeightDebugData data1 = WeightDebug.GetWeightDebug(this);
8853 }
8854 #endif
8855
8857 }
8858 else if (HasEnergyManager())
8859 {
8860 #ifdef DEVELOPER
8861 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
8862 {
8863 WeightDebugData data2 = WeightDebug.GetWeightDebug(this);
8864 data2.
SetCalcDetails(
"TIB2: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " + GetCompEM().
GetEnergy()+
"(energy) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit)");
8865 }
8866 #endif
8867 return super.GetWeightSpecialized(forceRecalc) + (GetCompEM().GetEnergy() * ConfigGetFloat("weightPerQuantityUnit")) + GetConfigWeightModified();
8868 }
8869 else
8870 {
8871 #ifdef DEVELOPER
8872 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
8873 {
8874 WeightDebugData data3 = WeightDebug.GetWeightDebug(this);
8875 data3.
SetCalcDetails(
"TIB3: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " +
GetQuantity()+
"(quantity) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit))");
8876 }
8877 #endif
8878 return super.GetWeightSpecialized(forceRecalc) + (
GetQuantity() * ConfigGetFloat(
"weightPerQuantityUnit")) + GetConfigWeightModified();
8879 }
8880 }
8881
8884 {
8885 int item_count = 0;
8887
8888 if (GetInventory().GetCargo() != NULL)
8889 {
8890 item_count = GetInventory().GetCargo().GetItemCount();
8891 }
8892
8893 for (int i = 0; i < GetInventory().AttachmentCount(); i++)
8894 {
8895 Class.CastTo(item,GetInventory().GetAttachmentFromIndex(i));
8896 if (item)
8897 item_count += item.GetNumberOfItems();
8898 }
8899 return item_count;
8900 }
8901
8904 {
8905 float weight = 0;
8906 float wetness = 1;
8907 if (include_wetness)
8910 {
8911 weight = wetness * m_ConfigWeight;
8912 }
8914 {
8915 weight = 1;
8916 }
8917 return weight;
8918 }
8919
8920
8921
8923 {
8924 if ((
GetGame().IsServer() || !
GetGame().IsMultiplayer()) && GetInventory())
8925 {
8926 GameInventory inv = GetInventory();
8927 array<EntityAI> items = new array<EntityAI>;
8929 for (int i = 0; i < items.Count(); i++)
8930 {
8932 if (item)
8933 {
8935 }
8936 }
8937 }
8938 }
8939
8940
8941
8942
8944 {
8945 float energy = 0;
8946 if (HasEnergyManager())
8947 {
8948 energy = GetCompEM().GetEnergy();
8949 }
8950 return energy;
8951 }
8952
8953
8955 {
8956 super.OnEnergyConsumed();
8957
8959 }
8960
8962 {
8963 super.OnEnergyAdded();
8964
8966 }
8967
8968
8970 {
8971 if (
GetGame().IsServer() && HasEnergyManager() && GetCompEM().HasConversionOfEnergyToQuantity())
8972 {
8974 {
8975 float energy_0to1 = GetCompEM().GetEnergy0To1();
8977 }
8978 }
8979 }
8980
8981
8983 {
8984 return ConfigGetFloat("heatIsolation");
8985 }
8986
8988 {
8990 }
8991
8993 {
8994 string paramPath =
string.Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Drying %2",
GetType(), pIncrementName);
8995 if (
GetGame().ConfigIsExisting(paramPath))
8997
8998 return 0.0;
8999 }
9000
9002 {
9003 string paramPath =
string.
Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Soaking %2",
GetType(), pIncrementName);
9004 if (
GetGame().ConfigIsExisting(paramPath))
9006
9007 return 0.0;
9008 }
9009
9010 override void SetWet(
float value,
bool allow_client =
false)
9011 {
9012 if (!IsServerCheck(allow_client))
9013 return;
9014
9017
9019
9020 m_VarWet = Math.Clamp(value, min, max);
9021
9023 {
9026 }
9027 }
9028
9029 override void AddWet(
float value)
9030 {
9032 }
9033
9035 {
9037 }
9038
9040 {
9042 }
9043
9045 {
9047 }
9048
9050 {
9052 }
9053
9055 {
9057 }
9058
9060 {
9063 if (newLevel != oldLevel)
9064 {
9066 }
9067 }
9068
9070 {
9071 SetWeightDirty();
9072 }
9073
9075 {
9076 return GetWetLevelInternal(
m_VarWet);
9077 }
9078
9079
9080
9082 {
9084 }
9085
9087 {
9089 }
9090
9092 {
9094 }
9095
9097 {
9099 }
9100
9101
9102
9104 {
9105 if (ConfigIsExisting("itemModelLength"))
9106 {
9107 return ConfigGetFloat("itemModelLength");
9108 }
9109 return 0;
9110 }
9111
9113 {
9114 if (ConfigIsExisting("itemAttachOffset"))
9115 {
9116 return ConfigGetFloat("itemAttachOffset");
9117 }
9118 return 0;
9119 }
9120
9121 override void SetCleanness(
int value,
bool allow_client =
false)
9122 {
9123 if (!IsServerCheck(allow_client))
9124 return;
9125
9127
9129
9132 }
9133
9135 {
9137 }
9138
9140 {
9141 return true;
9142 }
9143
9144
9145
9146
9148 {
9150 }
9151
9153 {
9155 }
9156
9157
9158
9159
9160 override void SetColor(
int r,
int g,
int b,
int a)
9161 {
9167 }
9169 override void GetColor(out
int r,out
int g,out
int b,out
int a)
9170 {
9175 }
9176
9178 {
9180 }
9181
9184 {
9185 int r,g,b,a;
9187 r = r/255;
9188 g = g/255;
9189 b = b/255;
9190 a = a/255;
9191 return MiscGameplayFunctions.GetColorString(r, g, b, a);
9192 }
9193
9194
9195
9196 override void SetLiquidType(
int value,
bool allow_client =
false)
9197 {
9198 if (!IsServerCheck(allow_client))
9199 return;
9200
9205 }
9206
9208 {
9209 return ConfigGetInt("varLiquidTypeInit");
9210 }
9211
9213 {
9215 }
9216
9218 {
9220 SetFrozen(false);
9221 }
9222
9225 {
9226 player.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
9227 }
9228
9229
9232 {
9233 PlayerBase nplayer;
9234 if (PlayerBase.CastTo(nplayer, player))
9235 {
9237
9238 nplayer.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
9239 }
9240 }
9241
9242
9245 {
9246 PlayerBase nplayer;
9247 if (PlayerBase.CastTo(nplayer,player))
9248 {
9249
9250 nplayer.SetEnableQuickBarEntityShortcut(this,false);
9251
9252 }
9253
9254
9255 player.GetHumanInventory().ClearUserReservedLocationForContainer(this);
9256
9257
9258 if (HasEnergyManager())
9259 {
9260 GetCompEM().UpdatePlugState();
9261 }
9262 }
9263
9264
9266 {
9267 super.OnPlacementStarted(player);
9268
9270 }
9271
9272 override void OnPlacementComplete(Man player, vector position =
"0 0 0", vector orientation =
"0 0 0")
9273 {
9275 {
9276 m_AdminLog.OnPlacementComplete(player,
this);
9277 }
9278
9279 super.OnPlacementComplete(player, position, orientation);
9280 }
9281
9282
9283
9284
9285
9287 {
9289 {
9290 return true;
9291 }
9292 else
9293 {
9294 return false;
9295 }
9296 }
9297
9298
9300 {
9302 {
9304 }
9305 }
9306
9307
9309 {
9311 }
9312
9314 {
9316 }
9317
9318 override void InsertAgent(
int agent,
float count = 1)
9319 {
9320 if (count < 1)
9321 return;
9322
9324 }
9325
9328 {
9330 }
9331
9332
9334 {
9336 }
9337
9338
9339
9340
9341
9342
9343
9344
9345
9346
9347
9348
9349
9350
9351
9352
9353
9354
9355
9356
9357
9358
9359
9360
9361
9362
9363
9364
9365
9366
9367
9368
9369
9370
9371
9372
9373
9374
9375
9376
9377
9378
9380 {
9382 return false;
9383 return true;
9384 }
9385
9387 {
9388
9390 }
9391
9392
9395 {
9396 super.CheckForRoofLimited(timeTresholdMS);
9397
9399 if ((time - m_PreviousRoofTestTime) >= timeTresholdMS)
9400 {
9401 m_PreviousRoofTestTime = time;
9402 SetRoofAbove(MiscGameplayFunctions.IsUnderRoof(this));
9403 }
9404 }
9405
9406
9408 {
9410 {
9411 return 0;
9412 }
9413
9414 if (GetInventory().GetAttachmentSlotsCount() != 0)
9415 {
9416 ItemBase filter =
ItemBase.Cast(FindAttachmentBySlotName(
"GasMaskFilter"));
9417 if (filter)
9418 return filter.GetProtectionLevel(type, false, system);
9419 else
9420 return 0;
9421 }
9422
9423 string subclassPath, entryName;
9424
9425 switch (type)
9426 {
9428 entryName = "biological";
9429 break;
9431 entryName = "chemical";
9432 break;
9433 default:
9434 entryName = "biological";
9435 break;
9436 }
9437
9438 subclassPath =
"CfgVehicles " + this.
GetType() +
" Protection ";
9439
9441 }
9442
9443
9444
9447 {
9448 if (!IsMagazine())
9450
9452 }
9453
9454
9455
9456
9457
9462 {
9463 return true;
9464 }
9465
9467 {
9469 }
9470
9471
9472
9473
9474
9476 {
9477 if (parent)
9478 {
9479 if (parent.IsInherited(DayZInfected))
9480 return true;
9481
9482 if (!parent.IsRuined())
9483 return true;
9484 }
9485
9486 return true;
9487 }
9488
9490 {
9491 if (!super.CanPutAsAttachment(parent))
9492 {
9493 return false;
9494 }
9495
9496 if (!IsRuined() && !parent.IsRuined())
9497 {
9498 return true;
9499 }
9500
9501 return false;
9502 }
9503
9505 {
9506
9507
9508
9509
9510 return super.CanReceiveItemIntoCargo(item);
9511 }
9512
9514 {
9515
9516
9517
9518
9519 GameInventory attachmentInv = attachment.GetInventory();
9521 {
9522 if (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase))
9523 return false;
9524 }
9525
9526 InventoryLocation loc = new InventoryLocation();
9527 attachment.GetInventory().GetCurrentInventoryLocation(loc);
9528 if (loc && loc.
IsValid() && !GetInventory().AreChildrenAccessible())
9529 return false;
9530
9531 return super.CanReceiveAttachment(attachment, slotId);
9532 }
9533
9535 {
9536 if (!super.CanReleaseAttachment(attachment))
9537 return false;
9538
9539 return GetInventory().AreChildrenAccessible();
9540 }
9541
9542
9543
9544
9545
9546
9547
9548
9549
9550
9551
9552
9553
9554
9555
9556
9557
9558
9559
9560
9561
9563 {
9564 int id = muzzle_owner.GetMuzzleID();
9565 array<ref WeaponParticlesOnFire> WPOF_array =
m_OnFireEffect.Get(
id);
9566
9567 if (WPOF_array)
9568 {
9569 for (int i = 0; i < WPOF_array.Count(); i++)
9570 {
9571 WeaponParticlesOnFire WPOF = WPOF_array.Get(i);
9572
9573 if (WPOF)
9574 {
9575 WPOF.OnActivate(weapon, muzzle_index, ammoType, muzzle_owner, suppressor, config_to_search);
9576 }
9577 }
9578 }
9579 }
9580
9581
9583 {
9584 int id = muzzle_owner.GetMuzzleID();
9586
9587 if (WPOBE_array)
9588 {
9589 for (int i = 0; i < WPOBE_array.Count(); i++)
9590 {
9591 WeaponParticlesOnBulletCasingEject WPOBE = WPOBE_array.Get(i);
9592
9593 if (WPOBE)
9594 {
9595 WPOBE.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
9596 }
9597 }
9598 }
9599 }
9600
9601
9603 {
9604 int id = muzzle_owner.GetMuzzleID();
9605 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
9606
9607 if (WPOOH_array)
9608 {
9609 for (int i = 0; i < WPOOH_array.Count(); i++)
9610 {
9611 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
9612
9613 if (WPOOH)
9614 {
9615 WPOOH.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
9616 }
9617 }
9618 }
9619 }
9620
9621
9623 {
9624 int id = muzzle_owner.GetMuzzleID();
9625 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
9626
9627 if (WPOOH_array)
9628 {
9629 for (int i = 0; i < WPOOH_array.Count(); i++)
9630 {
9631 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
9632
9633 if (WPOOH)
9634 {
9635 WPOOH.OnUpdate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9636 }
9637 }
9638 }
9639 }
9640
9641
9643 {
9644 int id = muzzle_owner.GetMuzzleID();
9645 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
9646
9647 if (WPOOH_array)
9648 {
9649 for (int i = 0; i < WPOOH_array.Count(); i++)
9650 {
9651 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
9652
9653 if (WPOOH)
9654 {
9655 WPOOH.OnDeactivate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9656 }
9657 }
9658 }
9659 }
9660
9661
9662
9664 {
9666 {
9667 return true;
9668 }
9669
9670 return false;
9671 }
9672
9674 {
9676 {
9677 return true;
9678 }
9679
9680 return false;
9681 }
9682
9684 {
9686 {
9687 return true;
9688 }
9689
9690 return false;
9691 }
9692
9694 {
9695 return false;
9696 }
9697
9700 {
9701 return UATimeSpent.DEFAULT_DEPLOY;
9702 }
9703
9704
9705
9706
9708 {
9710 SetSynchDirty();
9711 }
9712
9714 {
9716 }
9717
9718
9720 {
9721 return false;
9722 }
9723
9726 {
9727 string att_type = "None";
9728
9729 if (ConfigIsExisting("soundAttType"))
9730 {
9731 att_type = ConfigGetString("soundAttType");
9732 }
9733
9735 }
9736
9738 {
9740 }
9741
9742
9743
9744
9745
9751
9753 {
9756
9758 }
9759
9760
9762 {
9764 return;
9765
9767
9770
9773
9774 SoundParameters params = new SoundParameters();
9778 }
9779
9780
9782 {
9784 return;
9785
9787 SetSynchDirty();
9788
9791 }
9792
9793
9795 {
9797 return;
9798
9800 SetSynchDirty();
9801
9804 }
9805
9807 {
9809 }
9810
9812 {
9814 }
9815
9818 {
9819 if (!
GetGame().IsDedicatedServer())
9820 {
9821 if (ConfigIsExisting("attachSoundSet"))
9822 {
9823 string cfg_path = "";
9824 string soundset = "";
9826
9829 ConfigGetTextArray("attachSoundSet",cfg_soundset_array);
9830 ConfigGetTextArray("attachSoundSlot",cfg_slot_array);
9831
9832 if (cfg_soundset_array.Count() > 0 && cfg_soundset_array.Count() == cfg_slot_array.Count())
9833 {
9834 for (int i = 0; i < cfg_soundset_array.Count(); i++)
9835 {
9836 if (cfg_slot_array[i] == slot_type)
9837 {
9838 soundset = cfg_soundset_array[i];
9839 break;
9840 }
9841 }
9842 }
9843
9844 if (soundset != "")
9845 {
9846 EffectSound sound = SEffectManager.PlaySound(soundset,
GetPosition());
9848 }
9849 }
9850 }
9851 }
9852
9854 {
9855
9856 }
9857
9858 void OnApply(PlayerBase player);
9859
9861 {
9862 return 1.0;
9863 };
9864
9866 {
9868 }
9869
9871 {
9873 }
9874
9876
9878 {
9879 SetDynamicPhysicsLifeTime(0.01);
9881 }
9882
9884 {
9885 array<string> zone_names = new array<string>;
9886 GetDamageZones(zone_names);
9887 for (int i = 0; i < zone_names.Count(); i++)
9888 {
9889 SetHealthMax(zone_names.Get(i),"Health");
9890 }
9891 SetHealthMax("","Health");
9892 }
9893
9896 {
9897 float global_health = GetHealth01("","Health");
9898 array<string> zones = new array<string>;
9899 GetDamageZones(zones);
9900
9901 for (int i = 0; i < zones.Count(); i++)
9902 {
9903 SetHealth01(zones.Get(i),"Health",global_health);
9904 }
9905 }
9906
9909 {
9910 return IsExclusionFlagPresent(PlayerBase.GetFaceCoverageShaveValues());
9911 }
9912
9914 {
9915 if (!hasRootAsPlayer)
9916 {
9917 if (refParentIB)
9918 {
9919
9920 if ((refParentIB.GetWet() >= GameConstants.STATE_SOAKING_WET) && (
m_VarWet <
m_VarWetMax))
9921 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_INSIDE);
9922
9923 else if ((refParentIB.GetLiquidType() != 0) && (refParentIB.GetQuantity() > 0) && (
m_VarWet <
m_VarWetMax))
9924 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_LIQUID);
9925
9928 }
9929 else
9930 {
9931
9934 }
9935 }
9936 }
9937
9939 {
9941 {
9942 float target =
g_Game.GetMission().GetWorldData().GetBaseEnvTemperatureAtObject(
this);
9943 if (
GetTemperature() != target || !IsFreezeThawProgressFinished())
9944 {
9945 float heatPermCoef = 1.0;
9947 while (ent)
9948 {
9949 heatPermCoef *= ent.GetHeatPermeabilityCoef();
9950 ent = ent.GetHierarchyParent();
9951 }
9952
9953 SetTemperatureEx(
new TemperatureDataInterpolated(target,
ETemperatureAccessTypes.ACCESS_WORLD,delta,GameConstants.TEMP_COEF_WORLD,heatPermCoef));
9954 }
9955 }
9956 }
9957
9959 {
9960
9961 EntityAI parent = GetHierarchyParent();
9962 if (!parent)
9963 {
9964 hasParent = false;
9965 hasRootAsPlayer = false;
9966 }
9967 else
9968 {
9969 hasParent = true;
9970 hasRootAsPlayer = (GetHierarchyRootPlayer() != null);
9971 refParentIB =
ItemBase.Cast(parent);
9972 }
9973 }
9974
9975 protected void ProcessDecay(
float delta,
bool hasRootAsPlayer)
9976 {
9977
9978 }
9979
9981 {
9982
9983 return false;
9984 }
9985
9987 {
9988
9989
9990 return false;
9991 }
9992
9994 {
9995
9996 return false;
9997 }
9998
10001 {
10002 return !GetIsFrozen() &&
IsOpen();
10003 }
10004
10006 {
10007 bool hasParent = false, hasRootAsPlayer = false;
10009
10010 bool wwtu =
g_Game.IsWorldWetTempUpdateEnabled();
10011 bool foodDecay =
g_Game.IsFoodDecayEnabled();
10012
10013 if (wwtu || foodDecay)
10014 {
10018
10019 if (processWetness || processTemperature || processDecay)
10020 {
10022
10023 if (processWetness)
10024 ProcessItemWetness(m_ElapsedSinceLastUpdate, hasParent, hasRootAsPlayer, refParentIB);
10025
10026 if (processTemperature)
10028
10029 if (processDecay)
10030 ProcessDecay(m_ElapsedSinceLastUpdate, hasRootAsPlayer);
10031 }
10032 }
10033 }
10034
10037 {
10039 }
10040
10042 {
10045
10046 return super.GetTemperatureFreezeThreshold();
10047 }
10048
10050 {
10053
10054 return super.GetTemperatureThawThreshold();
10055 }
10056
10058 {
10061
10062 return super.GetItemOverheatThreshold();
10063 }
10064
10066 {
10068 return Math.Lerp(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureFreezeTime()),
GetQuantityNormalized());
10069
10070 return super.GetTemperatureFreezeTime();
10071 }
10072
10074 {
10076 return Math.Lerp(GameConstants.TEMPERATURE_TIME_THAW_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureThawTime()),
GetQuantityNormalized());
10077
10078 return super.GetTemperatureThawTime();
10079 }
10080
10085
10087 {
10088 return (item.IsKindOf("Cauldron") || item.IsKindOf("Pot") || item.IsKindOf("FryingPan") || item.IsKindOf("SmallProtectorCase") || (item.IsKindOf("PortableGasStove") && item.FindAttachmentBySlotName("CookingEquipment")));
10089 }
10090
10092 {
10093 MiscGameplayFunctions.TransferItemProperties(oldItem, this);
10094 }
10095
10098 {
10100 }
10101
10103 {
10105 }
10106
10108 {
10110 }
10111
10114 {
10115 return null;
10116 }
10117
10120 {
10121 return false;
10122 }
10123
10125 {
10127 {
10130 if (!trg)
10131 {
10133 explosive = this;
10134 }
10135
10136 explosive.PairRemote(trg);
10138
10139 int persistentID = RemotelyActivatedItemBehaviour.GeneratePersistentID();
10140 trg.SetPersistentPairID(persistentID);
10141 explosive.SetPersistentPairID(persistentID);
10142
10143 return true;
10144 }
10145 return false;
10146 }
10147
10150 {
10151 float ret = 1.0;
10154 ret *= GetHealth01();
10155
10156 return ret;
10157 }
10158
10159 #ifdef DEVELOPER
10160 override void SetDebugItem()
10161 {
10162 super.SetDebugItem();
10163 _itemBase = this;
10164 }
10165
10167 {
10168 string text = super.GetDebugText();
10169
10171 text +=
string.
Format(
"Heat isolation(modified): %1\n", MiscGameplayFunctions.GetCurrentItemHeatIsolation(
this));
10172
10173 return text;
10174 }
10175 #endif
10176
10178 {
10179 return true;
10180 }
10181
10183
10185
10187 {
10190 }
10191
10192
10200
10216}
10217
10219{
10221 if (entity)
10222 {
10223 bool is_item = entity.IsInherited(
ItemBase);
10224 if (is_item && full_quantity)
10225 {
10228 }
10229 }
10230 else
10231 {
10233 return NULL;
10234 }
10235 return entity;
10236}
10237
10239{
10240 if (item)
10241 {
10242 if (health > 0)
10243 item.SetHealth("", "", health);
10244
10245 if (item.CanHaveTemperature())
10246 {
10248 if (item.CanFreeze())
10249 item.SetFrozen(false);
10250 }
10251
10252 if (item.HasEnergyManager())
10253 {
10254 if (quantity >= 0)
10255 {
10256 item.GetCompEM().SetEnergy0To1(quantity);
10257 }
10258 else
10259 {
10261 }
10262 }
10263 else if (item.IsMagazine())
10264 {
10265 Magazine mag = Magazine.Cast(item);
10266 if (quantity >= 0)
10267 {
10268 mag.ServerSetAmmoCount(mag.GetAmmoMax() * quantity);
10269 }
10270 else
10271 {
10273 }
10274
10275 }
10276 else
10277 {
10278 if (quantity >= 0)
10279 {
10280 item.SetQuantityNormalized(quantity, false);
10281 }
10282 else
10283 {
10285 }
10286
10287 }
10288 }
10289}
10290
10291#ifdef DEVELOPER
10293#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.