5128{
5130 {
5131 return true;
5132 }
5133};
5134
5135
5136
5138{
5142
5144
5147
5148
5149
5150
5151
5160
5166
5171
5176
5197 protected bool m_IsResultOfSplit
5198
5200
5205
5206
5207
5209
5213
5214
5215
5217
5220
5221
5222
5228
5229
5237
5240
5241
5243
5244
5246
5247
5252
5253
5258
5259
5261
5262
5264 {
5269
5270 if (!
GetGame().IsDedicatedServer())
5271 {
5273 {
5275
5277 {
5279 }
5280 }
5281
5284 }
5285
5286 m_OldLocation = null;
5287
5289 {
5291 }
5292
5293 if (ConfigIsExisting("headSelectionsToHide"))
5294 {
5297 }
5298
5300 if (ConfigIsExisting("hideSelectionsByinventorySlot"))
5301 {
5303 }
5304
5306
5307 m_IsResultOfSplit = false;
5308
5310 }
5311
5313 {
5314 super.InitItemVariables();
5315
5321 m_Count = ConfigGetInt(
"count");
5322
5325
5330
5333
5338
5350
5354
5355
5358 if (ConfigIsExisting("canBeSplit"))
5359 {
5362 }
5363
5365 if (ConfigIsExisting("itemBehaviour"))
5367
5368
5371 RegisterNetSyncVariableInt("m_VarLiquidType");
5372 RegisterNetSyncVariableInt("m_Cleanness",0,1);
5373
5374 RegisterNetSyncVariableBoolSignal("m_WantPlayImpactSound");
5375 RegisterNetSyncVariableFloat("m_ImpactSpeed");
5376 RegisterNetSyncVariableInt("m_ImpactSoundSurfaceHash");
5377
5378 RegisterNetSyncVariableInt("m_ColorComponentR", 0, 255);
5379 RegisterNetSyncVariableInt("m_ColorComponentG", 0, 255);
5380 RegisterNetSyncVariableInt("m_ColorComponentB", 0, 255);
5381 RegisterNetSyncVariableInt("m_ColorComponentA", 0, 255);
5382
5383 RegisterNetSyncVariableBool("m_IsBeingPlaced");
5384 RegisterNetSyncVariableBool("m_IsTakeable");
5385 RegisterNetSyncVariableBool("m_IsHologram");
5386
5389 {
5392 }
5393
5395
5397 if (ConfigIsExisting("temperaturePerQuantityWeight"))
5399
5400 }
5401
5403 {
5405 }
5406
5408 {
5411 {
5416 }
5417 }
5418
5419 override void GetActions(
typename action_input_type, out array<ActionBase_Basic> actions)
5420 {
5422 {
5425 }
5426
5428 }
5429
5431 {
5437 }
5438
5440
5442 {
5444
5445 if (!action)
5446 {
5447 Debug.LogError(
"Action " + actionName +
" dosn't exist!");
5448 return;
5449 }
5450
5452 if (!ai)
5453 {
5455 return;
5456 }
5457
5459 if (!action_array)
5460 {
5461 action_array = new array<ActionBase_Basic>;
5463 }
5464 if (LogManager.IsActionLogEnable())
5465 {
5466 Debug.ActionLog(action.ToString() +
" -> " + ai,
this.ToString() ,
"n/a",
"Add action");
5467 }
5468
5469 if (action_array.Find(action) != -1)
5470 {
5471 Debug.Log(
"Action " + action.Type() +
" already added to " +
this +
", skipping!");
5472 }
5473 else
5474 {
5475 action_array.Insert(action);
5476 }
5477 }
5478
5480 {
5482 ActionBase action = player.GetActionManager().GetAction(actionName);
5485
5486 if (action_array)
5487 {
5488 action_array.RemoveItem(action);
5489 }
5490 }
5491
5492
5493
5495 {
5496 ActionOverrideData overrideData = new ActionOverrideData();
5500
5502 if (!actionMap)
5503 {
5506 }
5507
5508 actionMap.Insert(this.
Type(), overrideData);
5509
5510 }
5511
5513
5515
5516
5518 {
5521
5524
5525 string config_to_search = "CfgVehicles";
5526 string muzzle_owner_config;
5527
5529 {
5530 if (IsInherited(Weapon))
5531 config_to_search = "CfgWeapons";
5532
5533 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
5534
5535 string config_OnFire_class = muzzle_owner_config + "Particles " + "OnFire ";
5536
5538
5539 if (config_OnFire_subclass_count > 0)
5540 {
5541 array<ref WeaponParticlesOnFire> WPOF_array = new array<ref WeaponParticlesOnFire>;
5542
5543 for (int i = 0; i < config_OnFire_subclass_count; i++)
5544 {
5545 string particle_class = "";
5547 string config_OnFire_entry = config_OnFire_class + particle_class;
5548 WeaponParticlesOnFire WPOF = new WeaponParticlesOnFire(this, config_OnFire_entry);
5549 WPOF_array.Insert(WPOF);
5550 }
5551
5552
5554 }
5555 }
5556
5558 {
5559 config_to_search = "CfgWeapons";
5560 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
5561
5562 string config_OnBulletCasingEject_class = muzzle_owner_config + "Particles " + "OnBulletCasingEject ";
5563
5565
5566 if (config_OnBulletCasingEject_count > 0 && IsInherited(Weapon))
5567 {
5568 array<ref WeaponParticlesOnBulletCasingEject> WPOBE_array = new array<ref WeaponParticlesOnBulletCasingEject>;
5569
5570 for (i = 0; i < config_OnBulletCasingEject_count; i++)
5571 {
5572 string particle_class2 = "";
5574 string config_OnBulletCasingEject_entry = config_OnBulletCasingEject_class + particle_class2;
5575 WeaponParticlesOnBulletCasingEject WPOBE = new WeaponParticlesOnBulletCasingEject(this, config_OnBulletCasingEject_entry);
5576 WPOBE_array.Insert(WPOBE);
5577 }
5578
5579
5581 }
5582 }
5583 }
5584
5585
5587 {
5590
5592 {
5593 string config_to_search = "CfgVehicles";
5594
5595 if (IsInherited(Weapon))
5596 config_to_search = "CfgWeapons";
5597
5598 string muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
5599 string config_OnOverheating_class = muzzle_owner_config + "Particles " + "OnOverheating ";
5600
5601 if (
GetGame().ConfigIsExisting(config_OnOverheating_class))
5602 {
5603
5605
5607 {
5609 string error =
"Error reading config " +
GetType() +
">Particles>OnOverheating - Parameter shotsToStartOverheating is configured wrong or is missing! Its value must be 1 or higher!";
5611 return;
5612 }
5613
5616
5617
5618
5620 array<ref WeaponParticlesOnOverheating> WPOOH_array = new array<ref WeaponParticlesOnOverheating>;
5621
5622 for (int i = 0; i < config_OnOverheating_subclass_count; i++)
5623 {
5624 string particle_class = "";
5626 string config_OnOverheating_entry = config_OnOverheating_class + particle_class;
5628
5629 if (entry_type == CT_CLASS)
5630 {
5631 WeaponParticlesOnOverheating WPOF = new WeaponParticlesOnOverheating(this, config_OnOverheating_entry);
5632 WPOOH_array.Insert(WPOF);
5633 }
5634 }
5635
5636
5638 }
5639 }
5640 }
5641
5643 {
5645 }
5646
5648 {
5650 {
5652
5655
5658
5659 CheckOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
5660 }
5661 }
5662
5664 {
5666 UpdateOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
5667
5669 StartOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
5670
5672 StopOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
5673
5675 {
5677 }
5678 }
5679
5681 {
5683 }
5684
5686 {
5689 else
5691
5693 {
5696 }
5697 else
5698 {
5701
5704 }
5705
5707 }
5708
5710 {
5712 ItemBase.PlayOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
5713 }
5714
5716 {
5718 ItemBase.UpdateOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
5720 }
5721
5723 {
5725 ItemBase.StopOverheatingParticles(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
5726 }
5727
5729 {
5732
5733 OverheatingParticle OP = new OverheatingParticle();
5738
5740 }
5741
5743 {
5746
5747 return -1;
5748 }
5749
5751 {
5753 {
5756
5757 for (int i = count; i > 0; --i)
5758 {
5759 int id = i - 1;
5762
5765
5766 if (overheat_coef < overheat_min && overheat_coef >= overheat_max)
5767 {
5768 if (p)
5769 {
5772 }
5773 }
5774 }
5775 }
5776 }
5777
5779 {
5781 {
5783 {
5784 int id = i - 1;
5786
5787 if (OP)
5788 {
5790
5791 if (p)
5792 {
5794 }
5795
5796 delete OP;
5797 }
5798 }
5799
5802 }
5803 }
5804
5807 {
5808 return 0.0;
5809 }
5810
5811
5813 {
5814 return 250;
5815 }
5816
5818 {
5819 return 0;
5820 }
5821
5824 {
5826 return true;
5827
5828 return false;
5829 }
5830
5833 {
5836
5838 {
5840 }
5841 else
5842 {
5843
5845 }
5846
5848 }
5849
5856 {
5857 return -1;
5858 }
5859
5860
5861
5862
5864 {
5866 {
5868 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
5869
5870 if (r_index >= 0)
5871 {
5872 InventoryLocation r_il = new InventoryLocation;
5873 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
5874
5875 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
5878 {
5879 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
5880 }
5882 {
5883 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
5884 }
5885
5886 }
5887
5888 player.GetHumanInventory().ClearUserReservedLocation(this);
5889 }
5890
5893 }
5894
5895
5896
5897
5899 {
5900 return ItemBase.m_DebugActionsMask;
5901 }
5902
5904 {
5905 return ItemBase.m_DebugActionsMask & mask;
5906 }
5907
5909 {
5910 ItemBase.m_DebugActionsMask = mask;
5911 }
5912
5914 {
5915 ItemBase.m_DebugActionsMask |= mask;
5916 }
5917
5919 {
5920 ItemBase.m_DebugActionsMask &= ~mask;
5921 }
5922
5924 {
5926 {
5928 }
5929 else
5930 {
5932 }
5933 }
5934
5935
5937 {
5938 if (GetEconomyProfile())
5939 {
5940 float q_max = GetEconomyProfile().GetQuantityMax();
5941 if (q_max > 0)
5942 {
5943 float q_min = GetEconomyProfile().GetQuantityMin();
5944 float quantity_randomized = Math.RandomFloatInclusive(q_min, q_max);
5945
5947 {
5948 ComponentEnergyManager comp = GetCompEM();
5950 {
5952 }
5953 }
5955 {
5957
5958 }
5959
5960 }
5961 }
5962 }
5963
5966 {
5967 EntityAI parent = GetHierarchyParent();
5968
5969 if (parent)
5970 {
5971 InventoryLocation inventory_location_to_lock = new InventoryLocation;
5972 GetInventory().GetCurrentInventoryLocation(inventory_location_to_lock);
5973 parent.GetInventory().SetSlotLock(inventory_location_to_lock.
GetSlot(),
true);
5974 }
5975 }
5976
5979 {
5980 EntityAI parent = GetHierarchyParent();
5981
5982 if (parent)
5983 {
5984 InventoryLocation inventory_location_to_unlock = new InventoryLocation;
5985 GetInventory().GetCurrentInventoryLocation(inventory_location_to_unlock);
5986 parent.GetInventory().SetSlotLock(inventory_location_to_unlock.
GetSlot(),
false);
5987 }
5988 }
5989
5991 {
5992
5993
5994
5995
5997
5999 {
6000 if (ScriptInputUserData.CanStoreInputUserData())
6001 {
6002 ScriptInputUserData ctx = new ScriptInputUserData;
6008 ctx.
Write(use_stack_max);
6011
6013 {
6014 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(item2,null,GameInventory.c_InventoryReservationTimeoutShortMS);
6015 }
6016 }
6017 }
6018 else if (!
GetGame().IsMultiplayer())
6019 {
6021 }
6022 }
6023
6025 {
6027 }
6028
6030 {
6032 }
6033
6035 {
6037 }
6038
6040 {
6041
6042 return false;
6043 }
6044
6046 {
6047 return false;
6048 }
6049
6053 {
6054 return false;
6055 }
6056
6058 {
6059 return "";
6060 }
6061
6063
6065 {
6066 return false;
6067 }
6068
6070 {
6071 return true;
6072 }
6073
6074
6075
6077 {
6078 return true;
6079 }
6080
6082 {
6083 return true;
6084 }
6085
6087 {
6088 PlayerBase player = PlayerBase.Cast(
g_Game.GetPlayer());
6090 }
6091
6093 {
6095 }
6096
6098 {
6100 if (!is_being_placed)
6102 SetSynchDirty();
6103 }
6104
6105
6107
6109 {
6111 }
6112
6114 {
6116 }
6117
6119 {
6120 return 1;
6121 }
6122
6124 {
6125 return false;
6126 }
6127
6129 {
6131 SetSynchDirty();
6132 }
6133
6134
6135
6136
6137
6138
6139
6140
6141
6142
6143
6144
6145
6146
6147
6148
6149
6150
6151
6152
6153
6154
6155
6156
6157
6158
6159
6160
6161
6162
6163
6164
6165
6166
6167
6169 {
6170 super.OnMovedInsideCargo(container);
6171
6172 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
6173 }
6174
6175 override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
6176 {
6177 super.EEItemLocationChanged(oldLoc,newLoc);
6178
6179 PlayerBase new_player = null;
6180 PlayerBase old_player = null;
6181
6182 if (newLoc.GetParent())
6183 new_player = PlayerBase.Cast(newLoc.GetParent().GetHierarchyRootPlayer());
6184
6185 if (oldLoc.GetParent())
6186 old_player = PlayerBase.Cast(oldLoc.GetParent().GetHierarchyRootPlayer());
6187
6189 {
6190 int r_index = old_player.GetHumanInventory().FindUserReservedLocationIndex(this);
6191
6192 if (r_index >= 0)
6193 {
6194 InventoryLocation r_il = new InventoryLocation;
6195 old_player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
6196
6197 old_player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
6200 {
6201 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
6202 }
6204 {
6205 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
6206 }
6207
6208 }
6209 }
6210
6212 {
6213 if (new_player)
6214 new_player.ForceStandUpForHeavyItems(newLoc.GetItem());
6215
6216 if (new_player == old_player)
6217 {
6218
6219 if (oldLoc.GetParent() && new_player.GetHumanInventory().LocationGetEntity(oldLoc) == NULL)
6220 {
6222 {
6223 if (oldLoc.GetParent().GetInventory().TestAddEntityInCargoExLoc(oldLoc, false, false, false, true, false, false))
6224 {
6225 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
6226 }
6227 }
6228 else
6229 {
6230 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
6231 }
6232 }
6233
6234 if (new_player.GetHumanInventory().FindUserReservedLocationIndex(this) >= 0)
6235 {
6236 int type = oldLoc.GetType();
6238 {
6239 oldLoc.GetParent().GetOnSetLock().Invoke(this);
6240 }
6242 {
6243 oldLoc.GetParent().GetOnAttachmentSetLock().Invoke(this, oldLoc.GetSlot());
6244 }
6245 }
6246 if (!m_OldLocation)
6247 {
6248 m_OldLocation = new InventoryLocation;
6249 }
6250 m_OldLocation.Copy(oldLoc);
6251 }
6252 else
6253 {
6254 if (m_OldLocation)
6255 {
6256 m_OldLocation.Reset();
6257 }
6258 }
6259
6261 }
6262 else
6263 {
6264 if (new_player)
6265 {
6266 int res_index = new_player.GetHumanInventory().FindCollidingUserReservedLocationIndex(this, newLoc);
6267 if (res_index >= 0)
6268 {
6269 InventoryLocation il = new InventoryLocation;
6270 new_player.GetHumanInventory().GetUserReservedLocation(res_index,il);
6272 new_player.GetHumanInventory().ClearUserReservedLocationAtIndex(res_index);
6275 {
6276 il.
GetParent().GetOnReleaseLock().Invoke(it);
6277 }
6279 {
6281 }
6282
6283 }
6284 }
6286 {
6287
6289 }
6290
6291 if (m_OldLocation)
6292 {
6293 m_OldLocation.Reset();
6294 }
6295 }
6296 }
6297
6298 override void EOnContact(IEntity other, Contact extra)
6299 {
6301 {
6302 int liquidType = -1;
6304 if (impactSpeed > 0.0)
6305 {
6307 #ifndef SERVER
6309 #else
6311 SetSynchDirty();
6312 #endif
6314 }
6315 }
6316
6317 #ifdef SERVER
6318 if (GetCompEM() && GetCompEM().IsPlugged())
6319 {
6320 if (GetCompEM().GetCordLength() < vector.Distance(
GetPosition(), GetCompEM().GetEnergySource().
GetPosition()))
6321 GetCompEM().UnplugThis();
6322 }
6323 #endif
6324 }
6325
6327
6329 {
6331 }
6332
6334 {
6335
6336 }
6337
6339 {
6340 super.OnItemLocationChanged(old_owner, new_owner);
6341
6342 PlayerBase relatedPlayer = PlayerBase.Cast(old_owner);
6343 PlayerBase playerNew = PlayerBase.Cast(new_owner);
6344
6345 if (!relatedPlayer && playerNew)
6346 relatedPlayer = playerNew;
6347
6348 if (relatedPlayer && relatedPlayer.GetPerformedActionID() != -1)
6349 {
6351 if (actionMgr)
6352 {
6353 ActionBase currentAction = actionMgr.GetRunningAction();
6354 if (currentAction)
6356 }
6357 }
6358
6359 Man ownerPlayerOld = null;
6360 Man ownerPlayerNew = null;
6361
6362 if (old_owner)
6363 {
6364 if (old_owner.
IsMan())
6365 {
6366 ownerPlayerOld = Man.Cast(old_owner);
6367 }
6368 else
6369 {
6370 ownerPlayerOld = Man.Cast(old_owner.GetHierarchyRootPlayer());
6371 }
6372 }
6373 else
6374 {
6376 {
6378
6379 if (!action || !playerNew || playerNew.GetPerformedActionID() != action.
GetID())
6380 {
6381 GetCompEM().UnplugThis();
6382 }
6383 }
6384 }
6385
6386 if (new_owner)
6387 {
6388 if (new_owner.
IsMan())
6389 {
6390 ownerPlayerNew = Man.Cast(new_owner);
6391 }
6392 else
6393 {
6394 ownerPlayerNew = Man.Cast(new_owner.GetHierarchyRootPlayer());
6395 }
6396 }
6397
6398 if (ownerPlayerOld != ownerPlayerNew)
6399 {
6400 if (ownerPlayerOld)
6401 {
6402 array<EntityAI> subItemsExit = new array<EntityAI>;
6404 for (int i = 0; i < subItemsExit.Count(); i++)
6405 {
6408 }
6409 }
6410
6411 if (ownerPlayerNew)
6412 {
6413 array<EntityAI> subItemsEnter = new array<EntityAI>;
6415 for (int j = 0; j < subItemsEnter.Count(); j++)
6416 {
6419 }
6420 }
6421 }
6422 else if (ownerPlayerNew != null)
6423 {
6424 PlayerBase nplayer;
6425 if (PlayerBase.CastTo(nplayer, ownerPlayerNew))
6426 {
6427 array<EntityAI> subItemsUpdate = new array<EntityAI>;
6429 for (int k = 0; k < subItemsUpdate.Count(); k++)
6430 {
6432 itemUpdate.UpdateQuickbarShortcutVisibility(nplayer);
6433 }
6434 }
6435 }
6436
6437 if (old_owner)
6438 old_owner.OnChildItemRemoved(this);
6439 if (new_owner)
6440 new_owner.OnChildItemReceived(this);
6441 }
6442
6443
6445 {
6446 super.EEDelete(parent);
6447 PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
6448 if (player)
6449 {
6451
6452 if (player.IsAlive())
6453 {
6454 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
6455 if (r_index >= 0)
6456 {
6457 InventoryLocation r_il = new InventoryLocation;
6458 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
6459
6460 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
6463 {
6464 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
6465 }
6467 {
6468 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
6469 }
6470
6471 }
6472
6473 player.RemoveQuickBarEntityShortcut(this);
6474 }
6475 }
6476 }
6477
6479 {
6480 super.EEKilled(killer);
6481
6484 {
6485 if (
GetTemperature() >= GameConstants.ITEM_TEMPERATURE_TO_EXPLODE_MIN)
6486 {
6487 if (IsMagazine())
6488 {
6489 if (Magazine.Cast(this).GetAmmoCount() > 0)
6490 {
6492 }
6493 }
6494 else
6495 {
6497 }
6498 }
6499 }
6500 }
6501
6503 {
6504 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
6505
6506 super.OnWasAttached(parent, slot_id);
6507
6510
6512 }
6513
6515 {
6516 super.OnWasDetached(parent, slot_id);
6517
6520 }
6521
6523 {
6524 int idx;
6527
6528 ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
6529 if (inventory_slots.Count() < 1)
6530 {
6531 inventory_slots.Insert(ConfigGetString("ChangeInventorySlot"));
6532 attach_types.Insert(ConfigGetString("ChangeIntoOnAttach"));
6533 }
6534 else
6535 {
6536 ConfigGetTextArray("ChangeIntoOnAttach",attach_types);
6537 }
6538
6539 idx = inventory_slots.Find(slot);
6540 if (idx < 0)
6541 return "";
6542
6543 return attach_types.Get(idx);
6544 }
6545
6547 {
6548 int idx = -1;
6549 string slot;
6550
6553
6554 this.ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
6555 if (inventory_slots.Count() < 1)
6556 {
6557 inventory_slots.Insert(this.ConfigGetString("ChangeInventorySlot"));
6558 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
6559 }
6560 else
6561 {
6562 this.ConfigGetTextArray("ChangeIntoOnDetach",detach_types);
6563 if (detach_types.Count() < 1)
6564 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
6565 }
6566
6567 for (int i = 0; i < inventory_slots.Count(); i++)
6568 {
6569 slot = inventory_slots.Get(i);
6570 }
6571
6572 if (slot != "")
6573 {
6574 if (detach_types.Count() == 1)
6575 idx = 0;
6576 else
6577 idx = inventory_slots.Find(slot);
6578 }
6579 if (idx < 0)
6580 return "";
6581
6582 return detach_types.Get(idx);
6583 }
6584
6586 {
6587
6589
6590
6591 float min_time = 1;
6592 float max_time = 3;
6593 float delay = Math.RandomFloat(min_time, max_time);
6594
6595 explode_timer.Run(delay, this, "DoAmmoExplosion");
6596 }
6597
6599 {
6600 Magazine magazine = Magazine.Cast(this);
6601 int pop_sounds_count = 6;
6602 string pop_sounds[ 6 ] = { "ammopops_1","ammopops_2","ammopops_3","ammopops_4","ammopops_5","ammopops_6" };
6603
6604
6605 int sound_idx = Math.RandomInt(0, pop_sounds_count - 1);
6606 string sound_name = pop_sounds[ sound_idx ];
6608
6609
6610 magazine.ServerAddAmmoCount(-1);
6611
6612
6613 float min_temp_to_explode = 100;
6614
6615 if (magazine.GetAmmoCount() > 0 &&
GetTemperature() >= min_temp_to_explode)
6616 {
6618 }
6619 }
6620
6621
6622 override void EEHitBy(TotalDamageResult damageResult,
int damageType,
EntityAI source,
int component,
string dmgZone,
string ammo, vector modelPos,
float speedCoef)
6623 {
6624 super.EEHitBy(damageResult, damageType, source,
component, dmgZone, ammo, modelPos, speedCoef);
6625
6626 const int CHANCE_DAMAGE_CARGO = 4;
6627 const int CHANCE_DAMAGE_ATTACHMENT = 1;
6628 const int CHANCE_DAMAGE_NOTHING = 2;
6629
6631 {
6632 float dmg = damageResult.
GetDamage(
"",
"Health") * -0.5;
6633 int chances;
6634 int rnd;
6635
6636 if (GetInventory().GetCargo())
6637 {
6638 chances = CHANCE_DAMAGE_CARGO + CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
6639 rnd = Math.RandomInt(0,chances);
6640
6641 if (rnd < CHANCE_DAMAGE_CARGO)
6642 {
6644 }
6645 else if (rnd < (chances - CHANCE_DAMAGE_NOTHING))
6646 {
6648 }
6649 }
6650 else
6651 {
6652 chances = CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
6653 rnd = Math.RandomInt(0,chances);
6654
6655 if (rnd < CHANCE_DAMAGE_ATTACHMENT)
6656 {
6658 }
6659 }
6660 }
6661 }
6662
6664 {
6665 if (GetInventory().GetCargo())
6666 {
6667 int item_count = GetInventory().GetCargo().GetItemCount();
6668 if (item_count > 0)
6669 {
6670 int random_pick = Math.RandomInt(0, item_count);
6672 if (!item.IsExplosive())
6673 {
6674 item.AddHealth("","",damage);
6675 return true;
6676 }
6677 }
6678 }
6679 return false;
6680 }
6681
6683 {
6684 int attachment_count = GetInventory().AttachmentCount();
6685 if (attachment_count > 0)
6686 {
6687 int random_pick = Math.RandomInt(0, attachment_count);
6688 ItemBase attachment =
ItemBase.Cast(GetInventory().GetAttachmentFromIndex(random_pick));
6689 if (!attachment.IsExplosive())
6690 {
6691 attachment.AddHealth("","",damage);
6692 return true;
6693 }
6694 }
6695 return false;
6696 }
6697
6699 {
6701 }
6702
6704 {
6706 return GetInventory().CanRemoveEntity();
6707
6708 return false;
6709 }
6710
6712 {
6713
6715 return false;
6716
6717
6719 return false;
6720
6721
6722
6724 if (delta == 0)
6725 return false;
6726
6727
6728 return true;
6729 }
6730
6732 {
6734 {
6735 if (ScriptInputUserData.CanStoreInputUserData())
6736 {
6737 ScriptInputUserData ctx = new ScriptInputUserData;
6742 ctx.
Write(destination_entity);
6746 }
6747 }
6748 else if (!
GetGame().IsMultiplayer())
6749 {
6751 }
6752 }
6753
6755 {
6756 float split_quantity_new;
6760 InventoryLocation loc = new InventoryLocation;
6761
6762 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
6763 {
6765 split_quantity_new = stack_max;
6766 else
6768
6770 {
6771 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
6772 if (new_item)
6773 {
6774 new_item.SetResultOfSplit(true);
6775 MiscGameplayFunctions.TransferItemProperties(this, new_item);
6777 new_item.
SetQuantity(split_quantity_new,
false,
true);
6778 }
6779 }
6780 }
6781 else if (destination_entity && slot_id == -1)
6782 {
6783 if (quantity > stack_max)
6784 split_quantity_new = stack_max;
6785 else
6786 split_quantity_new = quantity;
6787
6789 {
6791 {
6794 }
6795
6796 if (new_item)
6797 {
6798 new_item.SetResultOfSplit(true);
6799 MiscGameplayFunctions.TransferItemProperties(this, new_item);
6801 new_item.
SetQuantity(split_quantity_new,
false,
true);
6802 }
6803 }
6804 }
6805 else
6806 {
6807 if (stack_max != 0)
6808 {
6810 {
6812 }
6813
6814 if (split_quantity_new == 0)
6815 {
6816 if (!
GetGame().IsMultiplayer())
6817 player.PhysicalPredictiveDropItem(this);
6818 else
6819 player.ServerDropEntity(this);
6820 return;
6821 }
6822
6824 {
6826
6827 if (new_item)
6828 {
6829 new_item.SetResultOfSplit(true);
6830 MiscGameplayFunctions.TransferItemProperties(this, new_item);
6833 new_item.PlaceOnSurface();
6834 }
6835 }
6836 }
6837 }
6838 }
6839
6841 {
6842 float split_quantity_new;
6846 InventoryLocation loc = new InventoryLocation;
6847
6848 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
6849 {
6851 split_quantity_new = stack_max;
6852 else
6854
6856 {
6857 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
6858 if (new_item)
6859 {
6860 new_item.SetResultOfSplit(true);
6861 MiscGameplayFunctions.TransferItemProperties(this, new_item);
6863 new_item.
SetQuantity(split_quantity_new,
false,
true);
6864 }
6865 }
6866 }
6867 else if (destination_entity && slot_id == -1)
6868 {
6869 if (quantity > stack_max)
6870 split_quantity_new = stack_max;
6871 else
6872 split_quantity_new = quantity;
6873
6875 {
6877 {
6880 }
6881
6882 if (new_item)
6883 {
6884 new_item.SetResultOfSplit(true);
6885 MiscGameplayFunctions.TransferItemProperties(this, new_item);
6887 new_item.
SetQuantity(split_quantity_new,
false,
true);
6888 }
6889 }
6890 }
6891 else
6892 {
6893 if (stack_max != 0)
6894 {
6896 {
6898 }
6899
6901 {
6903
6904 if (new_item)
6905 {
6906 new_item.SetResultOfSplit(true);
6907 MiscGameplayFunctions.TransferItemProperties(this, new_item);
6910 new_item.PlaceOnSurface();
6911 }
6912 }
6913 }
6914 }
6915 }
6916
6918 {
6920 {
6921 if (ScriptInputUserData.CanStoreInputUserData())
6922 {
6923 ScriptInputUserData ctx = new ScriptInputUserData;
6928 dst.WriteToContext(ctx);
6930 }
6931 }
6932 else if (!
GetGame().IsMultiplayer())
6933 {
6935 }
6936 }
6937
6939 {
6941 {
6942 if (ScriptInputUserData.CanStoreInputUserData())
6943 {
6944 ScriptInputUserData ctx = new ScriptInputUserData;
6949 ctx.
Write(destination_entity);
6955 }
6956 }
6957 else if (!
GetGame().IsMultiplayer())
6958 {
6960 }
6961 }
6962
6964 {
6966 }
6967
6969 {
6971 float split_quantity_new;
6973 if (dst.IsValid())
6974 {
6975 int slot_id = dst.GetSlot();
6977
6978 if (quantity > stack_max)
6979 split_quantity_new = stack_max;
6980 else
6981 split_quantity_new = quantity;
6982
6984 {
6986
6987 if (new_item)
6988 {
6989 new_item.SetResultOfSplit(true);
6990 MiscGameplayFunctions.TransferItemProperties(this,new_item);
6992 new_item.
SetQuantity(split_quantity_new,
false,
true);
6993 }
6994
6995 return new_item;
6996 }
6997 }
6998
6999 return null;
7000 }
7001
7003 {
7005 float split_quantity_new;
7007 if (destination_entity)
7008 {
7010 if (quantity > stackable)
7011 split_quantity_new = stackable;
7012 else
7013 split_quantity_new = quantity;
7014
7016 {
7017 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateEntityInCargoEx(
this.GetType(), idx, row, col,
false));
7018 if (new_item)
7019 {
7020 new_item.SetResultOfSplit(true);
7021 MiscGameplayFunctions.TransferItemProperties(this,new_item);
7023 new_item.
SetQuantity(split_quantity_new,
false,
true);
7024 }
7025 }
7026 }
7027 }
7028
7030 {
7032 {
7033 if (ScriptInputUserData.CanStoreInputUserData())
7034 {
7035 ScriptInputUserData ctx = new ScriptInputUserData;
7040 ItemBase destination_entity =
this;
7041 ctx.
Write(destination_entity);
7045 }
7046 }
7047 else if (!
GetGame().IsMultiplayer())
7048 {
7050 }
7051 }
7052
7054 {
7056 float split_quantity_new;
7058 if (player)
7059 {
7061 if (quantity > stackable)
7062 split_quantity_new = stackable;
7063 else
7064 split_quantity_new = quantity;
7065
7067 {
7068 EntityAI in_hands = player.GetHumanInventory().CreateInHands(this.
GetType());
7069 new_item =
ItemBase.Cast(in_hands);
7070 if (new_item)
7071 {
7072 new_item.SetResultOfSplit(true);
7073 MiscGameplayFunctions.TransferItemProperties(this,new_item);
7075 new_item.SetQuantity(split_quantity_new, false, true);
7076 }
7077 }
7078 }
7079 }
7080
7082 {
7084 float split_quantity_new = Math.Floor(quantity * 0.5);
7085
7087 return;
7088
7090
7091 if (new_item)
7092 {
7093 if (new_item.GetQuantityMax() < split_quantity_new)
7094 {
7095 split_quantity_new = new_item.GetQuantityMax();
7096 }
7097
7098 new_item.SetResultOfSplit(true);
7099 MiscGameplayFunctions.TransferItemProperties(this, new_item);
7100
7102 {
7105 }
7106 else
7107 {
7109 new_item.
SetQuantity(split_quantity_new,
false,
true);
7110 }
7111 }
7112 }
7113
7115 {
7117 float split_quantity_new = Math.Floor(quantity / 2);
7118
7120 return;
7121
7122 InventoryLocation invloc = new InventoryLocation;
7124
7126 new_item = player.CreateCopyOfItemInInventoryOrGroundEx(this, true);
7127
7128 if (new_item)
7129 {
7130 if (new_item.GetQuantityMax() < split_quantity_new)
7131 {
7132 split_quantity_new = new_item.GetQuantityMax();
7133 }
7135 {
7138 }
7139 else if (split_quantity_new > 1)
7140 {
7142 new_item.
SetQuantity(split_quantity_new,
false,
true);
7143 }
7144 }
7145 }
7146
7149 {
7150 SetWeightDirty();
7152
7153 if (parent)
7154 parent.OnAttachmentQuantityChangedEx(this, delta);
7155
7157 {
7159 {
7161 }
7163 {
7164 ErrorEx(
"Undefined liquid type quantity changed, please define liquid type first! Using init value.",
ErrorExSeverity.INFO);
7166 }
7167 }
7168
7169 }
7170
7173 {
7174
7175 }
7176
7179 {
7181 }
7182
7184 {
7185 super.EEHealthLevelChanged(oldLevel,newLevel,zone);
7186
7188 {
7189 if (newLevel == GameConstants.STATE_RUINED)
7190 {
7192 EntityAI parent = GetHierarchyParent();
7193 if (parent && parent.IsFireplace())
7194 {
7195 CargoBase cargo = GetInventory().GetCargo();
7196 if (cargo)
7197 {
7199 {
7201 }
7202 }
7203 }
7204 }
7205
7207 {
7208
7210 return;
7211 }
7212
7213 if (
m_Cleanness != 0 && oldLevel < newLevel && newLevel != 0)
7214 {
7216 }
7217 }
7218 }
7219
7220
7222 {
7223 super.OnRightClick();
7224
7226 {
7228 {
7229 if (ScriptInputUserData.CanStoreInputUserData())
7230 {
7231 EntityAI root = GetHierarchyRoot();
7232 Man playerOwner = GetHierarchyRootPlayer();
7233 InventoryLocation dst = new InventoryLocation;
7234
7235
7236 if (!playerOwner && root && root == this)
7237 {
7239 }
7240 else
7241 {
7242
7243 GetInventory().GetCurrentInventoryLocation(dst);
7245 {
7248 {
7250 }
7251 else
7252 {
7254
7255
7256 if (
GetGame().
GetPlayer().GetInventory().HasInventoryReservation(
this, dst))
7257 {
7259 }
7260 else
7261 {
7262 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(null, dst, GameInventory.c_InventoryReservationTimeoutShortMS);
7263 }
7264 }
7265 }
7266 }
7267
7268 ScriptInputUserData ctx = new ScriptInputUserData;
7276 }
7277 }
7278 else if (!
GetGame().IsMultiplayer())
7279 {
7281 }
7282 }
7283 }
7284
7286 {
7287 if (root)
7288 {
7289 vector m4[4];
7290 root.GetTransform(m4);
7291 dst.SetGround(this, m4);
7292 }
7293 else
7294 {
7295 GetInventory().GetCurrentInventoryLocation(dst);
7296 }
7297 }
7298
7299 override bool CanBeCombined(
EntityAI other_item,
bool reservation_check =
true,
bool stack_max_limit =
false)
7300 {
7301
7302 if (!other_item ||
GetType() != other_item.GetType() || (
IsFullQuantity() && other_item.GetQuantity() > 0) || other_item ==
this)
7303 return false;
7304
7305 if (GetHealthLevel() == GameConstants.STATE_RUINED || other_item.GetHealthLevel() == GameConstants.STATE_RUINED)
7306 return false;
7307
7308
7310 return false;
7311
7312
7313 Magazine mag = Magazine.Cast(this);
7314 if (mag)
7315 {
7316 if (mag.GetAmmoCount() >= mag.GetAmmoMax())
7317 return false;
7318
7319 if (stack_max_limit)
7320 {
7321 Magazine other_mag = Magazine.Cast(other_item);
7322 if (other_item)
7323 {
7324 if (mag.GetAmmoCount() + other_mag.GetAmmoCount() > mag.GetAmmoMax())
7325 return false;
7326 }
7327
7328 }
7329 }
7330 else
7331 {
7332
7334 return false;
7335
7337 return false;
7338 }
7339
7340 PlayerBase player = null;
7341 if (CastTo(player, GetHierarchyRootPlayer()))
7342 {
7343 if (player.GetInventory().HasAttachment(this))
7344 return false;
7345
7346 if (player.IsItemsToDelete())
7347 return false;
7348 }
7349
7350 if (reservation_check && (GetInventory().HasInventoryReservation(this, null) || other_item.GetInventory().HasInventoryReservation(other_item, null)))
7351 return false;
7352
7353 int slotID;
7355 if (GetInventory().GetCurrentAttachmentSlotInfo(slotID,
slotName) && GetHierarchyParent().GetInventory().GetSlotLock(slotID))
7356 return false;
7357
7358 return true;
7359 }
7360
7362 {
7364 }
7365
7367 {
7368 return m_IsResultOfSplit;
7369 }
7370
7372 {
7373 m_IsResultOfSplit = value;
7374 }
7375
7377 {
7379 }
7380
7382 {
7383 float other_item_quantity = other_item.GetQuantity();
7384 float this_free_space;
7385
7387
7389
7390 if (other_item_quantity > this_free_space)
7391 {
7392 return this_free_space;
7393 }
7394 else
7395 {
7396 return other_item_quantity;
7397 }
7398 }
7399
7401 {
7403 }
7404
7406 {
7408 return;
7409
7410 if (!IsMagazine() && other_item)
7411 {
7413 if (quantity_used != 0)
7414 {
7415 float hp1 = GetHealth01("","");
7416 float hp2 = other_item.GetHealth01("","");
7417 float hpResult = ((hp1*
GetQuantity()) + (hp2*quantity_used));
7418 hpResult = hpResult / (
GetQuantity() + quantity_used);
7419
7420 hpResult *= GetMaxHealth();
7421 Math.Round(hpResult);
7422 SetHealth("", "Health", hpResult);
7423
7425 other_item.AddQuantity(-quantity_used);
7426 }
7427 }
7429 }
7430
7432 {
7433 #ifdef SERVER
7434 if (!GetHierarchyRootPlayer() && GetHierarchyParent())
7435 GetHierarchyParent().IncreaseLifetimeUp();
7436 #endif
7437 };
7438
7440 {
7441 PlayerBase p = PlayerBase.Cast(player);
7442
7443 array<int> recipesIds = p.m_Recipes;
7444 PluginRecipesManager moduleRecipesManager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
7445 if (moduleRecipesManager)
7446 {
7447 EntityAI itemInHands = player.GetHumanInventory().GetEntityInHands();
7448 moduleRecipesManager.GetValidRecipes(
ItemBase.Cast(
this),
ItemBase.Cast(itemInHands), recipesIds, p);
7449 }
7450
7451 for (int i = 0;i < recipesIds.Count(); i++)
7452 {
7453 int key = recipesIds.Get(i);
7454 string recipeName = moduleRecipesManager.GetRecipeName(key);
7456 }
7457 }
7458
7459
7460 override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
7461 {
7462 super.GetDebugActions(outputList);
7463
7464
7470
7471
7476
7481
7482
7486
7487
7489 {
7493 }
7494
7497
7498
7502
7504
7505 InventoryLocation loc = new InventoryLocation();
7506 GetInventory().GetCurrentInventoryLocation(loc);
7508 {
7509 if (Gizmo_IsSupported())
7512 }
7513
7515 }
7516
7517
7518
7519
7521 {
7522 super.OnAction(action_id, player, ctx);
7523
7525 {
7526 switch (action_id)
7527 {
7530 return true;
7533 return true;
7534 }
7535 }
7536
7538 {
7539 switch (action_id)
7540 {
7542 Delete();
7543 return true;
7544 }
7545 }
7546
7547 if (action_id >=
EActions.RECIPES_RANGE_START && action_id <
EActions.RECIPES_RANGE_END)
7548 {
7549 PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
7550 int idWithoutOffset = action_id -
EActions.RECIPES_RANGE_START;
7551 PlayerBase p = PlayerBase.Cast(player);
7552 if (
EActions.RECIPES_RANGE_START < 1000)
7553 {
7554 float anim_length = plugin_recipes_manager.GetRecipeLengthInSecs(idWithoutOffset);
7555 float specialty_weight = plugin_recipes_manager.GetRecipeSpecialty(idWithoutOffset);
7556 }
7557 }
7558 #ifndef SERVER
7559 else if (action_id ==
EActions.WATCH_PLAYER)
7560 {
7561 PluginDeveloper.SetDeveloperItemClientEx(player);
7562 }
7563 #endif
7565 {
7566 if (action_id >=
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START && action_id <
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_END)
7567 {
7568 int id = action_id -
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START;
7569 OnDebugButtonPressServer(id + 1);
7570 }
7571
7572 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_INJECT_START && action_id <
EActions.DEBUG_AGENTS_RANGE_INJECT_END)
7573 {
7574 int agent_id = action_id -
EActions.DEBUG_AGENTS_RANGE_INJECT_START;
7576 }
7577
7578 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_REMOVE_START && action_id <
EActions.DEBUG_AGENTS_RANGE_REMOVE_END)
7579 {
7580 int agent_id2 = action_id -
EActions.DEBUG_AGENTS_RANGE_REMOVE_START;
7582 }
7583
7584 else if (action_id ==
EActions.ADD_QUANTITY)
7585 {
7586 if (IsMagazine())
7587 {
7588 Magazine mag = Magazine.Cast(this);
7589 mag.ServerSetAmmoCount(mag.GetAmmoCount() + mag.GetAmmoMax() * 0.2);
7590 }
7591 else
7592 {
7594 }
7595
7596 if (m_EM)
7597 {
7598 m_EM.AddEnergy(m_EM.GetEnergyMax() * 0.2);
7599 }
7600
7601 }
7602
7603 else if (action_id ==
EActions.REMOVE_QUANTITY)
7604 {
7605 if (IsMagazine())
7606 {
7607 Magazine mag2 = Magazine.Cast(this);
7608 mag2.ServerSetAmmoCount(mag2.GetAmmoCount() - mag2.GetAmmoMax() * 0.2);
7609 }
7610 else
7611 {
7613 }
7614 if (m_EM)
7615 {
7616 m_EM.AddEnergy(- m_EM.GetEnergyMax() * 0.2);
7617 }
7618
7619 }
7620
7621 else if (action_id ==
EActions.SET_QUANTITY_0)
7622 {
7624
7625 if (m_EM)
7626 {
7627 m_EM.SetEnergy(0);
7628 }
7629 }
7630
7631 else if (action_id ==
EActions.SET_MAX_QUANTITY)
7632 {
7634
7635 if (m_EM)
7636 {
7637 m_EM.SetEnergy(m_EM.GetEnergyMax());
7638 }
7639 }
7640
7641 else if (action_id ==
EActions.ADD_HEALTH)
7642 {
7643 AddHealth("","",GetMaxHealth("","Health")/5);
7644 }
7645 else if (action_id ==
EActions.REMOVE_HEALTH)
7646 {
7647 AddHealth("","",-GetMaxHealth("","Health")/5);
7648 }
7649 else if (action_id ==
EActions.DESTROY_HEALTH)
7650 {
7651 SetHealth01("","",0);
7652 }
7653 else if (action_id ==
EActions.WATCH_ITEM)
7654 {
7656 mid.RegisterDebugItem(
ItemBase.Cast(
this), PlayerBase.Cast(player));
7657 #ifdef DEVELOPER
7658 SetDebugDeveloper_item(this);
7659 #endif
7660 }
7661
7662 else if (action_id ==
EActions.ADD_TEMPERATURE)
7663 {
7664 AddTemperature(20);
7665
7666 }
7667
7668 else if (action_id ==
EActions.REMOVE_TEMPERATURE)
7669 {
7670 AddTemperature(-20);
7671
7672 }
7673
7674 else if (action_id ==
EActions.FLIP_FROZEN)
7675 {
7676 SetFrozen(!GetIsFrozen());
7677
7678 }
7679
7680 else if (action_id ==
EActions.ADD_WETNESS)
7681 {
7683
7684 }
7685
7686 else if (action_id ==
EActions.REMOVE_WETNESS)
7687 {
7689
7690 }
7691
7692 else if (action_id ==
EActions.LIQUIDTYPE_UP)
7693 {
7696
7697
7698 }
7699
7700 else if (action_id ==
EActions.LIQUIDTYPE_DOWN)
7701 {
7704 }
7705
7706 else if (action_id ==
EActions.MAKE_SPECIAL)
7707 {
7708 auto debugParams = DebugSpawnParams.WithPlayer(player);
7709 OnDebugSpawnEx(debugParams);
7710 }
7711
7712 }
7713
7714
7715 return false;
7716 }
7717
7718
7719
7720
7724
7727
7728
7729
7731 {
7732 return false;
7733 }
7734
7735
7737 {
7738 return true;
7739 }
7740
7741
7743 {
7744 return true;
7745 }
7746
7747
7748
7750 {
7751 string config_path =
string.Format(
"CfgVehicles %1 Food FoodStages",
GetType());
7753 }
7754
7757 {
7758 return null;
7759 }
7760
7762 {
7763 return false;
7764 }
7765
7767 {
7768 return false;
7769 }
7770
7774
7775
7777 {
7778 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
7779 return module_repairing.CanRepair(this, item_repair_kit);
7780 }
7781
7782
7783 bool Repair(PlayerBase player,
ItemBase item_repair_kit,
float specialty_weight)
7784 {
7785 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
7786 return module_repairing.Repair(player, this, item_repair_kit, specialty_weight);
7787 }
7788
7789
7791 {
7792
7793
7794
7795
7796
7797
7798
7799
7800 return 1;
7801 }
7802
7803
7804
7806 {
7808 }
7809
7810
7811
7813 {
7815 }
7816
7817
7826 {
7827 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
7828
7829 if (player)
7830 {
7831 player.MessageStatus(text);
7832 }
7833 }
7834
7835
7844 {
7845 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
7846
7847 if (player)
7848 {
7849 player.MessageAction(text);
7850 }
7851 }
7852
7853
7862 {
7863 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
7864
7865 if (player)
7866 {
7867 player.MessageFriendly(text);
7868 }
7869 }
7870
7871
7880 {
7881 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
7882
7883 if (player)
7884 {
7885 player.MessageImportant(text);
7886 }
7887 }
7888
7890 {
7891 return true;
7892 }
7893
7894
7895 override bool KindOf(
string tag)
7896 {
7897 bool found = false;
7898 string item_name = this.
GetType();
7901
7902 int array_size = item_tag_array.Count();
7903 for (int i = 0; i < array_size; i++)
7904 {
7905 if (item_tag_array.Get(i) == tag)
7906 {
7907 found = true;
7908 break;
7909 }
7910 }
7911 return found;
7912 }
7913
7914
7916 {
7917
7918 super.OnRPC(sender, rpc_type,ctx);
7919
7920
7921 switch (rpc_type)
7922 {
7923 #ifndef SERVER
7924 case ERPCs.RPC_SOUND_LOCK_ATTACH:
7925 Param2<bool, string> p = new Param2<bool, string>(false, "");
7926
7928 return;
7929
7930 bool play = p.param1;
7931 string soundSet = p.param2;
7932
7933 if (play)
7934 {
7936 {
7938 {
7940 }
7941 }
7942 else
7943 {
7945 }
7946 }
7947 else
7948 {
7950 }
7951
7952 break;
7953 #endif
7954
7955 }
7956
7958 {
7960 }
7961 }
7962
7963
7964
7965
7967 {
7968 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
7969 return plugin.GetID(
name);
7970 }
7971
7973 {
7974 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
7975 return plugin.GetName(id);
7976 }
7977
7980 {
7981
7982
7983 int varFlags;
7984 if (!ctx.
Read(varFlags))
7985 return;
7986
7987 if (varFlags & ItemVariableFlags.FLOAT)
7988 {
7990 }
7991 }
7992
7994 {
7995
7996 super.SerializeNumericalVars(floats_out);
7997
7998
7999
8001 {
8003 }
8004
8006 {
8008 }
8009
8011 {
8013 }
8014
8016 {
8021 }
8022
8024 {
8026 }
8027 }
8028
8030 {
8031
8032 super.DeSerializeNumericalVars(floats);
8033
8034
8035 int index = 0;
8036 int mask = Math.Round(floats.Get(index));
8037
8038 index++;
8039
8041 {
8043 {
8045 }
8046 else
8047 {
8048 float quantity = floats.Get(index);
8050 }
8051 index++;
8052 }
8053
8055 {
8056 float wet = floats.Get(index);
8058 index++;
8059 }
8060
8062 {
8063 int liquidtype = Math.Round(floats.Get(index));
8065 index++;
8066 }
8067
8069 {
8071 index++;
8073 index++;
8075 index++;
8077 index++;
8078 }
8079
8081 {
8082 int cleanness = Math.Round(floats.Get(index));
8084 index++;
8085 }
8086 }
8087
8089 {
8090 super.WriteVarsToCTX(ctx);
8091
8092
8094 {
8096 }
8097
8099 {
8101 }
8102
8104 {
8106 }
8107
8109 {
8110 int r,g,b,a;
8116 }
8117
8119 {
8121 }
8122 }
8123
8125 {
8126 if (!super.ReadVarsFromCTX(ctx,version))
8127 return false;
8128
8129 int intValue;
8130 float value;
8131
8132 if (version < 140)
8133 {
8134 if (!ctx.
Read(intValue))
8135 return false;
8136
8137 m_VariablesMask = intValue;
8138 }
8139
8141 {
8142 if (!ctx.
Read(value))
8143 return false;
8144
8146 {
8148 }
8149 else
8150 {
8152 }
8153 }
8154
8155 if (version < 140)
8156 {
8158 {
8159 if (!ctx.
Read(value))
8160 return false;
8161 SetTemperatureDirect(value);
8162 }
8163 }
8164
8166 {
8167 if (!ctx.
Read(value))
8168 return false;
8170 }
8171
8173 {
8174 if (!ctx.
Read(intValue))
8175 return false;
8177 }
8178
8180 {
8181 int r,g,b,a;
8183 return false;
8185 return false;
8187 return false;
8189 return false;
8190
8192 }
8193
8195 {
8196 if (!ctx.
Read(intValue))
8197 return false;
8199 }
8200
8201 if (version >= 138 && version < 140)
8202 {
8204 {
8205 if (!ctx.
Read(intValue))
8206 return false;
8207 SetFrozen(intValue);
8208 }
8209 }
8210
8211 return true;
8212 }
8213
8214
8216 {
8219 {
8221 }
8222
8223 if (!super.OnStoreLoad(ctx, version))
8224 {
8226 return false;
8227 }
8228
8229 if (version >= 114)
8230 {
8231 bool hasQuickBarIndexSaved;
8232
8233 if (!ctx.
Read(hasQuickBarIndexSaved))
8234 {
8236 return false;
8237 }
8238
8239 if (hasQuickBarIndexSaved)
8240 {
8241 int itmQBIndex;
8242
8243
8244 if (!ctx.
Read(itmQBIndex))
8245 {
8247 return false;
8248 }
8249
8250 PlayerBase parentPlayer = PlayerBase.Cast(GetHierarchyRootPlayer());
8251 if (itmQBIndex != -1 && parentPlayer)
8252 parentPlayer.SetLoadedQuickBarItemBind(this, itmQBIndex);
8253 }
8254 }
8255 else
8256 {
8257
8258 PlayerBase player;
8259 int itemQBIndex;
8260 if (version ==
int.
MAX)
8261 {
8262 if (!ctx.
Read(itemQBIndex))
8263 {
8265 return false;
8266 }
8267 }
8268 else if (Class.CastTo(player, GetHierarchyRootPlayer()))
8269 {
8270
8271 if (!ctx.
Read(itemQBIndex))
8272 {
8274 return false;
8275 }
8276 if (itemQBIndex != -1 && player)
8277 player.SetLoadedQuickBarItemBind(this,itemQBIndex);
8278 }
8279 }
8280
8281 if (version < 140)
8282 {
8283
8284 if (!LoadVariables(ctx, version))
8285 {
8287 return false;
8288 }
8289 }
8290
8291
8293 {
8295 return false;
8296 }
8297 if (version >= 132)
8298 {
8300 if (raib)
8301 {
8303 {
8305 return false;
8306 }
8307 }
8308 }
8309
8311 return true;
8312 }
8313
8314
8315
8317 {
8318 super.OnStoreSave(ctx);
8319
8320 PlayerBase player;
8321 if (PlayerBase.CastTo(player,GetHierarchyRootPlayer()))
8322 {
8324
8325 int itemQBIndex = -1;
8326 itemQBIndex = player.FindQuickBarEntityIndex(this);
8327 ctx.
Write(itemQBIndex);
8328 }
8329 else
8330 {
8332 }
8333
8335
8337 if (raib)
8338 {
8340 }
8341 }
8342
8343
8345 {
8346 super.AfterStoreLoad();
8347
8349 {
8351 }
8352
8354 {
8357 }
8358 }
8359
8361 {
8362 super.EEOnAfterLoad();
8363
8365 {
8367 }
8368
8371 }
8372
8374 {
8375 return false;
8376 }
8377
8378
8379
8381 {
8383 {
8384 #ifdef PLATFORM_CONSOLE
8385
8387 {
8389 if (menu)
8390 {
8392 }
8393 }
8394 #endif
8395 }
8396
8398 {
8401 }
8402
8404 {
8405 SetWeightDirty();
8407 }
8409 {
8412 }
8413
8415 {
8418 }
8420 {
8423 }
8424
8425 super.OnVariablesSynchronized();
8426 }
8427
8428
8429
8431 override bool SetQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false,
bool allow_client =
false,
bool clamp_to_stack_max =
true)
8432 {
8433 if (!IsServerCheck(allow_client))
8434 return false;
8435
8437 return false;
8438
8441
8442 if (value <= (min + 0.001))
8443 value = min;
8444
8445 if (value == min)
8446 {
8447 if (destroy_config)
8448 {
8449 bool dstr = ConfigGetBool("varQuantityDestroyOnMin");
8450 if (dstr)
8451 {
8453 this.Delete();
8454 return true;
8455 }
8456 }
8457 else if (destroy_forced)
8458 {
8460 this.Delete();
8461 return true;
8462 }
8463
8465 }
8466
8469
8471 {
8473
8474 if (delta)
8476 }
8477
8479
8480 return false;
8481 }
8482
8483
8485 bool AddQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
8486 {
8488 }
8489
8491 {
8494 }
8495
8497 {
8500 }
8501
8503 override void SetQuantityNormalized(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
8504 {
8505 float value_clamped = Math.Clamp(value, 0, 1);
8507 SetQuantity(result, destroy_config, destroy_forced);
8508 }
8509
8510
8513 {
8515 }
8516
8518 {
8520 }
8521
8522
8523
8524
8525
8526
8527
8528
8529
8530
8532 {
8533 int slot = -1;
8534 if (GetInventory())
8535 {
8536 InventoryLocation il = new InventoryLocation;
8537 GetInventory().GetCurrentInventoryLocation(il);
8539 }
8540
8542 }
8543
8545 {
8546 float quantity_max = 0;
8547
8549 {
8550 if (attSlotID != -1)
8551 quantity_max = InventorySlots.GetStackMaxForSlotId(attSlotID);
8552
8553 if (quantity_max <= 0)
8555 }
8556
8557 if (quantity_max <= 0)
8559
8560 return quantity_max;
8561 }
8562
8564 {
8566 }
8567
8569 {
8571 }
8572
8573
8575 {
8577 }
8578
8580 {
8582 }
8583
8585 {
8587 }
8588
8589
8591 {
8592
8593 float weightEx = GetWeightEx();
8594 float special = GetInventoryAndCargoWeight();
8595 return weightEx - special;
8596 }
8597
8598
8600 {
8602 }
8603
8605 {
8607 {
8608 #ifdef DEVELOPER
8609 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
8610 {
8611 WeightDebugData data1 = WeightDebug.GetWeightDebug(this);
8613 }
8614 #endif
8615
8617 }
8618 else if (HasEnergyManager())
8619 {
8620 #ifdef DEVELOPER
8621 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
8622 {
8623 WeightDebugData data2 = WeightDebug.GetWeightDebug(this);
8624 data2.
SetCalcDetails(
"TIB2: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " + GetCompEM().
GetEnergy()+
"(energy) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit)");
8625 }
8626 #endif
8627 return super.GetWeightSpecialized(forceRecalc) + (GetCompEM().GetEnergy() * ConfigGetFloat("weightPerQuantityUnit")) + GetConfigWeightModified();
8628 }
8629 else
8630 {
8631 #ifdef DEVELOPER
8632 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
8633 {
8634 WeightDebugData data3 = WeightDebug.GetWeightDebug(this);
8635 data3.
SetCalcDetails(
"TIB3: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " +
GetQuantity()+
"(quantity) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit))");
8636 }
8637 #endif
8638 return super.GetWeightSpecialized(forceRecalc) + (
GetQuantity() * ConfigGetFloat(
"weightPerQuantityUnit")) + GetConfigWeightModified();
8639 }
8640 }
8641
8644 {
8645 int item_count = 0;
8647
8648 if (GetInventory().GetCargo() != NULL)
8649 {
8650 item_count = GetInventory().GetCargo().GetItemCount();
8651 }
8652
8653 for (int i = 0; i < GetInventory().AttachmentCount(); i++)
8654 {
8655 Class.CastTo(item,GetInventory().GetAttachmentFromIndex(i));
8656 if (item)
8657 item_count += item.GetNumberOfItems();
8658 }
8659 return item_count;
8660 }
8661
8664 {
8665 float weight = 0;
8666 float wetness = 1;
8667 if (include_wetness)
8670 {
8671 weight = wetness * m_ConfigWeight;
8672 }
8674 {
8675 weight = 1;
8676 }
8677 return weight;
8678 }
8679
8680
8681
8683 {
8684 if ((
GetGame().IsServer() || !
GetGame().IsMultiplayer()) && GetInventory())
8685 {
8686 GameInventory inv = GetInventory();
8687 array<EntityAI> items = new array<EntityAI>;
8689 for (int i = 0; i < items.Count(); i++)
8690 {
8692 if (item)
8693 {
8695 }
8696 }
8697 }
8698 }
8699
8700
8701
8702
8704 {
8705 float energy = 0;
8706 if (HasEnergyManager())
8707 {
8708 energy = GetCompEM().GetEnergy();
8709 }
8710 return energy;
8711 }
8712
8713
8715 {
8716 super.OnEnergyConsumed();
8717
8719 }
8720
8722 {
8723 super.OnEnergyAdded();
8724
8726 }
8727
8728
8730 {
8731 if (
GetGame().IsServer() && HasEnergyManager() && GetCompEM().HasConversionOfEnergyToQuantity())
8732 {
8734 {
8735 float energy_0to1 = GetCompEM().GetEnergy0To1();
8737 }
8738 }
8739 }
8740
8741
8743 {
8744 return ConfigGetFloat("heatIsolation");
8745 }
8746
8748 {
8750 }
8751
8753 {
8754 string paramPath =
string.Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Drying %2",
GetType(), pIncrementName);
8755 if (
GetGame().ConfigIsExisting(paramPath))
8757
8758 return 0.0;
8759 }
8760
8762 {
8763 string paramPath =
string.
Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Soaking %2",
GetType(), pIncrementName);
8764 if (
GetGame().ConfigIsExisting(paramPath))
8766
8767 return 0.0;
8768 }
8769
8770 override void SetWet(
float value,
bool allow_client =
false)
8771 {
8772 if (!IsServerCheck(allow_client))
8773 return;
8774
8777
8779
8780 m_VarWet = Math.Clamp(value, min, max);
8781
8783 {
8786 }
8787 }
8788
8789 override void AddWet(
float value)
8790 {
8792 }
8793
8795 {
8797 }
8798
8800 {
8802 }
8803
8805 {
8807 }
8808
8810 {
8812 }
8813
8815 {
8817 }
8818
8820 {
8823 if (newLevel != oldLevel)
8824 {
8826 }
8827 }
8828
8830 {
8831 SetWeightDirty();
8832 }
8833
8835 {
8836 return GetWetLevelInternal(
m_VarWet);
8837 }
8838
8839
8840
8842 {
8844 }
8845
8847 {
8849 }
8850
8852 {
8854 }
8855
8857 {
8859 }
8860
8861
8862
8864 {
8865 if (ConfigIsExisting("itemModelLength"))
8866 {
8867 return ConfigGetFloat("itemModelLength");
8868 }
8869 return 0;
8870 }
8871
8873 {
8874 if (ConfigIsExisting("itemAttachOffset"))
8875 {
8876 return ConfigGetFloat("itemAttachOffset");
8877 }
8878 return 0;
8879 }
8880
8881 override void SetCleanness(
int value,
bool allow_client =
false)
8882 {
8883 if (!IsServerCheck(allow_client))
8884 return;
8885
8887
8889
8892 }
8893
8895 {
8897 }
8898
8900 {
8901 return true;
8902 }
8903
8904
8905
8906
8908 {
8910 }
8911
8913 {
8915 }
8916
8917
8918
8919
8920 override void SetColor(
int r,
int g,
int b,
int a)
8921 {
8927 }
8929 override void GetColor(out
int r,out
int g,out
int b,out
int a)
8930 {
8935 }
8936
8938 {
8940 }
8941
8944 {
8945 int r,g,b,a;
8947 r = r/255;
8948 g = g/255;
8949 b = b/255;
8950 a = a/255;
8951 return MiscGameplayFunctions.GetColorString(r, g, b, a);
8952 }
8953
8954
8955
8956 override void SetLiquidType(
int value,
bool allow_client =
false)
8957 {
8958 if (!IsServerCheck(allow_client))
8959 return;
8960
8965 }
8966
8968 {
8969 return ConfigGetInt("varLiquidTypeInit");
8970 }
8971
8973 {
8975 }
8976
8978 {
8980 SetFrozen(false);
8981 }
8982
8985 {
8986 player.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
8987 }
8988
8989
8992 {
8993 PlayerBase nplayer;
8994 if (PlayerBase.CastTo(nplayer, player))
8995 {
8997
8998 nplayer.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
8999 }
9000 }
9001
9002
9005 {
9006 PlayerBase nplayer;
9007 if (PlayerBase.CastTo(nplayer,player))
9008 {
9009
9010 nplayer.SetEnableQuickBarEntityShortcut(this,false);
9011
9012 }
9013
9014
9015 player.GetHumanInventory().ClearUserReservedLocationForContainer(this);
9016
9017
9018 if (HasEnergyManager())
9019 {
9020 GetCompEM().UpdatePlugState();
9021 }
9022 }
9023
9024
9026 {
9027 super.OnPlacementStarted(player);
9028
9030 }
9031
9032 override void OnPlacementComplete(Man player, vector position =
"0 0 0", vector orientation =
"0 0 0")
9033 {
9035 {
9036 m_AdminLog.OnPlacementComplete(player,
this);
9037 }
9038
9039 super.OnPlacementComplete(player, position, orientation);
9040 }
9041
9042
9043
9044
9045
9047 {
9049 {
9050 return true;
9051 }
9052 else
9053 {
9054 return false;
9055 }
9056 }
9057
9058
9060 {
9062 {
9064 }
9065 }
9066
9067
9069 {
9071 }
9072
9074 {
9076 }
9077
9078 override void InsertAgent(
int agent,
float count = 1)
9079 {
9080 if (count < 1)
9081 return;
9082
9084 }
9085
9088 {
9090 }
9091
9092
9094 {
9096 }
9097
9098
9099
9100
9101
9102
9103
9104
9105
9106
9107
9108
9109
9110
9111
9112
9113
9114
9115
9116
9117
9118
9119
9120
9121
9122
9123
9124
9125
9126
9127
9128
9129
9130
9131
9132
9133
9134
9135
9136
9137
9138
9140 {
9142 return false;
9143 return true;
9144 }
9145
9147 {
9148
9150 }
9151
9152
9155 {
9156 super.CheckForRoofLimited(timeTresholdMS);
9157
9159 if ((time - m_PreviousRoofTestTime) >= timeTresholdMS)
9160 {
9161 m_PreviousRoofTestTime = time;
9162 SetRoofAbove(MiscGameplayFunctions.IsUnderRoof(this));
9163 }
9164 }
9165
9166
9168 {
9170 {
9171 return 0;
9172 }
9173
9174 if (GetInventory().GetAttachmentSlotsCount() != 0)
9175 {
9176 ItemBase filter =
ItemBase.Cast(FindAttachmentBySlotName(
"GasMaskFilter"));
9177 if (filter)
9178 return filter.GetProtectionLevel(type, false, system);
9179 else
9180 return 0;
9181 }
9182
9183 string subclassPath, entryName;
9184
9185 switch (type)
9186 {
9188 entryName = "biological";
9189 break;
9191 entryName = "chemical";
9192 break;
9193 default:
9194 entryName = "biological";
9195 break;
9196 }
9197
9198 subclassPath =
"CfgVehicles " + this.
GetType() +
" Protection ";
9199
9201 }
9202
9203
9204
9207 {
9208 if (!IsMagazine())
9210
9212 }
9213
9214
9215
9216
9217
9222 {
9223 return true;
9224 }
9225
9227 {
9229 }
9230
9231
9232
9233
9234
9236 {
9237 if (parent)
9238 {
9239 if (parent.IsInherited(DayZInfected))
9240 return true;
9241
9242 if (!parent.IsRuined())
9243 return true;
9244 }
9245
9246 return true;
9247 }
9248
9250 {
9251 if (!super.CanPutAsAttachment(parent))
9252 {
9253 return false;
9254 }
9255
9256 if (!IsRuined() && !parent.IsRuined())
9257 {
9258 return true;
9259 }
9260
9261 return false;
9262 }
9263
9265 {
9266
9267
9268
9269
9270 return super.CanReceiveItemIntoCargo(item);
9271 }
9272
9274 {
9275
9276
9277
9278
9279 GameInventory attachmentInv = attachment.GetInventory();
9281 {
9282 if (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase))
9283 return false;
9284 }
9285
9286 InventoryLocation loc = new InventoryLocation();
9287 attachment.GetInventory().GetCurrentInventoryLocation(loc);
9288 if (loc && loc.
IsValid() && !GetInventory().AreChildrenAccessible())
9289 return false;
9290
9291 return super.CanReceiveAttachment(attachment, slotId);
9292 }
9293
9295 {
9296 if (!super.CanReleaseAttachment(attachment))
9297 return false;
9298
9299 return GetInventory().AreChildrenAccessible();
9300 }
9301
9302
9303
9304
9305
9306
9307
9308
9309
9310
9311
9312
9313
9314
9315
9316
9317
9318
9319
9320
9321
9323 {
9324 int id = muzzle_owner.GetMuzzleID();
9325 array<ref WeaponParticlesOnFire> WPOF_array =
m_OnFireEffect.Get(
id);
9326
9327 if (WPOF_array)
9328 {
9329 for (int i = 0; i < WPOF_array.Count(); i++)
9330 {
9331 WeaponParticlesOnFire WPOF = WPOF_array.Get(i);
9332
9333 if (WPOF)
9334 {
9335 WPOF.OnActivate(weapon, muzzle_index, ammoType, muzzle_owner, suppressor, config_to_search);
9336 }
9337 }
9338 }
9339 }
9340
9341
9343 {
9344 int id = muzzle_owner.GetMuzzleID();
9346
9347 if (WPOBE_array)
9348 {
9349 for (int i = 0; i < WPOBE_array.Count(); i++)
9350 {
9351 WeaponParticlesOnBulletCasingEject WPOBE = WPOBE_array.Get(i);
9352
9353 if (WPOBE)
9354 {
9355 WPOBE.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
9356 }
9357 }
9358 }
9359 }
9360
9361
9363 {
9364 int id = muzzle_owner.GetMuzzleID();
9365 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
9366
9367 if (WPOOH_array)
9368 {
9369 for (int i = 0; i < WPOOH_array.Count(); i++)
9370 {
9371 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
9372
9373 if (WPOOH)
9374 {
9375 WPOOH.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
9376 }
9377 }
9378 }
9379 }
9380
9381
9383 {
9384 int id = muzzle_owner.GetMuzzleID();
9385 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
9386
9387 if (WPOOH_array)
9388 {
9389 for (int i = 0; i < WPOOH_array.Count(); i++)
9390 {
9391 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
9392
9393 if (WPOOH)
9394 {
9395 WPOOH.OnUpdate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9396 }
9397 }
9398 }
9399 }
9400
9401
9403 {
9404 int id = muzzle_owner.GetMuzzleID();
9405 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
9406
9407 if (WPOOH_array)
9408 {
9409 for (int i = 0; i < WPOOH_array.Count(); i++)
9410 {
9411 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
9412
9413 if (WPOOH)
9414 {
9415 WPOOH.OnDeactivate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9416 }
9417 }
9418 }
9419 }
9420
9421
9422
9424 {
9426 {
9427 return true;
9428 }
9429
9430 return false;
9431 }
9432
9434 {
9436 {
9437 return true;
9438 }
9439
9440 return false;
9441 }
9442
9444 {
9446 {
9447 return true;
9448 }
9449
9450 return false;
9451 }
9452
9454 {
9455 return false;
9456 }
9457
9460 {
9461 return UATimeSpent.DEFAULT_DEPLOY;
9462 }
9463
9464
9465
9466
9468 {
9470 SetSynchDirty();
9471 }
9472
9474 {
9476 }
9477
9478
9480 {
9481 return false;
9482 }
9483
9486 {
9487 string att_type = "None";
9488
9489 if (ConfigIsExisting("soundAttType"))
9490 {
9491 att_type = ConfigGetString("soundAttType");
9492 }
9493
9495 }
9496
9498 {
9500 }
9501
9502
9503
9504
9505
9511
9513 {
9516
9518 }
9519
9520
9522 {
9524 return;
9525
9527
9530
9533
9534 SoundParameters params = new SoundParameters();
9538 }
9539
9540
9542 {
9544 return;
9545
9547 SetSynchDirty();
9548
9551 }
9552
9553
9555 {
9557 return;
9558
9560 SetSynchDirty();
9561
9564 }
9565
9567 {
9569 }
9570
9572 {
9574 }
9575
9578 {
9579 if (!
GetGame().IsDedicatedServer())
9580 {
9581 if (ConfigIsExisting("attachSoundSet"))
9582 {
9583 string cfg_path = "";
9584 string soundset = "";
9586
9589 ConfigGetTextArray("attachSoundSet",cfg_soundset_array);
9590 ConfigGetTextArray("attachSoundSlot",cfg_slot_array);
9591
9592 if (cfg_soundset_array.Count() > 0 && cfg_soundset_array.Count() == cfg_slot_array.Count())
9593 {
9594 for (int i = 0; i < cfg_soundset_array.Count(); i++)
9595 {
9596 if (cfg_slot_array[i] == slot_type)
9597 {
9598 soundset = cfg_soundset_array[i];
9599 break;
9600 }
9601 }
9602 }
9603
9604 if (soundset != "")
9605 {
9606 EffectSound sound = SEffectManager.PlaySound(soundset,
GetPosition());
9608 }
9609 }
9610 }
9611 }
9612
9614 {
9615
9616 }
9617
9618 void OnApply(PlayerBase player);
9619
9621 {
9622 return 1.0;
9623 };
9624
9626 {
9628 }
9629
9631 {
9633 }
9634
9636
9638 {
9639 SetDynamicPhysicsLifeTime(0.01);
9641 }
9642
9644 {
9645 array<string> zone_names = new array<string>;
9646 GetDamageZones(zone_names);
9647 for (int i = 0; i < zone_names.Count(); i++)
9648 {
9649 SetHealthMax(zone_names.Get(i),"Health");
9650 }
9651 SetHealthMax("","Health");
9652 }
9653
9656 {
9657 float global_health = GetHealth01("","Health");
9658 array<string> zones = new array<string>;
9659 GetDamageZones(zones);
9660
9661 for (int i = 0; i < zones.Count(); i++)
9662 {
9663 SetHealth01(zones.Get(i),"Health",global_health);
9664 }
9665 }
9666
9669 {
9670 return IsExclusionFlagPresent(PlayerBase.GetFaceCoverageShaveValues());
9671 }
9672
9674 {
9675 if (!hasRootAsPlayer)
9676 {
9677 if (refParentIB)
9678 {
9679
9680 if ((refParentIB.GetWet() >= GameConstants.STATE_SOAKING_WET) && (
m_VarWet <
m_VarWetMax))
9681 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_INSIDE);
9682
9683 else if ((refParentIB.GetLiquidType() != 0) && (refParentIB.GetQuantity() > 0) && (
m_VarWet <
m_VarWetMax))
9684 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_LIQUID);
9685
9688 }
9689 else
9690 {
9691
9694 }
9695 }
9696 }
9697
9699 {
9701 {
9702 float target =
g_Game.GetMission().GetWorldData().GetBaseEnvTemperatureAtObject(
this);
9703 if (
GetTemperature() != target || !IsFreezeThawProgressFinished())
9704 {
9705 float heatPermCoef = 1.0;
9707 while (ent)
9708 {
9709 heatPermCoef *= ent.GetHeatPermeabilityCoef();
9710 ent = ent.GetHierarchyParent();
9711 }
9712
9713 SetTemperatureEx(
new TemperatureDataInterpolated(target,
ETemperatureAccessTypes.ACCESS_WORLD,delta,GameConstants.TEMP_COEF_WORLD,heatPermCoef));
9714 }
9715 }
9716 }
9717
9719 {
9720
9721 EntityAI parent = GetHierarchyParent();
9722 if (!parent)
9723 {
9724 hasParent = false;
9725 hasRootAsPlayer = false;
9726 }
9727 else
9728 {
9729 hasParent = true;
9730 hasRootAsPlayer = (GetHierarchyRootPlayer() != null);
9731 refParentIB =
ItemBase.Cast(parent);
9732 }
9733 }
9734
9735 protected void ProcessDecay(
float delta,
bool hasRootAsPlayer)
9736 {
9737
9738 }
9739
9741 {
9742
9743 return false;
9744 }
9745
9747 {
9748
9749
9750 return false;
9751 }
9752
9754 {
9755
9756 return false;
9757 }
9758
9761 {
9762 return !GetIsFrozen() &&
IsOpen();
9763 }
9764
9766 {
9767 bool hasParent = false, hasRootAsPlayer = false;
9769
9770 bool wwtu =
g_Game.IsWorldWetTempUpdateEnabled();
9771 bool foodDecay =
g_Game.IsFoodDecayEnabled();
9772
9773 if (wwtu || foodDecay)
9774 {
9778
9779 if (processWetness || processTemperature || processDecay)
9780 {
9782
9783 if (processWetness)
9784 ProcessItemWetness(m_ElapsedSinceLastUpdate, hasParent, hasRootAsPlayer, refParentIB);
9785
9786 if (processTemperature)
9788
9789 if (processDecay)
9790 ProcessDecay(m_ElapsedSinceLastUpdate, hasRootAsPlayer);
9791 }
9792 }
9793 }
9794
9797 {
9799 }
9800
9802 {
9805
9806 return super.GetTemperatureFreezeThreshold();
9807 }
9808
9810 {
9813
9814 return super.GetTemperatureThawThreshold();
9815 }
9816
9818 {
9821
9822 return super.GetItemOverheatThreshold();
9823 }
9824
9826 {
9828 return Math.Lerp(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureFreezeTime()),
GetQuantityNormalized());
9829
9830 return super.GetTemperatureFreezeTime();
9831 }
9832
9834 {
9836 return Math.Lerp(GameConstants.TEMPERATURE_TIME_THAW_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureThawTime()),
GetQuantityNormalized());
9837
9838 return super.GetTemperatureThawTime();
9839 }
9840
9845
9847 {
9848 return (item.IsKindOf("Cauldron") || item.IsKindOf("Pot") || item.IsKindOf("FryingPan") || item.IsKindOf("SmallProtectorCase") || (item.IsKindOf("PortableGasStove") && item.FindAttachmentBySlotName("CookingEquipment")));
9849 }
9850
9852 {
9853 MiscGameplayFunctions.TransferItemProperties(oldItem, this);
9854 }
9855
9858 {
9860 }
9861
9863 {
9865 }
9866
9868 {
9870 }
9871
9874 {
9875 return null;
9876 }
9877
9880 {
9881 return false;
9882 }
9883
9885 {
9887 {
9890 if (!trg)
9891 {
9893 explosive = this;
9894 }
9895
9896 explosive.PairRemote(trg);
9898
9899 int persistentID = RemotelyActivatedItemBehaviour.GeneratePersistentID();
9900 trg.SetPersistentPairID(persistentID);
9901 explosive.SetPersistentPairID(persistentID);
9902
9903 return true;
9904 }
9905 return false;
9906 }
9907
9910 {
9911 float ret = 1.0;
9914 ret *= GetHealth01();
9915
9916 return ret;
9917 }
9918
9919 #ifdef DEVELOPER
9920 override void SetDebugItem()
9921 {
9922 super.SetDebugItem();
9923 _itemBase = this;
9924 }
9925
9927 {
9928 string text = super.GetDebugText();
9929
9931 text +=
string.
Format(
"Heat isolation(modified): %1\n", MiscGameplayFunctions.GetCurrentItemHeatIsolation(
this));
9932
9933 return text;
9934 }
9935 #endif
9936
9938 {
9939 return true;
9940 }
9941
9943
9945
9947 {
9950 }
9951
9952
9960
9976}
9977
9979{
9981 if (entity)
9982 {
9983 bool is_item = entity.IsInherited(
ItemBase);
9984 if (is_item && full_quantity)
9985 {
9988 }
9989 }
9990 else
9991 {
9993 return NULL;
9994 }
9995 return entity;
9996}
9997
9999{
10000 if (item)
10001 {
10002 if (health > 0)
10003 item.SetHealth("", "", health);
10004
10005 if (item.CanHaveTemperature())
10006 {
10008 if (item.CanFreeze())
10009 item.SetFrozen(false);
10010 }
10011
10012 if (item.HasEnergyManager())
10013 {
10014 if (quantity >= 0)
10015 {
10016 item.GetCompEM().SetEnergy0To1(quantity);
10017 }
10018 else
10019 {
10021 }
10022 }
10023 else if (item.IsMagazine())
10024 {
10025 Magazine mag = Magazine.Cast(item);
10026 if (quantity >= 0)
10027 {
10028 mag.ServerSetAmmoCount(mag.GetAmmoMax() * quantity);
10029 }
10030 else
10031 {
10033 }
10034
10035 }
10036 else
10037 {
10038 if (quantity >= 0)
10039 {
10040 item.SetQuantityNormalized(quantity, false);
10041 }
10042 else
10043 {
10045 }
10046
10047 }
10048 }
10049}
10050
10051#ifdef DEVELOPER
10053#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.