5436{
5438 {
5439 return true;
5440 }
5441};
5442
5443
5444
5446{
5450
5452
5455
5456
5457
5458
5459
5468
5474
5479
5484
5505 protected bool m_IsResultOfSplit
5506
5508
5513
5514
5515
5517
5521
5522
5523
5525
5528
5529
5530
5536
5537
5545
5548
5549
5551
5552
5554
5555
5560
5561
5566
5567
5569
5570
5572 {
5577
5578 if (!
GetGame().IsDedicatedServer())
5579 {
5581 {
5583
5585 {
5587 }
5588 }
5589
5592 }
5593
5594 m_OldLocation = null;
5595
5597 {
5599 }
5600
5601 if (ConfigIsExisting("headSelectionsToHide"))
5602 {
5605 }
5606
5608 if (ConfigIsExisting("hideSelectionsByinventorySlot"))
5609 {
5611 }
5612
5614
5615 m_IsResultOfSplit = false;
5616
5618 }
5619
5621 {
5622 super.InitItemVariables();
5623
5629 m_Count = ConfigGetInt(
"count");
5630
5633
5638
5641
5646
5658
5662
5663
5666 if (ConfigIsExisting("canBeSplit"))
5667 {
5670 }
5671
5673 if (ConfigIsExisting("itemBehaviour"))
5675
5676
5679 RegisterNetSyncVariableInt("m_VarLiquidType");
5680 RegisterNetSyncVariableInt("m_Cleanness",0,1);
5681
5682 RegisterNetSyncVariableBoolSignal("m_WantPlayImpactSound");
5683 RegisterNetSyncVariableFloat("m_ImpactSpeed");
5684 RegisterNetSyncVariableInt("m_ImpactSoundSurfaceHash");
5685
5686 RegisterNetSyncVariableInt("m_ColorComponentR", 0, 255);
5687 RegisterNetSyncVariableInt("m_ColorComponentG", 0, 255);
5688 RegisterNetSyncVariableInt("m_ColorComponentB", 0, 255);
5689 RegisterNetSyncVariableInt("m_ColorComponentA", 0, 255);
5690
5691 RegisterNetSyncVariableBool("m_IsBeingPlaced");
5692 RegisterNetSyncVariableBool("m_IsTakeable");
5693 RegisterNetSyncVariableBool("m_IsHologram");
5694
5697 {
5700 }
5701
5703
5705 if (ConfigIsExisting("temperaturePerQuantityWeight"))
5707
5708 }
5709
5711 {
5713 }
5714
5716 {
5719 {
5724 }
5725 }
5726
5727 override void GetActions(
typename action_input_type, out array<ActionBase_Basic> actions)
5728 {
5730 {
5733 }
5734
5736 }
5737
5739 {
5745 }
5746
5748
5750 {
5752
5753 if (!action)
5754 {
5755 Debug.LogError(
"Action " + actionName +
" dosn't exist!");
5756 return;
5757 }
5758
5760 if (!ai)
5761 {
5763 return;
5764 }
5765
5767 if (!action_array)
5768 {
5769 action_array = new array<ActionBase_Basic>;
5771 }
5772 if (LogManager.IsActionLogEnable())
5773 {
5774 Debug.ActionLog(action.ToString() +
" -> " + ai,
this.ToString() ,
"n/a",
"Add action");
5775 }
5776
5777 if (action_array.Find(action) != -1)
5778 {
5779 Debug.Log(
"Action " + action.Type() +
" already added to " +
this +
", skipping!");
5780 }
5781 else
5782 {
5783 action_array.Insert(action);
5784 }
5785 }
5786
5788 {
5790 ActionBase action = player.GetActionManager().GetAction(actionName);
5793
5794 if (action_array)
5795 {
5796 action_array.RemoveItem(action);
5797 }
5798 }
5799
5800
5801
5803 {
5804 ActionOverrideData overrideData = new ActionOverrideData();
5808
5810 if (!actionMap)
5811 {
5814 }
5815
5816 actionMap.Insert(this.
Type(), overrideData);
5817
5818 }
5819
5821
5823
5824
5826 {
5829
5832
5833 string config_to_search = "CfgVehicles";
5834 string muzzle_owner_config;
5835
5837 {
5838 if (IsInherited(Weapon))
5839 config_to_search = "CfgWeapons";
5840
5841 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
5842
5843 string config_OnFire_class = muzzle_owner_config + "Particles " + "OnFire ";
5844
5846
5847 if (config_OnFire_subclass_count > 0)
5848 {
5849 array<ref WeaponParticlesOnFire> WPOF_array = new array<ref WeaponParticlesOnFire>;
5850
5851 for (int i = 0; i < config_OnFire_subclass_count; i++)
5852 {
5853 string particle_class = "";
5855 string config_OnFire_entry = config_OnFire_class + particle_class;
5856 WeaponParticlesOnFire WPOF = new WeaponParticlesOnFire(this, config_OnFire_entry);
5857 WPOF_array.Insert(WPOF);
5858 }
5859
5860
5862 }
5863 }
5864
5866 {
5867 config_to_search = "CfgWeapons";
5868 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
5869
5870 string config_OnBulletCasingEject_class = muzzle_owner_config + "Particles " + "OnBulletCasingEject ";
5871
5873
5874 if (config_OnBulletCasingEject_count > 0 && IsInherited(Weapon))
5875 {
5876 array<ref WeaponParticlesOnBulletCasingEject> WPOBE_array = new array<ref WeaponParticlesOnBulletCasingEject>;
5877
5878 for (i = 0; i < config_OnBulletCasingEject_count; i++)
5879 {
5880 string particle_class2 = "";
5882 string config_OnBulletCasingEject_entry = config_OnBulletCasingEject_class + particle_class2;
5883 WeaponParticlesOnBulletCasingEject WPOBE = new WeaponParticlesOnBulletCasingEject(this, config_OnBulletCasingEject_entry);
5884 WPOBE_array.Insert(WPOBE);
5885 }
5886
5887
5889 }
5890 }
5891 }
5892
5893
5895 {
5898
5900 {
5901 string config_to_search = "CfgVehicles";
5902
5903 if (IsInherited(Weapon))
5904 config_to_search = "CfgWeapons";
5905
5906 string muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
5907 string config_OnOverheating_class = muzzle_owner_config + "Particles " + "OnOverheating ";
5908
5909 if (
GetGame().ConfigIsExisting(config_OnOverheating_class))
5910 {
5911
5913
5915 {
5917 string error =
"Error reading config " +
GetType() +
">Particles>OnOverheating - Parameter shotsToStartOverheating is configured wrong or is missing! Its value must be 1 or higher!";
5919 return;
5920 }
5921
5924
5925
5926
5928 array<ref WeaponParticlesOnOverheating> WPOOH_array = new array<ref WeaponParticlesOnOverheating>;
5929
5930 for (int i = 0; i < config_OnOverheating_subclass_count; i++)
5931 {
5932 string particle_class = "";
5934 string config_OnOverheating_entry = config_OnOverheating_class + particle_class;
5936
5937 if (entry_type == CT_CLASS)
5938 {
5939 WeaponParticlesOnOverheating WPOF = new WeaponParticlesOnOverheating(this, config_OnOverheating_entry);
5940 WPOOH_array.Insert(WPOF);
5941 }
5942 }
5943
5944
5946 }
5947 }
5948 }
5949
5951 {
5953 }
5954
5956 {
5958 {
5960
5963
5966
5967 CheckOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
5968 }
5969 }
5970
5972 {
5974 UpdateOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
5975
5977 StartOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
5978
5980 StopOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
5981
5983 {
5985 }
5986 }
5987
5989 {
5991 }
5992
5994 {
5997 else
5999
6001 {
6004 }
6005 else
6006 {
6009
6012 }
6013
6015 }
6016
6018 {
6020 ItemBase.PlayOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
6021 }
6022
6024 {
6026 ItemBase.UpdateOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
6028 }
6029
6031 {
6033 ItemBase.StopOverheatingParticles(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
6034 }
6035
6037 {
6040
6041 OverheatingParticle OP = new OverheatingParticle();
6046
6048 }
6049
6051 {
6054
6055 return -1;
6056 }
6057
6059 {
6061 {
6064
6065 for (int i = count; i > 0; --i)
6066 {
6067 int id = i - 1;
6070
6073
6074 if (overheat_coef < overheat_min && overheat_coef >= overheat_max)
6075 {
6076 if (p)
6077 {
6080 }
6081 }
6082 }
6083 }
6084 }
6085
6087 {
6089 {
6091 {
6092 int id = i - 1;
6094
6095 if (OP)
6096 {
6098
6099 if (p)
6100 {
6102 }
6103
6104 delete OP;
6105 }
6106 }
6107
6110 }
6111 }
6112
6115 {
6116 return 0.0;
6117 }
6118
6119
6121 {
6122 return 250;
6123 }
6124
6126 {
6127 return 0;
6128 }
6129
6132 {
6134 return true;
6135
6136 return false;
6137 }
6138
6141 {
6144
6146 {
6148 }
6149 else
6150 {
6151
6153 }
6154
6156 }
6157
6164 {
6165 return -1;
6166 }
6167
6168
6169
6170
6172 {
6174 {
6176 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
6177
6178 if (r_index >= 0)
6179 {
6180 InventoryLocation r_il = new InventoryLocation;
6181 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
6182
6183 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
6186 {
6187 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
6188 }
6190 {
6191 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
6192 }
6193
6194 }
6195
6196 player.GetHumanInventory().ClearUserReservedLocation(this);
6197 }
6198
6201 }
6202
6203
6204
6205
6207 {
6208 return ItemBase.m_DebugActionsMask;
6209 }
6210
6212 {
6213 return ItemBase.m_DebugActionsMask & mask;
6214 }
6215
6217 {
6218 ItemBase.m_DebugActionsMask = mask;
6219 }
6220
6222 {
6223 ItemBase.m_DebugActionsMask |= mask;
6224 }
6225
6227 {
6228 ItemBase.m_DebugActionsMask &= ~mask;
6229 }
6230
6232 {
6234 {
6236 }
6237 else
6238 {
6240 }
6241 }
6242
6243
6245 {
6246 if (GetEconomyProfile())
6247 {
6248 float q_max = GetEconomyProfile().GetQuantityMax();
6249 if (q_max > 0)
6250 {
6251 float q_min = GetEconomyProfile().GetQuantityMin();
6252 float quantity_randomized = Math.RandomFloatInclusive(q_min, q_max);
6253
6255 {
6256 ComponentEnergyManager comp = GetCompEM();
6258 {
6260 }
6261 }
6263 {
6265
6266 }
6267
6268 }
6269 }
6270 }
6271
6274 {
6275 EntityAI parent = GetHierarchyParent();
6276
6277 if (parent)
6278 {
6279 InventoryLocation inventory_location_to_lock = new InventoryLocation;
6280 GetInventory().GetCurrentInventoryLocation(inventory_location_to_lock);
6281 parent.GetInventory().SetSlotLock(inventory_location_to_lock.
GetSlot(),
true);
6282 }
6283 }
6284
6287 {
6288 EntityAI parent = GetHierarchyParent();
6289
6290 if (parent)
6291 {
6292 InventoryLocation inventory_location_to_unlock = new InventoryLocation;
6293 GetInventory().GetCurrentInventoryLocation(inventory_location_to_unlock);
6294 parent.GetInventory().SetSlotLock(inventory_location_to_unlock.
GetSlot(),
false);
6295 }
6296 }
6297
6299 {
6300
6301
6302
6303
6305
6307 {
6308 if (ScriptInputUserData.CanStoreInputUserData())
6309 {
6310 ScriptInputUserData ctx = new ScriptInputUserData;
6316 ctx.
Write(use_stack_max);
6319
6321 {
6322 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(item2,null,GameInventory.c_InventoryReservationTimeoutShortMS);
6323 }
6324 }
6325 }
6326 else if (!
GetGame().IsMultiplayer())
6327 {
6329 }
6330 }
6331
6333 {
6335 }
6336
6338 {
6340 }
6341
6343 {
6345 }
6346
6348 {
6349
6350 return false;
6351 }
6352
6354 {
6355 return false;
6356 }
6357
6361 {
6362 return false;
6363 }
6364
6366 {
6367 return "";
6368 }
6369
6371
6373 {
6374 return false;
6375 }
6376
6378 {
6379 return true;
6380 }
6381
6382
6383
6385 {
6386 return true;
6387 }
6388
6390 {
6391 return true;
6392 }
6393
6395 {
6396 PlayerBase player = PlayerBase.Cast(
g_Game.GetPlayer());
6398 }
6399
6401 {
6403 }
6404
6406 {
6408 if (!is_being_placed)
6410 SetSynchDirty();
6411 }
6412
6413
6415
6417 {
6419 }
6420
6422 {
6424 }
6425
6427 {
6428 return 1;
6429 }
6430
6432 {
6433 return false;
6434 }
6435
6437 {
6439 SetSynchDirty();
6440 }
6441
6442
6443
6444
6445
6446
6447
6448
6449
6450
6451
6452
6453
6454
6455
6456
6457
6458
6459
6460
6461
6462
6463
6464
6465
6466
6467
6468
6469
6470
6471
6472
6473
6474
6475
6477 {
6478 super.OnMovedInsideCargo(container);
6479
6480 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
6481 }
6482
6483 override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
6484 {
6485 super.EEItemLocationChanged(oldLoc,newLoc);
6486
6487 PlayerBase new_player = null;
6488 PlayerBase old_player = null;
6489
6490 if (newLoc.GetParent())
6491 new_player = PlayerBase.Cast(newLoc.GetParent().GetHierarchyRootPlayer());
6492
6493 if (oldLoc.GetParent())
6494 old_player = PlayerBase.Cast(oldLoc.GetParent().GetHierarchyRootPlayer());
6495
6497 {
6498 int r_index = old_player.GetHumanInventory().FindUserReservedLocationIndex(this);
6499
6500 if (r_index >= 0)
6501 {
6502 InventoryLocation r_il = new InventoryLocation;
6503 old_player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
6504
6505 old_player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
6508 {
6509 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
6510 }
6512 {
6513 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
6514 }
6515
6516 }
6517 }
6518
6520 {
6521 if (new_player)
6522 new_player.ForceStandUpForHeavyItems(newLoc.GetItem());
6523
6524 if (new_player == old_player)
6525 {
6526
6527 if (oldLoc.GetParent() && new_player.GetHumanInventory().LocationGetEntity(oldLoc) == NULL)
6528 {
6530 {
6531 if (oldLoc.GetParent().GetInventory().TestAddEntityInCargoExLoc(oldLoc, false, false, false, true, false, false))
6532 {
6533 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
6534 }
6535 }
6536 else
6537 {
6538 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
6539 }
6540 }
6541
6542 if (new_player.GetHumanInventory().FindUserReservedLocationIndex(this) >= 0)
6543 {
6544 int type = oldLoc.GetType();
6546 {
6547 oldLoc.GetParent().GetOnSetLock().Invoke(this);
6548 }
6550 {
6551 oldLoc.GetParent().GetOnAttachmentSetLock().Invoke(this, oldLoc.GetSlot());
6552 }
6553 }
6554 if (!m_OldLocation)
6555 {
6556 m_OldLocation = new InventoryLocation;
6557 }
6558 m_OldLocation.Copy(oldLoc);
6559 }
6560 else
6561 {
6562 if (m_OldLocation)
6563 {
6564 m_OldLocation.Reset();
6565 }
6566 }
6567
6569 }
6570 else
6571 {
6572 if (new_player)
6573 {
6574 int res_index = new_player.GetHumanInventory().FindCollidingUserReservedLocationIndex(this, newLoc);
6575 if (res_index >= 0)
6576 {
6577 InventoryLocation il = new InventoryLocation;
6578 new_player.GetHumanInventory().GetUserReservedLocation(res_index,il);
6580 new_player.GetHumanInventory().ClearUserReservedLocationAtIndex(res_index);
6583 {
6584 il.
GetParent().GetOnReleaseLock().Invoke(it);
6585 }
6587 {
6589 }
6590
6591 }
6592 }
6594 {
6595
6597 }
6598
6599 if (m_OldLocation)
6600 {
6601 m_OldLocation.Reset();
6602 }
6603 }
6604 }
6605
6606 override void EOnContact(IEntity other, Contact extra)
6607 {
6609 {
6610 int liquidType = -1;
6612 if (impactSpeed > 0.0)
6613 {
6615 #ifndef SERVER
6617 #else
6619 SetSynchDirty();
6620 #endif
6622 }
6623 }
6624
6625 #ifdef SERVER
6626 if (GetCompEM() && GetCompEM().IsPlugged())
6627 {
6628 if (GetCompEM().GetCordLength() < vector.Distance(
GetPosition(), GetCompEM().GetEnergySource().
GetPosition()))
6629 GetCompEM().UnplugThis();
6630 }
6631 #endif
6632 }
6633
6635
6637 {
6639 }
6640
6642 {
6643
6644 }
6645
6647 {
6648 super.OnItemLocationChanged(old_owner, new_owner);
6649
6650 PlayerBase relatedPlayer = PlayerBase.Cast(old_owner);
6651 PlayerBase playerNew = PlayerBase.Cast(new_owner);
6652
6653 if (!relatedPlayer && playerNew)
6654 relatedPlayer = playerNew;
6655
6656 if (relatedPlayer && relatedPlayer.GetPerformedActionID() != -1)
6657 {
6659 if (actionMgr)
6660 {
6661 ActionBase currentAction = actionMgr.GetRunningAction();
6662 if (currentAction)
6664 }
6665 }
6666
6667 Man ownerPlayerOld = null;
6668 Man ownerPlayerNew = null;
6669
6670 if (old_owner)
6671 {
6672 if (old_owner.
IsMan())
6673 {
6674 ownerPlayerOld = Man.Cast(old_owner);
6675 }
6676 else
6677 {
6678 ownerPlayerOld = Man.Cast(old_owner.GetHierarchyRootPlayer());
6679 }
6680 }
6681 else
6682 {
6684 {
6686
6687 if (!action || !playerNew || playerNew.GetPerformedActionID() != action.
GetID())
6688 {
6689 GetCompEM().UnplugThis();
6690 }
6691 }
6692 }
6693
6694 if (new_owner)
6695 {
6696 if (new_owner.
IsMan())
6697 {
6698 ownerPlayerNew = Man.Cast(new_owner);
6699 }
6700 else
6701 {
6702 ownerPlayerNew = Man.Cast(new_owner.GetHierarchyRootPlayer());
6703 }
6704 }
6705
6706 if (ownerPlayerOld != ownerPlayerNew)
6707 {
6708 if (ownerPlayerOld)
6709 {
6710 array<EntityAI> subItemsExit = new array<EntityAI>;
6712 for (int i = 0; i < subItemsExit.Count(); i++)
6713 {
6716 }
6717 }
6718
6719 if (ownerPlayerNew)
6720 {
6721 array<EntityAI> subItemsEnter = new array<EntityAI>;
6723 for (int j = 0; j < subItemsEnter.Count(); j++)
6724 {
6727 }
6728 }
6729 }
6730 else if (ownerPlayerNew != null)
6731 {
6732 PlayerBase nplayer;
6733 if (PlayerBase.CastTo(nplayer, ownerPlayerNew))
6734 {
6735 array<EntityAI> subItemsUpdate = new array<EntityAI>;
6737 for (int k = 0; k < subItemsUpdate.Count(); k++)
6738 {
6740 itemUpdate.UpdateQuickbarShortcutVisibility(nplayer);
6741 }
6742 }
6743 }
6744
6745 if (old_owner)
6746 old_owner.OnChildItemRemoved(this);
6747 if (new_owner)
6748 new_owner.OnChildItemReceived(this);
6749 }
6750
6751
6753 {
6754 super.EEDelete(parent);
6755 PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
6756 if (player)
6757 {
6759
6760 if (player.IsAlive())
6761 {
6762 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
6763 if (r_index >= 0)
6764 {
6765 InventoryLocation r_il = new InventoryLocation;
6766 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
6767
6768 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
6771 {
6772 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
6773 }
6775 {
6776 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
6777 }
6778
6779 }
6780
6781 player.RemoveQuickBarEntityShortcut(this);
6782 }
6783 }
6784 }
6785
6787 {
6788 super.EEKilled(killer);
6789
6792 {
6793 if (
GetTemperature() >= GameConstants.ITEM_TEMPERATURE_TO_EXPLODE_MIN)
6794 {
6795 if (IsMagazine())
6796 {
6797 if (Magazine.Cast(this).GetAmmoCount() > 0)
6798 {
6800 }
6801 }
6802 else
6803 {
6805 }
6806 }
6807 }
6808 }
6809
6811 {
6812 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
6813
6814 super.OnWasAttached(parent, slot_id);
6815
6818
6820 }
6821
6823 {
6824 super.OnWasDetached(parent, slot_id);
6825
6828 }
6829
6831 {
6832 int idx;
6835
6836 ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
6837 if (inventory_slots.Count() < 1)
6838 {
6839 inventory_slots.Insert(ConfigGetString("ChangeInventorySlot"));
6840 attach_types.Insert(ConfigGetString("ChangeIntoOnAttach"));
6841 }
6842 else
6843 {
6844 ConfigGetTextArray("ChangeIntoOnAttach",attach_types);
6845 }
6846
6847 idx = inventory_slots.Find(slot);
6848 if (idx < 0)
6849 return "";
6850
6851 return attach_types.Get(idx);
6852 }
6853
6855 {
6856 int idx = -1;
6857 string slot;
6858
6861
6862 this.ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
6863 if (inventory_slots.Count() < 1)
6864 {
6865 inventory_slots.Insert(this.ConfigGetString("ChangeInventorySlot"));
6866 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
6867 }
6868 else
6869 {
6870 this.ConfigGetTextArray("ChangeIntoOnDetach",detach_types);
6871 if (detach_types.Count() < 1)
6872 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
6873 }
6874
6875 for (int i = 0; i < inventory_slots.Count(); i++)
6876 {
6877 slot = inventory_slots.Get(i);
6878 }
6879
6880 if (slot != "")
6881 {
6882 if (detach_types.Count() == 1)
6883 idx = 0;
6884 else
6885 idx = inventory_slots.Find(slot);
6886 }
6887 if (idx < 0)
6888 return "";
6889
6890 return detach_types.Get(idx);
6891 }
6892
6894 {
6895
6897
6898
6899 float min_time = 1;
6900 float max_time = 3;
6901 float delay = Math.RandomFloat(min_time, max_time);
6902
6903 explode_timer.Run(delay, this, "DoAmmoExplosion");
6904 }
6905
6907 {
6908 Magazine magazine = Magazine.Cast(this);
6909 int pop_sounds_count = 6;
6910 string pop_sounds[ 6 ] = { "ammopops_1","ammopops_2","ammopops_3","ammopops_4","ammopops_5","ammopops_6" };
6911
6912
6913 int sound_idx = Math.RandomInt(0, pop_sounds_count - 1);
6914 string sound_name = pop_sounds[ sound_idx ];
6916
6917
6918 magazine.ServerAddAmmoCount(-1);
6919
6920
6921 float min_temp_to_explode = 100;
6922
6923 if (magazine.GetAmmoCount() > 0 &&
GetTemperature() >= min_temp_to_explode)
6924 {
6926 }
6927 }
6928
6929
6930 override void EEHitBy(TotalDamageResult damageResult,
int damageType,
EntityAI source,
int component,
string dmgZone,
string ammo, vector modelPos,
float speedCoef)
6931 {
6932 super.EEHitBy(damageResult, damageType, source,
component, dmgZone, ammo, modelPos, speedCoef);
6933
6934 const int CHANCE_DAMAGE_CARGO = 4;
6935 const int CHANCE_DAMAGE_ATTACHMENT = 1;
6936 const int CHANCE_DAMAGE_NOTHING = 2;
6937
6939 {
6940 float dmg = damageResult.
GetDamage(
"",
"Health") * -0.5;
6941 int chances;
6942 int rnd;
6943
6944 if (GetInventory().GetCargo())
6945 {
6946 chances = CHANCE_DAMAGE_CARGO + CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
6947 rnd = Math.RandomInt(0,chances);
6948
6949 if (rnd < CHANCE_DAMAGE_CARGO)
6950 {
6952 }
6953 else if (rnd < (chances - CHANCE_DAMAGE_NOTHING))
6954 {
6956 }
6957 }
6958 else
6959 {
6960 chances = CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
6961 rnd = Math.RandomInt(0,chances);
6962
6963 if (rnd < CHANCE_DAMAGE_ATTACHMENT)
6964 {
6966 }
6967 }
6968 }
6969 }
6970
6972 {
6973 if (GetInventory().GetCargo())
6974 {
6975 int item_count = GetInventory().GetCargo().GetItemCount();
6976 if (item_count > 0)
6977 {
6978 int random_pick = Math.RandomInt(0, item_count);
6980 if (!item.IsExplosive())
6981 {
6982 item.AddHealth("","",damage);
6983 return true;
6984 }
6985 }
6986 }
6987 return false;
6988 }
6989
6991 {
6992 int attachment_count = GetInventory().AttachmentCount();
6993 if (attachment_count > 0)
6994 {
6995 int random_pick = Math.RandomInt(0, attachment_count);
6996 ItemBase attachment =
ItemBase.Cast(GetInventory().GetAttachmentFromIndex(random_pick));
6997 if (!attachment.IsExplosive())
6998 {
6999 attachment.AddHealth("","",damage);
7000 return true;
7001 }
7002 }
7003 return false;
7004 }
7005
7007 {
7009 }
7010
7012 {
7014 return GetInventory().CanRemoveEntity();
7015
7016 return false;
7017 }
7018
7020 {
7021
7023 return false;
7024
7025
7027 return false;
7028
7029
7030
7032 if (delta == 0)
7033 return false;
7034
7035
7036 return true;
7037 }
7038
7040 {
7042 {
7043 if (ScriptInputUserData.CanStoreInputUserData())
7044 {
7045 ScriptInputUserData ctx = new ScriptInputUserData;
7050 ctx.
Write(destination_entity);
7054 }
7055 }
7056 else if (!
GetGame().IsMultiplayer())
7057 {
7059 }
7060 }
7061
7063 {
7064 float split_quantity_new;
7068 InventoryLocation loc = new InventoryLocation;
7069
7070 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
7071 {
7073 split_quantity_new = stack_max;
7074 else
7076
7078 {
7079 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
7080 if (new_item)
7081 {
7082 new_item.SetResultOfSplit(true);
7083 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7085 new_item.
SetQuantity(split_quantity_new,
false,
true);
7086 }
7087 }
7088 }
7089 else if (destination_entity && slot_id == -1)
7090 {
7091 if (quantity > stack_max)
7092 split_quantity_new = stack_max;
7093 else
7094 split_quantity_new = quantity;
7095
7097 {
7099 {
7102 }
7103
7104 if (new_item)
7105 {
7106 new_item.SetResultOfSplit(true);
7107 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7109 new_item.
SetQuantity(split_quantity_new,
false,
true);
7110 }
7111 }
7112 }
7113 else
7114 {
7115 if (stack_max != 0)
7116 {
7118 {
7120 }
7121
7122 if (split_quantity_new == 0)
7123 {
7124 if (!
GetGame().IsMultiplayer())
7125 player.PhysicalPredictiveDropItem(this);
7126 else
7127 player.ServerDropEntity(this);
7128 return;
7129 }
7130
7132 {
7134
7135 if (new_item)
7136 {
7137 new_item.SetResultOfSplit(true);
7138 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7141 new_item.PlaceOnSurface();
7142 }
7143 }
7144 }
7145 }
7146 }
7147
7149 {
7150 float split_quantity_new;
7154 InventoryLocation loc = new InventoryLocation;
7155
7156 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
7157 {
7159 split_quantity_new = stack_max;
7160 else
7162
7164 {
7165 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
7166 if (new_item)
7167 {
7168 new_item.SetResultOfSplit(true);
7169 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7171 new_item.
SetQuantity(split_quantity_new,
false,
true);
7172 }
7173 }
7174 }
7175 else if (destination_entity && slot_id == -1)
7176 {
7177 if (quantity > stack_max)
7178 split_quantity_new = stack_max;
7179 else
7180 split_quantity_new = quantity;
7181
7183 {
7185 {
7188 }
7189
7190 if (new_item)
7191 {
7192 new_item.SetResultOfSplit(true);
7193 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7195 new_item.
SetQuantity(split_quantity_new,
false,
true);
7196 }
7197 }
7198 }
7199 else
7200 {
7201 if (stack_max != 0)
7202 {
7204 {
7206 }
7207
7209 {
7211
7212 if (new_item)
7213 {
7214 new_item.SetResultOfSplit(true);
7215 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7218 new_item.PlaceOnSurface();
7219 }
7220 }
7221 }
7222 }
7223 }
7224
7226 {
7228 {
7229 if (ScriptInputUserData.CanStoreInputUserData())
7230 {
7231 ScriptInputUserData ctx = new ScriptInputUserData;
7236 dst.WriteToContext(ctx);
7238 }
7239 }
7240 else if (!
GetGame().IsMultiplayer())
7241 {
7243 }
7244 }
7245
7247 {
7249 {
7250 if (ScriptInputUserData.CanStoreInputUserData())
7251 {
7252 ScriptInputUserData ctx = new ScriptInputUserData;
7257 ctx.
Write(destination_entity);
7263 }
7264 }
7265 else if (!
GetGame().IsMultiplayer())
7266 {
7268 }
7269 }
7270
7272 {
7274 }
7275
7277 {
7279 float split_quantity_new;
7281 if (dst.IsValid())
7282 {
7283 int slot_id = dst.GetSlot();
7285
7286 if (quantity > stack_max)
7287 split_quantity_new = stack_max;
7288 else
7289 split_quantity_new = quantity;
7290
7292 {
7294
7295 if (new_item)
7296 {
7297 new_item.SetResultOfSplit(true);
7298 MiscGameplayFunctions.TransferItemProperties(this,new_item);
7300 new_item.
SetQuantity(split_quantity_new,
false,
true);
7301 }
7302
7303 return new_item;
7304 }
7305 }
7306
7307 return null;
7308 }
7309
7311 {
7313 float split_quantity_new;
7315 if (destination_entity)
7316 {
7318 if (quantity > stackable)
7319 split_quantity_new = stackable;
7320 else
7321 split_quantity_new = quantity;
7322
7324 {
7325 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateEntityInCargoEx(
this.GetType(), idx, row, col,
false));
7326 if (new_item)
7327 {
7328 new_item.SetResultOfSplit(true);
7329 MiscGameplayFunctions.TransferItemProperties(this,new_item);
7331 new_item.
SetQuantity(split_quantity_new,
false,
true);
7332 }
7333 }
7334 }
7335 }
7336
7338 {
7340 {
7341 if (ScriptInputUserData.CanStoreInputUserData())
7342 {
7343 ScriptInputUserData ctx = new ScriptInputUserData;
7348 ItemBase destination_entity =
this;
7349 ctx.
Write(destination_entity);
7353 }
7354 }
7355 else if (!
GetGame().IsMultiplayer())
7356 {
7358 }
7359 }
7360
7362 {
7364 float split_quantity_new;
7366 if (player)
7367 {
7369 if (quantity > stackable)
7370 split_quantity_new = stackable;
7371 else
7372 split_quantity_new = quantity;
7373
7375 {
7376 EntityAI in_hands = player.GetHumanInventory().CreateInHands(this.
GetType());
7377 new_item =
ItemBase.Cast(in_hands);
7378 if (new_item)
7379 {
7380 new_item.SetResultOfSplit(true);
7381 MiscGameplayFunctions.TransferItemProperties(this,new_item);
7383 new_item.SetQuantity(split_quantity_new, false, true);
7384 }
7385 }
7386 }
7387 }
7388
7390 {
7392 float split_quantity_new = Math.Floor(quantity * 0.5);
7393
7395 return;
7396
7398
7399 if (new_item)
7400 {
7401 if (new_item.GetQuantityMax() < split_quantity_new)
7402 {
7403 split_quantity_new = new_item.GetQuantityMax();
7404 }
7405
7406 new_item.SetResultOfSplit(true);
7407 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7408
7410 {
7413 }
7414 else
7415 {
7417 new_item.
SetQuantity(split_quantity_new,
false,
true);
7418 }
7419 }
7420 }
7421
7423 {
7425 float split_quantity_new = Math.Floor(quantity / 2);
7426
7428 return;
7429
7430 InventoryLocation invloc = new InventoryLocation;
7432
7434 new_item = player.CreateCopyOfItemInInventoryOrGroundEx(this, true);
7435
7436 if (new_item)
7437 {
7438 if (new_item.GetQuantityMax() < split_quantity_new)
7439 {
7440 split_quantity_new = new_item.GetQuantityMax();
7441 }
7443 {
7446 }
7447 else if (split_quantity_new > 1)
7448 {
7450 new_item.
SetQuantity(split_quantity_new,
false,
true);
7451 }
7452 }
7453 }
7454
7457 {
7458 SetWeightDirty();
7460
7461 if (parent)
7462 parent.OnAttachmentQuantityChangedEx(this, delta);
7463
7465 {
7467 {
7469 }
7471 {
7472 ErrorEx(
"Undefined liquid type quantity changed, please define liquid type first! Using init value.",
ErrorExSeverity.INFO);
7474 }
7475 }
7476
7477 }
7478
7481 {
7482
7483 }
7484
7487 {
7489 }
7490
7492 {
7493 super.EEHealthLevelChanged(oldLevel,newLevel,zone);
7494
7496 {
7497 if (newLevel == GameConstants.STATE_RUINED)
7498 {
7500 EntityAI parent = GetHierarchyParent();
7501 if (parent && parent.IsFireplace())
7502 {
7503 CargoBase cargo = GetInventory().GetCargo();
7504 if (cargo)
7505 {
7507 {
7509 }
7510 }
7511 }
7512 }
7513
7515 {
7516
7518 return;
7519 }
7520
7521 if (
m_Cleanness != 0 && oldLevel < newLevel && newLevel != 0)
7522 {
7524 }
7525 }
7526 }
7527
7528
7530 {
7531 super.OnRightClick();
7532
7534 {
7536 {
7537 if (ScriptInputUserData.CanStoreInputUserData())
7538 {
7539 EntityAI root = GetHierarchyRoot();
7540 Man playerOwner = GetHierarchyRootPlayer();
7541 InventoryLocation dst = new InventoryLocation;
7542
7543
7544 if (!playerOwner && root && root == this)
7545 {
7547 }
7548 else
7549 {
7550
7551 GetInventory().GetCurrentInventoryLocation(dst);
7553 {
7556 {
7558 }
7559 else
7560 {
7562
7563
7564 if (
GetGame().
GetPlayer().GetInventory().HasInventoryReservation(
this, dst))
7565 {
7567 }
7568 else
7569 {
7570 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(null, dst, GameInventory.c_InventoryReservationTimeoutShortMS);
7571 }
7572 }
7573 }
7574 }
7575
7576 ScriptInputUserData ctx = new ScriptInputUserData;
7584 }
7585 }
7586 else if (!
GetGame().IsMultiplayer())
7587 {
7589 }
7590 }
7591 }
7592
7594 {
7595 if (root)
7596 {
7597 vector m4[4];
7598 root.GetTransform(m4);
7599 dst.SetGround(this, m4);
7600 }
7601 else
7602 {
7603 GetInventory().GetCurrentInventoryLocation(dst);
7604 }
7605 }
7606
7607 override bool CanBeCombined(
EntityAI other_item,
bool reservation_check =
true,
bool stack_max_limit =
false)
7608 {
7609
7610 if (!other_item ||
GetType() != other_item.GetType() || (
IsFullQuantity() && other_item.GetQuantity() > 0) || other_item ==
this)
7611 return false;
7612
7613 if (GetHealthLevel() == GameConstants.STATE_RUINED || other_item.GetHealthLevel() == GameConstants.STATE_RUINED)
7614 return false;
7615
7616
7618 return false;
7619
7620
7621 Magazine mag = Magazine.Cast(this);
7622 if (mag)
7623 {
7624 if (mag.GetAmmoCount() >= mag.GetAmmoMax())
7625 return false;
7626
7627 if (stack_max_limit)
7628 {
7629 Magazine other_mag = Magazine.Cast(other_item);
7630 if (other_item)
7631 {
7632 if (mag.GetAmmoCount() + other_mag.GetAmmoCount() > mag.GetAmmoMax())
7633 return false;
7634 }
7635
7636 }
7637 }
7638 else
7639 {
7640
7642 return false;
7643
7645 return false;
7646 }
7647
7648 PlayerBase player = null;
7649 if (CastTo(player, GetHierarchyRootPlayer()))
7650 {
7651 if (player.GetInventory().HasAttachment(this))
7652 return false;
7653
7654 if (player.IsItemsToDelete())
7655 return false;
7656 }
7657
7658 if (reservation_check && (GetInventory().HasInventoryReservation(this, null) || other_item.GetInventory().HasInventoryReservation(other_item, null)))
7659 return false;
7660
7661 int slotID;
7663 if (GetInventory().GetCurrentAttachmentSlotInfo(slotID,
slotName) && GetHierarchyParent().GetInventory().GetSlotLock(slotID))
7664 return false;
7665
7666 return true;
7667 }
7668
7670 {
7672 }
7673
7675 {
7676 return m_IsResultOfSplit;
7677 }
7678
7680 {
7681 m_IsResultOfSplit = value;
7682 }
7683
7685 {
7687 }
7688
7690 {
7691 float other_item_quantity = other_item.GetQuantity();
7692 float this_free_space;
7693
7695
7697
7698 if (other_item_quantity > this_free_space)
7699 {
7700 return this_free_space;
7701 }
7702 else
7703 {
7704 return other_item_quantity;
7705 }
7706 }
7707
7709 {
7711 }
7712
7714 {
7716 return;
7717
7718 if (!IsMagazine() && other_item)
7719 {
7721 if (quantity_used != 0)
7722 {
7723 float hp1 = GetHealth01("","");
7724 float hp2 = other_item.GetHealth01("","");
7725 float hpResult = ((hp1*
GetQuantity()) + (hp2*quantity_used));
7726 hpResult = hpResult / (
GetQuantity() + quantity_used);
7727
7728 hpResult *= GetMaxHealth();
7729 Math.Round(hpResult);
7730 SetHealth("", "Health", hpResult);
7731
7733 other_item.AddQuantity(-quantity_used);
7734 }
7735 }
7737 }
7738
7740 {
7741 #ifdef SERVER
7742 if (!GetHierarchyRootPlayer() && GetHierarchyParent())
7743 GetHierarchyParent().IncreaseLifetimeUp();
7744 #endif
7745 };
7746
7748 {
7749 PlayerBase p = PlayerBase.Cast(player);
7750
7751 array<int> recipesIds = p.m_Recipes;
7752 PluginRecipesManager moduleRecipesManager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
7753 if (moduleRecipesManager)
7754 {
7755 EntityAI itemInHands = player.GetHumanInventory().GetEntityInHands();
7756 moduleRecipesManager.GetValidRecipes(
ItemBase.Cast(
this),
ItemBase.Cast(itemInHands), recipesIds, p);
7757 }
7758
7759 for (int i = 0;i < recipesIds.Count(); i++)
7760 {
7761 int key = recipesIds.Get(i);
7762 string recipeName = moduleRecipesManager.GetRecipeName(key);
7764 }
7765 }
7766
7767
7768 override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
7769 {
7770 super.GetDebugActions(outputList);
7771
7772
7778
7779
7784
7789
7790
7794
7795
7797 {
7801 }
7802
7805
7806
7810
7812
7813 InventoryLocation loc = new InventoryLocation();
7814 GetInventory().GetCurrentInventoryLocation(loc);
7816 {
7817 if (Gizmo_IsSupported())
7820 }
7821
7823 }
7824
7825
7826
7827
7829 {
7830 super.OnAction(action_id, player, ctx);
7831
7833 {
7834 switch (action_id)
7835 {
7838 return true;
7841 return true;
7842 }
7843 }
7844
7846 {
7847 switch (action_id)
7848 {
7850 Delete();
7851 return true;
7852 }
7853 }
7854
7855 if (action_id >=
EActions.RECIPES_RANGE_START && action_id <
EActions.RECIPES_RANGE_END)
7856 {
7857 PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
7858 int idWithoutOffset = action_id -
EActions.RECIPES_RANGE_START;
7859 PlayerBase p = PlayerBase.Cast(player);
7860 if (
EActions.RECIPES_RANGE_START < 1000)
7861 {
7862 float anim_length = plugin_recipes_manager.GetRecipeLengthInSecs(idWithoutOffset);
7863 float specialty_weight = plugin_recipes_manager.GetRecipeSpecialty(idWithoutOffset);
7864 }
7865 }
7866 #ifndef SERVER
7867 else if (action_id ==
EActions.WATCH_PLAYER)
7868 {
7869 PluginDeveloper.SetDeveloperItemClientEx(player);
7870 }
7871 #endif
7873 {
7874 if (action_id >=
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START && action_id <
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_END)
7875 {
7876 int id = action_id -
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START;
7877 OnDebugButtonPressServer(id + 1);
7878 }
7879
7880 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_INJECT_START && action_id <
EActions.DEBUG_AGENTS_RANGE_INJECT_END)
7881 {
7882 int agent_id = action_id -
EActions.DEBUG_AGENTS_RANGE_INJECT_START;
7884 }
7885
7886 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_REMOVE_START && action_id <
EActions.DEBUG_AGENTS_RANGE_REMOVE_END)
7887 {
7888 int agent_id2 = action_id -
EActions.DEBUG_AGENTS_RANGE_REMOVE_START;
7890 }
7891
7892 else if (action_id ==
EActions.ADD_QUANTITY)
7893 {
7894 if (IsMagazine())
7895 {
7896 Magazine mag = Magazine.Cast(this);
7897 mag.ServerSetAmmoCount(mag.GetAmmoCount() + mag.GetAmmoMax() * 0.2);
7898 }
7899 else
7900 {
7902 }
7903
7904 if (m_EM)
7905 {
7906 m_EM.AddEnergy(m_EM.GetEnergyMax() * 0.2);
7907 }
7908
7909 }
7910
7911 else if (action_id ==
EActions.REMOVE_QUANTITY)
7912 {
7913 if (IsMagazine())
7914 {
7915 Magazine mag2 = Magazine.Cast(this);
7916 mag2.ServerSetAmmoCount(mag2.GetAmmoCount() - mag2.GetAmmoMax() * 0.2);
7917 }
7918 else
7919 {
7921 }
7922 if (m_EM)
7923 {
7924 m_EM.AddEnergy(- m_EM.GetEnergyMax() * 0.2);
7925 }
7926
7927 }
7928
7929 else if (action_id ==
EActions.SET_QUANTITY_0)
7930 {
7932
7933 if (m_EM)
7934 {
7935 m_EM.SetEnergy(0);
7936 }
7937 }
7938
7939 else if (action_id ==
EActions.SET_MAX_QUANTITY)
7940 {
7942
7943 if (m_EM)
7944 {
7945 m_EM.SetEnergy(m_EM.GetEnergyMax());
7946 }
7947 }
7948
7949 else if (action_id ==
EActions.ADD_HEALTH)
7950 {
7951 AddHealth("","",GetMaxHealth("","Health")/5);
7952 }
7953 else if (action_id ==
EActions.REMOVE_HEALTH)
7954 {
7955 AddHealth("","",-GetMaxHealth("","Health")/5);
7956 }
7957 else if (action_id ==
EActions.DESTROY_HEALTH)
7958 {
7959 SetHealth01("","",0);
7960 }
7961 else if (action_id ==
EActions.WATCH_ITEM)
7962 {
7964 mid.RegisterDebugItem(
ItemBase.Cast(
this), PlayerBase.Cast(player));
7965 #ifdef DEVELOPER
7966 SetDebugDeveloper_item(this);
7967 #endif
7968 }
7969
7970 else if (action_id ==
EActions.ADD_TEMPERATURE)
7971 {
7972 AddTemperature(20);
7973
7974 }
7975
7976 else if (action_id ==
EActions.REMOVE_TEMPERATURE)
7977 {
7978 AddTemperature(-20);
7979
7980 }
7981
7982 else if (action_id ==
EActions.FLIP_FROZEN)
7983 {
7984 SetFrozen(!GetIsFrozen());
7985
7986 }
7987
7988 else if (action_id ==
EActions.ADD_WETNESS)
7989 {
7991
7992 }
7993
7994 else if (action_id ==
EActions.REMOVE_WETNESS)
7995 {
7997
7998 }
7999
8000 else if (action_id ==
EActions.LIQUIDTYPE_UP)
8001 {
8004
8005
8006 }
8007
8008 else if (action_id ==
EActions.LIQUIDTYPE_DOWN)
8009 {
8012 }
8013
8014 else if (action_id ==
EActions.MAKE_SPECIAL)
8015 {
8016 auto debugParams = DebugSpawnParams.WithPlayer(player);
8017 OnDebugSpawnEx(debugParams);
8018 }
8019
8020 }
8021
8022
8023 return false;
8024 }
8025
8026
8027
8028
8032
8035
8036
8037
8039 {
8040 return false;
8041 }
8042
8043
8045 {
8046 return true;
8047 }
8048
8049
8051 {
8052 return true;
8053 }
8054
8055
8056
8058 {
8059 string config_path =
string.Format(
"CfgVehicles %1 Food FoodStages",
GetType());
8061 }
8062
8065 {
8066 return null;
8067 }
8068
8070 {
8071 return false;
8072 }
8073
8075 {
8076 return false;
8077 }
8078
8082
8083
8085 {
8086 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
8087 return module_repairing.CanRepair(this, item_repair_kit);
8088 }
8089
8090
8091 bool Repair(PlayerBase player,
ItemBase item_repair_kit,
float specialty_weight)
8092 {
8093 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
8094 return module_repairing.Repair(player, this, item_repair_kit, specialty_weight);
8095 }
8096
8097
8099 {
8100
8101
8102
8103
8104
8105
8106
8107
8108 return 1;
8109 }
8110
8111
8112
8114 {
8116 }
8117
8118
8119
8121 {
8123 }
8124
8125
8134 {
8135 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8136
8137 if (player)
8138 {
8139 player.MessageStatus(text);
8140 }
8141 }
8142
8143
8152 {
8153 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8154
8155 if (player)
8156 {
8157 player.MessageAction(text);
8158 }
8159 }
8160
8161
8170 {
8171 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8172
8173 if (player)
8174 {
8175 player.MessageFriendly(text);
8176 }
8177 }
8178
8179
8188 {
8189 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8190
8191 if (player)
8192 {
8193 player.MessageImportant(text);
8194 }
8195 }
8196
8198 {
8199 return true;
8200 }
8201
8202
8203 override bool KindOf(
string tag)
8204 {
8205 bool found = false;
8206 string item_name = this.
GetType();
8209
8210 int array_size = item_tag_array.Count();
8211 for (int i = 0; i < array_size; i++)
8212 {
8213 if (item_tag_array.Get(i) == tag)
8214 {
8215 found = true;
8216 break;
8217 }
8218 }
8219 return found;
8220 }
8221
8222
8224 {
8225
8226 super.OnRPC(sender, rpc_type,ctx);
8227
8228
8229 switch (rpc_type)
8230 {
8231 #ifndef SERVER
8232 case ERPCs.RPC_SOUND_LOCK_ATTACH:
8233 Param2<bool, string> p = new Param2<bool, string>(false, "");
8234
8236 return;
8237
8238 bool play = p.param1;
8239 string soundSet = p.param2;
8240
8241 if (play)
8242 {
8244 {
8246 {
8248 }
8249 }
8250 else
8251 {
8253 }
8254 }
8255 else
8256 {
8258 }
8259
8260 break;
8261 #endif
8262
8263 }
8264
8266 {
8268 }
8269 }
8270
8271
8272
8273
8275 {
8276 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
8277 return plugin.GetID(
name);
8278 }
8279
8281 {
8282 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
8283 return plugin.GetName(id);
8284 }
8285
8288 {
8289
8290
8291 int varFlags;
8292 if (!ctx.
Read(varFlags))
8293 return;
8294
8295 if (varFlags & ItemVariableFlags.FLOAT)
8296 {
8298 }
8299 }
8300
8302 {
8303
8304 super.SerializeNumericalVars(floats_out);
8305
8306
8307
8309 {
8311 }
8312
8314 {
8316 }
8317
8319 {
8321 }
8322
8324 {
8329 }
8330
8332 {
8334 }
8335 }
8336
8338 {
8339
8340 super.DeSerializeNumericalVars(floats);
8341
8342
8343 int index = 0;
8344 int mask = Math.Round(floats.Get(index));
8345
8346 index++;
8347
8349 {
8351 {
8353 }
8354 else
8355 {
8356 float quantity = floats.Get(index);
8358 }
8359 index++;
8360 }
8361
8363 {
8364 float wet = floats.Get(index);
8366 index++;
8367 }
8368
8370 {
8371 int liquidtype = Math.Round(floats.Get(index));
8373 index++;
8374 }
8375
8377 {
8379 index++;
8381 index++;
8383 index++;
8385 index++;
8386 }
8387
8389 {
8390 int cleanness = Math.Round(floats.Get(index));
8392 index++;
8393 }
8394 }
8395
8397 {
8398 super.WriteVarsToCTX(ctx);
8399
8400
8402 {
8404 }
8405
8407 {
8409 }
8410
8412 {
8414 }
8415
8417 {
8418 int r,g,b,a;
8424 }
8425
8427 {
8429 }
8430 }
8431
8433 {
8434 if (!super.ReadVarsFromCTX(ctx,version))
8435 return false;
8436
8437 int intValue;
8438 float value;
8439
8440 if (version < 140)
8441 {
8442 if (!ctx.
Read(intValue))
8443 return false;
8444
8445 m_VariablesMask = intValue;
8446 }
8447
8449 {
8450 if (!ctx.
Read(value))
8451 return false;
8452
8454 {
8456 }
8457 else
8458 {
8460 }
8461 }
8462
8463 if (version < 140)
8464 {
8466 {
8467 if (!ctx.
Read(value))
8468 return false;
8469 SetTemperatureDirect(value);
8470 }
8471 }
8472
8474 {
8475 if (!ctx.
Read(value))
8476 return false;
8478 }
8479
8481 {
8482 if (!ctx.
Read(intValue))
8483 return false;
8485 }
8486
8488 {
8489 int r,g,b,a;
8491 return false;
8493 return false;
8495 return false;
8497 return false;
8498
8500 }
8501
8503 {
8504 if (!ctx.
Read(intValue))
8505 return false;
8507 }
8508
8509 if (version >= 138 && version < 140)
8510 {
8512 {
8513 if (!ctx.
Read(intValue))
8514 return false;
8515 SetFrozen(intValue);
8516 }
8517 }
8518
8519 return true;
8520 }
8521
8522
8524 {
8527 {
8529 }
8530
8531 if (!super.OnStoreLoad(ctx, version))
8532 {
8534 return false;
8535 }
8536
8537 if (version >= 114)
8538 {
8539 bool hasQuickBarIndexSaved;
8540
8541 if (!ctx.
Read(hasQuickBarIndexSaved))
8542 {
8544 return false;
8545 }
8546
8547 if (hasQuickBarIndexSaved)
8548 {
8549 int itmQBIndex;
8550
8551
8552 if (!ctx.
Read(itmQBIndex))
8553 {
8555 return false;
8556 }
8557
8558 PlayerBase parentPlayer = PlayerBase.Cast(GetHierarchyRootPlayer());
8559 if (itmQBIndex != -1 && parentPlayer)
8560 parentPlayer.SetLoadedQuickBarItemBind(this, itmQBIndex);
8561 }
8562 }
8563 else
8564 {
8565
8566 PlayerBase player;
8567 int itemQBIndex;
8568 if (version ==
int.
MAX)
8569 {
8570 if (!ctx.
Read(itemQBIndex))
8571 {
8573 return false;
8574 }
8575 }
8576 else if (Class.CastTo(player, GetHierarchyRootPlayer()))
8577 {
8578
8579 if (!ctx.
Read(itemQBIndex))
8580 {
8582 return false;
8583 }
8584 if (itemQBIndex != -1 && player)
8585 player.SetLoadedQuickBarItemBind(this,itemQBIndex);
8586 }
8587 }
8588
8589 if (version < 140)
8590 {
8591
8592 if (!LoadVariables(ctx, version))
8593 {
8595 return false;
8596 }
8597 }
8598
8599
8601 {
8603 return false;
8604 }
8605 if (version >= 132)
8606 {
8608 if (raib)
8609 {
8611 {
8613 return false;
8614 }
8615 }
8616 }
8617
8619 return true;
8620 }
8621
8622
8623
8625 {
8626 super.OnStoreSave(ctx);
8627
8628 PlayerBase player;
8629 if (PlayerBase.CastTo(player,GetHierarchyRootPlayer()))
8630 {
8632
8633 int itemQBIndex = -1;
8634 itemQBIndex = player.FindQuickBarEntityIndex(this);
8635 ctx.
Write(itemQBIndex);
8636 }
8637 else
8638 {
8640 }
8641
8643
8645 if (raib)
8646 {
8648 }
8649 }
8650
8651
8653 {
8654 super.AfterStoreLoad();
8655
8657 {
8659 }
8660
8662 {
8665 }
8666 }
8667
8669 {
8670 super.EEOnAfterLoad();
8671
8673 {
8675 }
8676
8679 }
8680
8682 {
8683 return false;
8684 }
8685
8686
8687
8689 {
8691 {
8692 #ifdef PLATFORM_CONSOLE
8693
8695 {
8697 if (menu)
8698 {
8700 }
8701 }
8702 #endif
8703 }
8704
8706 {
8709 }
8710
8712 {
8713 SetWeightDirty();
8715 }
8717 {
8720 }
8721
8723 {
8726 }
8728 {
8731 }
8732
8733 super.OnVariablesSynchronized();
8734 }
8735
8736
8737
8739 override bool SetQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false,
bool allow_client =
false,
bool clamp_to_stack_max =
true)
8740 {
8741 if (!IsServerCheck(allow_client))
8742 return false;
8743
8745 return false;
8746
8749
8750 if (value <= (min + 0.001))
8751 value = min;
8752
8753 if (value == min)
8754 {
8755 if (destroy_config)
8756 {
8757 bool dstr = ConfigGetBool("varQuantityDestroyOnMin");
8758 if (dstr)
8759 {
8761 this.Delete();
8762 return true;
8763 }
8764 }
8765 else if (destroy_forced)
8766 {
8768 this.Delete();
8769 return true;
8770 }
8771
8773 }
8774
8777
8779 {
8781
8782 if (delta)
8784 }
8785
8787
8788 return false;
8789 }
8790
8791
8793 bool AddQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
8794 {
8796 }
8797
8799 {
8802 }
8803
8805 {
8808 }
8809
8811 override void SetQuantityNormalized(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
8812 {
8813 float value_clamped = Math.Clamp(value, 0, 1);
8815 SetQuantity(result, destroy_config, destroy_forced);
8816 }
8817
8818
8821 {
8823 }
8824
8826 {
8828 }
8829
8830
8831
8832
8833
8834
8835
8836
8837
8838
8840 {
8841 int slot = -1;
8842 if (GetInventory())
8843 {
8844 InventoryLocation il = new InventoryLocation;
8845 GetInventory().GetCurrentInventoryLocation(il);
8847 }
8848
8850 }
8851
8853 {
8854 float quantity_max = 0;
8855
8857 {
8858 if (attSlotID != -1)
8859 quantity_max = InventorySlots.GetStackMaxForSlotId(attSlotID);
8860
8861 if (quantity_max <= 0)
8863 }
8864
8865 if (quantity_max <= 0)
8867
8868 return quantity_max;
8869 }
8870
8872 {
8874 }
8875
8877 {
8879 }
8880
8881
8883 {
8885 }
8886
8888 {
8890 }
8891
8893 {
8895 }
8896
8897
8899 {
8900
8901 float weightEx = GetWeightEx();
8902 float special = GetInventoryAndCargoWeight();
8903 return weightEx - special;
8904 }
8905
8906
8908 {
8910 }
8911
8913 {
8915 {
8916 #ifdef DEVELOPER
8917 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
8918 {
8919 WeightDebugData data1 = WeightDebug.GetWeightDebug(this);
8921 }
8922 #endif
8923
8925 }
8926 else if (HasEnergyManager())
8927 {
8928 #ifdef DEVELOPER
8929 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
8930 {
8931 WeightDebugData data2 = WeightDebug.GetWeightDebug(this);
8932 data2.
SetCalcDetails(
"TIB2: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " + GetCompEM().
GetEnergy()+
"(energy) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit)");
8933 }
8934 #endif
8935 return super.GetWeightSpecialized(forceRecalc) + (GetCompEM().GetEnergy() * ConfigGetFloat("weightPerQuantityUnit")) + GetConfigWeightModified();
8936 }
8937 else
8938 {
8939 #ifdef DEVELOPER
8940 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
8941 {
8942 WeightDebugData data3 = WeightDebug.GetWeightDebug(this);
8943 data3.
SetCalcDetails(
"TIB3: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " +
GetQuantity()+
"(quantity) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit))");
8944 }
8945 #endif
8946 return super.GetWeightSpecialized(forceRecalc) + (
GetQuantity() * ConfigGetFloat(
"weightPerQuantityUnit")) + GetConfigWeightModified();
8947 }
8948 }
8949
8952 {
8953 int item_count = 0;
8955
8956 if (GetInventory().GetCargo() != NULL)
8957 {
8958 item_count = GetInventory().GetCargo().GetItemCount();
8959 }
8960
8961 for (int i = 0; i < GetInventory().AttachmentCount(); i++)
8962 {
8963 Class.CastTo(item,GetInventory().GetAttachmentFromIndex(i));
8964 if (item)
8965 item_count += item.GetNumberOfItems();
8966 }
8967 return item_count;
8968 }
8969
8972 {
8973 float weight = 0;
8974 float wetness = 1;
8975 if (include_wetness)
8978 {
8979 weight = wetness * m_ConfigWeight;
8980 }
8982 {
8983 weight = 1;
8984 }
8985 return weight;
8986 }
8987
8988
8989
8991 {
8992 if ((
GetGame().IsServer() || !
GetGame().IsMultiplayer()) && GetInventory())
8993 {
8994 GameInventory inv = GetInventory();
8995 array<EntityAI> items = new array<EntityAI>;
8997 for (int i = 0; i < items.Count(); i++)
8998 {
9000 if (item)
9001 {
9003 }
9004 }
9005 }
9006 }
9007
9008
9009
9010
9012 {
9013 float energy = 0;
9014 if (HasEnergyManager())
9015 {
9016 energy = GetCompEM().GetEnergy();
9017 }
9018 return energy;
9019 }
9020
9021
9023 {
9024 super.OnEnergyConsumed();
9025
9027 }
9028
9030 {
9031 super.OnEnergyAdded();
9032
9034 }
9035
9036
9038 {
9039 if (
GetGame().IsServer() && HasEnergyManager() && GetCompEM().HasConversionOfEnergyToQuantity())
9040 {
9042 {
9043 float energy_0to1 = GetCompEM().GetEnergy0To1();
9045 }
9046 }
9047 }
9048
9049
9051 {
9052 return ConfigGetFloat("heatIsolation");
9053 }
9054
9056 {
9058 }
9059
9061 {
9062 string paramPath =
string.Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Drying %2",
GetType(), pIncrementName);
9063 if (
GetGame().ConfigIsExisting(paramPath))
9065
9066 return 0.0;
9067 }
9068
9070 {
9071 string paramPath =
string.
Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Soaking %2",
GetType(), pIncrementName);
9072 if (
GetGame().ConfigIsExisting(paramPath))
9074
9075 return 0.0;
9076 }
9077
9078 override void SetWet(
float value,
bool allow_client =
false)
9079 {
9080 if (!IsServerCheck(allow_client))
9081 return;
9082
9085
9087
9088 m_VarWet = Math.Clamp(value, min, max);
9089
9091 {
9094 }
9095 }
9096
9097 override void AddWet(
float value)
9098 {
9100 }
9101
9103 {
9105 }
9106
9108 {
9110 }
9111
9113 {
9115 }
9116
9118 {
9120 }
9121
9123 {
9125 }
9126
9128 {
9131 if (newLevel != oldLevel)
9132 {
9134 }
9135 }
9136
9138 {
9139 SetWeightDirty();
9140 }
9141
9143 {
9144 return GetWetLevelInternal(
m_VarWet);
9145 }
9146
9147
9148
9150 {
9152 }
9153
9155 {
9157 }
9158
9160 {
9162 }
9163
9165 {
9167 }
9168
9169
9170
9172 {
9173 if (ConfigIsExisting("itemModelLength"))
9174 {
9175 return ConfigGetFloat("itemModelLength");
9176 }
9177 return 0;
9178 }
9179
9181 {
9182 if (ConfigIsExisting("itemAttachOffset"))
9183 {
9184 return ConfigGetFloat("itemAttachOffset");
9185 }
9186 return 0;
9187 }
9188
9189 override void SetCleanness(
int value,
bool allow_client =
false)
9190 {
9191 if (!IsServerCheck(allow_client))
9192 return;
9193
9195
9197
9200 }
9201
9203 {
9205 }
9206
9208 {
9209 return true;
9210 }
9211
9212
9213
9214
9216 {
9218 }
9219
9221 {
9223 }
9224
9225
9226
9227
9228 override void SetColor(
int r,
int g,
int b,
int a)
9229 {
9235 }
9237 override void GetColor(out
int r,out
int g,out
int b,out
int a)
9238 {
9243 }
9244
9246 {
9248 }
9249
9252 {
9253 int r,g,b,a;
9255 r = r/255;
9256 g = g/255;
9257 b = b/255;
9258 a = a/255;
9259 return MiscGameplayFunctions.GetColorString(r, g, b, a);
9260 }
9261
9262
9263
9264 override void SetLiquidType(
int value,
bool allow_client =
false)
9265 {
9266 if (!IsServerCheck(allow_client))
9267 return;
9268
9273 }
9274
9276 {
9277 return ConfigGetInt("varLiquidTypeInit");
9278 }
9279
9281 {
9283 }
9284
9286 {
9288 SetFrozen(false);
9289 }
9290
9293 {
9294 player.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
9295 }
9296
9297
9300 {
9301 PlayerBase nplayer;
9302 if (PlayerBase.CastTo(nplayer, player))
9303 {
9305
9306 nplayer.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
9307 }
9308 }
9309
9310
9313 {
9314 PlayerBase nplayer;
9315 if (PlayerBase.CastTo(nplayer,player))
9316 {
9317
9318 nplayer.SetEnableQuickBarEntityShortcut(this,false);
9319
9320 }
9321
9322
9323 player.GetHumanInventory().ClearUserReservedLocationForContainer(this);
9324
9325
9326 if (HasEnergyManager())
9327 {
9328 GetCompEM().UpdatePlugState();
9329 }
9330 }
9331
9332
9334 {
9335 super.OnPlacementStarted(player);
9336
9338 }
9339
9340 override void OnPlacementComplete(Man player, vector position =
"0 0 0", vector orientation =
"0 0 0")
9341 {
9343 {
9344 m_AdminLog.OnPlacementComplete(player,
this);
9345 }
9346
9347 super.OnPlacementComplete(player, position, orientation);
9348 }
9349
9350
9351
9352
9353
9355 {
9357 {
9358 return true;
9359 }
9360 else
9361 {
9362 return false;
9363 }
9364 }
9365
9366
9368 {
9370 {
9372 }
9373 }
9374
9375
9377 {
9379 }
9380
9382 {
9384 }
9385
9386 override void InsertAgent(
int agent,
float count = 1)
9387 {
9388 if (count < 1)
9389 return;
9390
9392 }
9393
9396 {
9398 }
9399
9400
9402 {
9404 }
9405
9406
9407
9408
9409
9410
9411
9412
9413
9414
9415
9416
9417
9418
9419
9420
9421
9422
9423
9424
9425
9426
9427
9428
9429
9430
9431
9432
9433
9434
9435
9436
9437
9438
9439
9440
9441
9442
9443
9444
9445
9446
9448 {
9450 return false;
9451 return true;
9452 }
9453
9455 {
9456
9458 }
9459
9460
9463 {
9464 super.CheckForRoofLimited(timeTresholdMS);
9465
9467 if ((time - m_PreviousRoofTestTime) >= timeTresholdMS)
9468 {
9469 m_PreviousRoofTestTime = time;
9470 SetRoofAbove(MiscGameplayFunctions.IsUnderRoof(this));
9471 }
9472 }
9473
9474
9476 {
9478 {
9479 return 0;
9480 }
9481
9482 if (GetInventory().GetAttachmentSlotsCount() != 0)
9483 {
9484 ItemBase filter =
ItemBase.Cast(FindAttachmentBySlotName(
"GasMaskFilter"));
9485 if (filter)
9486 return filter.GetProtectionLevel(type, false, system);
9487 else
9488 return 0;
9489 }
9490
9491 string subclassPath, entryName;
9492
9493 switch (type)
9494 {
9496 entryName = "biological";
9497 break;
9499 entryName = "chemical";
9500 break;
9501 default:
9502 entryName = "biological";
9503 break;
9504 }
9505
9506 subclassPath =
"CfgVehicles " + this.
GetType() +
" Protection ";
9507
9509 }
9510
9511
9512
9515 {
9516 if (!IsMagazine())
9518
9520 }
9521
9522
9523
9524
9525
9530 {
9531 return true;
9532 }
9533
9535 {
9537 }
9538
9539
9540
9541
9542
9544 {
9545 if (parent)
9546 {
9547 if (parent.IsInherited(DayZInfected))
9548 return true;
9549
9550 if (!parent.IsRuined())
9551 return true;
9552 }
9553
9554 return true;
9555 }
9556
9558 {
9559 if (!super.CanPutAsAttachment(parent))
9560 {
9561 return false;
9562 }
9563
9564 if (!IsRuined() && !parent.IsRuined())
9565 {
9566 return true;
9567 }
9568
9569 return false;
9570 }
9571
9573 {
9574
9575
9576
9577
9578 return super.CanReceiveItemIntoCargo(item);
9579 }
9580
9582 {
9583
9584
9585
9586
9587 GameInventory attachmentInv = attachment.GetInventory();
9589 {
9590 if (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase))
9591 return false;
9592 }
9593
9594 InventoryLocation loc = new InventoryLocation();
9595 attachment.GetInventory().GetCurrentInventoryLocation(loc);
9596 if (loc && loc.
IsValid() && !GetInventory().AreChildrenAccessible())
9597 return false;
9598
9599 return super.CanReceiveAttachment(attachment, slotId);
9600 }
9601
9603 {
9604 if (!super.CanReleaseAttachment(attachment))
9605 return false;
9606
9607 return GetInventory().AreChildrenAccessible();
9608 }
9609
9610
9611
9612
9613
9614
9615
9616
9617
9618
9619
9620
9621
9622
9623
9624
9625
9626
9627
9628
9629
9631 {
9632 int id = muzzle_owner.GetMuzzleID();
9633 array<ref WeaponParticlesOnFire> WPOF_array =
m_OnFireEffect.Get(
id);
9634
9635 if (WPOF_array)
9636 {
9637 for (int i = 0; i < WPOF_array.Count(); i++)
9638 {
9639 WeaponParticlesOnFire WPOF = WPOF_array.Get(i);
9640
9641 if (WPOF)
9642 {
9643 WPOF.OnActivate(weapon, muzzle_index, ammoType, muzzle_owner, suppressor, config_to_search);
9644 }
9645 }
9646 }
9647 }
9648
9649
9651 {
9652 int id = muzzle_owner.GetMuzzleID();
9654
9655 if (WPOBE_array)
9656 {
9657 for (int i = 0; i < WPOBE_array.Count(); i++)
9658 {
9659 WeaponParticlesOnBulletCasingEject WPOBE = WPOBE_array.Get(i);
9660
9661 if (WPOBE)
9662 {
9663 WPOBE.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
9664 }
9665 }
9666 }
9667 }
9668
9669
9671 {
9672 int id = muzzle_owner.GetMuzzleID();
9673 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
9674
9675 if (WPOOH_array)
9676 {
9677 for (int i = 0; i < WPOOH_array.Count(); i++)
9678 {
9679 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
9680
9681 if (WPOOH)
9682 {
9683 WPOOH.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
9684 }
9685 }
9686 }
9687 }
9688
9689
9691 {
9692 int id = muzzle_owner.GetMuzzleID();
9693 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
9694
9695 if (WPOOH_array)
9696 {
9697 for (int i = 0; i < WPOOH_array.Count(); i++)
9698 {
9699 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
9700
9701 if (WPOOH)
9702 {
9703 WPOOH.OnUpdate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9704 }
9705 }
9706 }
9707 }
9708
9709
9711 {
9712 int id = muzzle_owner.GetMuzzleID();
9713 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
9714
9715 if (WPOOH_array)
9716 {
9717 for (int i = 0; i < WPOOH_array.Count(); i++)
9718 {
9719 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
9720
9721 if (WPOOH)
9722 {
9723 WPOOH.OnDeactivate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9724 }
9725 }
9726 }
9727 }
9728
9729
9730
9732 {
9734 {
9735 return true;
9736 }
9737
9738 return false;
9739 }
9740
9742 {
9744 {
9745 return true;
9746 }
9747
9748 return false;
9749 }
9750
9752 {
9754 {
9755 return true;
9756 }
9757
9758 return false;
9759 }
9760
9762 {
9763 return false;
9764 }
9765
9768 {
9769 return UATimeSpent.DEFAULT_DEPLOY;
9770 }
9771
9772
9773
9774
9776 {
9778 SetSynchDirty();
9779 }
9780
9782 {
9784 }
9785
9786
9788 {
9789 return false;
9790 }
9791
9794 {
9795 string att_type = "None";
9796
9797 if (ConfigIsExisting("soundAttType"))
9798 {
9799 att_type = ConfigGetString("soundAttType");
9800 }
9801
9803 }
9804
9806 {
9808 }
9809
9810
9811
9812
9813
9819
9821 {
9824
9826 }
9827
9828
9830 {
9832 return;
9833
9835
9838
9841
9842 SoundParameters params = new SoundParameters();
9846 }
9847
9848
9850 {
9852 return;
9853
9855 SetSynchDirty();
9856
9859 }
9860
9861
9863 {
9865 return;
9866
9868 SetSynchDirty();
9869
9872 }
9873
9875 {
9877 }
9878
9880 {
9882 }
9883
9886 {
9887 if (!
GetGame().IsDedicatedServer())
9888 {
9889 if (ConfigIsExisting("attachSoundSet"))
9890 {
9891 string cfg_path = "";
9892 string soundset = "";
9894
9897 ConfigGetTextArray("attachSoundSet",cfg_soundset_array);
9898 ConfigGetTextArray("attachSoundSlot",cfg_slot_array);
9899
9900 if (cfg_soundset_array.Count() > 0 && cfg_soundset_array.Count() == cfg_slot_array.Count())
9901 {
9902 for (int i = 0; i < cfg_soundset_array.Count(); i++)
9903 {
9904 if (cfg_slot_array[i] == slot_type)
9905 {
9906 soundset = cfg_soundset_array[i];
9907 break;
9908 }
9909 }
9910 }
9911
9912 if (soundset != "")
9913 {
9914 EffectSound sound = SEffectManager.PlaySound(soundset,
GetPosition());
9916 }
9917 }
9918 }
9919 }
9920
9922 {
9923
9924 }
9925
9926 void OnApply(PlayerBase player);
9927
9929 {
9930 return 1.0;
9931 };
9932
9934 {
9936 }
9937
9939 {
9941 }
9942
9944
9946 {
9947 SetDynamicPhysicsLifeTime(0.01);
9949 }
9950
9952 {
9953 array<string> zone_names = new array<string>;
9954 GetDamageZones(zone_names);
9955 for (int i = 0; i < zone_names.Count(); i++)
9956 {
9957 SetHealthMax(zone_names.Get(i),"Health");
9958 }
9959 SetHealthMax("","Health");
9960 }
9961
9964 {
9965 float global_health = GetHealth01("","Health");
9966 array<string> zones = new array<string>;
9967 GetDamageZones(zones);
9968
9969 for (int i = 0; i < zones.Count(); i++)
9970 {
9971 SetHealth01(zones.Get(i),"Health",global_health);
9972 }
9973 }
9974
9977 {
9978 return IsExclusionFlagPresent(PlayerBase.GetFaceCoverageShaveValues());
9979 }
9980
9982 {
9983 if (!hasRootAsPlayer)
9984 {
9985 if (refParentIB)
9986 {
9987
9988 if ((refParentIB.GetWet() >= GameConstants.STATE_SOAKING_WET) && (
m_VarWet <
m_VarWetMax))
9989 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_INSIDE);
9990
9991 else if ((refParentIB.GetLiquidType() != 0) && (refParentIB.GetQuantity() > 0) && (
m_VarWet <
m_VarWetMax))
9992 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_LIQUID);
9993
9996 }
9997 else
9998 {
9999
10002 }
10003 }
10004 }
10005
10007 {
10009 {
10010 float target =
g_Game.GetMission().GetWorldData().GetBaseEnvTemperatureAtObject(
this);
10011 if (
GetTemperature() != target || !IsFreezeThawProgressFinished())
10012 {
10013 float heatPermCoef = 1.0;
10015 while (ent)
10016 {
10017 heatPermCoef *= ent.GetHeatPermeabilityCoef();
10018 ent = ent.GetHierarchyParent();
10019 }
10020
10021 SetTemperatureEx(
new TemperatureDataInterpolated(target,
ETemperatureAccessTypes.ACCESS_WORLD,delta,GameConstants.TEMP_COEF_WORLD,heatPermCoef));
10022 }
10023 }
10024 }
10025
10027 {
10028
10029 EntityAI parent = GetHierarchyParent();
10030 if (!parent)
10031 {
10032 hasParent = false;
10033 hasRootAsPlayer = false;
10034 }
10035 else
10036 {
10037 hasParent = true;
10038 hasRootAsPlayer = (GetHierarchyRootPlayer() != null);
10039 refParentIB =
ItemBase.Cast(parent);
10040 }
10041 }
10042
10043 protected void ProcessDecay(
float delta,
bool hasRootAsPlayer)
10044 {
10045
10046 }
10047
10049 {
10050
10051 return false;
10052 }
10053
10055 {
10056
10057
10058 return false;
10059 }
10060
10062 {
10063
10064 return false;
10065 }
10066
10069 {
10070 return !GetIsFrozen() &&
IsOpen();
10071 }
10072
10074 {
10075 bool hasParent = false, hasRootAsPlayer = false;
10077
10078 bool wwtu =
g_Game.IsWorldWetTempUpdateEnabled();
10079 bool foodDecay =
g_Game.IsFoodDecayEnabled();
10080
10081 if (wwtu || foodDecay)
10082 {
10086
10087 if (processWetness || processTemperature || processDecay)
10088 {
10090
10091 if (processWetness)
10092 ProcessItemWetness(m_ElapsedSinceLastUpdate, hasParent, hasRootAsPlayer, refParentIB);
10093
10094 if (processTemperature)
10096
10097 if (processDecay)
10098 ProcessDecay(m_ElapsedSinceLastUpdate, hasRootAsPlayer);
10099 }
10100 }
10101 }
10102
10105 {
10107 }
10108
10110 {
10113
10114 return super.GetTemperatureFreezeThreshold();
10115 }
10116
10118 {
10121
10122 return super.GetTemperatureThawThreshold();
10123 }
10124
10126 {
10129
10130 return super.GetItemOverheatThreshold();
10131 }
10132
10134 {
10136 return Math.Lerp(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureFreezeTime()),
GetQuantityNormalized());
10137
10138 return super.GetTemperatureFreezeTime();
10139 }
10140
10142 {
10144 return Math.Lerp(GameConstants.TEMPERATURE_TIME_THAW_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureThawTime()),
GetQuantityNormalized());
10145
10146 return super.GetTemperatureThawTime();
10147 }
10148
10153
10155 {
10156 return (item.IsKindOf("Cauldron") || item.IsKindOf("Pot") || item.IsKindOf("FryingPan") || item.IsKindOf("SmallProtectorCase") || (item.IsKindOf("PortableGasStove") && item.FindAttachmentBySlotName("CookingEquipment")));
10157 }
10158
10160 {
10161 MiscGameplayFunctions.TransferItemProperties(oldItem, this);
10162 }
10163
10166 {
10168 }
10169
10171 {
10173 }
10174
10176 {
10178 }
10179
10182 {
10183 return null;
10184 }
10185
10188 {
10189 return false;
10190 }
10191
10193 {
10195 {
10198 if (!trg)
10199 {
10201 explosive = this;
10202 }
10203
10204 explosive.PairRemote(trg);
10206
10207 int persistentID = RemotelyActivatedItemBehaviour.GeneratePersistentID();
10208 trg.SetPersistentPairID(persistentID);
10209 explosive.SetPersistentPairID(persistentID);
10210
10211 return true;
10212 }
10213 return false;
10214 }
10215
10218 {
10219 float ret = 1.0;
10222 ret *= GetHealth01();
10223
10224 return ret;
10225 }
10226
10227 #ifdef DEVELOPER
10228 override void SetDebugItem()
10229 {
10230 super.SetDebugItem();
10231 _itemBase = this;
10232 }
10233
10235 {
10236 string text = super.GetDebugText();
10237
10239 text +=
string.
Format(
"Heat isolation(modified): %1\n", MiscGameplayFunctions.GetCurrentItemHeatIsolation(
this));
10240
10241 return text;
10242 }
10243 #endif
10244
10246 {
10247 return true;
10248 }
10249
10251
10253
10255 {
10258 }
10259
10260
10268
10284}
10285
10287{
10289 if (entity)
10290 {
10291 bool is_item = entity.IsInherited(
ItemBase);
10292 if (is_item && full_quantity)
10293 {
10296 }
10297 }
10298 else
10299 {
10301 return NULL;
10302 }
10303 return entity;
10304}
10305
10307{
10308 if (item)
10309 {
10310 if (health > 0)
10311 item.SetHealth("", "", health);
10312
10313 if (item.CanHaveTemperature())
10314 {
10316 if (item.CanFreeze())
10317 item.SetFrozen(false);
10318 }
10319
10320 if (item.HasEnergyManager())
10321 {
10322 if (quantity >= 0)
10323 {
10324 item.GetCompEM().SetEnergy0To1(quantity);
10325 }
10326 else
10327 {
10329 }
10330 }
10331 else if (item.IsMagazine())
10332 {
10333 Magazine mag = Magazine.Cast(item);
10334 if (quantity >= 0)
10335 {
10336 mag.ServerSetAmmoCount(mag.GetAmmoMax() * quantity);
10337 }
10338 else
10339 {
10341 }
10342
10343 }
10344 else
10345 {
10346 if (quantity >= 0)
10347 {
10348 item.SetQuantityNormalized(quantity, false);
10349 }
10350 else
10351 {
10353 }
10354
10355 }
10356 }
10357}
10358
10359#ifdef DEVELOPER
10361#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.