5785{
5787 {
5788 return true;
5789 }
5790};
5791
5792
5793
5795{
5799
5801
5804
5805
5806
5807
5808
5817
5823
5828
5833
5854 protected bool m_IsResultOfSplit
5855
5857
5862
5863
5864
5866
5870
5871
5872
5874
5877
5878
5879
5885
5886
5894
5897
5898
5900
5901
5903
5904
5909
5910
5915
5916
5918
5919
5921 {
5926
5927 if (!
GetGame().IsDedicatedServer())
5928 {
5930 {
5932
5934 {
5936 }
5937 }
5938
5941 }
5942
5943 m_OldLocation = null;
5944
5946 {
5948 }
5949
5950 if (ConfigIsExisting("headSelectionsToHide"))
5951 {
5954 }
5955
5957 if (ConfigIsExisting("hideSelectionsByinventorySlot"))
5958 {
5960 }
5961
5963
5964 m_IsResultOfSplit = false;
5965
5967 }
5968
5970 {
5971 super.InitItemVariables();
5972
5978 m_Count = ConfigGetInt(
"count");
5979
5982
5987
5990
5995
6007
6011
6012
6015 if (ConfigIsExisting("canBeSplit"))
6016 {
6019 }
6020
6022 if (ConfigIsExisting("itemBehaviour"))
6024
6025
6028 RegisterNetSyncVariableInt("m_VarLiquidType");
6029 RegisterNetSyncVariableInt("m_Cleanness",0,1);
6030
6031 RegisterNetSyncVariableBoolSignal("m_WantPlayImpactSound");
6032 RegisterNetSyncVariableFloat("m_ImpactSpeed");
6033 RegisterNetSyncVariableInt("m_ImpactSoundSurfaceHash");
6034
6035 RegisterNetSyncVariableInt("m_ColorComponentR", 0, 255);
6036 RegisterNetSyncVariableInt("m_ColorComponentG", 0, 255);
6037 RegisterNetSyncVariableInt("m_ColorComponentB", 0, 255);
6038 RegisterNetSyncVariableInt("m_ColorComponentA", 0, 255);
6039
6040 RegisterNetSyncVariableBool("m_IsBeingPlaced");
6041 RegisterNetSyncVariableBool("m_IsTakeable");
6042 RegisterNetSyncVariableBool("m_IsHologram");
6043
6046 {
6049 }
6050
6052
6054 if (ConfigIsExisting("temperaturePerQuantityWeight"))
6056
6057 }
6058
6060 {
6062 }
6063
6065 {
6068 {
6073 }
6074 }
6075
6076 override void GetActions(
typename action_input_type, out array<ActionBase_Basic> actions)
6077 {
6079 {
6082 }
6083
6085 }
6086
6088 {
6094 }
6095
6097
6099 {
6101
6102 if (!action)
6103 {
6104 Debug.LogError(
"Action " + actionName +
" dosn't exist!");
6105 return;
6106 }
6107
6109 if (!ai)
6110 {
6112 return;
6113 }
6114
6116 if (!action_array)
6117 {
6118 action_array = new array<ActionBase_Basic>;
6120 }
6121 if (LogManager.IsActionLogEnable())
6122 {
6123 Debug.ActionLog(action.ToString() +
" -> " + ai,
this.ToString() ,
"n/a",
"Add action");
6124 }
6125
6126 if (action_array.Find(action) != -1)
6127 {
6128 Debug.Log(
"Action " + action.Type() +
" already added to " +
this +
", skipping!");
6129 }
6130 else
6131 {
6132 action_array.Insert(action);
6133 }
6134 }
6135
6137 {
6139 ActionBase action = player.GetActionManager().GetAction(actionName);
6142
6143 if (action_array)
6144 {
6145 action_array.RemoveItem(action);
6146 }
6147 }
6148
6149
6150
6152 {
6153 ActionOverrideData overrideData = new ActionOverrideData();
6157
6159 if (!actionMap)
6160 {
6163 }
6164
6165 actionMap.Insert(this.
Type(), overrideData);
6166
6167 }
6168
6170
6172
6173
6175 {
6178
6181
6182 string config_to_search = "CfgVehicles";
6183 string muzzle_owner_config;
6184
6186 {
6187 if (IsInherited(Weapon))
6188 config_to_search = "CfgWeapons";
6189
6190 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
6191
6192 string config_OnFire_class = muzzle_owner_config + "Particles " + "OnFire ";
6193
6195
6196 if (config_OnFire_subclass_count > 0)
6197 {
6198 array<ref WeaponParticlesOnFire> WPOF_array = new array<ref WeaponParticlesOnFire>;
6199
6200 for (int i = 0; i < config_OnFire_subclass_count; i++)
6201 {
6202 string particle_class = "";
6204 string config_OnFire_entry = config_OnFire_class + particle_class;
6205 WeaponParticlesOnFire WPOF = new WeaponParticlesOnFire(this, config_OnFire_entry);
6206 WPOF_array.Insert(WPOF);
6207 }
6208
6209
6211 }
6212 }
6213
6215 {
6216 config_to_search = "CfgWeapons";
6217 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
6218
6219 string config_OnBulletCasingEject_class = muzzle_owner_config + "Particles " + "OnBulletCasingEject ";
6220
6222
6223 if (config_OnBulletCasingEject_count > 0 && IsInherited(Weapon))
6224 {
6225 array<ref WeaponParticlesOnBulletCasingEject> WPOBE_array = new array<ref WeaponParticlesOnBulletCasingEject>;
6226
6227 for (i = 0; i < config_OnBulletCasingEject_count; i++)
6228 {
6229 string particle_class2 = "";
6231 string config_OnBulletCasingEject_entry = config_OnBulletCasingEject_class + particle_class2;
6232 WeaponParticlesOnBulletCasingEject WPOBE = new WeaponParticlesOnBulletCasingEject(this, config_OnBulletCasingEject_entry);
6233 WPOBE_array.Insert(WPOBE);
6234 }
6235
6236
6238 }
6239 }
6240 }
6241
6242
6244 {
6247
6249 {
6250 string config_to_search = "CfgVehicles";
6251
6252 if (IsInherited(Weapon))
6253 config_to_search = "CfgWeapons";
6254
6255 string muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
6256 string config_OnOverheating_class = muzzle_owner_config + "Particles " + "OnOverheating ";
6257
6258 if (
GetGame().ConfigIsExisting(config_OnOverheating_class))
6259 {
6260
6262
6264 {
6266 string error =
"Error reading config " +
GetType() +
">Particles>OnOverheating - Parameter shotsToStartOverheating is configured wrong or is missing! Its value must be 1 or higher!";
6268 return;
6269 }
6270
6273
6274
6275
6277 array<ref WeaponParticlesOnOverheating> WPOOH_array = new array<ref WeaponParticlesOnOverheating>;
6278
6279 for (int i = 0; i < config_OnOverheating_subclass_count; i++)
6280 {
6281 string particle_class = "";
6283 string config_OnOverheating_entry = config_OnOverheating_class + particle_class;
6285
6286 if (entry_type == CT_CLASS)
6287 {
6288 WeaponParticlesOnOverheating WPOF = new WeaponParticlesOnOverheating(this, config_OnOverheating_entry);
6289 WPOOH_array.Insert(WPOF);
6290 }
6291 }
6292
6293
6295 }
6296 }
6297 }
6298
6300 {
6302 }
6303
6305 {
6307 {
6309
6312
6315
6316 CheckOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
6317 }
6318 }
6319
6321 {
6323 UpdateOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
6324
6326 StartOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
6327
6329 StopOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
6330
6332 {
6334 }
6335 }
6336
6338 {
6340 }
6341
6343 {
6346 else
6348
6350 {
6353 }
6354 else
6355 {
6358
6361 }
6362
6364 }
6365
6367 {
6369 ItemBase.PlayOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
6370 }
6371
6373 {
6375 ItemBase.UpdateOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
6377 }
6378
6380 {
6382 ItemBase.StopOverheatingParticles(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
6383 }
6384
6386 {
6389
6390 OverheatingParticle OP = new OverheatingParticle();
6395
6397 }
6398
6400 {
6403
6404 return -1;
6405 }
6406
6408 {
6410 {
6413
6414 for (int i = count; i > 0; --i)
6415 {
6416 int id = i - 1;
6419
6422
6423 if (overheat_coef < overheat_min && overheat_coef >= overheat_max)
6424 {
6425 if (p)
6426 {
6429 }
6430 }
6431 }
6432 }
6433 }
6434
6436 {
6438 {
6440 {
6441 int id = i - 1;
6443
6444 if (OP)
6445 {
6447
6448 if (p)
6449 {
6451 }
6452
6453 delete OP;
6454 }
6455 }
6456
6459 }
6460 }
6461
6464 {
6465 return 0.0;
6466 }
6467
6468
6470 {
6471 return 250;
6472 }
6473
6475 {
6476 return 0;
6477 }
6478
6481 {
6483 return true;
6484
6485 return false;
6486 }
6487
6490 {
6493
6495 {
6497 }
6498 else
6499 {
6500
6502 }
6503
6505 }
6506
6513 {
6514 return -1;
6515 }
6516
6517
6518
6519
6521 {
6523 {
6525 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
6526
6527 if (r_index >= 0)
6528 {
6529 InventoryLocation r_il = new InventoryLocation;
6530 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
6531
6532 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 player.GetHumanInventory().ClearUserReservedLocation(this);
6546 }
6547
6550 }
6551
6552
6553
6554
6556 {
6557 return ItemBase.m_DebugActionsMask;
6558 }
6559
6561 {
6562 return ItemBase.m_DebugActionsMask & mask;
6563 }
6564
6566 {
6567 ItemBase.m_DebugActionsMask = mask;
6568 }
6569
6571 {
6572 ItemBase.m_DebugActionsMask |= mask;
6573 }
6574
6576 {
6577 ItemBase.m_DebugActionsMask &= ~mask;
6578 }
6579
6581 {
6583 {
6585 }
6586 else
6587 {
6589 }
6590 }
6591
6592
6594 {
6595 if (GetEconomyProfile())
6596 {
6597 float q_max = GetEconomyProfile().GetQuantityMax();
6598 if (q_max > 0)
6599 {
6600 float q_min = GetEconomyProfile().GetQuantityMin();
6601 float quantity_randomized = Math.RandomFloatInclusive(q_min, q_max);
6602
6604 {
6605 ComponentEnergyManager comp = GetCompEM();
6607 {
6609 }
6610 }
6612 {
6614
6615 }
6616
6617 }
6618 }
6619 }
6620
6623 {
6624 EntityAI parent = GetHierarchyParent();
6625
6626 if (parent)
6627 {
6628 InventoryLocation inventory_location_to_lock = new InventoryLocation;
6629 GetInventory().GetCurrentInventoryLocation(inventory_location_to_lock);
6630 parent.GetInventory().SetSlotLock(inventory_location_to_lock.
GetSlot(),
true);
6631 }
6632 }
6633
6636 {
6637 EntityAI parent = GetHierarchyParent();
6638
6639 if (parent)
6640 {
6641 InventoryLocation inventory_location_to_unlock = new InventoryLocation;
6642 GetInventory().GetCurrentInventoryLocation(inventory_location_to_unlock);
6643 parent.GetInventory().SetSlotLock(inventory_location_to_unlock.
GetSlot(),
false);
6644 }
6645 }
6646
6648 {
6649
6650
6651
6652
6654
6656 {
6657 if (ScriptInputUserData.CanStoreInputUserData())
6658 {
6659 ScriptInputUserData ctx = new ScriptInputUserData;
6665 ctx.
Write(use_stack_max);
6668
6670 {
6671 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(item2,null,GameInventory.c_InventoryReservationTimeoutShortMS);
6672 }
6673 }
6674 }
6675 else if (!
GetGame().IsMultiplayer())
6676 {
6678 }
6679 }
6680
6682 {
6684 }
6685
6687 {
6689 }
6690
6692 {
6694 }
6695
6697 {
6698
6699 return false;
6700 }
6701
6703 {
6704 return false;
6705 }
6706
6710 {
6711 return false;
6712 }
6713
6715 {
6716 return "";
6717 }
6718
6720
6722 {
6723 return false;
6724 }
6725
6727 {
6728 return true;
6729 }
6730
6731
6732
6734 {
6735 return true;
6736 }
6737
6739 {
6740 return true;
6741 }
6742
6744 {
6745 PlayerBase player = PlayerBase.Cast(
g_Game.GetPlayer());
6747 }
6748
6750 {
6752 }
6753
6755 {
6757 if (!is_being_placed)
6759 SetSynchDirty();
6760 }
6761
6762
6764
6766 {
6768 }
6769
6771 {
6773 }
6774
6776 {
6777 return 1;
6778 }
6779
6781 {
6782 return false;
6783 }
6784
6786 {
6788 SetSynchDirty();
6789 }
6790
6791
6792
6793
6794
6795
6796
6797
6798
6799
6800
6801
6802
6803
6804
6805
6806
6807
6808
6809
6810
6811
6812
6813
6814
6815
6816
6817
6818
6819
6820
6821
6822
6823
6824
6826 {
6827 super.OnMovedInsideCargo(container);
6828
6829 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
6830 }
6831
6832 override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
6833 {
6834 super.EEItemLocationChanged(oldLoc,newLoc);
6835
6836 PlayerBase new_player = null;
6837 PlayerBase old_player = null;
6838
6839 if (newLoc.GetParent())
6840 new_player = PlayerBase.Cast(newLoc.GetParent().GetHierarchyRootPlayer());
6841
6842 if (oldLoc.GetParent())
6843 old_player = PlayerBase.Cast(oldLoc.GetParent().GetHierarchyRootPlayer());
6844
6846 {
6847 int r_index = old_player.GetHumanInventory().FindUserReservedLocationIndex(this);
6848
6849 if (r_index >= 0)
6850 {
6851 InventoryLocation r_il = new InventoryLocation;
6852 old_player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
6853
6854 old_player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
6857 {
6858 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
6859 }
6861 {
6862 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
6863 }
6864
6865 }
6866 }
6867
6869 {
6870 if (new_player)
6871 new_player.ForceStandUpForHeavyItems(newLoc.GetItem());
6872
6873 if (new_player == old_player)
6874 {
6875
6876 if (oldLoc.GetParent() && new_player.GetHumanInventory().LocationGetEntity(oldLoc) == NULL)
6877 {
6879 {
6880 if (oldLoc.GetParent().GetInventory().TestAddEntityInCargoExLoc(oldLoc, false, false, false, true, false, false))
6881 {
6882 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
6883 }
6884 }
6885 else
6886 {
6887 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
6888 }
6889 }
6890
6891 if (new_player.GetHumanInventory().FindUserReservedLocationIndex(this) >= 0)
6892 {
6893 int type = oldLoc.GetType();
6895 {
6896 oldLoc.GetParent().GetOnSetLock().Invoke(this);
6897 }
6899 {
6900 oldLoc.GetParent().GetOnAttachmentSetLock().Invoke(this, oldLoc.GetSlot());
6901 }
6902 }
6903 if (!m_OldLocation)
6904 {
6905 m_OldLocation = new InventoryLocation;
6906 }
6907 m_OldLocation.Copy(oldLoc);
6908 }
6909 else
6910 {
6911 if (m_OldLocation)
6912 {
6913 m_OldLocation.Reset();
6914 }
6915 }
6916
6918 }
6919 else
6920 {
6921 if (new_player)
6922 {
6923 int res_index = new_player.GetHumanInventory().FindCollidingUserReservedLocationIndex(this, newLoc);
6924 if (res_index >= 0)
6925 {
6926 InventoryLocation il = new InventoryLocation;
6927 new_player.GetHumanInventory().GetUserReservedLocation(res_index,il);
6929 new_player.GetHumanInventory().ClearUserReservedLocationAtIndex(res_index);
6932 {
6933 il.
GetParent().GetOnReleaseLock().Invoke(it);
6934 }
6936 {
6938 }
6939
6940 }
6941 }
6943 {
6944
6946 }
6947
6948 if (m_OldLocation)
6949 {
6950 m_OldLocation.Reset();
6951 }
6952 }
6953 }
6954
6955 override void EOnContact(IEntity other, Contact extra)
6956 {
6958 {
6959 int liquidType = -1;
6961 if (impactSpeed > 0.0)
6962 {
6964 #ifndef SERVER
6966 #else
6968 SetSynchDirty();
6969 #endif
6971 }
6972 }
6973
6974 #ifdef SERVER
6975 if (GetCompEM() && GetCompEM().IsPlugged())
6976 {
6977 if (GetCompEM().GetCordLength() < vector.Distance(
GetPosition(), GetCompEM().GetEnergySource().
GetPosition()))
6978 GetCompEM().UnplugThis();
6979 }
6980 #endif
6981 }
6982
6984
6986 {
6988 }
6989
6991 {
6992
6993 }
6994
6996 {
6997 super.OnItemLocationChanged(old_owner, new_owner);
6998
6999 PlayerBase relatedPlayer = PlayerBase.Cast(old_owner);
7000 PlayerBase playerNew = PlayerBase.Cast(new_owner);
7001
7002 if (!relatedPlayer && playerNew)
7003 relatedPlayer = playerNew;
7004
7005 if (relatedPlayer && relatedPlayer.GetPerformedActionID() != -1)
7006 {
7008 if (actionMgr)
7009 {
7010 ActionBase currentAction = actionMgr.GetRunningAction();
7011 if (currentAction)
7013 }
7014 }
7015
7016 Man ownerPlayerOld = null;
7017 Man ownerPlayerNew = null;
7018
7019 if (old_owner)
7020 {
7021 if (old_owner.
IsMan())
7022 {
7023 ownerPlayerOld = Man.Cast(old_owner);
7024 }
7025 else
7026 {
7027 ownerPlayerOld = Man.Cast(old_owner.GetHierarchyRootPlayer());
7028 }
7029 }
7030 else
7031 {
7033 {
7035
7036 if (!action || !playerNew || playerNew.GetPerformedActionID() != action.
GetID())
7037 {
7038 GetCompEM().UnplugThis();
7039 }
7040 }
7041 }
7042
7043 if (new_owner)
7044 {
7045 if (new_owner.
IsMan())
7046 {
7047 ownerPlayerNew = Man.Cast(new_owner);
7048 }
7049 else
7050 {
7051 ownerPlayerNew = Man.Cast(new_owner.GetHierarchyRootPlayer());
7052 }
7053 }
7054
7055 if (ownerPlayerOld != ownerPlayerNew)
7056 {
7057 if (ownerPlayerOld)
7058 {
7059 array<EntityAI> subItemsExit = new array<EntityAI>;
7061 for (int i = 0; i < subItemsExit.Count(); i++)
7062 {
7065 }
7066 }
7067
7068 if (ownerPlayerNew)
7069 {
7070 array<EntityAI> subItemsEnter = new array<EntityAI>;
7072 for (int j = 0; j < subItemsEnter.Count(); j++)
7073 {
7076 }
7077 }
7078 }
7079 else if (ownerPlayerNew != null)
7080 {
7081 PlayerBase nplayer;
7082 if (PlayerBase.CastTo(nplayer, ownerPlayerNew))
7083 {
7084 array<EntityAI> subItemsUpdate = new array<EntityAI>;
7086 for (int k = 0; k < subItemsUpdate.Count(); k++)
7087 {
7089 itemUpdate.UpdateQuickbarShortcutVisibility(nplayer);
7090 }
7091 }
7092 }
7093
7094 if (old_owner)
7095 old_owner.OnChildItemRemoved(this);
7096 if (new_owner)
7097 new_owner.OnChildItemReceived(this);
7098 }
7099
7100
7102 {
7103 super.EEDelete(parent);
7104 PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
7105 if (player)
7106 {
7108
7109 if (player.IsAlive())
7110 {
7111 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
7112 if (r_index >= 0)
7113 {
7114 InventoryLocation r_il = new InventoryLocation;
7115 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
7116
7117 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
7120 {
7121 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
7122 }
7124 {
7125 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
7126 }
7127
7128 }
7129
7130 player.RemoveQuickBarEntityShortcut(this);
7131 }
7132 }
7133 }
7134
7136 {
7137 super.EEKilled(killer);
7138
7141 {
7142 if (
GetTemperature() >= GameConstants.ITEM_TEMPERATURE_TO_EXPLODE_MIN)
7143 {
7144 if (IsMagazine())
7145 {
7146 if (Magazine.Cast(this).GetAmmoCount() > 0)
7147 {
7149 }
7150 }
7151 else
7152 {
7154 }
7155 }
7156 }
7157 }
7158
7160 {
7161 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
7162
7163 super.OnWasAttached(parent, slot_id);
7164
7167
7169 }
7170
7172 {
7173 super.OnWasDetached(parent, slot_id);
7174
7177 }
7178
7180 {
7181 int idx;
7184
7185 ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
7186 if (inventory_slots.Count() < 1)
7187 {
7188 inventory_slots.Insert(ConfigGetString("ChangeInventorySlot"));
7189 attach_types.Insert(ConfigGetString("ChangeIntoOnAttach"));
7190 }
7191 else
7192 {
7193 ConfigGetTextArray("ChangeIntoOnAttach",attach_types);
7194 }
7195
7196 idx = inventory_slots.Find(slot);
7197 if (idx < 0)
7198 return "";
7199
7200 return attach_types.Get(idx);
7201 }
7202
7204 {
7205 int idx = -1;
7206 string slot;
7207
7210
7211 this.ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
7212 if (inventory_slots.Count() < 1)
7213 {
7214 inventory_slots.Insert(this.ConfigGetString("ChangeInventorySlot"));
7215 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
7216 }
7217 else
7218 {
7219 this.ConfigGetTextArray("ChangeIntoOnDetach",detach_types);
7220 if (detach_types.Count() < 1)
7221 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
7222 }
7223
7224 for (int i = 0; i < inventory_slots.Count(); i++)
7225 {
7226 slot = inventory_slots.Get(i);
7227 }
7228
7229 if (slot != "")
7230 {
7231 if (detach_types.Count() == 1)
7232 idx = 0;
7233 else
7234 idx = inventory_slots.Find(slot);
7235 }
7236 if (idx < 0)
7237 return "";
7238
7239 return detach_types.Get(idx);
7240 }
7241
7243 {
7244
7246
7247
7248 float min_time = 1;
7249 float max_time = 3;
7250 float delay = Math.RandomFloat(min_time, max_time);
7251
7252 explode_timer.Run(delay, this, "DoAmmoExplosion");
7253 }
7254
7256 {
7257 Magazine magazine = Magazine.Cast(this);
7258 int pop_sounds_count = 6;
7259 string pop_sounds[ 6 ] = { "ammopops_1","ammopops_2","ammopops_3","ammopops_4","ammopops_5","ammopops_6" };
7260
7261
7262 int sound_idx = Math.RandomInt(0, pop_sounds_count - 1);
7263 string sound_name = pop_sounds[ sound_idx ];
7265
7266
7267 magazine.ServerAddAmmoCount(-1);
7268
7269
7270 float min_temp_to_explode = 100;
7271
7272 if (magazine.GetAmmoCount() > 0 &&
GetTemperature() >= min_temp_to_explode)
7273 {
7275 }
7276 }
7277
7278
7279 override void EEHitBy(TotalDamageResult damageResult,
int damageType,
EntityAI source,
int component,
string dmgZone,
string ammo, vector modelPos,
float speedCoef)
7280 {
7281 super.EEHitBy(damageResult, damageType, source,
component, dmgZone, ammo, modelPos, speedCoef);
7282
7283 const int CHANCE_DAMAGE_CARGO = 4;
7284 const int CHANCE_DAMAGE_ATTACHMENT = 1;
7285 const int CHANCE_DAMAGE_NOTHING = 2;
7286
7288 {
7289 float dmg = damageResult.
GetDamage(
"",
"Health") * -0.5;
7290 int chances;
7291 int rnd;
7292
7293 if (GetInventory().GetCargo())
7294 {
7295 chances = CHANCE_DAMAGE_CARGO + CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
7296 rnd = Math.RandomInt(0,chances);
7297
7298 if (rnd < CHANCE_DAMAGE_CARGO)
7299 {
7301 }
7302 else if (rnd < (chances - CHANCE_DAMAGE_NOTHING))
7303 {
7305 }
7306 }
7307 else
7308 {
7309 chances = CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
7310 rnd = Math.RandomInt(0,chances);
7311
7312 if (rnd < CHANCE_DAMAGE_ATTACHMENT)
7313 {
7315 }
7316 }
7317 }
7318 }
7319
7321 {
7322 if (GetInventory().GetCargo())
7323 {
7324 int item_count = GetInventory().GetCargo().GetItemCount();
7325 if (item_count > 0)
7326 {
7327 int random_pick = Math.RandomInt(0, item_count);
7329 if (!item.IsExplosive())
7330 {
7331 item.AddHealth("","",damage);
7332 return true;
7333 }
7334 }
7335 }
7336 return false;
7337 }
7338
7340 {
7341 int attachment_count = GetInventory().AttachmentCount();
7342 if (attachment_count > 0)
7343 {
7344 int random_pick = Math.RandomInt(0, attachment_count);
7345 ItemBase attachment =
ItemBase.Cast(GetInventory().GetAttachmentFromIndex(random_pick));
7346 if (!attachment.IsExplosive())
7347 {
7348 attachment.AddHealth("","",damage);
7349 return true;
7350 }
7351 }
7352 return false;
7353 }
7354
7356 {
7358 }
7359
7361 {
7363 return GetInventory().CanRemoveEntity();
7364
7365 return false;
7366 }
7367
7369 {
7370
7372 return false;
7373
7374
7376 return false;
7377
7378
7379
7381 if (delta == 0)
7382 return false;
7383
7384
7385 return true;
7386 }
7387
7389 {
7391 {
7392 if (ScriptInputUserData.CanStoreInputUserData())
7393 {
7394 ScriptInputUserData ctx = new ScriptInputUserData;
7399 ctx.
Write(destination_entity);
7403 }
7404 }
7405 else if (!
GetGame().IsMultiplayer())
7406 {
7408 }
7409 }
7410
7412 {
7413 float split_quantity_new;
7417 InventoryLocation loc = new InventoryLocation;
7418
7419 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
7420 {
7422 split_quantity_new = stack_max;
7423 else
7425
7427 {
7428 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
7429 if (new_item)
7430 {
7431 new_item.SetResultOfSplit(true);
7432 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7434 new_item.
SetQuantity(split_quantity_new,
false,
true);
7435 }
7436 }
7437 }
7438 else if (destination_entity && slot_id == -1)
7439 {
7440 if (quantity > stack_max)
7441 split_quantity_new = stack_max;
7442 else
7443 split_quantity_new = quantity;
7444
7446 {
7448 {
7451 }
7452
7453 if (new_item)
7454 {
7455 new_item.SetResultOfSplit(true);
7456 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7458 new_item.
SetQuantity(split_quantity_new,
false,
true);
7459 }
7460 }
7461 }
7462 else
7463 {
7464 if (stack_max != 0)
7465 {
7467 {
7469 }
7470
7471 if (split_quantity_new == 0)
7472 {
7473 if (!
GetGame().IsMultiplayer())
7474 player.PhysicalPredictiveDropItem(this);
7475 else
7476 player.ServerDropEntity(this);
7477 return;
7478 }
7479
7481 {
7483
7484 if (new_item)
7485 {
7486 new_item.SetResultOfSplit(true);
7487 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7490 new_item.PlaceOnSurface();
7491 }
7492 }
7493 }
7494 }
7495 }
7496
7498 {
7499 float split_quantity_new;
7503 InventoryLocation loc = new InventoryLocation;
7504
7505 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
7506 {
7508 split_quantity_new = stack_max;
7509 else
7511
7513 {
7514 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
7515 if (new_item)
7516 {
7517 new_item.SetResultOfSplit(true);
7518 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7520 new_item.
SetQuantity(split_quantity_new,
false,
true);
7521 }
7522 }
7523 }
7524 else if (destination_entity && slot_id == -1)
7525 {
7526 if (quantity > stack_max)
7527 split_quantity_new = stack_max;
7528 else
7529 split_quantity_new = quantity;
7530
7532 {
7534 {
7537 }
7538
7539 if (new_item)
7540 {
7541 new_item.SetResultOfSplit(true);
7542 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7544 new_item.
SetQuantity(split_quantity_new,
false,
true);
7545 }
7546 }
7547 }
7548 else
7549 {
7550 if (stack_max != 0)
7551 {
7553 {
7555 }
7556
7558 {
7560
7561 if (new_item)
7562 {
7563 new_item.SetResultOfSplit(true);
7564 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7567 new_item.PlaceOnSurface();
7568 }
7569 }
7570 }
7571 }
7572 }
7573
7575 {
7577 {
7578 if (ScriptInputUserData.CanStoreInputUserData())
7579 {
7580 ScriptInputUserData ctx = new ScriptInputUserData;
7585 dst.WriteToContext(ctx);
7587 }
7588 }
7589 else if (!
GetGame().IsMultiplayer())
7590 {
7592 }
7593 }
7594
7596 {
7598 {
7599 if (ScriptInputUserData.CanStoreInputUserData())
7600 {
7601 ScriptInputUserData ctx = new ScriptInputUserData;
7606 ctx.
Write(destination_entity);
7612 }
7613 }
7614 else if (!
GetGame().IsMultiplayer())
7615 {
7617 }
7618 }
7619
7621 {
7623 }
7624
7626 {
7628 float split_quantity_new;
7630 if (dst.IsValid())
7631 {
7632 int slot_id = dst.GetSlot();
7634
7635 if (quantity > stack_max)
7636 split_quantity_new = stack_max;
7637 else
7638 split_quantity_new = quantity;
7639
7641 {
7643
7644 if (new_item)
7645 {
7646 new_item.SetResultOfSplit(true);
7647 MiscGameplayFunctions.TransferItemProperties(this,new_item);
7649 new_item.
SetQuantity(split_quantity_new,
false,
true);
7650 }
7651
7652 return new_item;
7653 }
7654 }
7655
7656 return null;
7657 }
7658
7660 {
7662 float split_quantity_new;
7664 if (destination_entity)
7665 {
7667 if (quantity > stackable)
7668 split_quantity_new = stackable;
7669 else
7670 split_quantity_new = quantity;
7671
7673 {
7674 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateEntityInCargoEx(
this.GetType(), idx, row, col,
false));
7675 if (new_item)
7676 {
7677 new_item.SetResultOfSplit(true);
7678 MiscGameplayFunctions.TransferItemProperties(this,new_item);
7680 new_item.
SetQuantity(split_quantity_new,
false,
true);
7681 }
7682 }
7683 }
7684 }
7685
7687 {
7689 {
7690 if (ScriptInputUserData.CanStoreInputUserData())
7691 {
7692 ScriptInputUserData ctx = new ScriptInputUserData;
7697 ItemBase destination_entity =
this;
7698 ctx.
Write(destination_entity);
7702 }
7703 }
7704 else if (!
GetGame().IsMultiplayer())
7705 {
7707 }
7708 }
7709
7711 {
7713 float split_quantity_new;
7715 if (player)
7716 {
7718 if (quantity > stackable)
7719 split_quantity_new = stackable;
7720 else
7721 split_quantity_new = quantity;
7722
7724 {
7725 EntityAI in_hands = player.GetHumanInventory().CreateInHands(this.
GetType());
7726 new_item =
ItemBase.Cast(in_hands);
7727 if (new_item)
7728 {
7729 new_item.SetResultOfSplit(true);
7730 MiscGameplayFunctions.TransferItemProperties(this,new_item);
7732 new_item.SetQuantity(split_quantity_new, false, true);
7733 }
7734 }
7735 }
7736 }
7737
7739 {
7741 float split_quantity_new = Math.Floor(quantity * 0.5);
7742
7744 return;
7745
7747
7748 if (new_item)
7749 {
7750 if (new_item.GetQuantityMax() < split_quantity_new)
7751 {
7752 split_quantity_new = new_item.GetQuantityMax();
7753 }
7754
7755 new_item.SetResultOfSplit(true);
7756 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7757
7759 {
7762 }
7763 else
7764 {
7766 new_item.
SetQuantity(split_quantity_new,
false,
true);
7767 }
7768 }
7769 }
7770
7772 {
7774 float split_quantity_new = Math.Floor(quantity / 2);
7775
7777 return;
7778
7779 InventoryLocation invloc = new InventoryLocation;
7781
7783 new_item = player.CreateCopyOfItemInInventoryOrGroundEx(this, true);
7784
7785 if (new_item)
7786 {
7787 if (new_item.GetQuantityMax() < split_quantity_new)
7788 {
7789 split_quantity_new = new_item.GetQuantityMax();
7790 }
7792 {
7795 }
7796 else if (split_quantity_new > 1)
7797 {
7799 new_item.
SetQuantity(split_quantity_new,
false,
true);
7800 }
7801 }
7802 }
7803
7806 {
7807 SetWeightDirty();
7809
7810 if (parent)
7811 parent.OnAttachmentQuantityChangedEx(this, delta);
7812
7814 {
7816 {
7818 }
7820 {
7821 ErrorEx(
"Undefined liquid type quantity changed, please define liquid type first! Using init value.",
ErrorExSeverity.INFO);
7823 }
7824 }
7825
7826 }
7827
7830 {
7831
7832 }
7833
7836 {
7838 }
7839
7841 {
7842 super.EEHealthLevelChanged(oldLevel,newLevel,zone);
7843
7845 {
7846 if (newLevel == GameConstants.STATE_RUINED)
7847 {
7849 EntityAI parent = GetHierarchyParent();
7850 if (parent && parent.IsFireplace())
7851 {
7852 CargoBase cargo = GetInventory().GetCargo();
7853 if (cargo)
7854 {
7856 {
7858 }
7859 }
7860 }
7861 }
7862
7864 {
7865
7867 return;
7868 }
7869
7870 if (
m_Cleanness != 0 && oldLevel < newLevel && newLevel != 0)
7871 {
7873 }
7874 }
7875 }
7876
7877
7879 {
7880 super.OnRightClick();
7881
7883 {
7885 {
7886 if (ScriptInputUserData.CanStoreInputUserData())
7887 {
7888 EntityAI root = GetHierarchyRoot();
7889 Man playerOwner = GetHierarchyRootPlayer();
7890 InventoryLocation dst = new InventoryLocation;
7891
7892
7893 if (!playerOwner && root && root == this)
7894 {
7896 }
7897 else
7898 {
7899
7900 GetInventory().GetCurrentInventoryLocation(dst);
7902 {
7905 {
7907 }
7908 else
7909 {
7911
7912
7913 if (
GetGame().
GetPlayer().GetInventory().HasInventoryReservation(
this, dst))
7914 {
7916 }
7917 else
7918 {
7919 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(null, dst, GameInventory.c_InventoryReservationTimeoutShortMS);
7920 }
7921 }
7922 }
7923 }
7924
7925 ScriptInputUserData ctx = new ScriptInputUserData;
7933 }
7934 }
7935 else if (!
GetGame().IsMultiplayer())
7936 {
7938 }
7939 }
7940 }
7941
7943 {
7944 if (root)
7945 {
7946 vector m4[4];
7947 root.GetTransform(m4);
7948 dst.SetGround(this, m4);
7949 }
7950 else
7951 {
7952 GetInventory().GetCurrentInventoryLocation(dst);
7953 }
7954 }
7955
7956 override bool CanBeCombined(
EntityAI other_item,
bool reservation_check =
true,
bool stack_max_limit =
false)
7957 {
7958
7959 if (!other_item ||
GetType() != other_item.GetType() || (
IsFullQuantity() && other_item.GetQuantity() > 0) || other_item ==
this)
7960 return false;
7961
7962 if (GetHealthLevel() == GameConstants.STATE_RUINED || other_item.GetHealthLevel() == GameConstants.STATE_RUINED)
7963 return false;
7964
7965
7967 return false;
7968
7969
7970 Magazine mag = Magazine.Cast(this);
7971 if (mag)
7972 {
7973 if (mag.GetAmmoCount() >= mag.GetAmmoMax())
7974 return false;
7975
7976 if (stack_max_limit)
7977 {
7978 Magazine other_mag = Magazine.Cast(other_item);
7979 if (other_item)
7980 {
7981 if (mag.GetAmmoCount() + other_mag.GetAmmoCount() > mag.GetAmmoMax())
7982 return false;
7983 }
7984
7985 }
7986 }
7987 else
7988 {
7989
7991 return false;
7992
7994 return false;
7995 }
7996
7997 PlayerBase player = null;
7998 if (CastTo(player, GetHierarchyRootPlayer()))
7999 {
8000 if (player.GetInventory().HasAttachment(this))
8001 return false;
8002
8003 if (player.IsItemsToDelete())
8004 return false;
8005 }
8006
8007 if (reservation_check && (GetInventory().HasInventoryReservation(this, null) || other_item.GetInventory().HasInventoryReservation(other_item, null)))
8008 return false;
8009
8010 int slotID;
8012 if (GetInventory().GetCurrentAttachmentSlotInfo(slotID,
slotName) && GetHierarchyParent().GetInventory().GetSlotLock(slotID))
8013 return false;
8014
8015 return true;
8016 }
8017
8019 {
8021 }
8022
8024 {
8025 return m_IsResultOfSplit;
8026 }
8027
8029 {
8030 m_IsResultOfSplit = value;
8031 }
8032
8034 {
8036 }
8037
8039 {
8040 float other_item_quantity = other_item.GetQuantity();
8041 float this_free_space;
8042
8044
8046
8047 if (other_item_quantity > this_free_space)
8048 {
8049 return this_free_space;
8050 }
8051 else
8052 {
8053 return other_item_quantity;
8054 }
8055 }
8056
8058 {
8060 }
8061
8063 {
8065 return;
8066
8067 if (!IsMagazine() && other_item)
8068 {
8070 if (quantity_used != 0)
8071 {
8072 float hp1 = GetHealth01("","");
8073 float hp2 = other_item.GetHealth01("","");
8074 float hpResult = ((hp1*
GetQuantity()) + (hp2*quantity_used));
8075 hpResult = hpResult / (
GetQuantity() + quantity_used);
8076
8077 hpResult *= GetMaxHealth();
8078 Math.Round(hpResult);
8079 SetHealth("", "Health", hpResult);
8080
8082 other_item.AddQuantity(-quantity_used);
8083 }
8084 }
8086 }
8087
8089 {
8090 #ifdef SERVER
8091 if (!GetHierarchyRootPlayer() && GetHierarchyParent())
8092 GetHierarchyParent().IncreaseLifetimeUp();
8093 #endif
8094 };
8095
8097 {
8098 PlayerBase p = PlayerBase.Cast(player);
8099
8100 array<int> recipesIds = p.m_Recipes;
8101 PluginRecipesManager moduleRecipesManager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
8102 if (moduleRecipesManager)
8103 {
8104 EntityAI itemInHands = player.GetHumanInventory().GetEntityInHands();
8105 moduleRecipesManager.GetValidRecipes(
ItemBase.Cast(
this),
ItemBase.Cast(itemInHands), recipesIds, p);
8106 }
8107
8108 for (int i = 0;i < recipesIds.Count(); i++)
8109 {
8110 int key = recipesIds.Get(i);
8111 string recipeName = moduleRecipesManager.GetRecipeName(key);
8113 }
8114 }
8115
8116
8117 override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
8118 {
8119 super.GetDebugActions(outputList);
8120
8121
8127
8128
8133
8138
8139
8143
8144
8146 {
8150 }
8151
8154
8155
8159
8161
8162 InventoryLocation loc = new InventoryLocation();
8163 GetInventory().GetCurrentInventoryLocation(loc);
8165 {
8166 if (Gizmo_IsSupported())
8169 }
8170
8172 }
8173
8174
8175
8176
8178 {
8179 super.OnAction(action_id, player, ctx);
8180
8182 {
8183 switch (action_id)
8184 {
8187 return true;
8190 return true;
8191 }
8192 }
8193
8195 {
8196 switch (action_id)
8197 {
8199 Delete();
8200 return true;
8201 }
8202 }
8203
8204 if (action_id >=
EActions.RECIPES_RANGE_START && action_id <
EActions.RECIPES_RANGE_END)
8205 {
8206 PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
8207 int idWithoutOffset = action_id -
EActions.RECIPES_RANGE_START;
8208 PlayerBase p = PlayerBase.Cast(player);
8209 if (
EActions.RECIPES_RANGE_START < 1000)
8210 {
8211 float anim_length = plugin_recipes_manager.GetRecipeLengthInSecs(idWithoutOffset);
8212 float specialty_weight = plugin_recipes_manager.GetRecipeSpecialty(idWithoutOffset);
8213 }
8214 }
8215 #ifndef SERVER
8216 else if (action_id ==
EActions.WATCH_PLAYER)
8217 {
8218 PluginDeveloper.SetDeveloperItemClientEx(player);
8219 }
8220 #endif
8222 {
8223 if (action_id >=
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START && action_id <
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_END)
8224 {
8225 int id = action_id -
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START;
8226 OnDebugButtonPressServer(id + 1);
8227 }
8228
8229 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_INJECT_START && action_id <
EActions.DEBUG_AGENTS_RANGE_INJECT_END)
8230 {
8231 int agent_id = action_id -
EActions.DEBUG_AGENTS_RANGE_INJECT_START;
8233 }
8234
8235 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_REMOVE_START && action_id <
EActions.DEBUG_AGENTS_RANGE_REMOVE_END)
8236 {
8237 int agent_id2 = action_id -
EActions.DEBUG_AGENTS_RANGE_REMOVE_START;
8239 }
8240
8241 else if (action_id ==
EActions.ADD_QUANTITY)
8242 {
8243 if (IsMagazine())
8244 {
8245 Magazine mag = Magazine.Cast(this);
8246 mag.ServerSetAmmoCount(mag.GetAmmoCount() + mag.GetAmmoMax() * 0.2);
8247 }
8248 else
8249 {
8251 }
8252
8253 if (m_EM)
8254 {
8255 m_EM.AddEnergy(m_EM.GetEnergyMax() * 0.2);
8256 }
8257
8258 }
8259
8260 else if (action_id ==
EActions.REMOVE_QUANTITY)
8261 {
8262 if (IsMagazine())
8263 {
8264 Magazine mag2 = Magazine.Cast(this);
8265 mag2.ServerSetAmmoCount(mag2.GetAmmoCount() - mag2.GetAmmoMax() * 0.2);
8266 }
8267 else
8268 {
8270 }
8271 if (m_EM)
8272 {
8273 m_EM.AddEnergy(- m_EM.GetEnergyMax() * 0.2);
8274 }
8275
8276 }
8277
8278 else if (action_id ==
EActions.SET_QUANTITY_0)
8279 {
8281
8282 if (m_EM)
8283 {
8284 m_EM.SetEnergy(0);
8285 }
8286 }
8287
8288 else if (action_id ==
EActions.SET_MAX_QUANTITY)
8289 {
8291
8292 if (m_EM)
8293 {
8294 m_EM.SetEnergy(m_EM.GetEnergyMax());
8295 }
8296 }
8297
8298 else if (action_id ==
EActions.ADD_HEALTH)
8299 {
8300 AddHealth("","",GetMaxHealth("","Health")/5);
8301 }
8302 else if (action_id ==
EActions.REMOVE_HEALTH)
8303 {
8304 AddHealth("","",-GetMaxHealth("","Health")/5);
8305 }
8306 else if (action_id ==
EActions.DESTROY_HEALTH)
8307 {
8308 SetHealth01("","",0);
8309 }
8310 else if (action_id ==
EActions.WATCH_ITEM)
8311 {
8313 mid.RegisterDebugItem(
ItemBase.Cast(
this), PlayerBase.Cast(player));
8314 #ifdef DEVELOPER
8315 SetDebugDeveloper_item(this);
8316 #endif
8317 }
8318
8319 else if (action_id ==
EActions.ADD_TEMPERATURE)
8320 {
8321 AddTemperature(20);
8322
8323 }
8324
8325 else if (action_id ==
EActions.REMOVE_TEMPERATURE)
8326 {
8327 AddTemperature(-20);
8328
8329 }
8330
8331 else if (action_id ==
EActions.FLIP_FROZEN)
8332 {
8333 SetFrozen(!GetIsFrozen());
8334
8335 }
8336
8337 else if (action_id ==
EActions.ADD_WETNESS)
8338 {
8340
8341 }
8342
8343 else if (action_id ==
EActions.REMOVE_WETNESS)
8344 {
8346
8347 }
8348
8349 else if (action_id ==
EActions.LIQUIDTYPE_UP)
8350 {
8353
8354
8355 }
8356
8357 else if (action_id ==
EActions.LIQUIDTYPE_DOWN)
8358 {
8361 }
8362
8363 else if (action_id ==
EActions.MAKE_SPECIAL)
8364 {
8365 auto debugParams = DebugSpawnParams.WithPlayer(player);
8366 OnDebugSpawnEx(debugParams);
8367 }
8368
8369 }
8370
8371
8372 return false;
8373 }
8374
8375
8376
8377
8381
8384
8385
8386
8388 {
8389 return false;
8390 }
8391
8392
8394 {
8395 return true;
8396 }
8397
8398
8400 {
8401 return true;
8402 }
8403
8404
8405
8407 {
8408 string config_path =
string.Format(
"CfgVehicles %1 Food FoodStages",
GetType());
8410 }
8411
8414 {
8415 return null;
8416 }
8417
8419 {
8420 return false;
8421 }
8422
8424 {
8425 return false;
8426 }
8427
8431
8432
8434 {
8435 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
8436 return module_repairing.CanRepair(this, item_repair_kit);
8437 }
8438
8439
8440 bool Repair(PlayerBase player,
ItemBase item_repair_kit,
float specialty_weight)
8441 {
8442 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
8443 return module_repairing.Repair(player, this, item_repair_kit, specialty_weight);
8444 }
8445
8446
8448 {
8449
8450
8451
8452
8453
8454
8455
8456
8457 return 1;
8458 }
8459
8460
8461
8463 {
8465 }
8466
8467
8468
8470 {
8472 }
8473
8474
8483 {
8484 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8485
8486 if (player)
8487 {
8488 player.MessageStatus(text);
8489 }
8490 }
8491
8492
8501 {
8502 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8503
8504 if (player)
8505 {
8506 player.MessageAction(text);
8507 }
8508 }
8509
8510
8519 {
8520 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8521
8522 if (player)
8523 {
8524 player.MessageFriendly(text);
8525 }
8526 }
8527
8528
8537 {
8538 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8539
8540 if (player)
8541 {
8542 player.MessageImportant(text);
8543 }
8544 }
8545
8547 {
8548 return true;
8549 }
8550
8551
8552 override bool KindOf(
string tag)
8553 {
8554 bool found = false;
8555 string item_name = this.
GetType();
8558
8559 int array_size = item_tag_array.Count();
8560 for (int i = 0; i < array_size; i++)
8561 {
8562 if (item_tag_array.Get(i) == tag)
8563 {
8564 found = true;
8565 break;
8566 }
8567 }
8568 return found;
8569 }
8570
8571
8573 {
8574
8575 super.OnRPC(sender, rpc_type,ctx);
8576
8577
8578 switch (rpc_type)
8579 {
8580 #ifndef SERVER
8581 case ERPCs.RPC_SOUND_LOCK_ATTACH:
8582 Param2<bool, string> p = new Param2<bool, string>(false, "");
8583
8585 return;
8586
8587 bool play = p.param1;
8588 string soundSet = p.param2;
8589
8590 if (play)
8591 {
8593 {
8595 {
8597 }
8598 }
8599 else
8600 {
8602 }
8603 }
8604 else
8605 {
8607 }
8608
8609 break;
8610 #endif
8611
8612 }
8613
8615 {
8617 }
8618 }
8619
8620
8621
8622
8624 {
8625 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
8626 return plugin.GetID(
name);
8627 }
8628
8630 {
8631 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
8632 return plugin.GetName(id);
8633 }
8634
8637 {
8638
8639
8640 int varFlags;
8641 if (!ctx.
Read(varFlags))
8642 return;
8643
8644 if (varFlags & ItemVariableFlags.FLOAT)
8645 {
8647 }
8648 }
8649
8651 {
8652
8653 super.SerializeNumericalVars(floats_out);
8654
8655
8656
8658 {
8660 }
8661
8663 {
8665 }
8666
8668 {
8670 }
8671
8673 {
8678 }
8679
8681 {
8683 }
8684 }
8685
8687 {
8688
8689 super.DeSerializeNumericalVars(floats);
8690
8691
8692 int index = 0;
8693 int mask = Math.Round(floats.Get(index));
8694
8695 index++;
8696
8698 {
8700 {
8702 }
8703 else
8704 {
8705 float quantity = floats.Get(index);
8707 }
8708 index++;
8709 }
8710
8712 {
8713 float wet = floats.Get(index);
8715 index++;
8716 }
8717
8719 {
8720 int liquidtype = Math.Round(floats.Get(index));
8722 index++;
8723 }
8724
8726 {
8728 index++;
8730 index++;
8732 index++;
8734 index++;
8735 }
8736
8738 {
8739 int cleanness = Math.Round(floats.Get(index));
8741 index++;
8742 }
8743 }
8744
8746 {
8747 super.WriteVarsToCTX(ctx);
8748
8749
8751 {
8753 }
8754
8756 {
8758 }
8759
8761 {
8763 }
8764
8766 {
8767 int r,g,b,a;
8773 }
8774
8776 {
8778 }
8779 }
8780
8782 {
8783 if (!super.ReadVarsFromCTX(ctx,version))
8784 return false;
8785
8786 int intValue;
8787 float value;
8788
8789 if (version < 140)
8790 {
8791 if (!ctx.
Read(intValue))
8792 return false;
8793
8794 m_VariablesMask = intValue;
8795 }
8796
8798 {
8799 if (!ctx.
Read(value))
8800 return false;
8801
8803 {
8805 }
8806 else
8807 {
8809 }
8810 }
8811
8812 if (version < 140)
8813 {
8815 {
8816 if (!ctx.
Read(value))
8817 return false;
8818 SetTemperatureDirect(value);
8819 }
8820 }
8821
8823 {
8824 if (!ctx.
Read(value))
8825 return false;
8827 }
8828
8830 {
8831 if (!ctx.
Read(intValue))
8832 return false;
8834 }
8835
8837 {
8838 int r,g,b,a;
8840 return false;
8842 return false;
8844 return false;
8846 return false;
8847
8849 }
8850
8852 {
8853 if (!ctx.
Read(intValue))
8854 return false;
8856 }
8857
8858 if (version >= 138 && version < 140)
8859 {
8861 {
8862 if (!ctx.
Read(intValue))
8863 return false;
8864 SetFrozen(intValue);
8865 }
8866 }
8867
8868 return true;
8869 }
8870
8871
8873 {
8876 {
8878 }
8879
8880 if (!super.OnStoreLoad(ctx, version))
8881 {
8883 return false;
8884 }
8885
8886 if (version >= 114)
8887 {
8888 bool hasQuickBarIndexSaved;
8889
8890 if (!ctx.
Read(hasQuickBarIndexSaved))
8891 {
8893 return false;
8894 }
8895
8896 if (hasQuickBarIndexSaved)
8897 {
8898 int itmQBIndex;
8899
8900
8901 if (!ctx.
Read(itmQBIndex))
8902 {
8904 return false;
8905 }
8906
8907 PlayerBase parentPlayer = PlayerBase.Cast(GetHierarchyRootPlayer());
8908 if (itmQBIndex != -1 && parentPlayer)
8909 parentPlayer.SetLoadedQuickBarItemBind(this, itmQBIndex);
8910 }
8911 }
8912 else
8913 {
8914
8915 PlayerBase player;
8916 int itemQBIndex;
8917 if (version ==
int.
MAX)
8918 {
8919 if (!ctx.
Read(itemQBIndex))
8920 {
8922 return false;
8923 }
8924 }
8925 else if (Class.CastTo(player, GetHierarchyRootPlayer()))
8926 {
8927
8928 if (!ctx.
Read(itemQBIndex))
8929 {
8931 return false;
8932 }
8933 if (itemQBIndex != -1 && player)
8934 player.SetLoadedQuickBarItemBind(this,itemQBIndex);
8935 }
8936 }
8937
8938 if (version < 140)
8939 {
8940
8941 if (!LoadVariables(ctx, version))
8942 {
8944 return false;
8945 }
8946 }
8947
8948
8950 {
8952 return false;
8953 }
8954 if (version >= 132)
8955 {
8957 if (raib)
8958 {
8960 {
8962 return false;
8963 }
8964 }
8965 }
8966
8968 return true;
8969 }
8970
8971
8972
8974 {
8975 super.OnStoreSave(ctx);
8976
8977 PlayerBase player;
8978 if (PlayerBase.CastTo(player,GetHierarchyRootPlayer()))
8979 {
8981
8982 int itemQBIndex = -1;
8983 itemQBIndex = player.FindQuickBarEntityIndex(this);
8984 ctx.
Write(itemQBIndex);
8985 }
8986 else
8987 {
8989 }
8990
8992
8994 if (raib)
8995 {
8997 }
8998 }
8999
9000
9002 {
9003 super.AfterStoreLoad();
9004
9006 {
9008 }
9009
9011 {
9014 }
9015 }
9016
9018 {
9019 super.EEOnAfterLoad();
9020
9022 {
9024 }
9025
9028 }
9029
9031 {
9032 return false;
9033 }
9034
9035
9036
9038 {
9040 {
9041 #ifdef PLATFORM_CONSOLE
9042
9044 {
9046 if (menu)
9047 {
9049 }
9050 }
9051 #endif
9052 }
9053
9055 {
9058 }
9059
9061 {
9062 SetWeightDirty();
9064 }
9066 {
9069 }
9070
9072 {
9075 }
9077 {
9080 }
9081
9082 super.OnVariablesSynchronized();
9083 }
9084
9085
9086
9088 override bool SetQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false,
bool allow_client =
false,
bool clamp_to_stack_max =
true)
9089 {
9090 if (!IsServerCheck(allow_client))
9091 return false;
9092
9094 return false;
9095
9098
9099 if (value <= (min + 0.001))
9100 value = min;
9101
9102 if (value == min)
9103 {
9104 if (destroy_config)
9105 {
9106 bool dstr = ConfigGetBool("varQuantityDestroyOnMin");
9107 if (dstr)
9108 {
9110 this.Delete();
9111 return true;
9112 }
9113 }
9114 else if (destroy_forced)
9115 {
9117 this.Delete();
9118 return true;
9119 }
9120
9122 }
9123
9126
9128 {
9130
9131 if (delta)
9133 }
9134
9136
9137 return false;
9138 }
9139
9140
9142 bool AddQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
9143 {
9145 }
9146
9148 {
9151 }
9152
9154 {
9157 }
9158
9160 override void SetQuantityNormalized(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
9161 {
9162 float value_clamped = Math.Clamp(value, 0, 1);
9164 SetQuantity(result, destroy_config, destroy_forced);
9165 }
9166
9167
9170 {
9172 }
9173
9175 {
9177 }
9178
9179
9180
9181
9182
9183
9184
9185
9186
9187
9189 {
9190 int slot = -1;
9191 if (GetInventory())
9192 {
9193 InventoryLocation il = new InventoryLocation;
9194 GetInventory().GetCurrentInventoryLocation(il);
9196 }
9197
9199 }
9200
9202 {
9203 float quantity_max = 0;
9204
9206 {
9207 if (attSlotID != -1)
9208 quantity_max = InventorySlots.GetStackMaxForSlotId(attSlotID);
9209
9210 if (quantity_max <= 0)
9212 }
9213
9214 if (quantity_max <= 0)
9216
9217 return quantity_max;
9218 }
9219
9221 {
9223 }
9224
9226 {
9228 }
9229
9230
9232 {
9234 }
9235
9237 {
9239 }
9240
9242 {
9244 }
9245
9246
9248 {
9249
9250 float weightEx = GetWeightEx();
9251 float special = GetInventoryAndCargoWeight();
9252 return weightEx - special;
9253 }
9254
9255
9257 {
9259 }
9260
9262 {
9264 {
9265 #ifdef DEVELOPER
9266 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
9267 {
9268 WeightDebugData data1 = WeightDebug.GetWeightDebug(this);
9270 }
9271 #endif
9272
9274 }
9275 else if (HasEnergyManager())
9276 {
9277 #ifdef DEVELOPER
9278 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
9279 {
9280 WeightDebugData data2 = WeightDebug.GetWeightDebug(this);
9281 data2.
SetCalcDetails(
"TIB2: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " + GetCompEM().
GetEnergy()+
"(energy) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit)");
9282 }
9283 #endif
9284 return super.GetWeightSpecialized(forceRecalc) + (GetCompEM().GetEnergy() * ConfigGetFloat("weightPerQuantityUnit")) + GetConfigWeightModified();
9285 }
9286 else
9287 {
9288 #ifdef DEVELOPER
9289 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
9290 {
9291 WeightDebugData data3 = WeightDebug.GetWeightDebug(this);
9292 data3.
SetCalcDetails(
"TIB3: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " +
GetQuantity()+
"(quantity) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit))");
9293 }
9294 #endif
9295 return super.GetWeightSpecialized(forceRecalc) + (
GetQuantity() * ConfigGetFloat(
"weightPerQuantityUnit")) + GetConfigWeightModified();
9296 }
9297 }
9298
9301 {
9302 int item_count = 0;
9304
9305 if (GetInventory().GetCargo() != NULL)
9306 {
9307 item_count = GetInventory().GetCargo().GetItemCount();
9308 }
9309
9310 for (int i = 0; i < GetInventory().AttachmentCount(); i++)
9311 {
9312 Class.CastTo(item,GetInventory().GetAttachmentFromIndex(i));
9313 if (item)
9314 item_count += item.GetNumberOfItems();
9315 }
9316 return item_count;
9317 }
9318
9321 {
9322 float weight = 0;
9323 float wetness = 1;
9324 if (include_wetness)
9327 {
9328 weight = wetness * m_ConfigWeight;
9329 }
9331 {
9332 weight = 1;
9333 }
9334 return weight;
9335 }
9336
9337
9338
9340 {
9341 if ((
GetGame().IsServer() || !
GetGame().IsMultiplayer()) && GetInventory())
9342 {
9343 GameInventory inv = GetInventory();
9344 array<EntityAI> items = new array<EntityAI>;
9346 for (int i = 0; i < items.Count(); i++)
9347 {
9349 if (item)
9350 {
9352 }
9353 }
9354 }
9355 }
9356
9357
9358
9359
9361 {
9362 float energy = 0;
9363 if (HasEnergyManager())
9364 {
9365 energy = GetCompEM().GetEnergy();
9366 }
9367 return energy;
9368 }
9369
9370
9372 {
9373 super.OnEnergyConsumed();
9374
9376 }
9377
9379 {
9380 super.OnEnergyAdded();
9381
9383 }
9384
9385
9387 {
9388 if (
GetGame().IsServer() && HasEnergyManager() && GetCompEM().HasConversionOfEnergyToQuantity())
9389 {
9391 {
9392 float energy_0to1 = GetCompEM().GetEnergy0To1();
9394 }
9395 }
9396 }
9397
9398
9400 {
9401 return ConfigGetFloat("heatIsolation");
9402 }
9403
9405 {
9407 }
9408
9410 {
9411 string paramPath =
string.Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Drying %2",
GetType(), pIncrementName);
9412 if (
GetGame().ConfigIsExisting(paramPath))
9414
9415 return 0.0;
9416 }
9417
9419 {
9420 string paramPath =
string.
Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Soaking %2",
GetType(), pIncrementName);
9421 if (
GetGame().ConfigIsExisting(paramPath))
9423
9424 return 0.0;
9425 }
9426
9427 override void SetWet(
float value,
bool allow_client =
false)
9428 {
9429 if (!IsServerCheck(allow_client))
9430 return;
9431
9434
9436
9437 m_VarWet = Math.Clamp(value, min, max);
9438
9440 {
9443 }
9444 }
9445
9446 override void AddWet(
float value)
9447 {
9449 }
9450
9452 {
9454 }
9455
9457 {
9459 }
9460
9462 {
9464 }
9465
9467 {
9469 }
9470
9472 {
9474 }
9475
9477 {
9480 if (newLevel != oldLevel)
9481 {
9483 }
9484 }
9485
9487 {
9488 SetWeightDirty();
9489 }
9490
9492 {
9493 return GetWetLevelInternal(
m_VarWet);
9494 }
9495
9496
9497
9499 {
9501 }
9502
9504 {
9506 }
9507
9509 {
9511 }
9512
9514 {
9516 }
9517
9518
9519
9521 {
9522 if (ConfigIsExisting("itemModelLength"))
9523 {
9524 return ConfigGetFloat("itemModelLength");
9525 }
9526 return 0;
9527 }
9528
9530 {
9531 if (ConfigIsExisting("itemAttachOffset"))
9532 {
9533 return ConfigGetFloat("itemAttachOffset");
9534 }
9535 return 0;
9536 }
9537
9538 override void SetCleanness(
int value,
bool allow_client =
false)
9539 {
9540 if (!IsServerCheck(allow_client))
9541 return;
9542
9544
9546
9549 }
9550
9552 {
9554 }
9555
9557 {
9558 return true;
9559 }
9560
9561
9562
9563
9565 {
9567 }
9568
9570 {
9572 }
9573
9574
9575
9576
9577 override void SetColor(
int r,
int g,
int b,
int a)
9578 {
9584 }
9586 override void GetColor(out
int r,out
int g,out
int b,out
int a)
9587 {
9592 }
9593
9595 {
9597 }
9598
9601 {
9602 int r,g,b,a;
9604 r = r/255;
9605 g = g/255;
9606 b = b/255;
9607 a = a/255;
9608 return MiscGameplayFunctions.GetColorString(r, g, b, a);
9609 }
9610
9611
9612
9613 override void SetLiquidType(
int value,
bool allow_client =
false)
9614 {
9615 if (!IsServerCheck(allow_client))
9616 return;
9617
9622 }
9623
9625 {
9626 return ConfigGetInt("varLiquidTypeInit");
9627 }
9628
9630 {
9632 }
9633
9635 {
9637 SetFrozen(false);
9638 }
9639
9642 {
9643 player.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
9644 }
9645
9646
9649 {
9650 PlayerBase nplayer;
9651 if (PlayerBase.CastTo(nplayer, player))
9652 {
9654
9655 nplayer.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
9656 }
9657 }
9658
9659
9662 {
9663 PlayerBase nplayer;
9664 if (PlayerBase.CastTo(nplayer,player))
9665 {
9666
9667 nplayer.SetEnableQuickBarEntityShortcut(this,false);
9668
9669 }
9670
9671
9672 player.GetHumanInventory().ClearUserReservedLocationForContainer(this);
9673
9674
9675 if (HasEnergyManager())
9676 {
9677 GetCompEM().UpdatePlugState();
9678 }
9679 }
9680
9681
9683 {
9684 super.OnPlacementStarted(player);
9685
9687 }
9688
9689 override void OnPlacementComplete(Man player, vector position =
"0 0 0", vector orientation =
"0 0 0")
9690 {
9692 {
9693 m_AdminLog.OnPlacementComplete(player,
this);
9694 }
9695
9696 super.OnPlacementComplete(player, position, orientation);
9697 }
9698
9699
9700
9701
9702
9704 {
9706 {
9707 return true;
9708 }
9709 else
9710 {
9711 return false;
9712 }
9713 }
9714
9715
9717 {
9719 {
9721 }
9722 }
9723
9724
9726 {
9728 }
9729
9731 {
9733 }
9734
9735 override void InsertAgent(
int agent,
float count = 1)
9736 {
9737 if (count < 1)
9738 return;
9739
9741 }
9742
9745 {
9747 }
9748
9749
9751 {
9753 }
9754
9755
9756
9757
9758
9759
9760
9761
9762
9763
9764
9765
9766
9767
9768
9769
9770
9771
9772
9773
9774
9775
9776
9777
9778
9779
9780
9781
9782
9783
9784
9785
9786
9787
9788
9789
9790
9791
9792
9793
9794
9795
9797 {
9799 return false;
9800 return true;
9801 }
9802
9804 {
9805
9807 }
9808
9809
9812 {
9813 super.CheckForRoofLimited(timeTresholdMS);
9814
9816 if ((time - m_PreviousRoofTestTime) >= timeTresholdMS)
9817 {
9818 m_PreviousRoofTestTime = time;
9819 SetRoofAbove(MiscGameplayFunctions.IsUnderRoof(this));
9820 }
9821 }
9822
9823
9825 {
9827 {
9828 return 0;
9829 }
9830
9831 if (GetInventory().GetAttachmentSlotsCount() != 0)
9832 {
9833 ItemBase filter =
ItemBase.Cast(FindAttachmentBySlotName(
"GasMaskFilter"));
9834 if (filter)
9835 return filter.GetProtectionLevel(type, false, system);
9836 else
9837 return 0;
9838 }
9839
9840 string subclassPath, entryName;
9841
9842 switch (type)
9843 {
9845 entryName = "biological";
9846 break;
9848 entryName = "chemical";
9849 break;
9850 default:
9851 entryName = "biological";
9852 break;
9853 }
9854
9855 subclassPath =
"CfgVehicles " + this.
GetType() +
" Protection ";
9856
9858 }
9859
9860
9861
9864 {
9865 if (!IsMagazine())
9867
9869 }
9870
9871
9872
9873
9874
9879 {
9880 return true;
9881 }
9882
9884 {
9886 }
9887
9888
9889
9890
9891
9893 {
9894 if (parent)
9895 {
9896 if (parent.IsInherited(DayZInfected))
9897 return true;
9898
9899 if (!parent.IsRuined())
9900 return true;
9901 }
9902
9903 return true;
9904 }
9905
9907 {
9908 if (!super.CanPutAsAttachment(parent))
9909 {
9910 return false;
9911 }
9912
9913 if (!IsRuined() && !parent.IsRuined())
9914 {
9915 return true;
9916 }
9917
9918 return false;
9919 }
9920
9922 {
9923
9924
9925
9926
9927 return super.CanReceiveItemIntoCargo(item);
9928 }
9929
9931 {
9932
9933
9934
9935
9936 GameInventory attachmentInv = attachment.GetInventory();
9938 {
9939 if (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase))
9940 return false;
9941 }
9942
9943 InventoryLocation loc = new InventoryLocation();
9944 attachment.GetInventory().GetCurrentInventoryLocation(loc);
9945 if (loc && loc.
IsValid() && !GetInventory().AreChildrenAccessible())
9946 return false;
9947
9948 return super.CanReceiveAttachment(attachment, slotId);
9949 }
9950
9952 {
9953 if (!super.CanReleaseAttachment(attachment))
9954 return false;
9955
9956 return GetInventory().AreChildrenAccessible();
9957 }
9958
9959
9960
9961
9962
9963
9964
9965
9966
9967
9968
9969
9970
9971
9972
9973
9974
9975
9976
9977
9978
9980 {
9981 int id = muzzle_owner.GetMuzzleID();
9982 array<ref WeaponParticlesOnFire> WPOF_array =
m_OnFireEffect.Get(
id);
9983
9984 if (WPOF_array)
9985 {
9986 for (int i = 0; i < WPOF_array.Count(); i++)
9987 {
9988 WeaponParticlesOnFire WPOF = WPOF_array.Get(i);
9989
9990 if (WPOF)
9991 {
9992 WPOF.OnActivate(weapon, muzzle_index, ammoType, muzzle_owner, suppressor, config_to_search);
9993 }
9994 }
9995 }
9996 }
9997
9998
10000 {
10001 int id = muzzle_owner.GetMuzzleID();
10003
10004 if (WPOBE_array)
10005 {
10006 for (int i = 0; i < WPOBE_array.Count(); i++)
10007 {
10008 WeaponParticlesOnBulletCasingEject WPOBE = WPOBE_array.Get(i);
10009
10010 if (WPOBE)
10011 {
10012 WPOBE.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
10013 }
10014 }
10015 }
10016 }
10017
10018
10020 {
10021 int id = muzzle_owner.GetMuzzleID();
10022 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
10023
10024 if (WPOOH_array)
10025 {
10026 for (int i = 0; i < WPOOH_array.Count(); i++)
10027 {
10028 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
10029
10030 if (WPOOH)
10031 {
10032 WPOOH.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
10033 }
10034 }
10035 }
10036 }
10037
10038
10040 {
10041 int id = muzzle_owner.GetMuzzleID();
10042 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
10043
10044 if (WPOOH_array)
10045 {
10046 for (int i = 0; i < WPOOH_array.Count(); i++)
10047 {
10048 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
10049
10050 if (WPOOH)
10051 {
10052 WPOOH.OnUpdate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
10053 }
10054 }
10055 }
10056 }
10057
10058
10060 {
10061 int id = muzzle_owner.GetMuzzleID();
10062 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
10063
10064 if (WPOOH_array)
10065 {
10066 for (int i = 0; i < WPOOH_array.Count(); i++)
10067 {
10068 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
10069
10070 if (WPOOH)
10071 {
10072 WPOOH.OnDeactivate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
10073 }
10074 }
10075 }
10076 }
10077
10078
10079
10081 {
10083 {
10084 return true;
10085 }
10086
10087 return false;
10088 }
10089
10091 {
10093 {
10094 return true;
10095 }
10096
10097 return false;
10098 }
10099
10101 {
10103 {
10104 return true;
10105 }
10106
10107 return false;
10108 }
10109
10111 {
10112 return false;
10113 }
10114
10117 {
10118 return UATimeSpent.DEFAULT_DEPLOY;
10119 }
10120
10121
10122
10123
10125 {
10127 SetSynchDirty();
10128 }
10129
10131 {
10133 }
10134
10135
10137 {
10138 return false;
10139 }
10140
10143 {
10144 string att_type = "None";
10145
10146 if (ConfigIsExisting("soundAttType"))
10147 {
10148 att_type = ConfigGetString("soundAttType");
10149 }
10150
10152 }
10153
10155 {
10157 }
10158
10159
10160
10161
10162
10168
10170 {
10173
10175 }
10176
10177
10179 {
10181 return;
10182
10184
10187
10190
10191 SoundParameters params = new SoundParameters();
10195 }
10196
10197
10199 {
10201 return;
10202
10204 SetSynchDirty();
10205
10208 }
10209
10210
10212 {
10214 return;
10215
10217 SetSynchDirty();
10218
10221 }
10222
10224 {
10226 }
10227
10229 {
10231 }
10232
10235 {
10236 if (!
GetGame().IsDedicatedServer())
10237 {
10238 if (ConfigIsExisting("attachSoundSet"))
10239 {
10240 string cfg_path = "";
10241 string soundset = "";
10242 string type_name =
GetType();
10243
10246 ConfigGetTextArray("attachSoundSet",cfg_soundset_array);
10247 ConfigGetTextArray("attachSoundSlot",cfg_slot_array);
10248
10249 if (cfg_soundset_array.Count() > 0 && cfg_soundset_array.Count() == cfg_slot_array.Count())
10250 {
10251 for (int i = 0; i < cfg_soundset_array.Count(); i++)
10252 {
10253 if (cfg_slot_array[i] == slot_type)
10254 {
10255 soundset = cfg_soundset_array[i];
10256 break;
10257 }
10258 }
10259 }
10260
10261 if (soundset != "")
10262 {
10263 EffectSound sound = SEffectManager.PlaySound(soundset,
GetPosition());
10265 }
10266 }
10267 }
10268 }
10269
10271 {
10272
10273 }
10274
10275 void OnApply(PlayerBase player);
10276
10278 {
10279 return 1.0;
10280 };
10281
10283 {
10285 }
10286
10288 {
10290 }
10291
10293
10295 {
10296 SetDynamicPhysicsLifeTime(0.01);
10298 }
10299
10301 {
10302 array<string> zone_names = new array<string>;
10303 GetDamageZones(zone_names);
10304 for (int i = 0; i < zone_names.Count(); i++)
10305 {
10306 SetHealthMax(zone_names.Get(i),"Health");
10307 }
10308 SetHealthMax("","Health");
10309 }
10310
10313 {
10314 float global_health = GetHealth01("","Health");
10315 array<string> zones = new array<string>;
10316 GetDamageZones(zones);
10317
10318 for (int i = 0; i < zones.Count(); i++)
10319 {
10320 SetHealth01(zones.Get(i),"Health",global_health);
10321 }
10322 }
10323
10326 {
10327 return IsExclusionFlagPresent(PlayerBase.GetFaceCoverageShaveValues());
10328 }
10329
10331 {
10332 if (!hasRootAsPlayer)
10333 {
10334 if (refParentIB)
10335 {
10336
10337 if ((refParentIB.GetWet() >= GameConstants.STATE_SOAKING_WET) && (
m_VarWet <
m_VarWetMax))
10338 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_INSIDE);
10339
10340 else if ((refParentIB.GetLiquidType() != 0) && (refParentIB.GetQuantity() > 0) && (
m_VarWet <
m_VarWetMax))
10341 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_LIQUID);
10342
10345 }
10346 else
10347 {
10348
10351 }
10352 }
10353 }
10354
10356 {
10358 {
10359 float target =
g_Game.GetMission().GetWorldData().GetBaseEnvTemperatureAtObject(
this);
10360 if (
GetTemperature() != target || !IsFreezeThawProgressFinished())
10361 {
10362 float heatPermCoef = 1.0;
10364 while (ent)
10365 {
10366 heatPermCoef *= ent.GetHeatPermeabilityCoef();
10367 ent = ent.GetHierarchyParent();
10368 }
10369
10370 SetTemperatureEx(
new TemperatureDataInterpolated(target,
ETemperatureAccessTypes.ACCESS_WORLD,delta,GameConstants.TEMP_COEF_WORLD,heatPermCoef));
10371 }
10372 }
10373 }
10374
10376 {
10377
10378 EntityAI parent = GetHierarchyParent();
10379 if (!parent)
10380 {
10381 hasParent = false;
10382 hasRootAsPlayer = false;
10383 }
10384 else
10385 {
10386 hasParent = true;
10387 hasRootAsPlayer = (GetHierarchyRootPlayer() != null);
10388 refParentIB =
ItemBase.Cast(parent);
10389 }
10390 }
10391
10392 protected void ProcessDecay(
float delta,
bool hasRootAsPlayer)
10393 {
10394
10395 }
10396
10398 {
10399
10400 return false;
10401 }
10402
10404 {
10405
10406
10407 return false;
10408 }
10409
10411 {
10412
10413 return false;
10414 }
10415
10418 {
10419 return !GetIsFrozen() &&
IsOpen();
10420 }
10421
10423 {
10424 bool hasParent = false, hasRootAsPlayer = false;
10426
10427 bool wwtu =
g_Game.IsWorldWetTempUpdateEnabled();
10428 bool foodDecay =
g_Game.IsFoodDecayEnabled();
10429
10430 if (wwtu || foodDecay)
10431 {
10435
10436 if (processWetness || processTemperature || processDecay)
10437 {
10439
10440 if (processWetness)
10441 ProcessItemWetness(m_ElapsedSinceLastUpdate, hasParent, hasRootAsPlayer, refParentIB);
10442
10443 if (processTemperature)
10445
10446 if (processDecay)
10447 ProcessDecay(m_ElapsedSinceLastUpdate, hasRootAsPlayer);
10448 }
10449 }
10450 }
10451
10454 {
10456 }
10457
10459 {
10462
10463 return super.GetTemperatureFreezeThreshold();
10464 }
10465
10467 {
10470
10471 return super.GetTemperatureThawThreshold();
10472 }
10473
10475 {
10478
10479 return super.GetItemOverheatThreshold();
10480 }
10481
10483 {
10485 return Math.Lerp(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureFreezeTime()),
GetQuantityNormalized());
10486
10487 return super.GetTemperatureFreezeTime();
10488 }
10489
10491 {
10493 return Math.Lerp(GameConstants.TEMPERATURE_TIME_THAW_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureThawTime()),
GetQuantityNormalized());
10494
10495 return super.GetTemperatureThawTime();
10496 }
10497
10502
10504 {
10505 return (item.IsKindOf("Cauldron") || item.IsKindOf("Pot") || item.IsKindOf("FryingPan") || item.IsKindOf("SmallProtectorCase") || (item.IsKindOf("PortableGasStove") && item.FindAttachmentBySlotName("CookingEquipment")));
10506 }
10507
10509 {
10510 MiscGameplayFunctions.TransferItemProperties(oldItem, this);
10511 }
10512
10515 {
10517 }
10518
10520 {
10522 }
10523
10525 {
10527 }
10528
10531 {
10532 return null;
10533 }
10534
10537 {
10538 return false;
10539 }
10540
10542 {
10544 {
10547 if (!trg)
10548 {
10550 explosive = this;
10551 }
10552
10553 explosive.PairRemote(trg);
10555
10556 int persistentID = RemotelyActivatedItemBehaviour.GeneratePersistentID();
10557 trg.SetPersistentPairID(persistentID);
10558 explosive.SetPersistentPairID(persistentID);
10559
10560 return true;
10561 }
10562 return false;
10563 }
10564
10567 {
10568 float ret = 1.0;
10571 ret *= GetHealth01();
10572
10573 return ret;
10574 }
10575
10576 #ifdef DEVELOPER
10577 override void SetDebugItem()
10578 {
10579 super.SetDebugItem();
10580 _itemBase = this;
10581 }
10582
10584 {
10585 string text = super.GetDebugText();
10586
10588 text +=
string.
Format(
"Heat isolation(modified): %1\n", MiscGameplayFunctions.GetCurrentItemHeatIsolation(
this));
10589
10590 return text;
10591 }
10592 #endif
10593
10595 {
10596 return true;
10597 }
10598
10600
10602
10604 {
10607 }
10608
10609
10617
10633}
10634
10636{
10638 if (entity)
10639 {
10640 bool is_item = entity.IsInherited(
ItemBase);
10641 if (is_item && full_quantity)
10642 {
10645 }
10646 }
10647 else
10648 {
10650 return NULL;
10651 }
10652 return entity;
10653}
10654
10656{
10657 if (item)
10658 {
10659 if (health > 0)
10660 item.SetHealth("", "", health);
10661
10662 if (item.CanHaveTemperature())
10663 {
10665 if (item.CanFreeze())
10666 item.SetFrozen(false);
10667 }
10668
10669 if (item.HasEnergyManager())
10670 {
10671 if (quantity >= 0)
10672 {
10673 item.GetCompEM().SetEnergy0To1(quantity);
10674 }
10675 else
10676 {
10678 }
10679 }
10680 else if (item.IsMagazine())
10681 {
10682 Magazine mag = Magazine.Cast(item);
10683 if (quantity >= 0)
10684 {
10685 mag.ServerSetAmmoCount(mag.GetAmmoMax() * quantity);
10686 }
10687 else
10688 {
10690 }
10691
10692 }
10693 else
10694 {
10695 if (quantity >= 0)
10696 {
10697 item.SetQuantityNormalized(quantity, false);
10698 }
10699 else
10700 {
10702 }
10703
10704 }
10705 }
10706}
10707
10708#ifdef DEVELOPER
10710#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.