5827{
5829 {
5830 return true;
5831 }
5832};
5833
5834
5835
5837{
5841
5843
5846
5847
5848
5849
5850
5859
5865
5870
5875
5896 protected bool m_IsResultOfSplit
5897
5899
5904
5905
5906
5908
5912
5913
5914
5916
5919
5920
5921
5927
5928
5936
5939
5940
5942
5943
5945
5946
5951
5952
5957
5958
5960
5961
5963 {
5968
5969 if (!
GetGame().IsDedicatedServer())
5970 {
5972 {
5974
5976 {
5978 }
5979 }
5980
5983 }
5984
5985 m_OldLocation = null;
5986
5988 {
5990 }
5991
5992 if (ConfigIsExisting("headSelectionsToHide"))
5993 {
5996 }
5997
5999 if (ConfigIsExisting("hideSelectionsByinventorySlot"))
6000 {
6002 }
6003
6005
6006 m_IsResultOfSplit = false;
6007
6009 }
6010
6012 {
6013 super.InitItemVariables();
6014
6020 m_Count = ConfigGetInt(
"count");
6021
6024
6029
6032
6037
6049
6053
6054
6057 if (ConfigIsExisting("canBeSplit"))
6058 {
6061 }
6062
6064 if (ConfigIsExisting("itemBehaviour"))
6066
6067
6070 RegisterNetSyncVariableInt("m_VarLiquidType");
6071 RegisterNetSyncVariableInt("m_Cleanness",0,1);
6072
6073 RegisterNetSyncVariableBoolSignal("m_WantPlayImpactSound");
6074 RegisterNetSyncVariableFloat("m_ImpactSpeed");
6075 RegisterNetSyncVariableInt("m_ImpactSoundSurfaceHash");
6076
6077 RegisterNetSyncVariableInt("m_ColorComponentR", 0, 255);
6078 RegisterNetSyncVariableInt("m_ColorComponentG", 0, 255);
6079 RegisterNetSyncVariableInt("m_ColorComponentB", 0, 255);
6080 RegisterNetSyncVariableInt("m_ColorComponentA", 0, 255);
6081
6082 RegisterNetSyncVariableBool("m_IsBeingPlaced");
6083 RegisterNetSyncVariableBool("m_IsTakeable");
6084 RegisterNetSyncVariableBool("m_IsHologram");
6085
6088 {
6091 }
6092
6094
6096 if (ConfigIsExisting("temperaturePerQuantityWeight"))
6098
6099 }
6100
6102 {
6104 }
6105
6107 {
6110 {
6115 }
6116 }
6117
6118 override void GetActions(
typename action_input_type, out array<ActionBase_Basic> actions)
6119 {
6121 {
6124 }
6125
6127 }
6128
6130 {
6136 }
6137
6139
6141 {
6143
6144 if (!action)
6145 {
6146 Debug.LogError(
"Action " + actionName +
" dosn't exist!");
6147 return;
6148 }
6149
6151 if (!ai)
6152 {
6154 return;
6155 }
6156
6158 if (!action_array)
6159 {
6160 action_array = new array<ActionBase_Basic>;
6162 }
6163 if (LogManager.IsActionLogEnable())
6164 {
6165 Debug.ActionLog(action.ToString() +
" -> " + ai,
this.ToString() ,
"n/a",
"Add action");
6166 }
6167
6168 if (action_array.Find(action) != -1)
6169 {
6170 Debug.Log(
"Action " + action.Type() +
" already added to " +
this +
", skipping!");
6171 }
6172 else
6173 {
6174 action_array.Insert(action);
6175 }
6176 }
6177
6179 {
6181 ActionBase action = player.GetActionManager().GetAction(actionName);
6184
6185 if (action_array)
6186 {
6187 action_array.RemoveItem(action);
6188 }
6189 }
6190
6191
6192
6194 {
6195 ActionOverrideData overrideData = new ActionOverrideData();
6199
6201 if (!actionMap)
6202 {
6205 }
6206
6207 actionMap.Insert(this.
Type(), overrideData);
6208
6209 }
6210
6212
6214
6215
6217 {
6220
6223
6224 string config_to_search = "CfgVehicles";
6225 string muzzle_owner_config;
6226
6228 {
6229 if (IsInherited(Weapon))
6230 config_to_search = "CfgWeapons";
6231
6232 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
6233
6234 string config_OnFire_class = muzzle_owner_config + "Particles " + "OnFire ";
6235
6237
6238 if (config_OnFire_subclass_count > 0)
6239 {
6240 array<ref WeaponParticlesOnFire> WPOF_array = new array<ref WeaponParticlesOnFire>;
6241
6242 for (int i = 0; i < config_OnFire_subclass_count; i++)
6243 {
6244 string particle_class = "";
6246 string config_OnFire_entry = config_OnFire_class + particle_class;
6247 WeaponParticlesOnFire WPOF = new WeaponParticlesOnFire(this, config_OnFire_entry);
6248 WPOF_array.Insert(WPOF);
6249 }
6250
6251
6253 }
6254 }
6255
6257 {
6258 config_to_search = "CfgWeapons";
6259 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
6260
6261 string config_OnBulletCasingEject_class = muzzle_owner_config + "Particles " + "OnBulletCasingEject ";
6262
6264
6265 if (config_OnBulletCasingEject_count > 0 && IsInherited(Weapon))
6266 {
6267 array<ref WeaponParticlesOnBulletCasingEject> WPOBE_array = new array<ref WeaponParticlesOnBulletCasingEject>;
6268
6269 for (i = 0; i < config_OnBulletCasingEject_count; i++)
6270 {
6271 string particle_class2 = "";
6273 string config_OnBulletCasingEject_entry = config_OnBulletCasingEject_class + particle_class2;
6274 WeaponParticlesOnBulletCasingEject WPOBE = new WeaponParticlesOnBulletCasingEject(this, config_OnBulletCasingEject_entry);
6275 WPOBE_array.Insert(WPOBE);
6276 }
6277
6278
6280 }
6281 }
6282 }
6283
6284
6286 {
6289
6291 {
6292 string config_to_search = "CfgVehicles";
6293
6294 if (IsInherited(Weapon))
6295 config_to_search = "CfgWeapons";
6296
6297 string muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
6298 string config_OnOverheating_class = muzzle_owner_config + "Particles " + "OnOverheating ";
6299
6300 if (
GetGame().ConfigIsExisting(config_OnOverheating_class))
6301 {
6302
6304
6306 {
6308 string error =
"Error reading config " +
GetType() +
">Particles>OnOverheating - Parameter shotsToStartOverheating is configured wrong or is missing! Its value must be 1 or higher!";
6310 return;
6311 }
6312
6315
6316
6317
6319 array<ref WeaponParticlesOnOverheating> WPOOH_array = new array<ref WeaponParticlesOnOverheating>;
6320
6321 for (int i = 0; i < config_OnOverheating_subclass_count; i++)
6322 {
6323 string particle_class = "";
6325 string config_OnOverheating_entry = config_OnOverheating_class + particle_class;
6327
6328 if (entry_type == CT_CLASS)
6329 {
6330 WeaponParticlesOnOverheating WPOF = new WeaponParticlesOnOverheating(this, config_OnOverheating_entry);
6331 WPOOH_array.Insert(WPOF);
6332 }
6333 }
6334
6335
6337 }
6338 }
6339 }
6340
6342 {
6344 }
6345
6347 {
6349 {
6351
6354
6357
6358 CheckOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
6359 }
6360 }
6361
6363 {
6365 UpdateOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
6366
6368 StartOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
6369
6371 StopOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
6372
6374 {
6376 }
6377 }
6378
6380 {
6382 }
6383
6385 {
6388 else
6390
6392 {
6395 }
6396 else
6397 {
6400
6403 }
6404
6406 }
6407
6409 {
6411 ItemBase.PlayOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
6412 }
6413
6415 {
6417 ItemBase.UpdateOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
6419 }
6420
6422 {
6424 ItemBase.StopOverheatingParticles(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
6425 }
6426
6428 {
6431
6432 OverheatingParticle OP = new OverheatingParticle();
6437
6439 }
6440
6442 {
6445
6446 return -1;
6447 }
6448
6450 {
6452 {
6455
6456 for (int i = count; i > 0; --i)
6457 {
6458 int id = i - 1;
6461
6464
6465 if (overheat_coef < overheat_min && overheat_coef >= overheat_max)
6466 {
6467 if (p)
6468 {
6471 }
6472 }
6473 }
6474 }
6475 }
6476
6478 {
6480 {
6482 {
6483 int id = i - 1;
6485
6486 if (OP)
6487 {
6489
6490 if (p)
6491 {
6493 }
6494
6495 delete OP;
6496 }
6497 }
6498
6501 }
6502 }
6503
6506 {
6507 return 0.0;
6508 }
6509
6510
6512 {
6513 return 250;
6514 }
6515
6517 {
6518 return 0;
6519 }
6520
6523 {
6525 return true;
6526
6527 return false;
6528 }
6529
6532 {
6535
6537 {
6539 }
6540 else
6541 {
6542
6544 }
6545
6547 }
6548
6555 {
6556 return -1;
6557 }
6558
6559
6560
6561
6563 {
6565 {
6567 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
6568
6569 if (r_index >= 0)
6570 {
6571 InventoryLocation r_il = new InventoryLocation;
6572 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
6573
6574 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
6577 {
6578 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
6579 }
6581 {
6582 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
6583 }
6584
6585 }
6586
6587 player.GetHumanInventory().ClearUserReservedLocation(this);
6588 }
6589
6592 }
6593
6594
6595
6596
6598 {
6599 return ItemBase.m_DebugActionsMask;
6600 }
6601
6603 {
6604 return ItemBase.m_DebugActionsMask & mask;
6605 }
6606
6608 {
6609 ItemBase.m_DebugActionsMask = mask;
6610 }
6611
6613 {
6614 ItemBase.m_DebugActionsMask |= mask;
6615 }
6616
6618 {
6619 ItemBase.m_DebugActionsMask &= ~mask;
6620 }
6621
6623 {
6625 {
6627 }
6628 else
6629 {
6631 }
6632 }
6633
6634
6636 {
6637 if (GetEconomyProfile())
6638 {
6639 float q_max = GetEconomyProfile().GetQuantityMax();
6640 if (q_max > 0)
6641 {
6642 float q_min = GetEconomyProfile().GetQuantityMin();
6643 float quantity_randomized = Math.RandomFloatInclusive(q_min, q_max);
6644
6646 {
6647 ComponentEnergyManager comp = GetCompEM();
6649 {
6651 }
6652 }
6654 {
6656
6657 }
6658
6659 }
6660 }
6661 }
6662
6665 {
6666 EntityAI parent = GetHierarchyParent();
6667
6668 if (parent)
6669 {
6670 InventoryLocation inventory_location_to_lock = new InventoryLocation;
6671 GetInventory().GetCurrentInventoryLocation(inventory_location_to_lock);
6672 parent.GetInventory().SetSlotLock(inventory_location_to_lock.
GetSlot(),
true);
6673 }
6674 }
6675
6678 {
6679 EntityAI parent = GetHierarchyParent();
6680
6681 if (parent)
6682 {
6683 InventoryLocation inventory_location_to_unlock = new InventoryLocation;
6684 GetInventory().GetCurrentInventoryLocation(inventory_location_to_unlock);
6685 parent.GetInventory().SetSlotLock(inventory_location_to_unlock.
GetSlot(),
false);
6686 }
6687 }
6688
6690 {
6691
6692
6693
6694
6696
6698 {
6699 if (ScriptInputUserData.CanStoreInputUserData())
6700 {
6701 ScriptInputUserData ctx = new ScriptInputUserData;
6707 ctx.
Write(use_stack_max);
6710
6712 {
6713 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(item2,null,GameInventory.c_InventoryReservationTimeoutShortMS);
6714 }
6715 }
6716 }
6717 else if (!
GetGame().IsMultiplayer())
6718 {
6720 }
6721 }
6722
6724 {
6726 }
6727
6729 {
6731 }
6732
6734 {
6736 }
6737
6739 {
6740
6741 return false;
6742 }
6743
6745 {
6746 return false;
6747 }
6748
6752 {
6753 return false;
6754 }
6755
6757 {
6758 return "";
6759 }
6760
6762
6764 {
6765 return false;
6766 }
6767
6769 {
6770 return true;
6771 }
6772
6773
6774
6776 {
6777 return true;
6778 }
6779
6781 {
6782 return true;
6783 }
6784
6786 {
6787 PlayerBase player = PlayerBase.Cast(
g_Game.GetPlayer());
6789 }
6790
6792 {
6794 }
6795
6797 {
6799 if (!is_being_placed)
6801 SetSynchDirty();
6802 }
6803
6804
6806
6808 {
6810 }
6811
6813 {
6815 }
6816
6818 {
6819 return 1;
6820 }
6821
6823 {
6824 return false;
6825 }
6826
6828 {
6830 SetSynchDirty();
6831 }
6832
6833
6834
6835
6836
6837
6838
6839
6840
6841
6842
6843
6844
6845
6846
6847
6848
6849
6850
6851
6852
6853
6854
6855
6856
6857
6858
6859
6860
6861
6862
6863
6864
6865
6866
6868 {
6869 super.OnMovedInsideCargo(container);
6870
6871 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
6872 }
6873
6874 override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
6875 {
6876 super.EEItemLocationChanged(oldLoc,newLoc);
6877
6878 PlayerBase new_player = null;
6879 PlayerBase old_player = null;
6880
6881 if (newLoc.GetParent())
6882 new_player = PlayerBase.Cast(newLoc.GetParent().GetHierarchyRootPlayer());
6883
6884 if (oldLoc.GetParent())
6885 old_player = PlayerBase.Cast(oldLoc.GetParent().GetHierarchyRootPlayer());
6886
6888 {
6889 int r_index = old_player.GetHumanInventory().FindUserReservedLocationIndex(this);
6890
6891 if (r_index >= 0)
6892 {
6893 InventoryLocation r_il = new InventoryLocation;
6894 old_player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
6895
6896 old_player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
6899 {
6900 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
6901 }
6903 {
6904 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
6905 }
6906
6907 }
6908 }
6909
6911 {
6912 if (new_player)
6913 new_player.ForceStandUpForHeavyItems(newLoc.GetItem());
6914
6915 if (new_player == old_player)
6916 {
6917
6918 if (oldLoc.GetParent() && new_player.GetHumanInventory().LocationGetEntity(oldLoc) == NULL)
6919 {
6921 {
6922 if (oldLoc.GetParent().GetInventory().TestAddEntityInCargoExLoc(oldLoc, false, false, false, true, false, false))
6923 {
6924 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
6925 }
6926 }
6927 else
6928 {
6929 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
6930 }
6931 }
6932
6933 if (new_player.GetHumanInventory().FindUserReservedLocationIndex(this) >= 0)
6934 {
6935 int type = oldLoc.GetType();
6937 {
6938 oldLoc.GetParent().GetOnSetLock().Invoke(this);
6939 }
6941 {
6942 oldLoc.GetParent().GetOnAttachmentSetLock().Invoke(this, oldLoc.GetSlot());
6943 }
6944 }
6945 if (!m_OldLocation)
6946 {
6947 m_OldLocation = new InventoryLocation;
6948 }
6949 m_OldLocation.Copy(oldLoc);
6950 }
6951 else
6952 {
6953 if (m_OldLocation)
6954 {
6955 m_OldLocation.Reset();
6956 }
6957 }
6958
6960 }
6961 else
6962 {
6963 if (new_player)
6964 {
6965 int res_index = new_player.GetHumanInventory().FindCollidingUserReservedLocationIndex(this, newLoc);
6966 if (res_index >= 0)
6967 {
6968 InventoryLocation il = new InventoryLocation;
6969 new_player.GetHumanInventory().GetUserReservedLocation(res_index,il);
6971 new_player.GetHumanInventory().ClearUserReservedLocationAtIndex(res_index);
6974 {
6975 il.
GetParent().GetOnReleaseLock().Invoke(it);
6976 }
6978 {
6980 }
6981
6982 }
6983 }
6985 {
6986
6988 }
6989
6990 if (m_OldLocation)
6991 {
6992 m_OldLocation.Reset();
6993 }
6994 }
6995 }
6996
6997 override void EOnContact(IEntity other, Contact extra)
6998 {
7000 {
7001 int liquidType = -1;
7003 if (impactSpeed > 0.0)
7004 {
7006 #ifndef SERVER
7008 #else
7010 SetSynchDirty();
7011 #endif
7013 }
7014 }
7015
7016 #ifdef SERVER
7017 if (GetCompEM() && GetCompEM().IsPlugged())
7018 {
7019 if (GetCompEM().GetCordLength() < vector.Distance(
GetPosition(), GetCompEM().GetEnergySource().
GetPosition()))
7020 GetCompEM().UnplugThis();
7021 }
7022 #endif
7023 }
7024
7026
7028 {
7030 }
7031
7033 {
7034
7035 }
7036
7038 {
7039 super.OnItemLocationChanged(old_owner, new_owner);
7040
7041 PlayerBase relatedPlayer = PlayerBase.Cast(old_owner);
7042 PlayerBase playerNew = PlayerBase.Cast(new_owner);
7043
7044 if (!relatedPlayer && playerNew)
7045 relatedPlayer = playerNew;
7046
7047 if (relatedPlayer && relatedPlayer.GetPerformedActionID() != -1)
7048 {
7050 if (actionMgr)
7051 {
7052 ActionBase currentAction = actionMgr.GetRunningAction();
7053 if (currentAction)
7055 }
7056 }
7057
7058 Man ownerPlayerOld = null;
7059 Man ownerPlayerNew = null;
7060
7061 if (old_owner)
7062 {
7063 if (old_owner.
IsMan())
7064 {
7065 ownerPlayerOld = Man.Cast(old_owner);
7066 }
7067 else
7068 {
7069 ownerPlayerOld = Man.Cast(old_owner.GetHierarchyRootPlayer());
7070 }
7071 }
7072 else
7073 {
7075 {
7077
7078 if (!action || !playerNew || playerNew.GetPerformedActionID() != action.
GetID())
7079 {
7080 GetCompEM().UnplugThis();
7081 }
7082 }
7083 }
7084
7085 if (new_owner)
7086 {
7087 if (new_owner.
IsMan())
7088 {
7089 ownerPlayerNew = Man.Cast(new_owner);
7090 }
7091 else
7092 {
7093 ownerPlayerNew = Man.Cast(new_owner.GetHierarchyRootPlayer());
7094 }
7095 }
7096
7097 if (ownerPlayerOld != ownerPlayerNew)
7098 {
7099 if (ownerPlayerOld)
7100 {
7101 array<EntityAI> subItemsExit = new array<EntityAI>;
7103 for (int i = 0; i < subItemsExit.Count(); i++)
7104 {
7107 }
7108 }
7109
7110 if (ownerPlayerNew)
7111 {
7112 array<EntityAI> subItemsEnter = new array<EntityAI>;
7114 for (int j = 0; j < subItemsEnter.Count(); j++)
7115 {
7118 }
7119 }
7120 }
7121 else if (ownerPlayerNew != null)
7122 {
7123 PlayerBase nplayer;
7124 if (PlayerBase.CastTo(nplayer, ownerPlayerNew))
7125 {
7126 array<EntityAI> subItemsUpdate = new array<EntityAI>;
7128 for (int k = 0; k < subItemsUpdate.Count(); k++)
7129 {
7131 itemUpdate.UpdateQuickbarShortcutVisibility(nplayer);
7132 }
7133 }
7134 }
7135
7136 if (old_owner)
7137 old_owner.OnChildItemRemoved(this);
7138 if (new_owner)
7139 new_owner.OnChildItemReceived(this);
7140 }
7141
7142
7144 {
7145 super.EEDelete(parent);
7146 PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
7147 if (player)
7148 {
7150
7151 if (player.IsAlive())
7152 {
7153 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
7154 if (r_index >= 0)
7155 {
7156 InventoryLocation r_il = new InventoryLocation;
7157 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
7158
7159 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
7162 {
7163 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
7164 }
7166 {
7167 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
7168 }
7169
7170 }
7171
7172 player.RemoveQuickBarEntityShortcut(this);
7173 }
7174 }
7175 }
7176
7178 {
7179 super.EEKilled(killer);
7180
7183 {
7184 if (
GetTemperature() >= GameConstants.ITEM_TEMPERATURE_TO_EXPLODE_MIN)
7185 {
7186 if (IsMagazine())
7187 {
7188 if (Magazine.Cast(this).GetAmmoCount() > 0)
7189 {
7191 }
7192 }
7193 else
7194 {
7196 }
7197 }
7198 }
7199 }
7200
7202 {
7203 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
7204
7205 super.OnWasAttached(parent, slot_id);
7206
7209
7211 }
7212
7214 {
7215 super.OnWasDetached(parent, slot_id);
7216
7219 }
7220
7222 {
7223 int idx;
7226
7227 ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
7228 if (inventory_slots.Count() < 1)
7229 {
7230 inventory_slots.Insert(ConfigGetString("ChangeInventorySlot"));
7231 attach_types.Insert(ConfigGetString("ChangeIntoOnAttach"));
7232 }
7233 else
7234 {
7235 ConfigGetTextArray("ChangeIntoOnAttach",attach_types);
7236 }
7237
7238 idx = inventory_slots.Find(slot);
7239 if (idx < 0)
7240 return "";
7241
7242 return attach_types.Get(idx);
7243 }
7244
7246 {
7247 int idx = -1;
7248 string slot;
7249
7252
7253 this.ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
7254 if (inventory_slots.Count() < 1)
7255 {
7256 inventory_slots.Insert(this.ConfigGetString("ChangeInventorySlot"));
7257 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
7258 }
7259 else
7260 {
7261 this.ConfigGetTextArray("ChangeIntoOnDetach",detach_types);
7262 if (detach_types.Count() < 1)
7263 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
7264 }
7265
7266 for (int i = 0; i < inventory_slots.Count(); i++)
7267 {
7268 slot = inventory_slots.Get(i);
7269 }
7270
7271 if (slot != "")
7272 {
7273 if (detach_types.Count() == 1)
7274 idx = 0;
7275 else
7276 idx = inventory_slots.Find(slot);
7277 }
7278 if (idx < 0)
7279 return "";
7280
7281 return detach_types.Get(idx);
7282 }
7283
7285 {
7286
7288
7289
7290 float min_time = 1;
7291 float max_time = 3;
7292 float delay = Math.RandomFloat(min_time, max_time);
7293
7294 explode_timer.Run(delay, this, "DoAmmoExplosion");
7295 }
7296
7298 {
7299 Magazine magazine = Magazine.Cast(this);
7300 int pop_sounds_count = 6;
7301 string pop_sounds[ 6 ] = { "ammopops_1","ammopops_2","ammopops_3","ammopops_4","ammopops_5","ammopops_6" };
7302
7303
7304 int sound_idx = Math.RandomInt(0, pop_sounds_count - 1);
7305 string sound_name = pop_sounds[ sound_idx ];
7307
7308
7309 magazine.ServerAddAmmoCount(-1);
7310
7311
7312 float min_temp_to_explode = 100;
7313
7314 if (magazine.GetAmmoCount() > 0 &&
GetTemperature() >= min_temp_to_explode)
7315 {
7317 }
7318 }
7319
7320
7321 override void EEHitBy(TotalDamageResult damageResult,
int damageType,
EntityAI source,
int component,
string dmgZone,
string ammo, vector modelPos,
float speedCoef)
7322 {
7323 super.EEHitBy(damageResult, damageType, source,
component, dmgZone, ammo, modelPos, speedCoef);
7324
7325 const int CHANCE_DAMAGE_CARGO = 4;
7326 const int CHANCE_DAMAGE_ATTACHMENT = 1;
7327 const int CHANCE_DAMAGE_NOTHING = 2;
7328
7330 {
7331 float dmg = damageResult.
GetDamage(
"",
"Health") * -0.5;
7332 int chances;
7333 int rnd;
7334
7335 if (GetInventory().GetCargo())
7336 {
7337 chances = CHANCE_DAMAGE_CARGO + CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
7338 rnd = Math.RandomInt(0,chances);
7339
7340 if (rnd < CHANCE_DAMAGE_CARGO)
7341 {
7343 }
7344 else if (rnd < (chances - CHANCE_DAMAGE_NOTHING))
7345 {
7347 }
7348 }
7349 else
7350 {
7351 chances = CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
7352 rnd = Math.RandomInt(0,chances);
7353
7354 if (rnd < CHANCE_DAMAGE_ATTACHMENT)
7355 {
7357 }
7358 }
7359 }
7360 }
7361
7363 {
7364 if (GetInventory().GetCargo())
7365 {
7366 int item_count = GetInventory().GetCargo().GetItemCount();
7367 if (item_count > 0)
7368 {
7369 int random_pick = Math.RandomInt(0, item_count);
7371 if (!item.IsExplosive())
7372 {
7373 item.AddHealth("","",damage);
7374 return true;
7375 }
7376 }
7377 }
7378 return false;
7379 }
7380
7382 {
7383 int attachment_count = GetInventory().AttachmentCount();
7384 if (attachment_count > 0)
7385 {
7386 int random_pick = Math.RandomInt(0, attachment_count);
7387 ItemBase attachment =
ItemBase.Cast(GetInventory().GetAttachmentFromIndex(random_pick));
7388 if (!attachment.IsExplosive())
7389 {
7390 attachment.AddHealth("","",damage);
7391 return true;
7392 }
7393 }
7394 return false;
7395 }
7396
7398 {
7400 }
7401
7403 {
7405 return GetInventory().CanRemoveEntity();
7406
7407 return false;
7408 }
7409
7411 {
7412
7414 return false;
7415
7416
7418 return false;
7419
7420
7421
7423 if (delta == 0)
7424 return false;
7425
7426
7427 return true;
7428 }
7429
7431 {
7433 {
7434 if (ScriptInputUserData.CanStoreInputUserData())
7435 {
7436 ScriptInputUserData ctx = new ScriptInputUserData;
7441 ctx.
Write(destination_entity);
7445 }
7446 }
7447 else if (!
GetGame().IsMultiplayer())
7448 {
7450 }
7451 }
7452
7454 {
7455 float split_quantity_new;
7459 InventoryLocation loc = new InventoryLocation;
7460
7461 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
7462 {
7464 split_quantity_new = stack_max;
7465 else
7467
7469 {
7470 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
7471 if (new_item)
7472 {
7473 new_item.SetResultOfSplit(true);
7474 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7476 new_item.
SetQuantity(split_quantity_new,
false,
true);
7477 }
7478 }
7479 }
7480 else if (destination_entity && slot_id == -1)
7481 {
7482 if (quantity > stack_max)
7483 split_quantity_new = stack_max;
7484 else
7485 split_quantity_new = quantity;
7486
7488 {
7490 {
7493 }
7494
7495 if (new_item)
7496 {
7497 new_item.SetResultOfSplit(true);
7498 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7500 new_item.
SetQuantity(split_quantity_new,
false,
true);
7501 }
7502 }
7503 }
7504 else
7505 {
7506 if (stack_max != 0)
7507 {
7509 {
7511 }
7512
7513 if (split_quantity_new == 0)
7514 {
7515 if (!
GetGame().IsMultiplayer())
7516 player.PhysicalPredictiveDropItem(this);
7517 else
7518 player.ServerDropEntity(this);
7519 return;
7520 }
7521
7523 {
7525
7526 if (new_item)
7527 {
7528 new_item.SetResultOfSplit(true);
7529 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7532 new_item.PlaceOnSurface();
7533 }
7534 }
7535 }
7536 }
7537 }
7538
7540 {
7541 float split_quantity_new;
7545 InventoryLocation loc = new InventoryLocation;
7546
7547 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
7548 {
7550 split_quantity_new = stack_max;
7551 else
7553
7555 {
7556 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
7557 if (new_item)
7558 {
7559 new_item.SetResultOfSplit(true);
7560 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7562 new_item.
SetQuantity(split_quantity_new,
false,
true);
7563 }
7564 }
7565 }
7566 else if (destination_entity && slot_id == -1)
7567 {
7568 if (quantity > stack_max)
7569 split_quantity_new = stack_max;
7570 else
7571 split_quantity_new = quantity;
7572
7574 {
7576 {
7579 }
7580
7581 if (new_item)
7582 {
7583 new_item.SetResultOfSplit(true);
7584 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7586 new_item.
SetQuantity(split_quantity_new,
false,
true);
7587 }
7588 }
7589 }
7590 else
7591 {
7592 if (stack_max != 0)
7593 {
7595 {
7597 }
7598
7600 {
7602
7603 if (new_item)
7604 {
7605 new_item.SetResultOfSplit(true);
7606 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7609 new_item.PlaceOnSurface();
7610 }
7611 }
7612 }
7613 }
7614 }
7615
7617 {
7619 {
7620 if (ScriptInputUserData.CanStoreInputUserData())
7621 {
7622 ScriptInputUserData ctx = new ScriptInputUserData;
7627 dst.WriteToContext(ctx);
7629 }
7630 }
7631 else if (!
GetGame().IsMultiplayer())
7632 {
7634 }
7635 }
7636
7638 {
7640 {
7641 if (ScriptInputUserData.CanStoreInputUserData())
7642 {
7643 ScriptInputUserData ctx = new ScriptInputUserData;
7648 ctx.
Write(destination_entity);
7654 }
7655 }
7656 else if (!
GetGame().IsMultiplayer())
7657 {
7659 }
7660 }
7661
7663 {
7665 }
7666
7668 {
7670 float split_quantity_new;
7672 if (dst.IsValid())
7673 {
7674 int slot_id = dst.GetSlot();
7676
7677 if (quantity > stack_max)
7678 split_quantity_new = stack_max;
7679 else
7680 split_quantity_new = quantity;
7681
7683 {
7685
7686 if (new_item)
7687 {
7688 new_item.SetResultOfSplit(true);
7689 MiscGameplayFunctions.TransferItemProperties(this,new_item);
7691 new_item.
SetQuantity(split_quantity_new,
false,
true);
7692 }
7693
7694 return new_item;
7695 }
7696 }
7697
7698 return null;
7699 }
7700
7702 {
7704 float split_quantity_new;
7706 if (destination_entity)
7707 {
7709 if (quantity > stackable)
7710 split_quantity_new = stackable;
7711 else
7712 split_quantity_new = quantity;
7713
7715 {
7716 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateEntityInCargoEx(
this.GetType(), idx, row, col,
false));
7717 if (new_item)
7718 {
7719 new_item.SetResultOfSplit(true);
7720 MiscGameplayFunctions.TransferItemProperties(this,new_item);
7722 new_item.
SetQuantity(split_quantity_new,
false,
true);
7723 }
7724 }
7725 }
7726 }
7727
7729 {
7731 {
7732 if (ScriptInputUserData.CanStoreInputUserData())
7733 {
7734 ScriptInputUserData ctx = new ScriptInputUserData;
7739 ItemBase destination_entity =
this;
7740 ctx.
Write(destination_entity);
7744 }
7745 }
7746 else if (!
GetGame().IsMultiplayer())
7747 {
7749 }
7750 }
7751
7753 {
7755 float split_quantity_new;
7757 if (player)
7758 {
7760 if (quantity > stackable)
7761 split_quantity_new = stackable;
7762 else
7763 split_quantity_new = quantity;
7764
7766 {
7767 EntityAI in_hands = player.GetHumanInventory().CreateInHands(this.
GetType());
7768 new_item =
ItemBase.Cast(in_hands);
7769 if (new_item)
7770 {
7771 new_item.SetResultOfSplit(true);
7772 MiscGameplayFunctions.TransferItemProperties(this,new_item);
7774 new_item.SetQuantity(split_quantity_new, false, true);
7775 }
7776 }
7777 }
7778 }
7779
7781 {
7783 float split_quantity_new = Math.Floor(quantity * 0.5);
7784
7786 return;
7787
7789
7790 if (new_item)
7791 {
7792 if (new_item.GetQuantityMax() < split_quantity_new)
7793 {
7794 split_quantity_new = new_item.GetQuantityMax();
7795 }
7796
7797 new_item.SetResultOfSplit(true);
7798 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7799
7801 {
7804 }
7805 else
7806 {
7808 new_item.
SetQuantity(split_quantity_new,
false,
true);
7809 }
7810 }
7811 }
7812
7814 {
7816 float split_quantity_new = Math.Floor(quantity / 2);
7817
7819 return;
7820
7821 InventoryLocation invloc = new InventoryLocation;
7823
7825 new_item = player.CreateCopyOfItemInInventoryOrGroundEx(this, true);
7826
7827 if (new_item)
7828 {
7829 if (new_item.GetQuantityMax() < split_quantity_new)
7830 {
7831 split_quantity_new = new_item.GetQuantityMax();
7832 }
7834 {
7837 }
7838 else if (split_quantity_new > 1)
7839 {
7841 new_item.
SetQuantity(split_quantity_new,
false,
true);
7842 }
7843 }
7844 }
7845
7848 {
7849 SetWeightDirty();
7851
7852 if (parent)
7853 parent.OnAttachmentQuantityChangedEx(this, delta);
7854
7856 {
7858 {
7860 }
7862 {
7863 ErrorEx(
"Undefined liquid type quantity changed, please define liquid type first! Using init value.",
ErrorExSeverity.INFO);
7865 }
7866 }
7867
7868 }
7869
7872 {
7873
7874 }
7875
7878 {
7880 }
7881
7883 {
7884 super.EEHealthLevelChanged(oldLevel,newLevel,zone);
7885
7887 {
7888 if (newLevel == GameConstants.STATE_RUINED)
7889 {
7891 EntityAI parent = GetHierarchyParent();
7892 if (parent && parent.IsFireplace())
7893 {
7894 CargoBase cargo = GetInventory().GetCargo();
7895 if (cargo)
7896 {
7898 {
7900 }
7901 }
7902 }
7903 }
7904
7906 {
7907
7909 return;
7910 }
7911
7912 if (
m_Cleanness != 0 && oldLevel < newLevel && newLevel != 0)
7913 {
7915 }
7916 }
7917 }
7918
7919
7921 {
7922 super.OnRightClick();
7923
7925 {
7927 {
7928 if (ScriptInputUserData.CanStoreInputUserData())
7929 {
7930 EntityAI root = GetHierarchyRoot();
7931 Man playerOwner = GetHierarchyRootPlayer();
7932 InventoryLocation dst = new InventoryLocation;
7933
7934
7935 if (!playerOwner && root && root == this)
7936 {
7938 }
7939 else
7940 {
7941
7942 GetInventory().GetCurrentInventoryLocation(dst);
7944 {
7947 {
7949 }
7950 else
7951 {
7953
7954
7955 if (
GetGame().
GetPlayer().GetInventory().HasInventoryReservation(
this, dst))
7956 {
7958 }
7959 else
7960 {
7961 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(null, dst, GameInventory.c_InventoryReservationTimeoutShortMS);
7962 }
7963 }
7964 }
7965 }
7966
7967 ScriptInputUserData ctx = new ScriptInputUserData;
7975 }
7976 }
7977 else if (!
GetGame().IsMultiplayer())
7978 {
7980 }
7981 }
7982 }
7983
7985 {
7986 if (root)
7987 {
7988 vector m4[4];
7989 root.GetTransform(m4);
7990 dst.SetGround(this, m4);
7991 }
7992 else
7993 {
7994 GetInventory().GetCurrentInventoryLocation(dst);
7995 }
7996 }
7997
7998 override bool CanBeCombined(
EntityAI other_item,
bool reservation_check =
true,
bool stack_max_limit =
false)
7999 {
8000
8001 if (!other_item ||
GetType() != other_item.GetType() || (
IsFullQuantity() && other_item.GetQuantity() > 0) || other_item ==
this)
8002 return false;
8003
8004 if (GetHealthLevel() == GameConstants.STATE_RUINED || other_item.GetHealthLevel() == GameConstants.STATE_RUINED)
8005 return false;
8006
8007
8009 return false;
8010
8011
8012 Magazine mag = Magazine.Cast(this);
8013 if (mag)
8014 {
8015 if (mag.GetAmmoCount() >= mag.GetAmmoMax())
8016 return false;
8017
8018 if (stack_max_limit)
8019 {
8020 Magazine other_mag = Magazine.Cast(other_item);
8021 if (other_item)
8022 {
8023 if (mag.GetAmmoCount() + other_mag.GetAmmoCount() > mag.GetAmmoMax())
8024 return false;
8025 }
8026
8027 }
8028 }
8029 else
8030 {
8031
8033 return false;
8034
8036 return false;
8037 }
8038
8039 PlayerBase player = null;
8040 if (CastTo(player, GetHierarchyRootPlayer()))
8041 {
8042 if (player.GetInventory().HasAttachment(this))
8043 return false;
8044
8045 if (player.IsItemsToDelete())
8046 return false;
8047 }
8048
8049 if (reservation_check && (GetInventory().HasInventoryReservation(this, null) || other_item.GetInventory().HasInventoryReservation(other_item, null)))
8050 return false;
8051
8052 int slotID;
8054 if (GetInventory().GetCurrentAttachmentSlotInfo(slotID,
slotName) && GetHierarchyParent().GetInventory().GetSlotLock(slotID))
8055 return false;
8056
8057 return true;
8058 }
8059
8061 {
8063 }
8064
8066 {
8067 return m_IsResultOfSplit;
8068 }
8069
8071 {
8072 m_IsResultOfSplit = value;
8073 }
8074
8076 {
8078 }
8079
8081 {
8082 float other_item_quantity = other_item.GetQuantity();
8083 float this_free_space;
8084
8086
8088
8089 if (other_item_quantity > this_free_space)
8090 {
8091 return this_free_space;
8092 }
8093 else
8094 {
8095 return other_item_quantity;
8096 }
8097 }
8098
8100 {
8102 }
8103
8105 {
8107 return;
8108
8109 if (!IsMagazine() && other_item)
8110 {
8112 if (quantity_used != 0)
8113 {
8114 float hp1 = GetHealth01("","");
8115 float hp2 = other_item.GetHealth01("","");
8116 float hpResult = ((hp1*
GetQuantity()) + (hp2*quantity_used));
8117 hpResult = hpResult / (
GetQuantity() + quantity_used);
8118
8119 hpResult *= GetMaxHealth();
8120 Math.Round(hpResult);
8121 SetHealth("", "Health", hpResult);
8122
8124 other_item.AddQuantity(-quantity_used);
8125 }
8126 }
8128 }
8129
8131 {
8132 #ifdef SERVER
8133 if (!GetHierarchyRootPlayer() && GetHierarchyParent())
8134 GetHierarchyParent().IncreaseLifetimeUp();
8135 #endif
8136 };
8137
8139 {
8140 PlayerBase p = PlayerBase.Cast(player);
8141
8142 array<int> recipesIds = p.m_Recipes;
8143 PluginRecipesManager moduleRecipesManager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
8144 if (moduleRecipesManager)
8145 {
8146 EntityAI itemInHands = player.GetHumanInventory().GetEntityInHands();
8147 moduleRecipesManager.GetValidRecipes(
ItemBase.Cast(
this),
ItemBase.Cast(itemInHands), recipesIds, p);
8148 }
8149
8150 for (int i = 0;i < recipesIds.Count(); i++)
8151 {
8152 int key = recipesIds.Get(i);
8153 string recipeName = moduleRecipesManager.GetRecipeName(key);
8155 }
8156 }
8157
8158
8159 override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
8160 {
8161 super.GetDebugActions(outputList);
8162
8163
8169
8170
8175
8180
8181
8185
8186
8188 {
8192 }
8193
8196
8197
8201
8203
8204 InventoryLocation loc = new InventoryLocation();
8205 GetInventory().GetCurrentInventoryLocation(loc);
8207 {
8208 if (Gizmo_IsSupported())
8211 }
8212
8214 }
8215
8216
8217
8218
8220 {
8221 super.OnAction(action_id, player, ctx);
8222
8224 {
8225 switch (action_id)
8226 {
8229 return true;
8232 return true;
8233 }
8234 }
8235
8237 {
8238 switch (action_id)
8239 {
8241 Delete();
8242 return true;
8243 }
8244 }
8245
8246 if (action_id >=
EActions.RECIPES_RANGE_START && action_id <
EActions.RECIPES_RANGE_END)
8247 {
8248 PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
8249 int idWithoutOffset = action_id -
EActions.RECIPES_RANGE_START;
8250 PlayerBase p = PlayerBase.Cast(player);
8251 if (
EActions.RECIPES_RANGE_START < 1000)
8252 {
8253 float anim_length = plugin_recipes_manager.GetRecipeLengthInSecs(idWithoutOffset);
8254 float specialty_weight = plugin_recipes_manager.GetRecipeSpecialty(idWithoutOffset);
8255 }
8256 }
8257 #ifndef SERVER
8258 else if (action_id ==
EActions.WATCH_PLAYER)
8259 {
8260 PluginDeveloper.SetDeveloperItemClientEx(player);
8261 }
8262 #endif
8264 {
8265 if (action_id >=
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START && action_id <
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_END)
8266 {
8267 int id = action_id -
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START;
8268 OnDebugButtonPressServer(id + 1);
8269 }
8270
8271 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_INJECT_START && action_id <
EActions.DEBUG_AGENTS_RANGE_INJECT_END)
8272 {
8273 int agent_id = action_id -
EActions.DEBUG_AGENTS_RANGE_INJECT_START;
8275 }
8276
8277 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_REMOVE_START && action_id <
EActions.DEBUG_AGENTS_RANGE_REMOVE_END)
8278 {
8279 int agent_id2 = action_id -
EActions.DEBUG_AGENTS_RANGE_REMOVE_START;
8281 }
8282
8283 else if (action_id ==
EActions.ADD_QUANTITY)
8284 {
8285 if (IsMagazine())
8286 {
8287 Magazine mag = Magazine.Cast(this);
8288 mag.ServerSetAmmoCount(mag.GetAmmoCount() + mag.GetAmmoMax() * 0.2);
8289 }
8290 else
8291 {
8293 }
8294
8295 if (m_EM)
8296 {
8297 m_EM.AddEnergy(m_EM.GetEnergyMax() * 0.2);
8298 }
8299
8300 }
8301
8302 else if (action_id ==
EActions.REMOVE_QUANTITY)
8303 {
8304 if (IsMagazine())
8305 {
8306 Magazine mag2 = Magazine.Cast(this);
8307 mag2.ServerSetAmmoCount(mag2.GetAmmoCount() - mag2.GetAmmoMax() * 0.2);
8308 }
8309 else
8310 {
8312 }
8313 if (m_EM)
8314 {
8315 m_EM.AddEnergy(- m_EM.GetEnergyMax() * 0.2);
8316 }
8317
8318 }
8319
8320 else if (action_id ==
EActions.SET_QUANTITY_0)
8321 {
8323
8324 if (m_EM)
8325 {
8326 m_EM.SetEnergy(0);
8327 }
8328 }
8329
8330 else if (action_id ==
EActions.SET_MAX_QUANTITY)
8331 {
8333
8334 if (m_EM)
8335 {
8336 m_EM.SetEnergy(m_EM.GetEnergyMax());
8337 }
8338 }
8339
8340 else if (action_id ==
EActions.ADD_HEALTH)
8341 {
8342 AddHealth("","",GetMaxHealth("","Health")/5);
8343 }
8344 else if (action_id ==
EActions.REMOVE_HEALTH)
8345 {
8346 AddHealth("","",-GetMaxHealth("","Health")/5);
8347 }
8348 else if (action_id ==
EActions.DESTROY_HEALTH)
8349 {
8350 SetHealth01("","",0);
8351 }
8352 else if (action_id ==
EActions.WATCH_ITEM)
8353 {
8355 mid.RegisterDebugItem(
ItemBase.Cast(
this), PlayerBase.Cast(player));
8356 #ifdef DEVELOPER
8357 SetDebugDeveloper_item(this);
8358 #endif
8359 }
8360
8361 else if (action_id ==
EActions.ADD_TEMPERATURE)
8362 {
8363 AddTemperature(20);
8364
8365 }
8366
8367 else if (action_id ==
EActions.REMOVE_TEMPERATURE)
8368 {
8369 AddTemperature(-20);
8370
8371 }
8372
8373 else if (action_id ==
EActions.FLIP_FROZEN)
8374 {
8375 SetFrozen(!GetIsFrozen());
8376
8377 }
8378
8379 else if (action_id ==
EActions.ADD_WETNESS)
8380 {
8382
8383 }
8384
8385 else if (action_id ==
EActions.REMOVE_WETNESS)
8386 {
8388
8389 }
8390
8391 else if (action_id ==
EActions.LIQUIDTYPE_UP)
8392 {
8395
8396
8397 }
8398
8399 else if (action_id ==
EActions.LIQUIDTYPE_DOWN)
8400 {
8403 }
8404
8405 else if (action_id ==
EActions.MAKE_SPECIAL)
8406 {
8407 auto debugParams = DebugSpawnParams.WithPlayer(player);
8408 OnDebugSpawnEx(debugParams);
8409 }
8410
8411 }
8412
8413
8414 return false;
8415 }
8416
8417
8418
8419
8423
8426
8427
8428
8430 {
8431 return false;
8432 }
8433
8434
8436 {
8437 return true;
8438 }
8439
8440
8442 {
8443 return true;
8444 }
8445
8446
8447
8449 {
8450 string config_path =
string.Format(
"CfgVehicles %1 Food FoodStages",
GetType());
8452 }
8453
8456 {
8457 return null;
8458 }
8459
8461 {
8462 return false;
8463 }
8464
8466 {
8467 return false;
8468 }
8469
8473
8474
8476 {
8477 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
8478 return module_repairing.CanRepair(this, item_repair_kit);
8479 }
8480
8481
8482 bool Repair(PlayerBase player,
ItemBase item_repair_kit,
float specialty_weight)
8483 {
8484 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
8485 return module_repairing.Repair(player, this, item_repair_kit, specialty_weight);
8486 }
8487
8488
8490 {
8491
8492
8493
8494
8495
8496
8497
8498
8499 return 1;
8500 }
8501
8502
8503
8505 {
8507 }
8508
8509
8510
8512 {
8514 }
8515
8516
8525 {
8526 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8527
8528 if (player)
8529 {
8530 player.MessageStatus(text);
8531 }
8532 }
8533
8534
8543 {
8544 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8545
8546 if (player)
8547 {
8548 player.MessageAction(text);
8549 }
8550 }
8551
8552
8561 {
8562 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8563
8564 if (player)
8565 {
8566 player.MessageFriendly(text);
8567 }
8568 }
8569
8570
8579 {
8580 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
8581
8582 if (player)
8583 {
8584 player.MessageImportant(text);
8585 }
8586 }
8587
8589 {
8590 return true;
8591 }
8592
8593
8594 override bool KindOf(
string tag)
8595 {
8596 bool found = false;
8597 string item_name = this.
GetType();
8600
8601 int array_size = item_tag_array.Count();
8602 for (int i = 0; i < array_size; i++)
8603 {
8604 if (item_tag_array.Get(i) == tag)
8605 {
8606 found = true;
8607 break;
8608 }
8609 }
8610 return found;
8611 }
8612
8613
8615 {
8616
8617 super.OnRPC(sender, rpc_type,ctx);
8618
8619
8620 switch (rpc_type)
8621 {
8622 #ifndef SERVER
8623 case ERPCs.RPC_SOUND_LOCK_ATTACH:
8624 Param2<bool, string> p = new Param2<bool, string>(false, "");
8625
8627 return;
8628
8629 bool play = p.param1;
8630 string soundSet = p.param2;
8631
8632 if (play)
8633 {
8635 {
8637 {
8639 }
8640 }
8641 else
8642 {
8644 }
8645 }
8646 else
8647 {
8649 }
8650
8651 break;
8652 #endif
8653
8654 }
8655
8657 {
8659 }
8660 }
8661
8662
8663
8664
8666 {
8667 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
8668 return plugin.GetID(
name);
8669 }
8670
8672 {
8673 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
8674 return plugin.GetName(id);
8675 }
8676
8679 {
8680
8681
8682 int varFlags;
8683 if (!ctx.
Read(varFlags))
8684 return;
8685
8686 if (varFlags & ItemVariableFlags.FLOAT)
8687 {
8689 }
8690 }
8691
8693 {
8694
8695 super.SerializeNumericalVars(floats_out);
8696
8697
8698
8700 {
8702 }
8703
8705 {
8707 }
8708
8710 {
8712 }
8713
8715 {
8720 }
8721
8723 {
8725 }
8726 }
8727
8729 {
8730
8731 super.DeSerializeNumericalVars(floats);
8732
8733
8734 int index = 0;
8735 int mask = Math.Round(floats.Get(index));
8736
8737 index++;
8738
8740 {
8742 {
8744 }
8745 else
8746 {
8747 float quantity = floats.Get(index);
8749 }
8750 index++;
8751 }
8752
8754 {
8755 float wet = floats.Get(index);
8757 index++;
8758 }
8759
8761 {
8762 int liquidtype = Math.Round(floats.Get(index));
8764 index++;
8765 }
8766
8768 {
8770 index++;
8772 index++;
8774 index++;
8776 index++;
8777 }
8778
8780 {
8781 int cleanness = Math.Round(floats.Get(index));
8783 index++;
8784 }
8785 }
8786
8788 {
8789 super.WriteVarsToCTX(ctx);
8790
8791
8793 {
8795 }
8796
8798 {
8800 }
8801
8803 {
8805 }
8806
8808 {
8809 int r,g,b,a;
8815 }
8816
8818 {
8820 }
8821 }
8822
8824 {
8825 if (!super.ReadVarsFromCTX(ctx,version))
8826 return false;
8827
8828 int intValue;
8829 float value;
8830
8831 if (version < 140)
8832 {
8833 if (!ctx.
Read(intValue))
8834 return false;
8835
8836 m_VariablesMask = intValue;
8837 }
8838
8840 {
8841 if (!ctx.
Read(value))
8842 return false;
8843
8845 {
8847 }
8848 else
8849 {
8851 }
8852 }
8853
8854 if (version < 140)
8855 {
8857 {
8858 if (!ctx.
Read(value))
8859 return false;
8860 SetTemperatureDirect(value);
8861 }
8862 }
8863
8865 {
8866 if (!ctx.
Read(value))
8867 return false;
8869 }
8870
8872 {
8873 if (!ctx.
Read(intValue))
8874 return false;
8876 }
8877
8879 {
8880 int r,g,b,a;
8882 return false;
8884 return false;
8886 return false;
8888 return false;
8889
8891 }
8892
8894 {
8895 if (!ctx.
Read(intValue))
8896 return false;
8898 }
8899
8900 if (version >= 138 && version < 140)
8901 {
8903 {
8904 if (!ctx.
Read(intValue))
8905 return false;
8906 SetFrozen(intValue);
8907 }
8908 }
8909
8910 return true;
8911 }
8912
8913
8915 {
8918 {
8920 }
8921
8922 if (!super.OnStoreLoad(ctx, version))
8923 {
8925 return false;
8926 }
8927
8928 if (version >= 114)
8929 {
8930 bool hasQuickBarIndexSaved;
8931
8932 if (!ctx.
Read(hasQuickBarIndexSaved))
8933 {
8935 return false;
8936 }
8937
8938 if (hasQuickBarIndexSaved)
8939 {
8940 int itmQBIndex;
8941
8942
8943 if (!ctx.
Read(itmQBIndex))
8944 {
8946 return false;
8947 }
8948
8949 PlayerBase parentPlayer = PlayerBase.Cast(GetHierarchyRootPlayer());
8950 if (itmQBIndex != -1 && parentPlayer)
8951 parentPlayer.SetLoadedQuickBarItemBind(this, itmQBIndex);
8952 }
8953 }
8954 else
8955 {
8956
8957 PlayerBase player;
8958 int itemQBIndex;
8959 if (version ==
int.
MAX)
8960 {
8961 if (!ctx.
Read(itemQBIndex))
8962 {
8964 return false;
8965 }
8966 }
8967 else if (Class.CastTo(player, GetHierarchyRootPlayer()))
8968 {
8969
8970 if (!ctx.
Read(itemQBIndex))
8971 {
8973 return false;
8974 }
8975 if (itemQBIndex != -1 && player)
8976 player.SetLoadedQuickBarItemBind(this,itemQBIndex);
8977 }
8978 }
8979
8980 if (version < 140)
8981 {
8982
8983 if (!LoadVariables(ctx, version))
8984 {
8986 return false;
8987 }
8988 }
8989
8990
8992 {
8994 return false;
8995 }
8996 if (version >= 132)
8997 {
8999 if (raib)
9000 {
9002 {
9004 return false;
9005 }
9006 }
9007 }
9008
9010 return true;
9011 }
9012
9013
9014
9016 {
9017 super.OnStoreSave(ctx);
9018
9019 PlayerBase player;
9020 if (PlayerBase.CastTo(player,GetHierarchyRootPlayer()))
9021 {
9023
9024 int itemQBIndex = -1;
9025 itemQBIndex = player.FindQuickBarEntityIndex(this);
9026 ctx.
Write(itemQBIndex);
9027 }
9028 else
9029 {
9031 }
9032
9034
9036 if (raib)
9037 {
9039 }
9040 }
9041
9042
9044 {
9045 super.AfterStoreLoad();
9046
9048 {
9050 }
9051
9053 {
9056 }
9057 }
9058
9060 {
9061 super.EEOnAfterLoad();
9062
9064 {
9066 }
9067
9070 }
9071
9073 {
9074 return false;
9075 }
9076
9077
9078
9080 {
9082 {
9083 #ifdef PLATFORM_CONSOLE
9084
9086 {
9088 if (menu)
9089 {
9091 }
9092 }
9093 #endif
9094 }
9095
9097 {
9100 }
9101
9103 {
9104 SetWeightDirty();
9106 }
9108 {
9111 }
9112
9114 {
9117 }
9119 {
9122 }
9123
9124 super.OnVariablesSynchronized();
9125 }
9126
9127
9128
9130 override bool SetQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false,
bool allow_client =
false,
bool clamp_to_stack_max =
true)
9131 {
9132 if (!IsServerCheck(allow_client))
9133 return false;
9134
9136 return false;
9137
9140
9141 if (value <= (min + 0.001))
9142 value = min;
9143
9144 if (value == min)
9145 {
9146 if (destroy_config)
9147 {
9148 bool dstr = ConfigGetBool("varQuantityDestroyOnMin");
9149 if (dstr)
9150 {
9152 this.Delete();
9153 return true;
9154 }
9155 }
9156 else if (destroy_forced)
9157 {
9159 this.Delete();
9160 return true;
9161 }
9162
9164 }
9165
9168
9170 {
9172
9173 if (delta)
9175 }
9176
9178
9179 return false;
9180 }
9181
9182
9184 bool AddQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
9185 {
9187 }
9188
9190 {
9193 }
9194
9196 {
9199 }
9200
9202 override void SetQuantityNormalized(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
9203 {
9204 float value_clamped = Math.Clamp(value, 0, 1);
9206 SetQuantity(result, destroy_config, destroy_forced);
9207 }
9208
9209
9212 {
9214 }
9215
9217 {
9219 }
9220
9221
9222
9223
9224
9225
9226
9227
9228
9229
9231 {
9232 int slot = -1;
9233 if (GetInventory())
9234 {
9235 InventoryLocation il = new InventoryLocation;
9236 GetInventory().GetCurrentInventoryLocation(il);
9238 }
9239
9241 }
9242
9244 {
9245 float quantity_max = 0;
9246
9248 {
9249 if (attSlotID != -1)
9250 quantity_max = InventorySlots.GetStackMaxForSlotId(attSlotID);
9251
9252 if (quantity_max <= 0)
9254 }
9255
9256 if (quantity_max <= 0)
9258
9259 return quantity_max;
9260 }
9261
9263 {
9265 }
9266
9268 {
9270 }
9271
9272
9274 {
9276 }
9277
9279 {
9281 }
9282
9284 {
9286 }
9287
9288
9290 {
9291
9292 float weightEx = GetWeightEx();
9293 float special = GetInventoryAndCargoWeight();
9294 return weightEx - special;
9295 }
9296
9297
9299 {
9301 }
9302
9304 {
9306 {
9307 #ifdef DEVELOPER
9308 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
9309 {
9310 WeightDebugData data1 = WeightDebug.GetWeightDebug(this);
9312 }
9313 #endif
9314
9316 }
9317 else if (HasEnergyManager())
9318 {
9319 #ifdef DEVELOPER
9320 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
9321 {
9322 WeightDebugData data2 = WeightDebug.GetWeightDebug(this);
9323 data2.
SetCalcDetails(
"TIB2: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " + GetCompEM().
GetEnergy()+
"(energy) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit)");
9324 }
9325 #endif
9326 return super.GetWeightSpecialized(forceRecalc) + (GetCompEM().GetEnergy() * ConfigGetFloat("weightPerQuantityUnit")) + GetConfigWeightModified();
9327 }
9328 else
9329 {
9330 #ifdef DEVELOPER
9331 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
9332 {
9333 WeightDebugData data3 = WeightDebug.GetWeightDebug(this);
9334 data3.
SetCalcDetails(
"TIB3: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " +
GetQuantity()+
"(quantity) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit))");
9335 }
9336 #endif
9337 return super.GetWeightSpecialized(forceRecalc) + (
GetQuantity() * ConfigGetFloat(
"weightPerQuantityUnit")) + GetConfigWeightModified();
9338 }
9339 }
9340
9343 {
9344 int item_count = 0;
9346
9347 if (GetInventory().GetCargo() != NULL)
9348 {
9349 item_count = GetInventory().GetCargo().GetItemCount();
9350 }
9351
9352 for (int i = 0; i < GetInventory().AttachmentCount(); i++)
9353 {
9354 Class.CastTo(item,GetInventory().GetAttachmentFromIndex(i));
9355 if (item)
9356 item_count += item.GetNumberOfItems();
9357 }
9358 return item_count;
9359 }
9360
9363 {
9364 float weight = 0;
9365 float wetness = 1;
9366 if (include_wetness)
9369 {
9370 weight = wetness * m_ConfigWeight;
9371 }
9373 {
9374 weight = 1;
9375 }
9376 return weight;
9377 }
9378
9379
9380
9382 {
9383 if ((
GetGame().IsServer() || !
GetGame().IsMultiplayer()) && GetInventory())
9384 {
9385 GameInventory inv = GetInventory();
9386 array<EntityAI> items = new array<EntityAI>;
9388 for (int i = 0; i < items.Count(); i++)
9389 {
9391 if (item)
9392 {
9394 }
9395 }
9396 }
9397 }
9398
9399
9400
9401
9403 {
9404 float energy = 0;
9405 if (HasEnergyManager())
9406 {
9407 energy = GetCompEM().GetEnergy();
9408 }
9409 return energy;
9410 }
9411
9412
9414 {
9415 super.OnEnergyConsumed();
9416
9418 }
9419
9421 {
9422 super.OnEnergyAdded();
9423
9425 }
9426
9427
9429 {
9430 if (
GetGame().IsServer() && HasEnergyManager() && GetCompEM().HasConversionOfEnergyToQuantity())
9431 {
9433 {
9434 float energy_0to1 = GetCompEM().GetEnergy0To1();
9436 }
9437 }
9438 }
9439
9440
9442 {
9443 return ConfigGetFloat("heatIsolation");
9444 }
9445
9447 {
9449 }
9450
9452 {
9453 string paramPath =
string.Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Drying %2",
GetType(), pIncrementName);
9454 if (
GetGame().ConfigIsExisting(paramPath))
9456
9457 return 0.0;
9458 }
9459
9461 {
9462 string paramPath =
string.
Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Soaking %2",
GetType(), pIncrementName);
9463 if (
GetGame().ConfigIsExisting(paramPath))
9465
9466 return 0.0;
9467 }
9468
9469 override void SetWet(
float value,
bool allow_client =
false)
9470 {
9471 if (!IsServerCheck(allow_client))
9472 return;
9473
9476
9478
9479 m_VarWet = Math.Clamp(value, min, max);
9480
9482 {
9485 }
9486 }
9487
9488 override void AddWet(
float value)
9489 {
9491 }
9492
9494 {
9496 }
9497
9499 {
9501 }
9502
9504 {
9506 }
9507
9509 {
9511 }
9512
9514 {
9516 }
9517
9519 {
9522 if (newLevel != oldLevel)
9523 {
9525 }
9526 }
9527
9529 {
9530 SetWeightDirty();
9531 }
9532
9534 {
9535 return GetWetLevelInternal(
m_VarWet);
9536 }
9537
9538
9539
9541 {
9543 }
9544
9546 {
9548 }
9549
9551 {
9553 }
9554
9556 {
9558 }
9559
9560
9561
9563 {
9564 if (ConfigIsExisting("itemModelLength"))
9565 {
9566 return ConfigGetFloat("itemModelLength");
9567 }
9568 return 0;
9569 }
9570
9572 {
9573 if (ConfigIsExisting("itemAttachOffset"))
9574 {
9575 return ConfigGetFloat("itemAttachOffset");
9576 }
9577 return 0;
9578 }
9579
9580 override void SetCleanness(
int value,
bool allow_client =
false)
9581 {
9582 if (!IsServerCheck(allow_client))
9583 return;
9584
9586
9588
9591 }
9592
9594 {
9596 }
9597
9599 {
9600 return true;
9601 }
9602
9603
9604
9605
9607 {
9609 }
9610
9612 {
9614 }
9615
9616
9617
9618
9619 override void SetColor(
int r,
int g,
int b,
int a)
9620 {
9626 }
9628 override void GetColor(out
int r,out
int g,out
int b,out
int a)
9629 {
9634 }
9635
9637 {
9639 }
9640
9643 {
9644 int r,g,b,a;
9646 r = r/255;
9647 g = g/255;
9648 b = b/255;
9649 a = a/255;
9650 return MiscGameplayFunctions.GetColorString(r, g, b, a);
9651 }
9652
9653
9654
9655 override void SetLiquidType(
int value,
bool allow_client =
false)
9656 {
9657 if (!IsServerCheck(allow_client))
9658 return;
9659
9664 }
9665
9667 {
9668 return ConfigGetInt("varLiquidTypeInit");
9669 }
9670
9672 {
9674 }
9675
9677 {
9679 SetFrozen(false);
9680 }
9681
9684 {
9685 player.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
9686 }
9687
9688
9691 {
9692 PlayerBase nplayer;
9693 if (PlayerBase.CastTo(nplayer, player))
9694 {
9696
9697 nplayer.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
9698 }
9699 }
9700
9701
9704 {
9705 PlayerBase nplayer;
9706 if (PlayerBase.CastTo(nplayer,player))
9707 {
9708
9709 nplayer.SetEnableQuickBarEntityShortcut(this,false);
9710
9711 }
9712
9713
9714 player.GetHumanInventory().ClearUserReservedLocationForContainer(this);
9715
9716
9717 if (HasEnergyManager())
9718 {
9719 GetCompEM().UpdatePlugState();
9720 }
9721 }
9722
9723
9725 {
9726 super.OnPlacementStarted(player);
9727
9729 }
9730
9731 override void OnPlacementComplete(Man player, vector position =
"0 0 0", vector orientation =
"0 0 0")
9732 {
9734 {
9735 m_AdminLog.OnPlacementComplete(player,
this);
9736 }
9737
9738 super.OnPlacementComplete(player, position, orientation);
9739 }
9740
9741
9742
9743
9744
9746 {
9748 {
9749 return true;
9750 }
9751 else
9752 {
9753 return false;
9754 }
9755 }
9756
9757
9759 {
9761 {
9763 }
9764 }
9765
9766
9768 {
9770 }
9771
9773 {
9775 }
9776
9777 override void InsertAgent(
int agent,
float count = 1)
9778 {
9779 if (count < 1)
9780 return;
9781
9783 }
9784
9787 {
9789 }
9790
9791
9793 {
9795 }
9796
9797
9798
9799
9800
9801
9802
9803
9804
9805
9806
9807
9808
9809
9810
9811
9812
9813
9814
9815
9816
9817
9818
9819
9820
9821
9822
9823
9824
9825
9826
9827
9828
9829
9830
9831
9832
9833
9834
9835
9836
9837
9839 {
9841 return false;
9842 return true;
9843 }
9844
9846 {
9847
9849 }
9850
9851
9854 {
9855 super.CheckForRoofLimited(timeTresholdMS);
9856
9858 if ((time - m_PreviousRoofTestTime) >= timeTresholdMS)
9859 {
9860 m_PreviousRoofTestTime = time;
9861 SetRoofAbove(MiscGameplayFunctions.IsUnderRoof(this));
9862 }
9863 }
9864
9865
9867 {
9869 {
9870 return 0;
9871 }
9872
9873 if (GetInventory().GetAttachmentSlotsCount() != 0)
9874 {
9875 ItemBase filter =
ItemBase.Cast(FindAttachmentBySlotName(
"GasMaskFilter"));
9876 if (filter)
9877 return filter.GetProtectionLevel(type, false, system);
9878 else
9879 return 0;
9880 }
9881
9882 string subclassPath, entryName;
9883
9884 switch (type)
9885 {
9887 entryName = "biological";
9888 break;
9890 entryName = "chemical";
9891 break;
9892 default:
9893 entryName = "biological";
9894 break;
9895 }
9896
9897 subclassPath =
"CfgVehicles " + this.
GetType() +
" Protection ";
9898
9900 }
9901
9902
9903
9906 {
9907 if (!IsMagazine())
9909
9911 }
9912
9913
9914
9915
9916
9921 {
9922 return true;
9923 }
9924
9926 {
9928 }
9929
9930
9931
9932
9933
9935 {
9936 if (parent)
9937 {
9938 if (parent.IsInherited(DayZInfected))
9939 return true;
9940
9941 if (!parent.IsRuined())
9942 return true;
9943 }
9944
9945 return true;
9946 }
9947
9949 {
9950 if (!super.CanPutAsAttachment(parent))
9951 {
9952 return false;
9953 }
9954
9955 if (!IsRuined() && !parent.IsRuined())
9956 {
9957 return true;
9958 }
9959
9960 return false;
9961 }
9962
9964 {
9965
9966
9967
9968
9969 return super.CanReceiveItemIntoCargo(item);
9970 }
9971
9973 {
9974
9975
9976
9977
9978 GameInventory attachmentInv = attachment.GetInventory();
9980 {
9981 if (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase))
9982 return false;
9983 }
9984
9985 InventoryLocation loc = new InventoryLocation();
9986 attachment.GetInventory().GetCurrentInventoryLocation(loc);
9987 if (loc && loc.
IsValid() && !GetInventory().AreChildrenAccessible())
9988 return false;
9989
9990 return super.CanReceiveAttachment(attachment, slotId);
9991 }
9992
9994 {
9995 if (!super.CanReleaseAttachment(attachment))
9996 return false;
9997
9998 return GetInventory().AreChildrenAccessible();
9999 }
10000
10001
10002
10003
10004
10005
10006
10007
10008
10009
10010
10011
10012
10013
10014
10015
10016
10017
10018
10019
10020
10022 {
10023 int id = muzzle_owner.GetMuzzleID();
10024 array<ref WeaponParticlesOnFire> WPOF_array =
m_OnFireEffect.Get(
id);
10025
10026 if (WPOF_array)
10027 {
10028 for (int i = 0; i < WPOF_array.Count(); i++)
10029 {
10030 WeaponParticlesOnFire WPOF = WPOF_array.Get(i);
10031
10032 if (WPOF)
10033 {
10034 WPOF.OnActivate(weapon, muzzle_index, ammoType, muzzle_owner, suppressor, config_to_search);
10035 }
10036 }
10037 }
10038 }
10039
10040
10042 {
10043 int id = muzzle_owner.GetMuzzleID();
10045
10046 if (WPOBE_array)
10047 {
10048 for (int i = 0; i < WPOBE_array.Count(); i++)
10049 {
10050 WeaponParticlesOnBulletCasingEject WPOBE = WPOBE_array.Get(i);
10051
10052 if (WPOBE)
10053 {
10054 WPOBE.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
10055 }
10056 }
10057 }
10058 }
10059
10060
10062 {
10063 int id = muzzle_owner.GetMuzzleID();
10064 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
10065
10066 if (WPOOH_array)
10067 {
10068 for (int i = 0; i < WPOOH_array.Count(); i++)
10069 {
10070 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
10071
10072 if (WPOOH)
10073 {
10074 WPOOH.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
10075 }
10076 }
10077 }
10078 }
10079
10080
10082 {
10083 int id = muzzle_owner.GetMuzzleID();
10084 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
10085
10086 if (WPOOH_array)
10087 {
10088 for (int i = 0; i < WPOOH_array.Count(); i++)
10089 {
10090 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
10091
10092 if (WPOOH)
10093 {
10094 WPOOH.OnUpdate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
10095 }
10096 }
10097 }
10098 }
10099
10100
10102 {
10103 int id = muzzle_owner.GetMuzzleID();
10104 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
10105
10106 if (WPOOH_array)
10107 {
10108 for (int i = 0; i < WPOOH_array.Count(); i++)
10109 {
10110 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
10111
10112 if (WPOOH)
10113 {
10114 WPOOH.OnDeactivate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
10115 }
10116 }
10117 }
10118 }
10119
10120
10121
10123 {
10125 {
10126 return true;
10127 }
10128
10129 return false;
10130 }
10131
10133 {
10135 {
10136 return true;
10137 }
10138
10139 return false;
10140 }
10141
10143 {
10145 {
10146 return true;
10147 }
10148
10149 return false;
10150 }
10151
10153 {
10154 return false;
10155 }
10156
10159 {
10160 return UATimeSpent.DEFAULT_DEPLOY;
10161 }
10162
10163
10164
10165
10167 {
10169 SetSynchDirty();
10170 }
10171
10173 {
10175 }
10176
10177
10179 {
10180 return false;
10181 }
10182
10185 {
10186 string att_type = "None";
10187
10188 if (ConfigIsExisting("soundAttType"))
10189 {
10190 att_type = ConfigGetString("soundAttType");
10191 }
10192
10194 }
10195
10197 {
10199 }
10200
10201
10202
10203
10204
10210
10212 {
10215
10217 }
10218
10219
10221 {
10223 return;
10224
10226
10229
10232
10233 SoundParameters params = new SoundParameters();
10237 }
10238
10239
10241 {
10243 return;
10244
10246 SetSynchDirty();
10247
10250 }
10251
10252
10254 {
10256 return;
10257
10259 SetSynchDirty();
10260
10263 }
10264
10266 {
10268 }
10269
10271 {
10273 }
10274
10277 {
10278 if (!
GetGame().IsDedicatedServer())
10279 {
10280 if (ConfigIsExisting("attachSoundSet"))
10281 {
10282 string cfg_path = "";
10283 string soundset = "";
10284 string type_name =
GetType();
10285
10288 ConfigGetTextArray("attachSoundSet",cfg_soundset_array);
10289 ConfigGetTextArray("attachSoundSlot",cfg_slot_array);
10290
10291 if (cfg_soundset_array.Count() > 0 && cfg_soundset_array.Count() == cfg_slot_array.Count())
10292 {
10293 for (int i = 0; i < cfg_soundset_array.Count(); i++)
10294 {
10295 if (cfg_slot_array[i] == slot_type)
10296 {
10297 soundset = cfg_soundset_array[i];
10298 break;
10299 }
10300 }
10301 }
10302
10303 if (soundset != "")
10304 {
10305 EffectSound sound = SEffectManager.PlaySound(soundset,
GetPosition());
10307 }
10308 }
10309 }
10310 }
10311
10313 {
10314
10315 }
10316
10317 void OnApply(PlayerBase player);
10318
10320 {
10321 return 1.0;
10322 };
10323
10325 {
10327 }
10328
10330 {
10332 }
10333
10335
10337 {
10338 SetDynamicPhysicsLifeTime(0.01);
10340 }
10341
10343 {
10344 array<string> zone_names = new array<string>;
10345 GetDamageZones(zone_names);
10346 for (int i = 0; i < zone_names.Count(); i++)
10347 {
10348 SetHealthMax(zone_names.Get(i),"Health");
10349 }
10350 SetHealthMax("","Health");
10351 }
10352
10355 {
10356 float global_health = GetHealth01("","Health");
10357 array<string> zones = new array<string>;
10358 GetDamageZones(zones);
10359
10360 for (int i = 0; i < zones.Count(); i++)
10361 {
10362 SetHealth01(zones.Get(i),"Health",global_health);
10363 }
10364 }
10365
10368 {
10369 return IsExclusionFlagPresent(PlayerBase.GetFaceCoverageShaveValues());
10370 }
10371
10373 {
10374 if (!hasRootAsPlayer)
10375 {
10376 if (refParentIB)
10377 {
10378
10379 if ((refParentIB.GetWet() >= GameConstants.STATE_SOAKING_WET) && (
m_VarWet <
m_VarWetMax))
10380 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_INSIDE);
10381
10382 else if ((refParentIB.GetLiquidType() != 0) && (refParentIB.GetQuantity() > 0) && (
m_VarWet <
m_VarWetMax))
10383 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_LIQUID);
10384
10387 }
10388 else
10389 {
10390
10393 }
10394 }
10395 }
10396
10398 {
10400 {
10401 float target =
g_Game.GetMission().GetWorldData().GetBaseEnvTemperatureAtObject(
this);
10402 if (
GetTemperature() != target || !IsFreezeThawProgressFinished())
10403 {
10404 float heatPermCoef = 1.0;
10406 while (ent)
10407 {
10408 heatPermCoef *= ent.GetHeatPermeabilityCoef();
10409 ent = ent.GetHierarchyParent();
10410 }
10411
10412 SetTemperatureEx(
new TemperatureDataInterpolated(target,
ETemperatureAccessTypes.ACCESS_WORLD,delta,GameConstants.TEMP_COEF_WORLD,heatPermCoef));
10413 }
10414 }
10415 }
10416
10418 {
10419
10420 EntityAI parent = GetHierarchyParent();
10421 if (!parent)
10422 {
10423 hasParent = false;
10424 hasRootAsPlayer = false;
10425 }
10426 else
10427 {
10428 hasParent = true;
10429 hasRootAsPlayer = (GetHierarchyRootPlayer() != null);
10430 refParentIB =
ItemBase.Cast(parent);
10431 }
10432 }
10433
10434 protected void ProcessDecay(
float delta,
bool hasRootAsPlayer)
10435 {
10436
10437 }
10438
10440 {
10441
10442 return false;
10443 }
10444
10446 {
10447
10448
10449 return false;
10450 }
10451
10453 {
10454
10455 return false;
10456 }
10457
10460 {
10461 return !GetIsFrozen() &&
IsOpen();
10462 }
10463
10465 {
10466 bool hasParent = false, hasRootAsPlayer = false;
10468
10469 bool wwtu =
g_Game.IsWorldWetTempUpdateEnabled();
10470 bool foodDecay =
g_Game.IsFoodDecayEnabled();
10471
10472 if (wwtu || foodDecay)
10473 {
10477
10478 if (processWetness || processTemperature || processDecay)
10479 {
10481
10482 if (processWetness)
10483 ProcessItemWetness(m_ElapsedSinceLastUpdate, hasParent, hasRootAsPlayer, refParentIB);
10484
10485 if (processTemperature)
10487
10488 if (processDecay)
10489 ProcessDecay(m_ElapsedSinceLastUpdate, hasRootAsPlayer);
10490 }
10491 }
10492 }
10493
10496 {
10498 }
10499
10501 {
10504
10505 return super.GetTemperatureFreezeThreshold();
10506 }
10507
10509 {
10512
10513 return super.GetTemperatureThawThreshold();
10514 }
10515
10517 {
10520
10521 return super.GetItemOverheatThreshold();
10522 }
10523
10525 {
10527 return Math.Lerp(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureFreezeTime()),
GetQuantityNormalized());
10528
10529 return super.GetTemperatureFreezeTime();
10530 }
10531
10533 {
10535 return Math.Lerp(GameConstants.TEMPERATURE_TIME_THAW_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureThawTime()),
GetQuantityNormalized());
10536
10537 return super.GetTemperatureThawTime();
10538 }
10539
10544
10546 {
10547 return (item.IsKindOf("Cauldron") || item.IsKindOf("Pot") || item.IsKindOf("FryingPan") || item.IsKindOf("SmallProtectorCase") || (item.IsKindOf("PortableGasStove") && item.FindAttachmentBySlotName("CookingEquipment")));
10548 }
10549
10551 {
10552 MiscGameplayFunctions.TransferItemProperties(oldItem, this);
10553 }
10554
10557 {
10559 }
10560
10562 {
10564 }
10565
10567 {
10569 }
10570
10573 {
10574 return null;
10575 }
10576
10579 {
10580 return false;
10581 }
10582
10584 {
10586 {
10589 if (!trg)
10590 {
10592 explosive = this;
10593 }
10594
10595 explosive.PairRemote(trg);
10597
10598 int persistentID = RemotelyActivatedItemBehaviour.GeneratePersistentID();
10599 trg.SetPersistentPairID(persistentID);
10600 explosive.SetPersistentPairID(persistentID);
10601
10602 return true;
10603 }
10604 return false;
10605 }
10606
10609 {
10610 float ret = 1.0;
10613 ret *= GetHealth01();
10614
10615 return ret;
10616 }
10617
10618 #ifdef DEVELOPER
10619 override void SetDebugItem()
10620 {
10621 super.SetDebugItem();
10622 _itemBase = this;
10623 }
10624
10626 {
10627 string text = super.GetDebugText();
10628
10630 text +=
string.
Format(
"Heat isolation(modified): %1\n", MiscGameplayFunctions.GetCurrentItemHeatIsolation(
this));
10631
10632 return text;
10633 }
10634 #endif
10635
10637 {
10638 return true;
10639 }
10640
10642
10644
10646 {
10649 }
10650
10651
10659
10675}
10676
10678{
10680 if (entity)
10681 {
10682 bool is_item = entity.IsInherited(
ItemBase);
10683 if (is_item && full_quantity)
10684 {
10687 }
10688 }
10689 else
10690 {
10692 return NULL;
10693 }
10694 return entity;
10695}
10696
10698{
10699 if (item)
10700 {
10701 if (health > 0)
10702 item.SetHealth("", "", health);
10703
10704 if (item.CanHaveTemperature())
10705 {
10707 if (item.CanFreeze())
10708 item.SetFrozen(false);
10709 }
10710
10711 if (item.HasEnergyManager())
10712 {
10713 if (quantity >= 0)
10714 {
10715 item.GetCompEM().SetEnergy0To1(quantity);
10716 }
10717 else
10718 {
10720 }
10721 }
10722 else if (item.IsMagazine())
10723 {
10724 Magazine mag = Magazine.Cast(item);
10725 if (quantity >= 0)
10726 {
10727 mag.ServerSetAmmoCount(mag.GetAmmoMax() * quantity);
10728 }
10729 else
10730 {
10732 }
10733
10734 }
10735 else
10736 {
10737 if (quantity >= 0)
10738 {
10739 item.SetQuantityNormalized(quantity, false);
10740 }
10741 else
10742 {
10744 }
10745
10746 }
10747 }
10748}
10749
10750#ifdef DEVELOPER
10752#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.