5463{
5465 {
5466 return true;
5467 }
5468};
5469
5470
5471
5473{
5477
5479
5482
5483
5484
5485
5486
5495
5501
5506
5511
5532 protected bool m_IsResultOfSplit
5533
5535
5540
5541
5542
5544
5548
5549
5550
5552
5555
5556
5557
5563
5564
5572
5575
5576
5578
5579
5581
5582
5587
5588
5593
5594
5596
5597
5599 {
5604
5605 if (!
GetGame().IsDedicatedServer())
5606 {
5608 {
5610
5612 {
5614 }
5615 }
5616
5619 }
5620
5621 m_OldLocation = null;
5622
5624 {
5626 }
5627
5628 if (ConfigIsExisting("headSelectionsToHide"))
5629 {
5632 }
5633
5635 if (ConfigIsExisting("hideSelectionsByinventorySlot"))
5636 {
5638 }
5639
5641
5642 m_IsResultOfSplit = false;
5643
5645 }
5646
5648 {
5649 super.InitItemVariables();
5650
5656 m_Count = ConfigGetInt(
"count");
5657
5660
5665
5668
5673
5685
5689
5690
5693 if (ConfigIsExisting("canBeSplit"))
5694 {
5697 }
5698
5700 if (ConfigIsExisting("itemBehaviour"))
5702
5703
5706 RegisterNetSyncVariableInt("m_VarLiquidType");
5707 RegisterNetSyncVariableInt("m_Cleanness",0,1);
5708
5709 RegisterNetSyncVariableBoolSignal("m_WantPlayImpactSound");
5710 RegisterNetSyncVariableFloat("m_ImpactSpeed");
5711 RegisterNetSyncVariableInt("m_ImpactSoundSurfaceHash");
5712
5713 RegisterNetSyncVariableInt("m_ColorComponentR", 0, 255);
5714 RegisterNetSyncVariableInt("m_ColorComponentG", 0, 255);
5715 RegisterNetSyncVariableInt("m_ColorComponentB", 0, 255);
5716 RegisterNetSyncVariableInt("m_ColorComponentA", 0, 255);
5717
5718 RegisterNetSyncVariableBool("m_IsBeingPlaced");
5719 RegisterNetSyncVariableBool("m_IsTakeable");
5720 RegisterNetSyncVariableBool("m_IsHologram");
5721
5724 {
5727 }
5728
5730
5732 if (ConfigIsExisting("temperaturePerQuantityWeight"))
5734
5735 }
5736
5738 {
5740 }
5741
5743 {
5746 {
5751 }
5752 }
5753
5754 override void GetActions(
typename action_input_type, out array<ActionBase_Basic> actions)
5755 {
5757 {
5760 }
5761
5763 }
5764
5766 {
5772 }
5773
5775
5777 {
5779
5780 if (!action)
5781 {
5782 Debug.LogError(
"Action " + actionName +
" dosn't exist!");
5783 return;
5784 }
5785
5787 if (!ai)
5788 {
5790 return;
5791 }
5792
5794 if (!action_array)
5795 {
5796 action_array = new array<ActionBase_Basic>;
5798 }
5799 if (LogManager.IsActionLogEnable())
5800 {
5801 Debug.ActionLog(action.ToString() +
" -> " + ai,
this.ToString() ,
"n/a",
"Add action");
5802 }
5803
5804 if (action_array.Find(action) != -1)
5805 {
5806 Debug.Log(
"Action " + action.Type() +
" already added to " +
this +
", skipping!");
5807 }
5808 else
5809 {
5810 action_array.Insert(action);
5811 }
5812 }
5813
5815 {
5817 ActionBase action = player.GetActionManager().GetAction(actionName);
5820
5821 if (action_array)
5822 {
5823 action_array.RemoveItem(action);
5824 }
5825 }
5826
5827
5828
5830 {
5831 ActionOverrideData overrideData = new ActionOverrideData();
5835
5837 if (!actionMap)
5838 {
5841 }
5842
5843 actionMap.Insert(this.
Type(), overrideData);
5844
5845 }
5846
5848
5850
5851
5853 {
5856
5859
5860 string config_to_search = "CfgVehicles";
5861 string muzzle_owner_config;
5862
5864 {
5865 if (IsInherited(Weapon))
5866 config_to_search = "CfgWeapons";
5867
5868 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
5869
5870 string config_OnFire_class = muzzle_owner_config + "Particles " + "OnFire ";
5871
5873
5874 if (config_OnFire_subclass_count > 0)
5875 {
5876 array<ref WeaponParticlesOnFire> WPOF_array = new array<ref WeaponParticlesOnFire>;
5877
5878 for (int i = 0; i < config_OnFire_subclass_count; i++)
5879 {
5880 string particle_class = "";
5882 string config_OnFire_entry = config_OnFire_class + particle_class;
5883 WeaponParticlesOnFire WPOF = new WeaponParticlesOnFire(this, config_OnFire_entry);
5884 WPOF_array.Insert(WPOF);
5885 }
5886
5887
5889 }
5890 }
5891
5893 {
5894 config_to_search = "CfgWeapons";
5895 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
5896
5897 string config_OnBulletCasingEject_class = muzzle_owner_config + "Particles " + "OnBulletCasingEject ";
5898
5900
5901 if (config_OnBulletCasingEject_count > 0 && IsInherited(Weapon))
5902 {
5903 array<ref WeaponParticlesOnBulletCasingEject> WPOBE_array = new array<ref WeaponParticlesOnBulletCasingEject>;
5904
5905 for (i = 0; i < config_OnBulletCasingEject_count; i++)
5906 {
5907 string particle_class2 = "";
5909 string config_OnBulletCasingEject_entry = config_OnBulletCasingEject_class + particle_class2;
5910 WeaponParticlesOnBulletCasingEject WPOBE = new WeaponParticlesOnBulletCasingEject(this, config_OnBulletCasingEject_entry);
5911 WPOBE_array.Insert(WPOBE);
5912 }
5913
5914
5916 }
5917 }
5918 }
5919
5920
5922 {
5925
5927 {
5928 string config_to_search = "CfgVehicles";
5929
5930 if (IsInherited(Weapon))
5931 config_to_search = "CfgWeapons";
5932
5933 string muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
5934 string config_OnOverheating_class = muzzle_owner_config + "Particles " + "OnOverheating ";
5935
5936 if (
GetGame().ConfigIsExisting(config_OnOverheating_class))
5937 {
5938
5940
5942 {
5944 string error =
"Error reading config " +
GetType() +
">Particles>OnOverheating - Parameter shotsToStartOverheating is configured wrong or is missing! Its value must be 1 or higher!";
5946 return;
5947 }
5948
5951
5952
5953
5955 array<ref WeaponParticlesOnOverheating> WPOOH_array = new array<ref WeaponParticlesOnOverheating>;
5956
5957 for (int i = 0; i < config_OnOverheating_subclass_count; i++)
5958 {
5959 string particle_class = "";
5961 string config_OnOverheating_entry = config_OnOverheating_class + particle_class;
5963
5964 if (entry_type == CT_CLASS)
5965 {
5966 WeaponParticlesOnOverheating WPOF = new WeaponParticlesOnOverheating(this, config_OnOverheating_entry);
5967 WPOOH_array.Insert(WPOF);
5968 }
5969 }
5970
5971
5973 }
5974 }
5975 }
5976
5978 {
5980 }
5981
5983 {
5985 {
5987
5990
5993
5994 CheckOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
5995 }
5996 }
5997
5999 {
6001 UpdateOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
6002
6004 StartOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
6005
6007 StopOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
6008
6010 {
6012 }
6013 }
6014
6016 {
6018 }
6019
6021 {
6024 else
6026
6028 {
6031 }
6032 else
6033 {
6036
6039 }
6040
6042 }
6043
6045 {
6047 ItemBase.PlayOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
6048 }
6049
6051 {
6053 ItemBase.UpdateOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
6055 }
6056
6058 {
6060 ItemBase.StopOverheatingParticles(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
6061 }
6062
6064 {
6067
6068 OverheatingParticle OP = new OverheatingParticle();
6073
6075 }
6076
6078 {
6081
6082 return -1;
6083 }
6084
6086 {
6088 {
6091
6092 for (int i = count; i > 0; --i)
6093 {
6094 int id = i - 1;
6097
6100
6101 if (overheat_coef < overheat_min && overheat_coef >= overheat_max)
6102 {
6103 if (p)
6104 {
6107 }
6108 }
6109 }
6110 }
6111 }
6112
6114 {
6116 {
6118 {
6119 int id = i - 1;
6121
6122 if (OP)
6123 {
6125
6126 if (p)
6127 {
6129 }
6130
6131 delete OP;
6132 }
6133 }
6134
6137 }
6138 }
6139
6142 {
6143 return 0.0;
6144 }
6145
6146
6148 {
6149 return 250;
6150 }
6151
6153 {
6154 return 0;
6155 }
6156
6159 {
6161 return true;
6162
6163 return false;
6164 }
6165
6168 {
6171
6173 {
6175 }
6176 else
6177 {
6178
6180 }
6181
6183 }
6184
6191 {
6192 return -1;
6193 }
6194
6195
6196
6197
6199 {
6201 {
6203 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
6204
6205 if (r_index >= 0)
6206 {
6207 InventoryLocation r_il = new InventoryLocation;
6208 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
6209
6210 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
6213 {
6214 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
6215 }
6217 {
6218 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
6219 }
6220
6221 }
6222
6223 player.GetHumanInventory().ClearUserReservedLocation(this);
6224 }
6225
6228 }
6229
6230
6231
6232
6234 {
6235 return ItemBase.m_DebugActionsMask;
6236 }
6237
6239 {
6240 return ItemBase.m_DebugActionsMask & mask;
6241 }
6242
6244 {
6245 ItemBase.m_DebugActionsMask = mask;
6246 }
6247
6249 {
6250 ItemBase.m_DebugActionsMask |= mask;
6251 }
6252
6254 {
6255 ItemBase.m_DebugActionsMask &= ~mask;
6256 }
6257
6259 {
6261 {
6263 }
6264 else
6265 {
6267 }
6268 }
6269
6270
6272 {
6273 if (GetEconomyProfile())
6274 {
6275 float q_max = GetEconomyProfile().GetQuantityMax();
6276 if (q_max > 0)
6277 {
6278 float q_min = GetEconomyProfile().GetQuantityMin();
6279 float quantity_randomized = Math.RandomFloatInclusive(q_min, q_max);
6280
6282 {
6283 ComponentEnergyManager comp = GetCompEM();
6285 {
6287 }
6288 }
6290 {
6292
6293 }
6294
6295 }
6296 }
6297 }
6298
6301 {
6302 EntityAI parent = GetHierarchyParent();
6303
6304 if (parent)
6305 {
6306 InventoryLocation inventory_location_to_lock = new InventoryLocation;
6307 GetInventory().GetCurrentInventoryLocation(inventory_location_to_lock);
6308 parent.GetInventory().SetSlotLock(inventory_location_to_lock.
GetSlot(),
true);
6309 }
6310 }
6311
6314 {
6315 EntityAI parent = GetHierarchyParent();
6316
6317 if (parent)
6318 {
6319 InventoryLocation inventory_location_to_unlock = new InventoryLocation;
6320 GetInventory().GetCurrentInventoryLocation(inventory_location_to_unlock);
6321 parent.GetInventory().SetSlotLock(inventory_location_to_unlock.
GetSlot(),
false);
6322 }
6323 }
6324
6326 {
6327
6328
6329
6330
6332
6334 {
6335 if (ScriptInputUserData.CanStoreInputUserData())
6336 {
6337 ScriptInputUserData ctx = new ScriptInputUserData;
6343 ctx.
Write(use_stack_max);
6346
6348 {
6349 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(item2,null,GameInventory.c_InventoryReservationTimeoutShortMS);
6350 }
6351 }
6352 }
6353 else if (!
GetGame().IsMultiplayer())
6354 {
6356 }
6357 }
6358
6360 {
6362 }
6363
6365 {
6367 }
6368
6370 {
6372 }
6373
6375 {
6376
6377 return false;
6378 }
6379
6381 {
6382 return false;
6383 }
6384
6388 {
6389 return false;
6390 }
6391
6393 {
6394 return "";
6395 }
6396
6398
6400 {
6401 return false;
6402 }
6403
6405 {
6406 return true;
6407 }
6408
6409
6410
6412 {
6413 return true;
6414 }
6415
6417 {
6418 return true;
6419 }
6420
6422 {
6423 PlayerBase player = PlayerBase.Cast(
g_Game.GetPlayer());
6425 }
6426
6428 {
6430 }
6431
6433 {
6435 if (!is_being_placed)
6437 SetSynchDirty();
6438 }
6439
6440
6442
6444 {
6446 }
6447
6449 {
6451 }
6452
6454 {
6455 return 1;
6456 }
6457
6459 {
6460 return false;
6461 }
6462
6464 {
6466 SetSynchDirty();
6467 }
6468
6469
6470
6471
6472
6473
6474
6475
6476
6477
6478
6479
6480
6481
6482
6483
6484
6485
6486
6487
6488
6489
6490
6491
6492
6493
6494
6495
6496
6497
6498
6499
6500
6501
6502
6504 {
6505 super.OnMovedInsideCargo(container);
6506
6507 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
6508 }
6509
6510 override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
6511 {
6512 super.EEItemLocationChanged(oldLoc,newLoc);
6513
6514 PlayerBase new_player = null;
6515 PlayerBase old_player = null;
6516
6517 if (newLoc.GetParent())
6518 new_player = PlayerBase.Cast(newLoc.GetParent().GetHierarchyRootPlayer());
6519
6520 if (oldLoc.GetParent())
6521 old_player = PlayerBase.Cast(oldLoc.GetParent().GetHierarchyRootPlayer());
6522
6524 {
6525 int r_index = old_player.GetHumanInventory().FindUserReservedLocationIndex(this);
6526
6527 if (r_index >= 0)
6528 {
6529 InventoryLocation r_il = new InventoryLocation;
6530 old_player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
6531
6532 old_player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
6535 {
6536 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
6537 }
6539 {
6540 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
6541 }
6542
6543 }
6544 }
6545
6547 {
6548 if (new_player)
6549 new_player.ForceStandUpForHeavyItems(newLoc.GetItem());
6550
6551 if (new_player == old_player)
6552 {
6553
6554 if (oldLoc.GetParent() && new_player.GetHumanInventory().LocationGetEntity(oldLoc) == NULL)
6555 {
6557 {
6558 if (oldLoc.GetParent().GetInventory().TestAddEntityInCargoExLoc(oldLoc, false, false, false, true, false, false))
6559 {
6560 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
6561 }
6562 }
6563 else
6564 {
6565 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
6566 }
6567 }
6568
6569 if (new_player.GetHumanInventory().FindUserReservedLocationIndex(this) >= 0)
6570 {
6571 int type = oldLoc.GetType();
6573 {
6574 oldLoc.GetParent().GetOnSetLock().Invoke(this);
6575 }
6577 {
6578 oldLoc.GetParent().GetOnAttachmentSetLock().Invoke(this, oldLoc.GetSlot());
6579 }
6580 }
6581 if (!m_OldLocation)
6582 {
6583 m_OldLocation = new InventoryLocation;
6584 }
6585 m_OldLocation.Copy(oldLoc);
6586 }
6587 else
6588 {
6589 if (m_OldLocation)
6590 {
6591 m_OldLocation.Reset();
6592 }
6593 }
6594
6596 }
6597 else
6598 {
6599 if (new_player)
6600 {
6601 int res_index = new_player.GetHumanInventory().FindCollidingUserReservedLocationIndex(this, newLoc);
6602 if (res_index >= 0)
6603 {
6604 InventoryLocation il = new InventoryLocation;
6605 new_player.GetHumanInventory().GetUserReservedLocation(res_index,il);
6607 new_player.GetHumanInventory().ClearUserReservedLocationAtIndex(res_index);
6610 {
6611 il.
GetParent().GetOnReleaseLock().Invoke(it);
6612 }
6614 {
6616 }
6617
6618 }
6619 }
6621 {
6622
6624 }
6625
6626 if (m_OldLocation)
6627 {
6628 m_OldLocation.Reset();
6629 }
6630 }
6631 }
6632
6633 override void EOnContact(IEntity other, Contact extra)
6634 {
6636 {
6637 int liquidType = -1;
6639 if (impactSpeed > 0.0)
6640 {
6642 #ifndef SERVER
6644 #else
6646 SetSynchDirty();
6647 #endif
6649 }
6650 }
6651
6652 #ifdef SERVER
6653 if (GetCompEM() && GetCompEM().IsPlugged())
6654 {
6655 if (GetCompEM().GetCordLength() < vector.Distance(
GetPosition(), GetCompEM().GetEnergySource().
GetPosition()))
6656 GetCompEM().UnplugThis();
6657 }
6658 #endif
6659 }
6660
6662
6664 {
6666 }
6667
6669 {
6670
6671 }
6672
6674 {
6675 super.OnItemLocationChanged(old_owner, new_owner);
6676
6677 PlayerBase relatedPlayer = PlayerBase.Cast(old_owner);
6678 PlayerBase playerNew = PlayerBase.Cast(new_owner);
6679
6680 if (!relatedPlayer && playerNew)
6681 relatedPlayer = playerNew;
6682
6683 if (relatedPlayer && relatedPlayer.GetPerformedActionID() != -1)
6684 {
6686 if (actionMgr)
6687 {
6688 ActionBase currentAction = actionMgr.GetRunningAction();
6689 if (currentAction)
6691 }
6692 }
6693
6694 Man ownerPlayerOld = null;
6695 Man ownerPlayerNew = null;
6696
6697 if (old_owner)
6698 {
6699 if (old_owner.
IsMan())
6700 {
6701 ownerPlayerOld = Man.Cast(old_owner);
6702 }
6703 else
6704 {
6705 ownerPlayerOld = Man.Cast(old_owner.GetHierarchyRootPlayer());
6706 }
6707 }
6708 else
6709 {
6711 {
6713
6714 if (!action || !playerNew || playerNew.GetPerformedActionID() != action.
GetID())
6715 {
6716 GetCompEM().UnplugThis();
6717 }
6718 }
6719 }
6720
6721 if (new_owner)
6722 {
6723 if (new_owner.
IsMan())
6724 {
6725 ownerPlayerNew = Man.Cast(new_owner);
6726 }
6727 else
6728 {
6729 ownerPlayerNew = Man.Cast(new_owner.GetHierarchyRootPlayer());
6730 }
6731 }
6732
6733 if (ownerPlayerOld != ownerPlayerNew)
6734 {
6735 if (ownerPlayerOld)
6736 {
6737 array<EntityAI> subItemsExit = new array<EntityAI>;
6739 for (int i = 0; i < subItemsExit.Count(); i++)
6740 {
6743 }
6744 }
6745
6746 if (ownerPlayerNew)
6747 {
6748 array<EntityAI> subItemsEnter = new array<EntityAI>;
6750 for (int j = 0; j < subItemsEnter.Count(); j++)
6751 {
6754 }
6755 }
6756 }
6757 else if (ownerPlayerNew != null)
6758 {
6759 PlayerBase nplayer;
6760 if (PlayerBase.CastTo(nplayer, ownerPlayerNew))
6761 {
6762 array<EntityAI> subItemsUpdate = new array<EntityAI>;
6764 for (int k = 0; k < subItemsUpdate.Count(); k++)
6765 {
6767 itemUpdate.UpdateQuickbarShortcutVisibility(nplayer);
6768 }
6769 }
6770 }
6771
6772 if (old_owner)
6773 old_owner.OnChildItemRemoved(this);
6774 if (new_owner)
6775 new_owner.OnChildItemReceived(this);
6776 }
6777
6778
6780 {
6781 super.EEDelete(parent);
6782 PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
6783 if (player)
6784 {
6786
6787 if (player.IsAlive())
6788 {
6789 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
6790 if (r_index >= 0)
6791 {
6792 InventoryLocation r_il = new InventoryLocation;
6793 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
6794
6795 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
6798 {
6799 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
6800 }
6802 {
6803 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
6804 }
6805
6806 }
6807
6808 player.RemoveQuickBarEntityShortcut(this);
6809 }
6810 }
6811 }
6812
6814 {
6815 super.EEKilled(killer);
6816
6819 {
6820 if (
GetTemperature() >= GameConstants.ITEM_TEMPERATURE_TO_EXPLODE_MIN)
6821 {
6822 if (IsMagazine())
6823 {
6824 if (Magazine.Cast(this).GetAmmoCount() > 0)
6825 {
6827 }
6828 }
6829 else
6830 {
6832 }
6833 }
6834 }
6835 }
6836
6838 {
6839 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
6840
6841 super.OnWasAttached(parent, slot_id);
6842
6845
6847 }
6848
6850 {
6851 super.OnWasDetached(parent, slot_id);
6852
6855 }
6856
6858 {
6859 int idx;
6862
6863 ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
6864 if (inventory_slots.Count() < 1)
6865 {
6866 inventory_slots.Insert(ConfigGetString("ChangeInventorySlot"));
6867 attach_types.Insert(ConfigGetString("ChangeIntoOnAttach"));
6868 }
6869 else
6870 {
6871 ConfigGetTextArray("ChangeIntoOnAttach",attach_types);
6872 }
6873
6874 idx = inventory_slots.Find(slot);
6875 if (idx < 0)
6876 return "";
6877
6878 return attach_types.Get(idx);
6879 }
6880
6882 {
6883 int idx = -1;
6884 string slot;
6885
6888
6889 this.ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
6890 if (inventory_slots.Count() < 1)
6891 {
6892 inventory_slots.Insert(this.ConfigGetString("ChangeInventorySlot"));
6893 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
6894 }
6895 else
6896 {
6897 this.ConfigGetTextArray("ChangeIntoOnDetach",detach_types);
6898 if (detach_types.Count() < 1)
6899 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
6900 }
6901
6902 for (int i = 0; i < inventory_slots.Count(); i++)
6903 {
6904 slot = inventory_slots.Get(i);
6905 }
6906
6907 if (slot != "")
6908 {
6909 if (detach_types.Count() == 1)
6910 idx = 0;
6911 else
6912 idx = inventory_slots.Find(slot);
6913 }
6914 if (idx < 0)
6915 return "";
6916
6917 return detach_types.Get(idx);
6918 }
6919
6921 {
6922
6924
6925
6926 float min_time = 1;
6927 float max_time = 3;
6928 float delay = Math.RandomFloat(min_time, max_time);
6929
6930 explode_timer.Run(delay, this, "DoAmmoExplosion");
6931 }
6932
6934 {
6935 Magazine magazine = Magazine.Cast(this);
6936 int pop_sounds_count = 6;
6937 string pop_sounds[ 6 ] = { "ammopops_1","ammopops_2","ammopops_3","ammopops_4","ammopops_5","ammopops_6" };
6938
6939
6940 int sound_idx = Math.RandomInt(0, pop_sounds_count - 1);
6941 string sound_name = pop_sounds[ sound_idx ];
6943
6944
6945 magazine.ServerAddAmmoCount(-1);
6946
6947
6948 float min_temp_to_explode = 100;
6949
6950 if (magazine.GetAmmoCount() > 0 &&
GetTemperature() >= min_temp_to_explode)
6951 {
6953 }
6954 }
6955
6956
6957 override void EEHitBy(TotalDamageResult damageResult,
int damageType,
EntityAI source,
int component,
string dmgZone,
string ammo, vector modelPos,
float speedCoef)
6958 {
6959 super.EEHitBy(damageResult, damageType, source,
component, dmgZone, ammo, modelPos, speedCoef);
6960
6961 const int CHANCE_DAMAGE_CARGO = 4;
6962 const int CHANCE_DAMAGE_ATTACHMENT = 1;
6963 const int CHANCE_DAMAGE_NOTHING = 2;
6964
6966 {
6967 float dmg = damageResult.
GetDamage(
"",
"Health") * -0.5;
6968 int chances;
6969 int rnd;
6970
6971 if (GetInventory().GetCargo())
6972 {
6973 chances = CHANCE_DAMAGE_CARGO + CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
6974 rnd = Math.RandomInt(0,chances);
6975
6976 if (rnd < CHANCE_DAMAGE_CARGO)
6977 {
6979 }
6980 else if (rnd < (chances - CHANCE_DAMAGE_NOTHING))
6981 {
6983 }
6984 }
6985 else
6986 {
6987 chances = CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
6988 rnd = Math.RandomInt(0,chances);
6989
6990 if (rnd < CHANCE_DAMAGE_ATTACHMENT)
6991 {
6993 }
6994 }
6995 }
6996 }
6997
6999 {
7000 if (GetInventory().GetCargo())
7001 {
7002 int item_count = GetInventory().GetCargo().GetItemCount();
7003 if (item_count > 0)
7004 {
7005 int random_pick = Math.RandomInt(0, item_count);
7007 if (!item.IsExplosive())
7008 {
7009 item.AddHealth("","",damage);
7010 return true;
7011 }
7012 }
7013 }
7014 return false;
7015 }
7016
7018 {
7019 int attachment_count = GetInventory().AttachmentCount();
7020 if (attachment_count > 0)
7021 {
7022 int random_pick = Math.RandomInt(0, attachment_count);
7023 ItemBase attachment =
ItemBase.Cast(GetInventory().GetAttachmentFromIndex(random_pick));
7024 if (!attachment.IsExplosive())
7025 {
7026 attachment.AddHealth("","",damage);
7027 return true;
7028 }
7029 }
7030 return false;
7031 }
7032
7034 {
7036 }
7037
7039 {
7041 return GetInventory().CanRemoveEntity();
7042
7043 return false;
7044 }
7045
7047 {
7048
7050 return false;
7051
7052
7054 return false;
7055
7056
7057
7059 if (delta == 0)
7060 return false;
7061
7062
7063 return true;
7064 }
7065
7067 {
7069 {
7070 if (ScriptInputUserData.CanStoreInputUserData())
7071 {
7072 ScriptInputUserData ctx = new ScriptInputUserData;
7077 ctx.
Write(destination_entity);
7081 }
7082 }
7083 else if (!
GetGame().IsMultiplayer())
7084 {
7086 }
7087 }
7088
7090 {
7091 float split_quantity_new;
7095 InventoryLocation loc = new InventoryLocation;
7096
7097 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
7098 {
7100 split_quantity_new = stack_max;
7101 else
7103
7105 {
7106 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
7107 if (new_item)
7108 {
7109 new_item.SetResultOfSplit(true);
7110 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7112 new_item.
SetQuantity(split_quantity_new,
false,
true);
7113 }
7114 }
7115 }
7116 else if (destination_entity && slot_id == -1)
7117 {
7118 if (quantity > stack_max)
7119 split_quantity_new = stack_max;
7120 else
7121 split_quantity_new = quantity;
7122
7124 {
7126 {
7129 }
7130
7131 if (new_item)
7132 {
7133 new_item.SetResultOfSplit(true);
7134 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7136 new_item.
SetQuantity(split_quantity_new,
false,
true);
7137 }
7138 }
7139 }
7140 else
7141 {
7142 if (stack_max != 0)
7143 {
7145 {
7147 }
7148
7149 if (split_quantity_new == 0)
7150 {
7151 if (!
GetGame().IsMultiplayer())
7152 player.PhysicalPredictiveDropItem(this);
7153 else
7154 player.ServerDropEntity(this);
7155 return;
7156 }
7157
7159 {
7161
7162 if (new_item)
7163 {
7164 new_item.SetResultOfSplit(true);
7165 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7168 new_item.PlaceOnSurface();
7169 }
7170 }
7171 }
7172 }
7173 }
7174
7176 {
7177 float split_quantity_new;
7181 InventoryLocation loc = new InventoryLocation;
7182
7183 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
7184 {
7186 split_quantity_new = stack_max;
7187 else
7189
7191 {
7192 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
7193 if (new_item)
7194 {
7195 new_item.SetResultOfSplit(true);
7196 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7198 new_item.
SetQuantity(split_quantity_new,
false,
true);
7199 }
7200 }
7201 }
7202 else if (destination_entity && slot_id == -1)
7203 {
7204 if (quantity > stack_max)
7205 split_quantity_new = stack_max;
7206 else
7207 split_quantity_new = quantity;
7208
7210 {
7212 {
7215 }
7216
7217 if (new_item)
7218 {
7219 new_item.SetResultOfSplit(true);
7220 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7222 new_item.
SetQuantity(split_quantity_new,
false,
true);
7223 }
7224 }
7225 }
7226 else
7227 {
7228 if (stack_max != 0)
7229 {
7231 {
7233 }
7234
7236 {
7238
7239 if (new_item)
7240 {
7241 new_item.SetResultOfSplit(true);
7242 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7245 new_item.PlaceOnSurface();
7246 }
7247 }
7248 }
7249 }
7250 }
7251
7253 {
7255 {
7256 if (ScriptInputUserData.CanStoreInputUserData())
7257 {
7258 ScriptInputUserData ctx = new ScriptInputUserData;
7263 dst.WriteToContext(ctx);
7265 }
7266 }
7267 else if (!
GetGame().IsMultiplayer())
7268 {
7270 }
7271 }
7272
7274 {
7276 {
7277 if (ScriptInputUserData.CanStoreInputUserData())
7278 {
7279 ScriptInputUserData ctx = new ScriptInputUserData;
7284 ctx.
Write(destination_entity);
7290 }
7291 }
7292 else if (!
GetGame().IsMultiplayer())
7293 {
7295 }
7296 }
7297
7299 {
7301 }
7302
7304 {
7306 float split_quantity_new;
7308 if (dst.IsValid())
7309 {
7310 int slot_id = dst.GetSlot();
7312
7313 if (quantity > stack_max)
7314 split_quantity_new = stack_max;
7315 else
7316 split_quantity_new = quantity;
7317
7319 {
7321
7322 if (new_item)
7323 {
7324 new_item.SetResultOfSplit(true);
7325 MiscGameplayFunctions.TransferItemProperties(this,new_item);
7327 new_item.
SetQuantity(split_quantity_new,
false,
true);
7328 }
7329
7330 return new_item;
7331 }
7332 }
7333
7334 return null;
7335 }
7336
7338 {
7340 float split_quantity_new;
7342 if (destination_entity)
7343 {
7345 if (quantity > stackable)
7346 split_quantity_new = stackable;
7347 else
7348 split_quantity_new = quantity;
7349
7351 {
7352 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateEntityInCargoEx(
this.GetType(), idx, row, col,
false));
7353 if (new_item)
7354 {
7355 new_item.SetResultOfSplit(true);
7356 MiscGameplayFunctions.TransferItemProperties(this,new_item);
7358 new_item.
SetQuantity(split_quantity_new,
false,
true);
7359 }
7360 }
7361 }
7362 }
7363
7365 {
7367 {
7368 if (ScriptInputUserData.CanStoreInputUserData())
7369 {
7370 ScriptInputUserData ctx = new ScriptInputUserData;
7375 ItemBase destination_entity =
this;
7376 ctx.
Write(destination_entity);
7380 }
7381 }
7382 else if (!
GetGame().IsMultiplayer())
7383 {
7385 }
7386 }
7387
7389 {
7391 float split_quantity_new;
7393 if (player)
7394 {
7396 if (quantity > stackable)
7397 split_quantity_new = stackable;
7398 else
7399 split_quantity_new = quantity;
7400
7402 {
7403 EntityAI in_hands = player.GetHumanInventory().CreateInHands(this.
GetType());
7404 new_item =
ItemBase.Cast(in_hands);
7405 if (new_item)
7406 {
7407 new_item.SetResultOfSplit(true);
7408 MiscGameplayFunctions.TransferItemProperties(this,new_item);
7410 new_item.SetQuantity(split_quantity_new, false, true);
7411 }
7412 }
7413 }
7414 }
7415
7417 {
7419 float split_quantity_new = Math.Floor(quantity * 0.5);
7420
7422 return;
7423
7425
7426 if (new_item)
7427 {
7428 if (new_item.GetQuantityMax() < split_quantity_new)
7429 {
7430 split_quantity_new = new_item.GetQuantityMax();
7431 }
7432
7433 new_item.SetResultOfSplit(true);
7434 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7435
7437 {
7440 }
7441 else
7442 {
7444 new_item.
SetQuantity(split_quantity_new,
false,
true);
7445 }
7446 }
7447 }
7448
7450 {
7452 float split_quantity_new = Math.Floor(quantity / 2);
7453
7455 return;
7456
7457 InventoryLocation invloc = new InventoryLocation;
7459
7461 new_item = player.CreateCopyOfItemInInventoryOrGroundEx(this, true);
7462
7463 if (new_item)
7464 {
7465 if (new_item.GetQuantityMax() < split_quantity_new)
7466 {
7467 split_quantity_new = new_item.GetQuantityMax();
7468 }
7470 {
7473 }
7474 else if (split_quantity_new > 1)
7475 {
7477 new_item.
SetQuantity(split_quantity_new,
false,
true);
7478 }
7479 }
7480 }
7481
7484 {
7485 SetWeightDirty();
7487
7488 if (parent)
7489 parent.OnAttachmentQuantityChangedEx(this, delta);
7490
7492 {
7494 {
7496 }
7498 {
7499 ErrorEx(
"Undefined liquid type quantity changed, please define liquid type first! Using init value.",
ErrorExSeverity.INFO);
7501 }
7502 }
7503
7504 }
7505
7508 {
7509
7510 }
7511
7514 {
7516 }
7517
7519 {
7520 super.EEHealthLevelChanged(oldLevel,newLevel,zone);
7521
7523 {
7524 if (newLevel == GameConstants.STATE_RUINED)
7525 {
7527 EntityAI parent = GetHierarchyParent();
7528 if (parent && parent.IsFireplace())
7529 {
7530 CargoBase cargo = GetInventory().GetCargo();
7531 if (cargo)
7532 {
7534 {
7536 }
7537 }
7538 }
7539 }
7540
7542 {
7543
7545 return;
7546 }
7547
7548 if (
m_Cleanness != 0 && oldLevel < newLevel && newLevel != 0)
7549 {
7551 }
7552 }
7553 }
7554
7555
7557 {
7558 super.OnRightClick();
7559
7561 {
7563 {
7564 if (ScriptInputUserData.CanStoreInputUserData())
7565 {
7566 EntityAI root = GetHierarchyRoot();
7567 Man playerOwner = GetHierarchyRootPlayer();
7568 InventoryLocation dst = new InventoryLocation;
7569
7570
7571 if (!playerOwner && root && root == this)
7572 {
7574 }
7575 else
7576 {
7577
7578 GetInventory().GetCurrentInventoryLocation(dst);
7580 {
7583 {
7585 }
7586 else
7587 {
7589
7590
7591 if (
GetGame().
GetPlayer().GetInventory().HasInventoryReservation(
this, dst))
7592 {
7594 }
7595 else
7596 {
7597 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(null, dst, GameInventory.c_InventoryReservationTimeoutShortMS);
7598 }
7599 }
7600 }
7601 }
7602
7603 ScriptInputUserData ctx = new ScriptInputUserData;
7611 }
7612 }
7613 else if (!
GetGame().IsMultiplayer())
7614 {
7616 }
7617 }
7618 }
7619
7621 {
7622 if (root)
7623 {
7624 vector m4[4];
7625 root.GetTransform(m4);
7626 dst.SetGround(this, m4);
7627 }
7628 else
7629 {
7630 GetInventory().GetCurrentInventoryLocation(dst);
7631 }
7632 }
7633
7634 override bool CanBeCombined(
EntityAI other_item,
bool reservation_check =
true,
bool stack_max_limit =
false)
7635 {
7636
7637 if (!other_item ||
GetType() != other_item.GetType() || (
IsFullQuantity() && other_item.GetQuantity() > 0) || other_item ==
this)
7638 return false;
7639
7640 if (GetHealthLevel() == GameConstants.STATE_RUINED || other_item.GetHealthLevel() == GameConstants.STATE_RUINED)
7641 return false;
7642
7643
7645 return false;
7646
7647
7648 Magazine mag = Magazine.Cast(this);
7649 if (mag)
7650 {
7651 if (mag.GetAmmoCount() >= mag.GetAmmoMax())
7652 return false;
7653
7654 if (stack_max_limit)
7655 {
7656 Magazine other_mag = Magazine.Cast(other_item);
7657 if (other_item)
7658 {
7659 if (mag.GetAmmoCount() + other_mag.GetAmmoCount() > mag.GetAmmoMax())
7660 return false;
7661 }
7662
7663 }
7664 }
7665 else
7666 {
7667
7669 return false;
7670
7672 return false;
7673 }
7674
7675 PlayerBase player = null;
7676 if (CastTo(player, GetHierarchyRootPlayer()))
7677 {
7678 if (player.GetInventory().HasAttachment(this))
7679 return false;
7680
7681 if (player.IsItemsToDelete())
7682 return false;
7683 }
7684
7685 if (reservation_check && (GetInventory().HasInventoryReservation(this, null) || other_item.GetInventory().HasInventoryReservation(other_item, null)))
7686 return false;
7687
7688 int slotID;
7690 if (GetInventory().GetCurrentAttachmentSlotInfo(slotID,
slotName) && GetHierarchyParent().GetInventory().GetSlotLock(slotID))
7691 return false;
7692
7693 return true;
7694 }
7695
7697 {
7699 }
7700
7702 {
7703 return m_IsResultOfSplit;
7704 }
7705
7707 {
7708 m_IsResultOfSplit = value;
7709 }
7710
7712 {
7714 }
7715
7717 {
7718 float other_item_quantity = other_item.GetQuantity();
7719 float this_free_space;
7720
7722
7724
7725 if (other_item_quantity > this_free_space)
7726 {
7727 return this_free_space;
7728 }
7729 else
7730 {
7731 return other_item_quantity;
7732 }
7733 }
7734
7736 {
7738 }
7739
7741 {
7743 return;
7744
7745 if (!IsMagazine() && other_item)
7746 {
7748 if (quantity_used != 0)
7749 {
7750 float hp1 = GetHealth01("","");
7751 float hp2 = other_item.GetHealth01("","");
7752 float hpResult = ((hp1*
GetQuantity()) + (hp2*quantity_used));
7753 hpResult = hpResult / (
GetQuantity() + quantity_used);
7754
7755 hpResult *= GetMaxHealth();
7756 Math.Round(hpResult);
7757 SetHealth("", "Health", hpResult);
7758
7760 other_item.AddQuantity(-quantity_used);
7761 }
7762 }
7764 }
7765
7767 {
7768 #ifdef SERVER
7769 if (!GetHierarchyRootPlayer() && GetHierarchyParent())
7770 GetHierarchyParent().IncreaseLifetimeUp();
7771 #endif
7772 };
7773
7775 {
7776 PlayerBase p = PlayerBase.Cast(player);
7777
7778 array<int> recipesIds = p.m_Recipes;
7779 PluginRecipesManager moduleRecipesManager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
7780 if (moduleRecipesManager)
7781 {
7782 EntityAI itemInHands = player.GetHumanInventory().GetEntityInHands();
7783 moduleRecipesManager.GetValidRecipes(
ItemBase.Cast(
this),
ItemBase.Cast(itemInHands), recipesIds, p);
7784 }
7785
7786 for (int i = 0;i < recipesIds.Count(); i++)
7787 {
7788 int key = recipesIds.Get(i);
7789 string recipeName = moduleRecipesManager.GetRecipeName(key);
7791 }
7792 }
7793
7794
7795 override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
7796 {
7797 super.GetDebugActions(outputList);
7798
7799
7805
7806
7811
7816
7817
7821
7822
7824 {
7828 }
7829
7832
7833
7837
7839
7840 InventoryLocation loc = new InventoryLocation();
7841 GetInventory().GetCurrentInventoryLocation(loc);
7843 {
7844 if (Gizmo_IsSupported())
7847 }
7848
7850 }
7851
7852
7853
7854
7856 {
7857 super.OnAction(action_id, player, ctx);
7858
7860 {
7861 switch (action_id)
7862 {
7865 return true;
7868 return true;
7869 }
7870 }
7871
7873 {
7874 switch (action_id)
7875 {
7877 Delete();
7878 return true;
7879 }
7880 }
7881
7882 if (action_id >=
EActions.RECIPES_RANGE_START && action_id <
EActions.RECIPES_RANGE_END)
7883 {
7884 PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
7885 int idWithoutOffset = action_id -
EActions.RECIPES_RANGE_START;
7886 PlayerBase p = PlayerBase.Cast(player);
7887 if (
EActions.RECIPES_RANGE_START < 1000)
7888 {
7889 float anim_length = plugin_recipes_manager.GetRecipeLengthInSecs(idWithoutOffset);
7890 float specialty_weight = plugin_recipes_manager.GetRecipeSpecialty(idWithoutOffset);
7891 }
7892 }
7893 #ifndef SERVER
7894 else if (action_id ==
EActions.WATCH_PLAYER)
7895 {
7896 PluginDeveloper.SetDeveloperItemClientEx(player);
7897 }
7898 #endif
7900 {
7901 if (action_id >=
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START && action_id <
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_END)
7902 {
7903 int id = action_id -
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START;
7904 OnDebugButtonPressServer(id + 1);
7905 }
7906
7907 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_INJECT_START && action_id <
EActions.DEBUG_AGENTS_RANGE_INJECT_END)
7908 {
7909 int agent_id = action_id -
EActions.DEBUG_AGENTS_RANGE_INJECT_START;
7911 }
7912
7913 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_REMOVE_START && action_id <
EActions.DEBUG_AGENTS_RANGE_REMOVE_END)
7914 {
7915 int agent_id2 = action_id -
EActions.DEBUG_AGENTS_RANGE_REMOVE_START;
7917 }
7918
7919 else if (action_id ==
EActions.ADD_QUANTITY)
7920 {
7921 if (IsMagazine())
7922 {
7923 Magazine mag = Magazine.Cast(this);
7924 mag.ServerSetAmmoCount(mag.GetAmmoCount() + mag.GetAmmoMax() * 0.2);
7925 }
7926 else
7927 {
7929 }
7930
7931 if (m_EM)
7932 {
7933 m_EM.AddEnergy(m_EM.GetEnergyMax() * 0.2);
7934 }
7935
7936 }
7937
7938 else if (action_id ==
EActions.REMOVE_QUANTITY)
7939 {
7940 if (IsMagazine())
7941 {
7942 Magazine mag2 = Magazine.Cast(this);
7943 mag2.ServerSetAmmoCount(mag2.GetAmmoCount() - mag2.GetAmmoMax() * 0.2);
7944 }
7945 else
7946 {
7948 }
7949 if (m_EM)
7950 {
7951 m_EM.AddEnergy(- m_EM.GetEnergyMax() * 0.2);
7952 }
7953
7954 }
7955
7956 else if (action_id ==
EActions.SET_QUANTITY_0)
7957 {
7959
7960 if (m_EM)
7961 {
7962 m_EM.SetEnergy(0);
7963 }
7964 }
7965
7966 else if (action_id ==
EActions.SET_MAX_QUANTITY)
7967 {
7969
7970 if (m_EM)
7971 {
7972 m_EM.SetEnergy(m_EM.GetEnergyMax());
7973 }
7974 }
7975
7976 else if (action_id ==
EActions.ADD_HEALTH)
7977 {
7978 AddHealth("","",GetMaxHealth("","Health")/5);
7979 }
7980 else if (action_id ==
EActions.REMOVE_HEALTH)
7981 {
7982 AddHealth("","",-GetMaxHealth("","Health")/5);
7983 }
7984 else if (action_id ==
EActions.DESTROY_HEALTH)
7985 {
7986 SetHealth01("","",0);
7987 }
7988 else if (action_id ==
EActions.WATCH_ITEM)
7989 {
7991 mid.RegisterDebugItem(
ItemBase.Cast(
this), PlayerBase.Cast(player));
7992 #ifdef DEVELOPER
7993 SetDebugDeveloper_item(this);
7994 #endif
7995 }
7996
7997 else if (action_id ==
EActions.ADD_TEMPERATURE)
7998 {
7999 AddTemperature(20);
8000
8001 }
8002
8003 else if (action_id ==
EActions.REMOVE_TEMPERATURE)
8004 {
8005 AddTemperature(-20);
8006
8007 }
8008
8009 else if (action_id ==
EActions.FLIP_FROZEN)
8010 {
8011 SetFrozen(!GetIsFrozen());
8012
8013 }
8014
8015 else if (action_id ==
EActions.ADD_WETNESS)
8016 {
8018
8019 }
8020
8021 else if (action_id ==
EActions.REMOVE_WETNESS)
8022 {
8024
8025 }
8026
8027 else if (action_id ==
EActions.LIQUIDTYPE_UP)
8028 {
8031
8032
8033 }
8034
8035 else if (action_id ==
EActions.LIQUIDTYPE_DOWN)
8036 {
8039 }
8040
8041 else if (action_id ==
EActions.MAKE_SPECIAL)
8042 {
8043 auto debugParams = DebugSpawnParams.WithPlayer(player);
8044 OnDebugSpawnEx(debugParams);
8045 }
8046
8047 }
8048
8049
8050 return false;
8051 }
8052
8053
8054
8055
8059
8062
8063
8064
8066 {
8067 return false;
8068 }
8069
8070
8072 {
8073 return true;
8074 }
8075
8076
8078 {
8079 return true;
8080 }
8081
8082
8083
8085 {
8086 string config_path =
string.Format(
"CfgVehicles %1 Food FoodStages",
GetType());
8088 }
8089
8092 {
8093 return null;
8094 }
8095
8097 {
8098 return false;
8099 }
8100
8102 {
8103 return false;
8104 }
8105
8109
8110
8112 {
8113 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
8114 return module_repairing.CanRepair(this, item_repair_kit);
8115 }
8116
8117
8118 bool Repair(PlayerBase player,
ItemBase item_repair_kit,
float specialty_weight)
8119 {
8120 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
8121 return module_repairing.Repair(player, this, item_repair_kit, specialty_weight);
8122 }
8123
8124
8126 {
8127
8128
8129
8130
8131
8132
8133
8134
8135 return 1;
8136 }
8137
8138
8139
8141 {
8143 }
8144
8145
8146
8148 {
8150 }
8151
8152
8161 {
8162 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8163
8164 if (player)
8165 {
8166 player.MessageStatus(text);
8167 }
8168 }
8169
8170
8179 {
8180 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8181
8182 if (player)
8183 {
8184 player.MessageAction(text);
8185 }
8186 }
8187
8188
8197 {
8198 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8199
8200 if (player)
8201 {
8202 player.MessageFriendly(text);
8203 }
8204 }
8205
8206
8215 {
8216 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8217
8218 if (player)
8219 {
8220 player.MessageImportant(text);
8221 }
8222 }
8223
8225 {
8226 return true;
8227 }
8228
8229
8230 override bool KindOf(
string tag)
8231 {
8232 bool found = false;
8233 string item_name = this.
GetType();
8236
8237 int array_size = item_tag_array.Count();
8238 for (int i = 0; i < array_size; i++)
8239 {
8240 if (item_tag_array.Get(i) == tag)
8241 {
8242 found = true;
8243 break;
8244 }
8245 }
8246 return found;
8247 }
8248
8249
8251 {
8252
8253 super.OnRPC(sender, rpc_type,ctx);
8254
8255
8256 switch (rpc_type)
8257 {
8258 #ifndef SERVER
8259 case ERPCs.RPC_SOUND_LOCK_ATTACH:
8260 Param2<bool, string> p = new Param2<bool, string>(false, "");
8261
8263 return;
8264
8265 bool play = p.param1;
8266 string soundSet = p.param2;
8267
8268 if (play)
8269 {
8271 {
8273 {
8275 }
8276 }
8277 else
8278 {
8280 }
8281 }
8282 else
8283 {
8285 }
8286
8287 break;
8288 #endif
8289
8290 }
8291
8293 {
8295 }
8296 }
8297
8298
8299
8300
8302 {
8303 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
8304 return plugin.GetID(
name);
8305 }
8306
8308 {
8309 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
8310 return plugin.GetName(id);
8311 }
8312
8315 {
8316
8317
8318 int varFlags;
8319 if (!ctx.
Read(varFlags))
8320 return;
8321
8322 if (varFlags & ItemVariableFlags.FLOAT)
8323 {
8325 }
8326 }
8327
8329 {
8330
8331 super.SerializeNumericalVars(floats_out);
8332
8333
8334
8336 {
8338 }
8339
8341 {
8343 }
8344
8346 {
8348 }
8349
8351 {
8356 }
8357
8359 {
8361 }
8362 }
8363
8365 {
8366
8367 super.DeSerializeNumericalVars(floats);
8368
8369
8370 int index = 0;
8371 int mask = Math.Round(floats.Get(index));
8372
8373 index++;
8374
8376 {
8378 {
8380 }
8381 else
8382 {
8383 float quantity = floats.Get(index);
8385 }
8386 index++;
8387 }
8388
8390 {
8391 float wet = floats.Get(index);
8393 index++;
8394 }
8395
8397 {
8398 int liquidtype = Math.Round(floats.Get(index));
8400 index++;
8401 }
8402
8404 {
8406 index++;
8408 index++;
8410 index++;
8412 index++;
8413 }
8414
8416 {
8417 int cleanness = Math.Round(floats.Get(index));
8419 index++;
8420 }
8421 }
8422
8424 {
8425 super.WriteVarsToCTX(ctx);
8426
8427
8429 {
8431 }
8432
8434 {
8436 }
8437
8439 {
8441 }
8442
8444 {
8445 int r,g,b,a;
8451 }
8452
8454 {
8456 }
8457 }
8458
8460 {
8461 if (!super.ReadVarsFromCTX(ctx,version))
8462 return false;
8463
8464 int intValue;
8465 float value;
8466
8467 if (version < 140)
8468 {
8469 if (!ctx.
Read(intValue))
8470 return false;
8471
8472 m_VariablesMask = intValue;
8473 }
8474
8476 {
8477 if (!ctx.
Read(value))
8478 return false;
8479
8481 {
8483 }
8484 else
8485 {
8487 }
8488 }
8489
8490 if (version < 140)
8491 {
8493 {
8494 if (!ctx.
Read(value))
8495 return false;
8496 SetTemperatureDirect(value);
8497 }
8498 }
8499
8501 {
8502 if (!ctx.
Read(value))
8503 return false;
8505 }
8506
8508 {
8509 if (!ctx.
Read(intValue))
8510 return false;
8512 }
8513
8515 {
8516 int r,g,b,a;
8518 return false;
8520 return false;
8522 return false;
8524 return false;
8525
8527 }
8528
8530 {
8531 if (!ctx.
Read(intValue))
8532 return false;
8534 }
8535
8536 if (version >= 138 && version < 140)
8537 {
8539 {
8540 if (!ctx.
Read(intValue))
8541 return false;
8542 SetFrozen(intValue);
8543 }
8544 }
8545
8546 return true;
8547 }
8548
8549
8551 {
8554 {
8556 }
8557
8558 if (!super.OnStoreLoad(ctx, version))
8559 {
8561 return false;
8562 }
8563
8564 if (version >= 114)
8565 {
8566 bool hasQuickBarIndexSaved;
8567
8568 if (!ctx.
Read(hasQuickBarIndexSaved))
8569 {
8571 return false;
8572 }
8573
8574 if (hasQuickBarIndexSaved)
8575 {
8576 int itmQBIndex;
8577
8578
8579 if (!ctx.
Read(itmQBIndex))
8580 {
8582 return false;
8583 }
8584
8585 PlayerBase parentPlayer = PlayerBase.Cast(GetHierarchyRootPlayer());
8586 if (itmQBIndex != -1 && parentPlayer)
8587 parentPlayer.SetLoadedQuickBarItemBind(this, itmQBIndex);
8588 }
8589 }
8590 else
8591 {
8592
8593 PlayerBase player;
8594 int itemQBIndex;
8595 if (version ==
int.
MAX)
8596 {
8597 if (!ctx.
Read(itemQBIndex))
8598 {
8600 return false;
8601 }
8602 }
8603 else if (Class.CastTo(player, GetHierarchyRootPlayer()))
8604 {
8605
8606 if (!ctx.
Read(itemQBIndex))
8607 {
8609 return false;
8610 }
8611 if (itemQBIndex != -1 && player)
8612 player.SetLoadedQuickBarItemBind(this,itemQBIndex);
8613 }
8614 }
8615
8616 if (version < 140)
8617 {
8618
8619 if (!LoadVariables(ctx, version))
8620 {
8622 return false;
8623 }
8624 }
8625
8626
8628 {
8630 return false;
8631 }
8632 if (version >= 132)
8633 {
8635 if (raib)
8636 {
8638 {
8640 return false;
8641 }
8642 }
8643 }
8644
8646 return true;
8647 }
8648
8649
8650
8652 {
8653 super.OnStoreSave(ctx);
8654
8655 PlayerBase player;
8656 if (PlayerBase.CastTo(player,GetHierarchyRootPlayer()))
8657 {
8659
8660 int itemQBIndex = -1;
8661 itemQBIndex = player.FindQuickBarEntityIndex(this);
8662 ctx.
Write(itemQBIndex);
8663 }
8664 else
8665 {
8667 }
8668
8670
8672 if (raib)
8673 {
8675 }
8676 }
8677
8678
8680 {
8681 super.AfterStoreLoad();
8682
8684 {
8686 }
8687
8689 {
8692 }
8693 }
8694
8696 {
8697 super.EEOnAfterLoad();
8698
8700 {
8702 }
8703
8706 }
8707
8709 {
8710 return false;
8711 }
8712
8713
8714
8716 {
8718 {
8719 #ifdef PLATFORM_CONSOLE
8720
8722 {
8724 if (menu)
8725 {
8727 }
8728 }
8729 #endif
8730 }
8731
8733 {
8736 }
8737
8739 {
8740 SetWeightDirty();
8742 }
8744 {
8747 }
8748
8750 {
8753 }
8755 {
8758 }
8759
8760 super.OnVariablesSynchronized();
8761 }
8762
8763
8764
8766 override bool SetQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false,
bool allow_client =
false,
bool clamp_to_stack_max =
true)
8767 {
8768 if (!IsServerCheck(allow_client))
8769 return false;
8770
8772 return false;
8773
8776
8777 if (value <= (min + 0.001))
8778 value = min;
8779
8780 if (value == min)
8781 {
8782 if (destroy_config)
8783 {
8784 bool dstr = ConfigGetBool("varQuantityDestroyOnMin");
8785 if (dstr)
8786 {
8788 this.Delete();
8789 return true;
8790 }
8791 }
8792 else if (destroy_forced)
8793 {
8795 this.Delete();
8796 return true;
8797 }
8798
8800 }
8801
8804
8806 {
8808
8809 if (delta)
8811 }
8812
8814
8815 return false;
8816 }
8817
8818
8820 bool AddQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
8821 {
8823 }
8824
8826 {
8829 }
8830
8832 {
8835 }
8836
8838 override void SetQuantityNormalized(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
8839 {
8840 float value_clamped = Math.Clamp(value, 0, 1);
8842 SetQuantity(result, destroy_config, destroy_forced);
8843 }
8844
8845
8848 {
8850 }
8851
8853 {
8855 }
8856
8857
8858
8859
8860
8861
8862
8863
8864
8865
8867 {
8868 int slot = -1;
8869 if (GetInventory())
8870 {
8871 InventoryLocation il = new InventoryLocation;
8872 GetInventory().GetCurrentInventoryLocation(il);
8874 }
8875
8877 }
8878
8880 {
8881 float quantity_max = 0;
8882
8884 {
8885 if (attSlotID != -1)
8886 quantity_max = InventorySlots.GetStackMaxForSlotId(attSlotID);
8887
8888 if (quantity_max <= 0)
8890 }
8891
8892 if (quantity_max <= 0)
8894
8895 return quantity_max;
8896 }
8897
8899 {
8901 }
8902
8904 {
8906 }
8907
8908
8910 {
8912 }
8913
8915 {
8917 }
8918
8920 {
8922 }
8923
8924
8926 {
8927
8928 float weightEx = GetWeightEx();
8929 float special = GetInventoryAndCargoWeight();
8930 return weightEx - special;
8931 }
8932
8933
8935 {
8937 }
8938
8940 {
8942 {
8943 #ifdef DEVELOPER
8944 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
8945 {
8946 WeightDebugData data1 = WeightDebug.GetWeightDebug(this);
8948 }
8949 #endif
8950
8952 }
8953 else if (HasEnergyManager())
8954 {
8955 #ifdef DEVELOPER
8956 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
8957 {
8958 WeightDebugData data2 = WeightDebug.GetWeightDebug(this);
8959 data2.
SetCalcDetails(
"TIB2: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " + GetCompEM().
GetEnergy()+
"(energy) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit)");
8960 }
8961 #endif
8962 return super.GetWeightSpecialized(forceRecalc) + (GetCompEM().GetEnergy() * ConfigGetFloat("weightPerQuantityUnit")) + GetConfigWeightModified();
8963 }
8964 else
8965 {
8966 #ifdef DEVELOPER
8967 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
8968 {
8969 WeightDebugData data3 = WeightDebug.GetWeightDebug(this);
8970 data3.
SetCalcDetails(
"TIB3: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " +
GetQuantity()+
"(quantity) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit))");
8971 }
8972 #endif
8973 return super.GetWeightSpecialized(forceRecalc) + (
GetQuantity() * ConfigGetFloat(
"weightPerQuantityUnit")) + GetConfigWeightModified();
8974 }
8975 }
8976
8979 {
8980 int item_count = 0;
8982
8983 if (GetInventory().GetCargo() != NULL)
8984 {
8985 item_count = GetInventory().GetCargo().GetItemCount();
8986 }
8987
8988 for (int i = 0; i < GetInventory().AttachmentCount(); i++)
8989 {
8990 Class.CastTo(item,GetInventory().GetAttachmentFromIndex(i));
8991 if (item)
8992 item_count += item.GetNumberOfItems();
8993 }
8994 return item_count;
8995 }
8996
8999 {
9000 float weight = 0;
9001 float wetness = 1;
9002 if (include_wetness)
9005 {
9006 weight = wetness * m_ConfigWeight;
9007 }
9009 {
9010 weight = 1;
9011 }
9012 return weight;
9013 }
9014
9015
9016
9018 {
9019 if ((
GetGame().IsServer() || !
GetGame().IsMultiplayer()) && GetInventory())
9020 {
9021 GameInventory inv = GetInventory();
9022 array<EntityAI> items = new array<EntityAI>;
9024 for (int i = 0; i < items.Count(); i++)
9025 {
9027 if (item)
9028 {
9030 }
9031 }
9032 }
9033 }
9034
9035
9036
9037
9039 {
9040 float energy = 0;
9041 if (HasEnergyManager())
9042 {
9043 energy = GetCompEM().GetEnergy();
9044 }
9045 return energy;
9046 }
9047
9048
9050 {
9051 super.OnEnergyConsumed();
9052
9054 }
9055
9057 {
9058 super.OnEnergyAdded();
9059
9061 }
9062
9063
9065 {
9066 if (
GetGame().IsServer() && HasEnergyManager() && GetCompEM().HasConversionOfEnergyToQuantity())
9067 {
9069 {
9070 float energy_0to1 = GetCompEM().GetEnergy0To1();
9072 }
9073 }
9074 }
9075
9076
9078 {
9079 return ConfigGetFloat("heatIsolation");
9080 }
9081
9083 {
9085 }
9086
9088 {
9089 string paramPath =
string.Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Drying %2",
GetType(), pIncrementName);
9090 if (
GetGame().ConfigIsExisting(paramPath))
9092
9093 return 0.0;
9094 }
9095
9097 {
9098 string paramPath =
string.
Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Soaking %2",
GetType(), pIncrementName);
9099 if (
GetGame().ConfigIsExisting(paramPath))
9101
9102 return 0.0;
9103 }
9104
9105 override void SetWet(
float value,
bool allow_client =
false)
9106 {
9107 if (!IsServerCheck(allow_client))
9108 return;
9109
9112
9114
9115 m_VarWet = Math.Clamp(value, min, max);
9116
9118 {
9121 }
9122 }
9123
9124 override void AddWet(
float value)
9125 {
9127 }
9128
9130 {
9132 }
9133
9135 {
9137 }
9138
9140 {
9142 }
9143
9145 {
9147 }
9148
9150 {
9152 }
9153
9155 {
9158 if (newLevel != oldLevel)
9159 {
9161 }
9162 }
9163
9165 {
9166 SetWeightDirty();
9167 }
9168
9170 {
9171 return GetWetLevelInternal(
m_VarWet);
9172 }
9173
9174
9175
9177 {
9179 }
9180
9182 {
9184 }
9185
9187 {
9189 }
9190
9192 {
9194 }
9195
9196
9197
9199 {
9200 if (ConfigIsExisting("itemModelLength"))
9201 {
9202 return ConfigGetFloat("itemModelLength");
9203 }
9204 return 0;
9205 }
9206
9208 {
9209 if (ConfigIsExisting("itemAttachOffset"))
9210 {
9211 return ConfigGetFloat("itemAttachOffset");
9212 }
9213 return 0;
9214 }
9215
9216 override void SetCleanness(
int value,
bool allow_client =
false)
9217 {
9218 if (!IsServerCheck(allow_client))
9219 return;
9220
9222
9224
9227 }
9228
9230 {
9232 }
9233
9235 {
9236 return true;
9237 }
9238
9239
9240
9241
9243 {
9245 }
9246
9248 {
9250 }
9251
9252
9253
9254
9255 override void SetColor(
int r,
int g,
int b,
int a)
9256 {
9262 }
9264 override void GetColor(out
int r,out
int g,out
int b,out
int a)
9265 {
9270 }
9271
9273 {
9275 }
9276
9279 {
9280 int r,g,b,a;
9282 r = r/255;
9283 g = g/255;
9284 b = b/255;
9285 a = a/255;
9286 return MiscGameplayFunctions.GetColorString(r, g, b, a);
9287 }
9288
9289
9290
9291 override void SetLiquidType(
int value,
bool allow_client =
false)
9292 {
9293 if (!IsServerCheck(allow_client))
9294 return;
9295
9300 }
9301
9303 {
9304 return ConfigGetInt("varLiquidTypeInit");
9305 }
9306
9308 {
9310 }
9311
9313 {
9315 SetFrozen(false);
9316 }
9317
9320 {
9321 player.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
9322 }
9323
9324
9327 {
9328 PlayerBase nplayer;
9329 if (PlayerBase.CastTo(nplayer, player))
9330 {
9332
9333 nplayer.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
9334 }
9335 }
9336
9337
9340 {
9341 PlayerBase nplayer;
9342 if (PlayerBase.CastTo(nplayer,player))
9343 {
9344
9345 nplayer.SetEnableQuickBarEntityShortcut(this,false);
9346
9347 }
9348
9349
9350 player.GetHumanInventory().ClearUserReservedLocationForContainer(this);
9351
9352
9353 if (HasEnergyManager())
9354 {
9355 GetCompEM().UpdatePlugState();
9356 }
9357 }
9358
9359
9361 {
9362 super.OnPlacementStarted(player);
9363
9365 }
9366
9367 override void OnPlacementComplete(Man player, vector position =
"0 0 0", vector orientation =
"0 0 0")
9368 {
9370 {
9371 m_AdminLog.OnPlacementComplete(player,
this);
9372 }
9373
9374 super.OnPlacementComplete(player, position, orientation);
9375 }
9376
9377
9378
9379
9380
9382 {
9384 {
9385 return true;
9386 }
9387 else
9388 {
9389 return false;
9390 }
9391 }
9392
9393
9395 {
9397 {
9399 }
9400 }
9401
9402
9404 {
9406 }
9407
9409 {
9411 }
9412
9413 override void InsertAgent(
int agent,
float count = 1)
9414 {
9415 if (count < 1)
9416 return;
9417
9419 }
9420
9423 {
9425 }
9426
9427
9429 {
9431 }
9432
9433
9434
9435
9436
9437
9438
9439
9440
9441
9442
9443
9444
9445
9446
9447
9448
9449
9450
9451
9452
9453
9454
9455
9456
9457
9458
9459
9460
9461
9462
9463
9464
9465
9466
9467
9468
9469
9470
9471
9472
9473
9475 {
9477 return false;
9478 return true;
9479 }
9480
9482 {
9483
9485 }
9486
9487
9490 {
9491 super.CheckForRoofLimited(timeTresholdMS);
9492
9494 if ((time - m_PreviousRoofTestTime) >= timeTresholdMS)
9495 {
9496 m_PreviousRoofTestTime = time;
9497 SetRoofAbove(MiscGameplayFunctions.IsUnderRoof(this));
9498 }
9499 }
9500
9501
9503 {
9505 {
9506 return 0;
9507 }
9508
9509 if (GetInventory().GetAttachmentSlotsCount() != 0)
9510 {
9511 ItemBase filter =
ItemBase.Cast(FindAttachmentBySlotName(
"GasMaskFilter"));
9512 if (filter)
9513 return filter.GetProtectionLevel(type, false, system);
9514 else
9515 return 0;
9516 }
9517
9518 string subclassPath, entryName;
9519
9520 switch (type)
9521 {
9523 entryName = "biological";
9524 break;
9526 entryName = "chemical";
9527 break;
9528 default:
9529 entryName = "biological";
9530 break;
9531 }
9532
9533 subclassPath =
"CfgVehicles " + this.
GetType() +
" Protection ";
9534
9536 }
9537
9538
9539
9542 {
9543 if (!IsMagazine())
9545
9547 }
9548
9549
9550
9551
9552
9557 {
9558 return true;
9559 }
9560
9562 {
9564 }
9565
9566
9567
9568
9569
9571 {
9572 if (parent)
9573 {
9574 if (parent.IsInherited(DayZInfected))
9575 return true;
9576
9577 if (!parent.IsRuined())
9578 return true;
9579 }
9580
9581 return true;
9582 }
9583
9585 {
9586 if (!super.CanPutAsAttachment(parent))
9587 {
9588 return false;
9589 }
9590
9591 if (!IsRuined() && !parent.IsRuined())
9592 {
9593 return true;
9594 }
9595
9596 return false;
9597 }
9598
9600 {
9601
9602
9603
9604
9605 return super.CanReceiveItemIntoCargo(item);
9606 }
9607
9609 {
9610
9611
9612
9613
9614 GameInventory attachmentInv = attachment.GetInventory();
9616 {
9617 if (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase))
9618 return false;
9619 }
9620
9621 InventoryLocation loc = new InventoryLocation();
9622 attachment.GetInventory().GetCurrentInventoryLocation(loc);
9623 if (loc && loc.
IsValid() && !GetInventory().AreChildrenAccessible())
9624 return false;
9625
9626 return super.CanReceiveAttachment(attachment, slotId);
9627 }
9628
9630 {
9631 if (!super.CanReleaseAttachment(attachment))
9632 return false;
9633
9634 return GetInventory().AreChildrenAccessible();
9635 }
9636
9637
9638
9639
9640
9641
9642
9643
9644
9645
9646
9647
9648
9649
9650
9651
9652
9653
9654
9655
9656
9658 {
9659 int id = muzzle_owner.GetMuzzleID();
9660 array<ref WeaponParticlesOnFire> WPOF_array =
m_OnFireEffect.Get(
id);
9661
9662 if (WPOF_array)
9663 {
9664 for (int i = 0; i < WPOF_array.Count(); i++)
9665 {
9666 WeaponParticlesOnFire WPOF = WPOF_array.Get(i);
9667
9668 if (WPOF)
9669 {
9670 WPOF.OnActivate(weapon, muzzle_index, ammoType, muzzle_owner, suppressor, config_to_search);
9671 }
9672 }
9673 }
9674 }
9675
9676
9678 {
9679 int id = muzzle_owner.GetMuzzleID();
9681
9682 if (WPOBE_array)
9683 {
9684 for (int i = 0; i < WPOBE_array.Count(); i++)
9685 {
9686 WeaponParticlesOnBulletCasingEject WPOBE = WPOBE_array.Get(i);
9687
9688 if (WPOBE)
9689 {
9690 WPOBE.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
9691 }
9692 }
9693 }
9694 }
9695
9696
9698 {
9699 int id = muzzle_owner.GetMuzzleID();
9700 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
9701
9702 if (WPOOH_array)
9703 {
9704 for (int i = 0; i < WPOOH_array.Count(); i++)
9705 {
9706 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
9707
9708 if (WPOOH)
9709 {
9710 WPOOH.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
9711 }
9712 }
9713 }
9714 }
9715
9716
9718 {
9719 int id = muzzle_owner.GetMuzzleID();
9720 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
9721
9722 if (WPOOH_array)
9723 {
9724 for (int i = 0; i < WPOOH_array.Count(); i++)
9725 {
9726 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
9727
9728 if (WPOOH)
9729 {
9730 WPOOH.OnUpdate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9731 }
9732 }
9733 }
9734 }
9735
9736
9738 {
9739 int id = muzzle_owner.GetMuzzleID();
9740 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
9741
9742 if (WPOOH_array)
9743 {
9744 for (int i = 0; i < WPOOH_array.Count(); i++)
9745 {
9746 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
9747
9748 if (WPOOH)
9749 {
9750 WPOOH.OnDeactivate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9751 }
9752 }
9753 }
9754 }
9755
9756
9757
9759 {
9761 {
9762 return true;
9763 }
9764
9765 return false;
9766 }
9767
9769 {
9771 {
9772 return true;
9773 }
9774
9775 return false;
9776 }
9777
9779 {
9781 {
9782 return true;
9783 }
9784
9785 return false;
9786 }
9787
9789 {
9790 return false;
9791 }
9792
9795 {
9796 return UATimeSpent.DEFAULT_DEPLOY;
9797 }
9798
9799
9800
9801
9803 {
9805 SetSynchDirty();
9806 }
9807
9809 {
9811 }
9812
9813
9815 {
9816 return false;
9817 }
9818
9821 {
9822 string att_type = "None";
9823
9824 if (ConfigIsExisting("soundAttType"))
9825 {
9826 att_type = ConfigGetString("soundAttType");
9827 }
9828
9830 }
9831
9833 {
9835 }
9836
9837
9838
9839
9840
9846
9848 {
9851
9853 }
9854
9855
9857 {
9859 return;
9860
9862
9865
9868
9869 SoundParameters params = new SoundParameters();
9873 }
9874
9875
9877 {
9879 return;
9880
9882 SetSynchDirty();
9883
9886 }
9887
9888
9890 {
9892 return;
9893
9895 SetSynchDirty();
9896
9899 }
9900
9902 {
9904 }
9905
9907 {
9909 }
9910
9913 {
9914 if (!
GetGame().IsDedicatedServer())
9915 {
9916 if (ConfigIsExisting("attachSoundSet"))
9917 {
9918 string cfg_path = "";
9919 string soundset = "";
9921
9924 ConfigGetTextArray("attachSoundSet",cfg_soundset_array);
9925 ConfigGetTextArray("attachSoundSlot",cfg_slot_array);
9926
9927 if (cfg_soundset_array.Count() > 0 && cfg_soundset_array.Count() == cfg_slot_array.Count())
9928 {
9929 for (int i = 0; i < cfg_soundset_array.Count(); i++)
9930 {
9931 if (cfg_slot_array[i] == slot_type)
9932 {
9933 soundset = cfg_soundset_array[i];
9934 break;
9935 }
9936 }
9937 }
9938
9939 if (soundset != "")
9940 {
9941 EffectSound sound = SEffectManager.PlaySound(soundset,
GetPosition());
9943 }
9944 }
9945 }
9946 }
9947
9949 {
9950
9951 }
9952
9953 void OnApply(PlayerBase player);
9954
9956 {
9957 return 1.0;
9958 };
9959
9961 {
9963 }
9964
9966 {
9968 }
9969
9971
9973 {
9974 SetDynamicPhysicsLifeTime(0.01);
9976 }
9977
9979 {
9980 array<string> zone_names = new array<string>;
9981 GetDamageZones(zone_names);
9982 for (int i = 0; i < zone_names.Count(); i++)
9983 {
9984 SetHealthMax(zone_names.Get(i),"Health");
9985 }
9986 SetHealthMax("","Health");
9987 }
9988
9991 {
9992 float global_health = GetHealth01("","Health");
9993 array<string> zones = new array<string>;
9994 GetDamageZones(zones);
9995
9996 for (int i = 0; i < zones.Count(); i++)
9997 {
9998 SetHealth01(zones.Get(i),"Health",global_health);
9999 }
10000 }
10001
10004 {
10005 return IsExclusionFlagPresent(PlayerBase.GetFaceCoverageShaveValues());
10006 }
10007
10009 {
10010 if (!hasRootAsPlayer)
10011 {
10012 if (refParentIB)
10013 {
10014
10015 if ((refParentIB.GetWet() >= GameConstants.STATE_SOAKING_WET) && (
m_VarWet <
m_VarWetMax))
10016 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_INSIDE);
10017
10018 else if ((refParentIB.GetLiquidType() != 0) && (refParentIB.GetQuantity() > 0) && (
m_VarWet <
m_VarWetMax))
10019 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_LIQUID);
10020
10023 }
10024 else
10025 {
10026
10029 }
10030 }
10031 }
10032
10034 {
10036 {
10037 float target =
g_Game.GetMission().GetWorldData().GetBaseEnvTemperatureAtObject(
this);
10038 if (
GetTemperature() != target || !IsFreezeThawProgressFinished())
10039 {
10040 float heatPermCoef = 1.0;
10042 while (ent)
10043 {
10044 heatPermCoef *= ent.GetHeatPermeabilityCoef();
10045 ent = ent.GetHierarchyParent();
10046 }
10047
10048 SetTemperatureEx(
new TemperatureDataInterpolated(target,
ETemperatureAccessTypes.ACCESS_WORLD,delta,GameConstants.TEMP_COEF_WORLD,heatPermCoef));
10049 }
10050 }
10051 }
10052
10054 {
10055
10056 EntityAI parent = GetHierarchyParent();
10057 if (!parent)
10058 {
10059 hasParent = false;
10060 hasRootAsPlayer = false;
10061 }
10062 else
10063 {
10064 hasParent = true;
10065 hasRootAsPlayer = (GetHierarchyRootPlayer() != null);
10066 refParentIB =
ItemBase.Cast(parent);
10067 }
10068 }
10069
10070 protected void ProcessDecay(
float delta,
bool hasRootAsPlayer)
10071 {
10072
10073 }
10074
10076 {
10077
10078 return false;
10079 }
10080
10082 {
10083
10084
10085 return false;
10086 }
10087
10089 {
10090
10091 return false;
10092 }
10093
10096 {
10097 return !GetIsFrozen() &&
IsOpen();
10098 }
10099
10101 {
10102 bool hasParent = false, hasRootAsPlayer = false;
10104
10105 bool wwtu =
g_Game.IsWorldWetTempUpdateEnabled();
10106 bool foodDecay =
g_Game.IsFoodDecayEnabled();
10107
10108 if (wwtu || foodDecay)
10109 {
10113
10114 if (processWetness || processTemperature || processDecay)
10115 {
10117
10118 if (processWetness)
10119 ProcessItemWetness(m_ElapsedSinceLastUpdate, hasParent, hasRootAsPlayer, refParentIB);
10120
10121 if (processTemperature)
10123
10124 if (processDecay)
10125 ProcessDecay(m_ElapsedSinceLastUpdate, hasRootAsPlayer);
10126 }
10127 }
10128 }
10129
10132 {
10134 }
10135
10137 {
10140
10141 return super.GetTemperatureFreezeThreshold();
10142 }
10143
10145 {
10148
10149 return super.GetTemperatureThawThreshold();
10150 }
10151
10153 {
10156
10157 return super.GetItemOverheatThreshold();
10158 }
10159
10161 {
10163 return Math.Lerp(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureFreezeTime()),
GetQuantityNormalized());
10164
10165 return super.GetTemperatureFreezeTime();
10166 }
10167
10169 {
10171 return Math.Lerp(GameConstants.TEMPERATURE_TIME_THAW_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureThawTime()),
GetQuantityNormalized());
10172
10173 return super.GetTemperatureThawTime();
10174 }
10175
10180
10182 {
10183 return (item.IsKindOf("Cauldron") || item.IsKindOf("Pot") || item.IsKindOf("FryingPan") || item.IsKindOf("SmallProtectorCase") || (item.IsKindOf("PortableGasStove") && item.FindAttachmentBySlotName("CookingEquipment")));
10184 }
10185
10187 {
10188 MiscGameplayFunctions.TransferItemProperties(oldItem, this);
10189 }
10190
10193 {
10195 }
10196
10198 {
10200 }
10201
10203 {
10205 }
10206
10209 {
10210 return null;
10211 }
10212
10215 {
10216 return false;
10217 }
10218
10220 {
10222 {
10225 if (!trg)
10226 {
10228 explosive = this;
10229 }
10230
10231 explosive.PairRemote(trg);
10233
10234 int persistentID = RemotelyActivatedItemBehaviour.GeneratePersistentID();
10235 trg.SetPersistentPairID(persistentID);
10236 explosive.SetPersistentPairID(persistentID);
10237
10238 return true;
10239 }
10240 return false;
10241 }
10242
10245 {
10246 float ret = 1.0;
10249 ret *= GetHealth01();
10250
10251 return ret;
10252 }
10253
10254 #ifdef DEVELOPER
10255 override void SetDebugItem()
10256 {
10257 super.SetDebugItem();
10258 _itemBase = this;
10259 }
10260
10262 {
10263 string text = super.GetDebugText();
10264
10266 text +=
string.
Format(
"Heat isolation(modified): %1\n", MiscGameplayFunctions.GetCurrentItemHeatIsolation(
this));
10267
10268 return text;
10269 }
10270 #endif
10271
10273 {
10274 return true;
10275 }
10276
10278
10280
10282 {
10285 }
10286
10287
10295
10311}
10312
10314{
10316 if (entity)
10317 {
10318 bool is_item = entity.IsInherited(
ItemBase);
10319 if (is_item && full_quantity)
10320 {
10323 }
10324 }
10325 else
10326 {
10328 return NULL;
10329 }
10330 return entity;
10331}
10332
10334{
10335 if (item)
10336 {
10337 if (health > 0)
10338 item.SetHealth("", "", health);
10339
10340 if (item.CanHaveTemperature())
10341 {
10343 if (item.CanFreeze())
10344 item.SetFrozen(false);
10345 }
10346
10347 if (item.HasEnergyManager())
10348 {
10349 if (quantity >= 0)
10350 {
10351 item.GetCompEM().SetEnergy0To1(quantity);
10352 }
10353 else
10354 {
10356 }
10357 }
10358 else if (item.IsMagazine())
10359 {
10360 Magazine mag = Magazine.Cast(item);
10361 if (quantity >= 0)
10362 {
10363 mag.ServerSetAmmoCount(mag.GetAmmoMax() * quantity);
10364 }
10365 else
10366 {
10368 }
10369
10370 }
10371 else
10372 {
10373 if (quantity >= 0)
10374 {
10375 item.SetQuantityNormalized(quantity, false);
10376 }
10377 else
10378 {
10380 }
10381
10382 }
10383 }
10384}
10385
10386#ifdef DEVELOPER
10388#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.