9144{
9146 {
9147 return true;
9148 }
9149};
9150
9151
9152
9154{
9158
9160
9163
9164
9165
9166
9167
9176
9182
9187
9192
9213 protected bool m_IsResultOfSplit
9214
9216
9221
9222
9223
9225
9229
9230
9231
9233
9236
9237
9238
9244
9245
9253
9256
9257
9259
9260
9262
9263
9268
9269
9274
9275
9277
9278
9280 {
9285
9286 if (!
GetGame().IsDedicatedServer())
9287 {
9289 {
9291
9293 {
9295 }
9296 }
9297
9300 }
9301
9302 m_OldLocation = null;
9303
9305 {
9307 }
9308
9309 if (ConfigIsExisting("headSelectionsToHide"))
9310 {
9313 }
9314
9316 if (ConfigIsExisting("hideSelectionsByinventorySlot"))
9317 {
9319 }
9320
9322
9323 m_IsResultOfSplit = false;
9324
9326 }
9327
9329 {
9330 super.InitItemVariables();
9331
9337 m_Count = ConfigGetInt(
"count");
9338
9341
9346
9349
9354
9366
9370
9371
9374 if (ConfigIsExisting("canBeSplit"))
9375 {
9378 }
9379
9381 if (ConfigIsExisting("itemBehaviour"))
9383
9384
9387 RegisterNetSyncVariableInt("m_VarLiquidType");
9388 RegisterNetSyncVariableInt("m_Cleanness",0,1);
9389
9390 RegisterNetSyncVariableBoolSignal("m_WantPlayImpactSound");
9391 RegisterNetSyncVariableFloat("m_ImpactSpeed");
9392 RegisterNetSyncVariableInt("m_ImpactSoundSurfaceHash");
9393
9394 RegisterNetSyncVariableInt("m_ColorComponentR", 0, 255);
9395 RegisterNetSyncVariableInt("m_ColorComponentG", 0, 255);
9396 RegisterNetSyncVariableInt("m_ColorComponentB", 0, 255);
9397 RegisterNetSyncVariableInt("m_ColorComponentA", 0, 255);
9398
9399 RegisterNetSyncVariableBool("m_IsBeingPlaced");
9400 RegisterNetSyncVariableBool("m_IsTakeable");
9401 RegisterNetSyncVariableBool("m_IsHologram");
9402
9405 {
9408 }
9409
9411
9413 if (ConfigIsExisting("temperaturePerQuantityWeight"))
9415
9416 }
9417
9419 {
9421 }
9422
9424 {
9427 {
9432 }
9433 }
9434
9435 override void GetActions(
typename action_input_type, out array<ActionBase_Basic> actions)
9436 {
9438 {
9441 }
9442
9444 }
9445
9447 {
9453 }
9454
9456
9458 {
9460
9461 if (!action)
9462 {
9463 Debug.LogError(
"Action " + actionName +
" dosn't exist!");
9464 return;
9465 }
9466
9468 if (!ai)
9469 {
9471 return;
9472 }
9473
9475 if (!action_array)
9476 {
9477 action_array = new array<ActionBase_Basic>;
9479 }
9480 if (LogManager.IsActionLogEnable())
9481 {
9482 Debug.ActionLog(action.ToString() +
" -> " + ai,
this.ToString() ,
"n/a",
"Add action");
9483 }
9484
9485 if (action_array.Find(action) != -1)
9486 {
9487 Debug.Log(
"Action " + action.Type() +
" already added to " +
this +
", skipping!");
9488 }
9489 else
9490 {
9491 action_array.Insert(action);
9492 }
9493 }
9494
9496 {
9498 ActionBase action = player.GetActionManager().GetAction(actionName);
9501
9502 if (action_array)
9503 {
9504 action_array.RemoveItem(action);
9505 }
9506 }
9507
9508
9509
9511 {
9512 ActionOverrideData overrideData = new ActionOverrideData();
9516
9518 if (!actionMap)
9519 {
9522 }
9523
9524 actionMap.Insert(this.
Type(), overrideData);
9525
9526 }
9527
9529
9531
9532
9534 {
9537
9540
9541 string config_to_search = "CfgVehicles";
9542 string muzzle_owner_config;
9543
9545 {
9546 if (IsInherited(Weapon))
9547 config_to_search = "CfgWeapons";
9548
9549 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
9550
9551 string config_OnFire_class = muzzle_owner_config + "Particles " + "OnFire ";
9552
9554
9555 if (config_OnFire_subclass_count > 0)
9556 {
9557 array<ref WeaponParticlesOnFire> WPOF_array = new array<ref WeaponParticlesOnFire>;
9558
9559 for (int i = 0; i < config_OnFire_subclass_count; i++)
9560 {
9561 string particle_class = "";
9563 string config_OnFire_entry = config_OnFire_class + particle_class;
9564 WeaponParticlesOnFire WPOF = new WeaponParticlesOnFire(this, config_OnFire_entry);
9565 WPOF_array.Insert(WPOF);
9566 }
9567
9568
9570 }
9571 }
9572
9574 {
9575 config_to_search = "CfgWeapons";
9576 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
9577
9578 string config_OnBulletCasingEject_class = muzzle_owner_config + "Particles " + "OnBulletCasingEject ";
9579
9581
9582 if (config_OnBulletCasingEject_count > 0 && IsInherited(Weapon))
9583 {
9584 array<ref WeaponParticlesOnBulletCasingEject> WPOBE_array = new array<ref WeaponParticlesOnBulletCasingEject>;
9585
9586 for (i = 0; i < config_OnBulletCasingEject_count; i++)
9587 {
9588 string particle_class2 = "";
9590 string config_OnBulletCasingEject_entry = config_OnBulletCasingEject_class + particle_class2;
9591 WeaponParticlesOnBulletCasingEject WPOBE = new WeaponParticlesOnBulletCasingEject(this, config_OnBulletCasingEject_entry);
9592 WPOBE_array.Insert(WPOBE);
9593 }
9594
9595
9597 }
9598 }
9599 }
9600
9601
9603 {
9606
9608 {
9609 string config_to_search = "CfgVehicles";
9610
9611 if (IsInherited(Weapon))
9612 config_to_search = "CfgWeapons";
9613
9614 string muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
9615 string config_OnOverheating_class = muzzle_owner_config + "Particles " + "OnOverheating ";
9616
9617 if (
GetGame().ConfigIsExisting(config_OnOverheating_class))
9618 {
9619
9621
9623 {
9625 string error =
"Error reading config " +
GetType() +
">Particles>OnOverheating - Parameter shotsToStartOverheating is configured wrong or is missing! Its value must be 1 or higher!";
9627 return;
9628 }
9629
9632
9633
9634
9636 array<ref WeaponParticlesOnOverheating> WPOOH_array = new array<ref WeaponParticlesOnOverheating>;
9637
9638 for (int i = 0; i < config_OnOverheating_subclass_count; i++)
9639 {
9640 string particle_class = "";
9642 string config_OnOverheating_entry = config_OnOverheating_class + particle_class;
9644
9645 if (entry_type == CT_CLASS)
9646 {
9647 WeaponParticlesOnOverheating WPOF = new WeaponParticlesOnOverheating(this, config_OnOverheating_entry);
9648 WPOOH_array.Insert(WPOF);
9649 }
9650 }
9651
9652
9654 }
9655 }
9656 }
9657
9659 {
9661 }
9662
9664 {
9666 {
9668
9671
9674
9675 CheckOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9676 }
9677 }
9678
9680 {
9682 UpdateOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9683
9685 StartOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9686
9688 StopOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9689
9691 {
9693 }
9694 }
9695
9697 {
9699 }
9700
9702 {
9705 else
9707
9709 {
9712 }
9713 else
9714 {
9717
9720 }
9721
9723 }
9724
9726 {
9728 ItemBase.PlayOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
9729 }
9730
9732 {
9734 ItemBase.UpdateOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
9736 }
9737
9739 {
9741 ItemBase.StopOverheatingParticles(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9742 }
9743
9745 {
9748
9749 OverheatingParticle OP = new OverheatingParticle();
9754
9756 }
9757
9759 {
9762
9763 return -1;
9764 }
9765
9767 {
9769 {
9772
9773 for (int i = count; i > 0; --i)
9774 {
9775 int id = i - 1;
9778
9781
9782 if (overheat_coef < overheat_min && overheat_coef >= overheat_max)
9783 {
9784 if (p)
9785 {
9788 }
9789 }
9790 }
9791 }
9792 }
9793
9795 {
9797 {
9799 {
9800 int id = i - 1;
9802
9803 if (OP)
9804 {
9806
9807 if (p)
9808 {
9810 }
9811
9812 delete OP;
9813 }
9814 }
9815
9818 }
9819 }
9820
9823 {
9824 return 0.0;
9825 }
9826
9827
9829 {
9830 return 250;
9831 }
9832
9834 {
9835 return 0;
9836 }
9837
9840 {
9842 return true;
9843
9844 return false;
9845 }
9846
9849 {
9852
9854 {
9856 }
9857 else
9858 {
9859
9861 }
9862
9864 }
9865
9872 {
9873 return -1;
9874 }
9875
9876
9877
9878
9880 {
9882 {
9884 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
9885
9886 if (r_index >= 0)
9887 {
9888 InventoryLocation r_il = new InventoryLocation;
9889 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
9890
9891 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
9894 {
9895 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
9896 }
9898 {
9899 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
9900 }
9901
9902 }
9903
9904 player.GetHumanInventory().ClearUserReservedLocation(this);
9905 }
9906
9909 }
9910
9911
9912
9913
9915 {
9916 return ItemBase.m_DebugActionsMask;
9917 }
9918
9920 {
9921 return ItemBase.m_DebugActionsMask & mask;
9922 }
9923
9925 {
9926 ItemBase.m_DebugActionsMask = mask;
9927 }
9928
9930 {
9931 ItemBase.m_DebugActionsMask |= mask;
9932 }
9933
9935 {
9936 ItemBase.m_DebugActionsMask &= ~mask;
9937 }
9938
9940 {
9942 {
9944 }
9945 else
9946 {
9948 }
9949 }
9950
9951
9953 {
9954 if (GetEconomyProfile())
9955 {
9956 float q_max = GetEconomyProfile().GetQuantityMax();
9957 if (q_max > 0)
9958 {
9959 float q_min = GetEconomyProfile().GetQuantityMin();
9960 float quantity_randomized = Math.RandomFloatInclusive(q_min, q_max);
9961
9963 {
9964 ComponentEnergyManager comp = GetCompEM();
9966 {
9968 }
9969 }
9971 {
9973
9974 }
9975
9976 }
9977 }
9978 }
9979
9982 {
9983 EntityAI parent = GetHierarchyParent();
9984
9985 if (parent)
9986 {
9987 InventoryLocation inventory_location_to_lock = new InventoryLocation;
9988 GetInventory().GetCurrentInventoryLocation(inventory_location_to_lock);
9989 parent.GetInventory().SetSlotLock(inventory_location_to_lock.
GetSlot(),
true);
9990 }
9991 }
9992
9995 {
9996 EntityAI parent = GetHierarchyParent();
9997
9998 if (parent)
9999 {
10000 InventoryLocation inventory_location_to_unlock = new InventoryLocation;
10001 GetInventory().GetCurrentInventoryLocation(inventory_location_to_unlock);
10002 parent.GetInventory().SetSlotLock(inventory_location_to_unlock.
GetSlot(),
false);
10003 }
10004 }
10005
10007 {
10008
10009
10010
10011
10013
10015 {
10016 if (ScriptInputUserData.CanStoreInputUserData())
10017 {
10018 ScriptInputUserData ctx = new ScriptInputUserData;
10024 ctx.
Write(use_stack_max);
10027
10029 {
10030 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(item2,null,GameInventory.c_InventoryReservationTimeoutShortMS);
10031 }
10032 }
10033 }
10034 else if (!
GetGame().IsMultiplayer())
10035 {
10037 }
10038 }
10039
10041 {
10043 }
10044
10046 {
10048 }
10049
10051 {
10053 }
10054
10056 {
10057
10058 return false;
10059 }
10060
10062 {
10063 return false;
10064 }
10065
10069 {
10070 return false;
10071 }
10072
10074 {
10075 return "";
10076 }
10077
10079
10081 {
10082 return false;
10083 }
10084
10086 {
10087 return true;
10088 }
10089
10090
10091
10093 {
10094 return true;
10095 }
10096
10098 {
10099 return true;
10100 }
10101
10103 {
10104 PlayerBase player = PlayerBase.Cast(
g_Game.GetPlayer());
10106 }
10107
10109 {
10111 }
10112
10114 {
10116 if (!is_being_placed)
10118 SetSynchDirty();
10119 }
10120
10121
10123
10125 {
10127 }
10128
10130 {
10132 }
10133
10135 {
10136 return 1;
10137 }
10138
10140 {
10141 return false;
10142 }
10143
10145 {
10147 SetSynchDirty();
10148 }
10149
10150
10151
10152
10153
10154
10155
10156
10157
10158
10159
10160
10161
10162
10163
10164
10165
10166
10167
10168
10169
10170
10171
10172
10173
10174
10175
10176
10177
10178
10179
10180
10181
10182
10183
10185 {
10186 super.OnMovedInsideCargo(container);
10187
10188 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
10189 }
10190
10191 override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
10192 {
10193 super.EEItemLocationChanged(oldLoc,newLoc);
10194
10195 PlayerBase new_player = null;
10196 PlayerBase old_player = null;
10197
10198 if (newLoc.GetParent())
10199 new_player = PlayerBase.Cast(newLoc.GetParent().GetHierarchyRootPlayer());
10200
10201 if (oldLoc.GetParent())
10202 old_player = PlayerBase.Cast(oldLoc.GetParent().GetHierarchyRootPlayer());
10203
10205 {
10206 int r_index = old_player.GetHumanInventory().FindUserReservedLocationIndex(this);
10207
10208 if (r_index >= 0)
10209 {
10210 InventoryLocation r_il = new InventoryLocation;
10211 old_player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
10212
10213 old_player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
10216 {
10217 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
10218 }
10220 {
10221 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
10222 }
10223
10224 }
10225 }
10226
10228 {
10229 if (new_player)
10230 new_player.ForceStandUpForHeavyItems(newLoc.GetItem());
10231
10232 if (new_player == old_player)
10233 {
10234
10235 if (oldLoc.GetParent() && new_player.GetHumanInventory().LocationGetEntity(oldLoc) == NULL)
10236 {
10238 {
10239 if (oldLoc.GetParent().GetInventory().TestAddEntityInCargoExLoc(oldLoc, false, false, false, true, false, false))
10240 {
10241 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
10242 }
10243 }
10244 else
10245 {
10246 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
10247 }
10248 }
10249
10250 if (new_player.GetHumanInventory().FindUserReservedLocationIndex(this) >= 0)
10251 {
10252 int type = oldLoc.GetType();
10254 {
10255 oldLoc.GetParent().GetOnSetLock().Invoke(this);
10256 }
10258 {
10259 oldLoc.GetParent().GetOnAttachmentSetLock().Invoke(this, oldLoc.GetSlot());
10260 }
10261 }
10262 if (!m_OldLocation)
10263 {
10264 m_OldLocation = new InventoryLocation;
10265 }
10266 m_OldLocation.Copy(oldLoc);
10267 }
10268 else
10269 {
10270 if (m_OldLocation)
10271 {
10272 m_OldLocation.Reset();
10273 }
10274 }
10275
10277 }
10278 else
10279 {
10280 if (new_player)
10281 {
10282 int res_index = new_player.GetHumanInventory().FindCollidingUserReservedLocationIndex(this, newLoc);
10283 if (res_index >= 0)
10284 {
10285 InventoryLocation il = new InventoryLocation;
10286 new_player.GetHumanInventory().GetUserReservedLocation(res_index,il);
10288 new_player.GetHumanInventory().ClearUserReservedLocationAtIndex(res_index);
10291 {
10292 il.
GetParent().GetOnReleaseLock().Invoke(it);
10293 }
10295 {
10297 }
10298
10299 }
10300 }
10302 {
10303
10305 }
10306
10307 if (m_OldLocation)
10308 {
10309 m_OldLocation.Reset();
10310 }
10311 }
10312 }
10313
10314 override void EOnContact(IEntity other, Contact extra)
10315 {
10317 {
10318 int liquidType = -1;
10320 if (impactSpeed > 0.0)
10321 {
10323 #ifndef SERVER
10325 #else
10327 SetSynchDirty();
10328 #endif
10330 }
10331 }
10332
10333 #ifdef SERVER
10334 if (GetCompEM() && GetCompEM().IsPlugged())
10335 {
10336 if (GetCompEM().GetCordLength() < vector.Distance(
GetPosition(), GetCompEM().GetEnergySource().
GetPosition()))
10337 GetCompEM().UnplugThis();
10338 }
10339 #endif
10340 }
10341
10343
10345 {
10347 }
10348
10350 {
10351
10352 }
10353
10355 {
10356 super.OnItemLocationChanged(old_owner, new_owner);
10357
10358 PlayerBase relatedPlayer = PlayerBase.Cast(old_owner);
10359 PlayerBase playerNew = PlayerBase.Cast(new_owner);
10360
10361 if (!relatedPlayer && playerNew)
10362 relatedPlayer = playerNew;
10363
10364 if (relatedPlayer && relatedPlayer.GetPerformedActionID() != -1)
10365 {
10367 if (actionMgr)
10368 {
10369 ActionBase currentAction = actionMgr.GetRunningAction();
10370 if (currentAction)
10372 }
10373 }
10374
10375 Man ownerPlayerOld = null;
10376 Man ownerPlayerNew = null;
10377
10378 if (old_owner)
10379 {
10380 if (old_owner.
IsMan())
10381 {
10382 ownerPlayerOld = Man.Cast(old_owner);
10383 }
10384 else
10385 {
10386 ownerPlayerOld = Man.Cast(old_owner.GetHierarchyRootPlayer());
10387 }
10388 }
10389 else
10390 {
10392 {
10394
10395 if (!action || !playerNew || playerNew.GetPerformedActionID() != action.
GetID())
10396 {
10397 GetCompEM().UnplugThis();
10398 }
10399 }
10400 }
10401
10402 if (new_owner)
10403 {
10404 if (new_owner.
IsMan())
10405 {
10406 ownerPlayerNew = Man.Cast(new_owner);
10407 }
10408 else
10409 {
10410 ownerPlayerNew = Man.Cast(new_owner.GetHierarchyRootPlayer());
10411 }
10412 }
10413
10414 if (ownerPlayerOld != ownerPlayerNew)
10415 {
10416 if (ownerPlayerOld)
10417 {
10418 array<EntityAI> subItemsExit = new array<EntityAI>;
10420 for (int i = 0; i < subItemsExit.Count(); i++)
10421 {
10424 }
10425 }
10426
10427 if (ownerPlayerNew)
10428 {
10429 array<EntityAI> subItemsEnter = new array<EntityAI>;
10431 for (int j = 0; j < subItemsEnter.Count(); j++)
10432 {
10435 }
10436 }
10437 }
10438 else if (ownerPlayerNew != null)
10439 {
10440 PlayerBase nplayer;
10441 if (PlayerBase.CastTo(nplayer, ownerPlayerNew))
10442 {
10443 array<EntityAI> subItemsUpdate = new array<EntityAI>;
10445 for (int k = 0; k < subItemsUpdate.Count(); k++)
10446 {
10448 itemUpdate.UpdateQuickbarShortcutVisibility(nplayer);
10449 }
10450 }
10451 }
10452
10453 if (old_owner)
10454 old_owner.OnChildItemRemoved(this);
10455 if (new_owner)
10456 new_owner.OnChildItemReceived(this);
10457 }
10458
10459
10461 {
10462 super.EEDelete(parent);
10463 PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
10464 if (player)
10465 {
10467
10468 if (player.IsAlive())
10469 {
10470 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
10471 if (r_index >= 0)
10472 {
10473 InventoryLocation r_il = new InventoryLocation;
10474 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
10475
10476 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
10479 {
10480 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
10481 }
10483 {
10484 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
10485 }
10486
10487 }
10488
10489 player.RemoveQuickBarEntityShortcut(this);
10490 }
10491 }
10492 }
10493
10495 {
10496 super.EEKilled(killer);
10497
10500 {
10501 if (
GetTemperature() >= GameConstants.ITEM_TEMPERATURE_TO_EXPLODE_MIN)
10502 {
10503 if (IsMagazine())
10504 {
10505 if (Magazine.Cast(this).GetAmmoCount() > 0)
10506 {
10508 }
10509 }
10510 else
10511 {
10513 }
10514 }
10515 }
10516 }
10517
10519 {
10520 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
10521
10522 super.OnWasAttached(parent, slot_id);
10523
10526
10528 }
10529
10531 {
10532 super.OnWasDetached(parent, slot_id);
10533
10536 }
10537
10539 {
10540 int idx;
10543
10544 ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
10545 if (inventory_slots.Count() < 1)
10546 {
10547 inventory_slots.Insert(ConfigGetString("ChangeInventorySlot"));
10548 attach_types.Insert(ConfigGetString("ChangeIntoOnAttach"));
10549 }
10550 else
10551 {
10552 ConfigGetTextArray("ChangeIntoOnAttach",attach_types);
10553 }
10554
10555 idx = inventory_slots.Find(slot);
10556 if (idx < 0)
10557 return "";
10558
10559 return attach_types.Get(idx);
10560 }
10561
10563 {
10564 int idx = -1;
10565 string slot;
10566
10569
10570 this.ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
10571 if (inventory_slots.Count() < 1)
10572 {
10573 inventory_slots.Insert(this.ConfigGetString("ChangeInventorySlot"));
10574 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
10575 }
10576 else
10577 {
10578 this.ConfigGetTextArray("ChangeIntoOnDetach",detach_types);
10579 if (detach_types.Count() < 1)
10580 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
10581 }
10582
10583 for (int i = 0; i < inventory_slots.Count(); i++)
10584 {
10585 slot = inventory_slots.Get(i);
10586 }
10587
10588 if (slot != "")
10589 {
10590 if (detach_types.Count() == 1)
10591 idx = 0;
10592 else
10593 idx = inventory_slots.Find(slot);
10594 }
10595 if (idx < 0)
10596 return "";
10597
10598 return detach_types.Get(idx);
10599 }
10600
10602 {
10603
10605
10606
10607 float min_time = 1;
10608 float max_time = 3;
10609 float delay = Math.RandomFloat(min_time, max_time);
10610
10611 explode_timer.Run(delay, this, "DoAmmoExplosion");
10612 }
10613
10615 {
10616 Magazine magazine = Magazine.Cast(this);
10617 int pop_sounds_count = 6;
10618 string pop_sounds[ 6 ] = { "ammopops_1","ammopops_2","ammopops_3","ammopops_4","ammopops_5","ammopops_6" };
10619
10620
10621 int sound_idx = Math.RandomInt(0, pop_sounds_count - 1);
10622 string sound_name = pop_sounds[ sound_idx ];
10624
10625
10626 magazine.ServerAddAmmoCount(-1);
10627
10628
10629 float min_temp_to_explode = 100;
10630
10631 if (magazine.GetAmmoCount() > 0 &&
GetTemperature() >= min_temp_to_explode)
10632 {
10634 }
10635 }
10636
10637
10638 override void EEHitBy(TotalDamageResult damageResult,
int damageType,
EntityAI source,
int component,
string dmgZone,
string ammo, vector modelPos,
float speedCoef)
10639 {
10640 super.EEHitBy(damageResult, damageType, source,
component, dmgZone, ammo, modelPos, speedCoef);
10641
10642 const int CHANCE_DAMAGE_CARGO = 4;
10643 const int CHANCE_DAMAGE_ATTACHMENT = 1;
10644 const int CHANCE_DAMAGE_NOTHING = 2;
10645
10647 {
10648 float dmg = damageResult.
GetDamage(
"",
"Health") * -0.5;
10649 int chances;
10650 int rnd;
10651
10652 if (GetInventory().GetCargo())
10653 {
10654 chances = CHANCE_DAMAGE_CARGO + CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
10655 rnd = Math.RandomInt(0,chances);
10656
10657 if (rnd < CHANCE_DAMAGE_CARGO)
10658 {
10660 }
10661 else if (rnd < (chances - CHANCE_DAMAGE_NOTHING))
10662 {
10664 }
10665 }
10666 else
10667 {
10668 chances = CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
10669 rnd = Math.RandomInt(0,chances);
10670
10671 if (rnd < CHANCE_DAMAGE_ATTACHMENT)
10672 {
10674 }
10675 }
10676 }
10677 }
10678
10680 {
10681 if (GetInventory().GetCargo())
10682 {
10683 int item_count = GetInventory().GetCargo().GetItemCount();
10684 if (item_count > 0)
10685 {
10686 int random_pick = Math.RandomInt(0, item_count);
10688 if (!item.IsExplosive())
10689 {
10690 item.AddHealth("","",damage);
10691 return true;
10692 }
10693 }
10694 }
10695 return false;
10696 }
10697
10699 {
10700 int attachment_count = GetInventory().AttachmentCount();
10701 if (attachment_count > 0)
10702 {
10703 int random_pick = Math.RandomInt(0, attachment_count);
10704 ItemBase attachment =
ItemBase.Cast(GetInventory().GetAttachmentFromIndex(random_pick));
10705 if (!attachment.IsExplosive())
10706 {
10707 attachment.AddHealth("","",damage);
10708 return true;
10709 }
10710 }
10711 return false;
10712 }
10713
10715 {
10717 }
10718
10720 {
10722 return GetInventory().CanRemoveEntity();
10723
10724 return false;
10725 }
10726
10728 {
10729
10731 return false;
10732
10733
10735 return false;
10736
10737
10738
10740 if (delta == 0)
10741 return false;
10742
10743
10744 return true;
10745 }
10746
10748 {
10750 {
10751 if (ScriptInputUserData.CanStoreInputUserData())
10752 {
10753 ScriptInputUserData ctx = new ScriptInputUserData;
10758 ctx.
Write(destination_entity);
10760 ctx.
Write(slot_id);
10762 }
10763 }
10764 else if (!
GetGame().IsMultiplayer())
10765 {
10767 }
10768 }
10769
10771 {
10772 float split_quantity_new;
10776 InventoryLocation loc = new InventoryLocation;
10777
10778 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
10779 {
10781 split_quantity_new = stack_max;
10782 else
10784
10786 {
10787 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
10788 if (new_item)
10789 {
10790 new_item.SetResultOfSplit(true);
10791 MiscGameplayFunctions.TransferItemProperties(this, new_item);
10793 new_item.
SetQuantity(split_quantity_new,
false,
true);
10794 }
10795 }
10796 }
10797 else if (destination_entity && slot_id == -1)
10798 {
10799 if (quantity > stack_max)
10800 split_quantity_new = stack_max;
10801 else
10802 split_quantity_new = quantity;
10803
10805 {
10807 {
10810 }
10811
10812 if (new_item)
10813 {
10814 new_item.SetResultOfSplit(true);
10815 MiscGameplayFunctions.TransferItemProperties(this, new_item);
10817 new_item.
SetQuantity(split_quantity_new,
false,
true);
10818 }
10819 }
10820 }
10821 else
10822 {
10823 if (stack_max != 0)
10824 {
10826 {
10828 }
10829
10830 if (split_quantity_new == 0)
10831 {
10832 if (!
GetGame().IsMultiplayer())
10833 player.PhysicalPredictiveDropItem(this);
10834 else
10835 player.ServerDropEntity(this);
10836 return;
10837 }
10838
10840 {
10842
10843 if (new_item)
10844 {
10845 new_item.SetResultOfSplit(true);
10846 MiscGameplayFunctions.TransferItemProperties(this, new_item);
10849 new_item.PlaceOnSurface();
10850 }
10851 }
10852 }
10853 }
10854 }
10855
10857 {
10858 float split_quantity_new;
10862 InventoryLocation loc = new InventoryLocation;
10863
10864 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
10865 {
10867 split_quantity_new = stack_max;
10868 else
10870
10872 {
10873 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
10874 if (new_item)
10875 {
10876 new_item.SetResultOfSplit(true);
10877 MiscGameplayFunctions.TransferItemProperties(this, new_item);
10879 new_item.
SetQuantity(split_quantity_new,
false,
true);
10880 }
10881 }
10882 }
10883 else if (destination_entity && slot_id == -1)
10884 {
10885 if (quantity > stack_max)
10886 split_quantity_new = stack_max;
10887 else
10888 split_quantity_new = quantity;
10889
10891 {
10893 {
10896 }
10897
10898 if (new_item)
10899 {
10900 new_item.SetResultOfSplit(true);
10901 MiscGameplayFunctions.TransferItemProperties(this, new_item);
10903 new_item.
SetQuantity(split_quantity_new,
false,
true);
10904 }
10905 }
10906 }
10907 else
10908 {
10909 if (stack_max != 0)
10910 {
10912 {
10914 }
10915
10917 {
10919
10920 if (new_item)
10921 {
10922 new_item.SetResultOfSplit(true);
10923 MiscGameplayFunctions.TransferItemProperties(this, new_item);
10926 new_item.PlaceOnSurface();
10927 }
10928 }
10929 }
10930 }
10931 }
10932
10934 {
10936 {
10937 if (ScriptInputUserData.CanStoreInputUserData())
10938 {
10939 ScriptInputUserData ctx = new ScriptInputUserData;
10944 dst.WriteToContext(ctx);
10946 }
10947 }
10948 else if (!
GetGame().IsMultiplayer())
10949 {
10951 }
10952 }
10953
10955 {
10957 {
10958 if (ScriptInputUserData.CanStoreInputUserData())
10959 {
10960 ScriptInputUserData ctx = new ScriptInputUserData;
10965 ctx.
Write(destination_entity);
10971 }
10972 }
10973 else if (!
GetGame().IsMultiplayer())
10974 {
10976 }
10977 }
10978
10980 {
10982 }
10983
10985 {
10987 float split_quantity_new;
10989 if (dst.IsValid())
10990 {
10991 int slot_id = dst.GetSlot();
10993
10994 if (quantity > stack_max)
10995 split_quantity_new = stack_max;
10996 else
10997 split_quantity_new = quantity;
10998
11000 {
11002
11003 if (new_item)
11004 {
11005 new_item.SetResultOfSplit(true);
11006 MiscGameplayFunctions.TransferItemProperties(this,new_item);
11008 new_item.
SetQuantity(split_quantity_new,
false,
true);
11009 }
11010
11011 return new_item;
11012 }
11013 }
11014
11015 return null;
11016 }
11017
11019 {
11021 float split_quantity_new;
11023 if (destination_entity)
11024 {
11026 if (quantity > stackable)
11027 split_quantity_new = stackable;
11028 else
11029 split_quantity_new = quantity;
11030
11032 {
11033 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateEntityInCargoEx(
this.GetType(), idx, row, col,
false));
11034 if (new_item)
11035 {
11036 new_item.SetResultOfSplit(true);
11037 MiscGameplayFunctions.TransferItemProperties(this,new_item);
11039 new_item.
SetQuantity(split_quantity_new,
false,
true);
11040 }
11041 }
11042 }
11043 }
11044
11046 {
11048 {
11049 if (ScriptInputUserData.CanStoreInputUserData())
11050 {
11051 ScriptInputUserData ctx = new ScriptInputUserData;
11056 ItemBase destination_entity =
this;
11057 ctx.
Write(destination_entity);
11061 }
11062 }
11063 else if (!
GetGame().IsMultiplayer())
11064 {
11066 }
11067 }
11068
11070 {
11072 float split_quantity_new;
11074 if (player)
11075 {
11077 if (quantity > stackable)
11078 split_quantity_new = stackable;
11079 else
11080 split_quantity_new = quantity;
11081
11083 {
11084 EntityAI in_hands = player.GetHumanInventory().CreateInHands(this.
GetType());
11085 new_item =
ItemBase.Cast(in_hands);
11086 if (new_item)
11087 {
11088 new_item.SetResultOfSplit(true);
11089 MiscGameplayFunctions.TransferItemProperties(this,new_item);
11091 new_item.SetQuantity(split_quantity_new, false, true);
11092 }
11093 }
11094 }
11095 }
11096
11098 {
11100 float split_quantity_new = Math.Floor(quantity * 0.5);
11101
11103 return;
11104
11106
11107 if (new_item)
11108 {
11109 if (new_item.GetQuantityMax() < split_quantity_new)
11110 {
11111 split_quantity_new = new_item.GetQuantityMax();
11112 }
11113
11114 new_item.SetResultOfSplit(true);
11115 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11116
11118 {
11121 }
11122 else
11123 {
11125 new_item.
SetQuantity(split_quantity_new,
false,
true);
11126 }
11127 }
11128 }
11129
11131 {
11133 float split_quantity_new = Math.Floor(quantity / 2);
11134
11136 return;
11137
11138 InventoryLocation invloc = new InventoryLocation;
11140
11142 new_item = player.CreateCopyOfItemInInventoryOrGroundEx(this, true);
11143
11144 if (new_item)
11145 {
11146 if (new_item.GetQuantityMax() < split_quantity_new)
11147 {
11148 split_quantity_new = new_item.GetQuantityMax();
11149 }
11151 {
11154 }
11155 else if (split_quantity_new > 1)
11156 {
11158 new_item.
SetQuantity(split_quantity_new,
false,
true);
11159 }
11160 }
11161 }
11162
11165 {
11166 SetWeightDirty();
11168
11169 if (parent)
11170 parent.OnAttachmentQuantityChangedEx(this, delta);
11171
11173 {
11175 {
11177 }
11179 {
11180 ErrorEx(
"Undefined liquid type quantity changed, please define liquid type first! Using init value.",
ErrorExSeverity.INFO);
11182 }
11183 }
11184
11185 }
11186
11189 {
11190
11191 }
11192
11195 {
11197 }
11198
11200 {
11201 super.EEHealthLevelChanged(oldLevel,newLevel,zone);
11202
11204 {
11205 if (newLevel == GameConstants.STATE_RUINED)
11206 {
11208 EntityAI parent = GetHierarchyParent();
11209 if (parent && parent.IsFireplace())
11210 {
11211 CargoBase cargo = GetInventory().GetCargo();
11212 if (cargo)
11213 {
11215 {
11217 }
11218 }
11219 }
11220 }
11221
11223 {
11224
11226 return;
11227 }
11228
11229 if (
m_Cleanness != 0 && oldLevel < newLevel && newLevel != 0)
11230 {
11232 }
11233 }
11234 }
11235
11236
11238 {
11239 super.OnRightClick();
11240
11242 {
11244 {
11245 if (ScriptInputUserData.CanStoreInputUserData())
11246 {
11247 EntityAI root = GetHierarchyRoot();
11248 Man playerOwner = GetHierarchyRootPlayer();
11249 InventoryLocation dst = new InventoryLocation;
11250
11251
11252 if (!playerOwner && root && root == this)
11253 {
11255 }
11256 else
11257 {
11258
11259 GetInventory().GetCurrentInventoryLocation(dst);
11261 {
11264 {
11266 }
11267 else
11268 {
11270
11271
11272 if (
GetGame().
GetPlayer().GetInventory().HasInventoryReservation(
this, dst))
11273 {
11275 }
11276 else
11277 {
11278 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(null, dst, GameInventory.c_InventoryReservationTimeoutShortMS);
11279 }
11280 }
11281 }
11282 }
11283
11284 ScriptInputUserData ctx = new ScriptInputUserData;
11292 }
11293 }
11294 else if (!
GetGame().IsMultiplayer())
11295 {
11297 }
11298 }
11299 }
11300
11302 {
11303 if (root)
11304 {
11305 vector m4[4];
11306 root.GetTransform(m4);
11307 dst.SetGround(this, m4);
11308 }
11309 else
11310 {
11311 GetInventory().GetCurrentInventoryLocation(dst);
11312 }
11313 }
11314
11315 override bool CanBeCombined(
EntityAI other_item,
bool reservation_check =
true,
bool stack_max_limit =
false)
11316 {
11317
11318 if (!other_item ||
GetType() != other_item.GetType() || (
IsFullQuantity() && other_item.GetQuantity() > 0) || other_item ==
this)
11319 return false;
11320
11321 if (GetHealthLevel() == GameConstants.STATE_RUINED || other_item.GetHealthLevel() == GameConstants.STATE_RUINED)
11322 return false;
11323
11324
11326 return false;
11327
11328
11329 Magazine mag = Magazine.Cast(this);
11330 if (mag)
11331 {
11332 if (mag.GetAmmoCount() >= mag.GetAmmoMax())
11333 return false;
11334
11335 if (stack_max_limit)
11336 {
11337 Magazine other_mag = Magazine.Cast(other_item);
11338 if (other_item)
11339 {
11340 if (mag.GetAmmoCount() + other_mag.GetAmmoCount() > mag.GetAmmoMax())
11341 return false;
11342 }
11343
11344 }
11345 }
11346 else
11347 {
11348
11350 return false;
11351
11353 return false;
11354 }
11355
11356 PlayerBase player = null;
11357 if (CastTo(player, GetHierarchyRootPlayer()))
11358 {
11359 if (player.GetInventory().HasAttachment(this))
11360 return false;
11361
11362 if (player.IsItemsToDelete())
11363 return false;
11364 }
11365
11366 if (reservation_check && (GetInventory().HasInventoryReservation(this, null) || other_item.GetInventory().HasInventoryReservation(other_item, null)))
11367 return false;
11368
11369 int slotID;
11371 if (GetInventory().GetCurrentAttachmentSlotInfo(slotID,
slotName) && GetHierarchyParent().GetInventory().GetSlotLock(slotID))
11372 return false;
11373
11374 return true;
11375 }
11376
11378 {
11380 }
11381
11383 {
11384 return m_IsResultOfSplit;
11385 }
11386
11388 {
11389 m_IsResultOfSplit = value;
11390 }
11391
11393 {
11395 }
11396
11398 {
11399 float other_item_quantity = other_item.GetQuantity();
11400 float this_free_space;
11401
11403
11405
11406 if (other_item_quantity > this_free_space)
11407 {
11408 return this_free_space;
11409 }
11410 else
11411 {
11412 return other_item_quantity;
11413 }
11414 }
11415
11417 {
11419 }
11420
11422 {
11424 return;
11425
11426 if (!IsMagazine() && other_item)
11427 {
11429 if (quantity_used != 0)
11430 {
11431 float hp1 = GetHealth01("","");
11432 float hp2 = other_item.GetHealth01("","");
11433 float hpResult = ((hp1*
GetQuantity()) + (hp2*quantity_used));
11434 hpResult = hpResult / (
GetQuantity() + quantity_used);
11435
11436 hpResult *= GetMaxHealth();
11437 Math.Round(hpResult);
11438 SetHealth("", "Health", hpResult);
11439
11441 other_item.AddQuantity(-quantity_used);
11442 }
11443 }
11445 }
11446
11448 {
11449 #ifdef SERVER
11450 if (!GetHierarchyRootPlayer() && GetHierarchyParent())
11451 GetHierarchyParent().IncreaseLifetimeUp();
11452 #endif
11453 };
11454
11456 {
11457 PlayerBase p = PlayerBase.Cast(player);
11458
11459 array<int> recipesIds = p.m_Recipes;
11460 PluginRecipesManager moduleRecipesManager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
11461 if (moduleRecipesManager)
11462 {
11463 EntityAI itemInHands = player.GetHumanInventory().GetEntityInHands();
11464 moduleRecipesManager.GetValidRecipes(
ItemBase.Cast(
this),
ItemBase.Cast(itemInHands), recipesIds, p);
11465 }
11466
11467 for (int i = 0;i < recipesIds.Count(); i++)
11468 {
11469 int key = recipesIds.Get(i);
11470 string recipeName = moduleRecipesManager.GetRecipeName(key);
11472 }
11473 }
11474
11475
11476 override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
11477 {
11478 super.GetDebugActions(outputList);
11479
11480
11486
11487
11492
11497
11498
11502
11503
11505 {
11509 }
11510
11513
11514
11518
11520
11521 InventoryLocation loc = new InventoryLocation();
11522 GetInventory().GetCurrentInventoryLocation(loc);
11524 {
11525 if (Gizmo_IsSupported())
11528 }
11529
11531 }
11532
11533
11534
11535
11537 {
11538 super.OnAction(action_id, player, ctx);
11539
11541 {
11542 switch (action_id)
11543 {
11546 return true;
11549 return true;
11550 }
11551 }
11552
11554 {
11555 switch (action_id)
11556 {
11558 Delete();
11559 return true;
11560 }
11561 }
11562
11563 if (action_id >=
EActions.RECIPES_RANGE_START && action_id <
EActions.RECIPES_RANGE_END)
11564 {
11565 PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
11566 int idWithoutOffset = action_id -
EActions.RECIPES_RANGE_START;
11567 PlayerBase p = PlayerBase.Cast(player);
11568 if (
EActions.RECIPES_RANGE_START < 1000)
11569 {
11570 float anim_length = plugin_recipes_manager.GetRecipeLengthInSecs(idWithoutOffset);
11571 float specialty_weight = plugin_recipes_manager.GetRecipeSpecialty(idWithoutOffset);
11572 }
11573 }
11574 #ifndef SERVER
11575 else if (action_id ==
EActions.WATCH_PLAYER)
11576 {
11577 PluginDeveloper.SetDeveloperItemClientEx(player);
11578 }
11579 #endif
11581 {
11582 if (action_id >=
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START && action_id <
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_END)
11583 {
11584 int id = action_id -
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START;
11585 OnDebugButtonPressServer(id + 1);
11586 }
11587
11588 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_INJECT_START && action_id <
EActions.DEBUG_AGENTS_RANGE_INJECT_END)
11589 {
11590 int agent_id = action_id -
EActions.DEBUG_AGENTS_RANGE_INJECT_START;
11592 }
11593
11594 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_REMOVE_START && action_id <
EActions.DEBUG_AGENTS_RANGE_REMOVE_END)
11595 {
11596 int agent_id2 = action_id -
EActions.DEBUG_AGENTS_RANGE_REMOVE_START;
11598 }
11599
11600 else if (action_id ==
EActions.ADD_QUANTITY)
11601 {
11602 if (IsMagazine())
11603 {
11604 Magazine mag = Magazine.Cast(this);
11605 mag.ServerSetAmmoCount(mag.GetAmmoCount() + mag.GetAmmoMax() * 0.2);
11606 }
11607 else
11608 {
11610 }
11611
11612 if (m_EM)
11613 {
11614 m_EM.AddEnergy(m_EM.GetEnergyMax() * 0.2);
11615 }
11616
11617 }
11618
11619 else if (action_id ==
EActions.REMOVE_QUANTITY)
11620 {
11621 if (IsMagazine())
11622 {
11623 Magazine mag2 = Magazine.Cast(this);
11624 mag2.ServerSetAmmoCount(mag2.GetAmmoCount() - mag2.GetAmmoMax() * 0.2);
11625 }
11626 else
11627 {
11629 }
11630 if (m_EM)
11631 {
11632 m_EM.AddEnergy(- m_EM.GetEnergyMax() * 0.2);
11633 }
11634
11635 }
11636
11637 else if (action_id ==
EActions.SET_QUANTITY_0)
11638 {
11640
11641 if (m_EM)
11642 {
11643 m_EM.SetEnergy(0);
11644 }
11645 }
11646
11647 else if (action_id ==
EActions.SET_MAX_QUANTITY)
11648 {
11650
11651 if (m_EM)
11652 {
11653 m_EM.SetEnergy(m_EM.GetEnergyMax());
11654 }
11655 }
11656
11657 else if (action_id ==
EActions.ADD_HEALTH)
11658 {
11659 AddHealth("","",GetMaxHealth("","Health")/5);
11660 }
11661 else if (action_id ==
EActions.REMOVE_HEALTH)
11662 {
11663 AddHealth("","",-GetMaxHealth("","Health")/5);
11664 }
11665 else if (action_id ==
EActions.DESTROY_HEALTH)
11666 {
11667 SetHealth01("","",0);
11668 }
11669 else if (action_id ==
EActions.WATCH_ITEM)
11670 {
11672 mid.RegisterDebugItem(
ItemBase.Cast(
this), PlayerBase.Cast(player));
11673 #ifdef DEVELOPER
11674 SetDebugDeveloper_item(this);
11675 #endif
11676 }
11677
11678 else if (action_id ==
EActions.ADD_TEMPERATURE)
11679 {
11680 AddTemperature(20);
11681
11682 }
11683
11684 else if (action_id ==
EActions.REMOVE_TEMPERATURE)
11685 {
11686 AddTemperature(-20);
11687
11688 }
11689
11690 else if (action_id ==
EActions.FLIP_FROZEN)
11691 {
11692 SetFrozen(!GetIsFrozen());
11693
11694 }
11695
11696 else if (action_id ==
EActions.ADD_WETNESS)
11697 {
11699
11700 }
11701
11702 else if (action_id ==
EActions.REMOVE_WETNESS)
11703 {
11705
11706 }
11707
11708 else if (action_id ==
EActions.LIQUIDTYPE_UP)
11709 {
11712
11713
11714 }
11715
11716 else if (action_id ==
EActions.LIQUIDTYPE_DOWN)
11717 {
11720 }
11721
11722 else if (action_id ==
EActions.MAKE_SPECIAL)
11723 {
11724 auto debugParams = DebugSpawnParams.WithPlayer(player);
11725 OnDebugSpawnEx(debugParams);
11726 }
11727
11728 }
11729
11730
11731 return false;
11732 }
11733
11734
11735
11736
11740
11743
11744
11745
11747 {
11748 return false;
11749 }
11750
11751
11753 {
11754 return true;
11755 }
11756
11757
11759 {
11760 return true;
11761 }
11762
11763
11764
11766 {
11767 string config_path =
string.Format(
"CfgVehicles %1 Food FoodStages",
GetType());
11769 }
11770
11773 {
11774 return null;
11775 }
11776
11778 {
11779 return false;
11780 }
11781
11783 {
11784 return false;
11785 }
11786
11790
11791
11793 {
11794 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
11795 return module_repairing.CanRepair(this, item_repair_kit);
11796 }
11797
11798
11799 bool Repair(PlayerBase player,
ItemBase item_repair_kit,
float specialty_weight)
11800 {
11801 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
11802 return module_repairing.Repair(player, this, item_repair_kit, specialty_weight);
11803 }
11804
11805
11807 {
11808
11809
11810
11811
11812
11813
11814
11815
11816 return 1;
11817 }
11818
11819
11820
11822 {
11824 }
11825
11826
11827
11829 {
11831 }
11832
11833
11842 {
11843 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
11844
11845 if (player)
11846 {
11847 player.MessageStatus(text);
11848 }
11849 }
11850
11851
11860 {
11861 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
11862
11863 if (player)
11864 {
11865 player.MessageAction(text);
11866 }
11867 }
11868
11869
11878 {
11879 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
11880
11881 if (player)
11882 {
11883 player.MessageFriendly(text);
11884 }
11885 }
11886
11887
11896 {
11897 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
11898
11899 if (player)
11900 {
11901 player.MessageImportant(text);
11902 }
11903 }
11904
11906 {
11907 return true;
11908 }
11909
11910
11911 override bool KindOf(
string tag)
11912 {
11913 bool found = false;
11914 string item_name = this.
GetType();
11917
11918 int array_size = item_tag_array.Count();
11919 for (int i = 0; i < array_size; i++)
11920 {
11921 if (item_tag_array.Get(i) == tag)
11922 {
11923 found = true;
11924 break;
11925 }
11926 }
11927 return found;
11928 }
11929
11930
11932 {
11933
11934 super.OnRPC(sender, rpc_type,ctx);
11935
11936
11937 switch (rpc_type)
11938 {
11939 #ifndef SERVER
11940 case ERPCs.RPC_SOUND_LOCK_ATTACH:
11941 Param2<bool, string> p = new Param2<bool, string>(false, "");
11942
11944 return;
11945
11946 bool play = p.param1;
11947 string soundSet = p.param2;
11948
11949 if (play)
11950 {
11952 {
11954 {
11956 }
11957 }
11958 else
11959 {
11961 }
11962 }
11963 else
11964 {
11966 }
11967
11968 break;
11969 #endif
11970
11971 }
11972
11974 {
11976 }
11977 }
11978
11979
11980
11981
11983 {
11984 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
11985 return plugin.GetID(
name);
11986 }
11987
11989 {
11990 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
11991 return plugin.GetName(id);
11992 }
11993
11996 {
11997
11998
11999 int varFlags;
12000 if (!ctx.
Read(varFlags))
12001 return;
12002
12003 if (varFlags & ItemVariableFlags.FLOAT)
12004 {
12006 }
12007 }
12008
12010 {
12011
12012 super.SerializeNumericalVars(floats_out);
12013
12014
12015
12017 {
12019 }
12020
12022 {
12024 }
12025
12027 {
12029 }
12030
12032 {
12037 }
12038
12040 {
12042 }
12043 }
12044
12046 {
12047
12048 super.DeSerializeNumericalVars(floats);
12049
12050
12051 int index = 0;
12052 int mask = Math.Round(floats.Get(index));
12053
12054 index++;
12055
12057 {
12059 {
12061 }
12062 else
12063 {
12064 float quantity = floats.Get(index);
12065 SetQuantity(quantity,
true,
false,
false,
false);
12066 }
12067 index++;
12068 }
12069
12071 {
12072 float wet = floats.Get(index);
12074 index++;
12075 }
12076
12078 {
12079 int liquidtype = Math.Round(floats.Get(index));
12081 index++;
12082 }
12083
12085 {
12087 index++;
12089 index++;
12091 index++;
12093 index++;
12094 }
12095
12097 {
12098 int cleanness = Math.Round(floats.Get(index));
12100 index++;
12101 }
12102 }
12103
12105 {
12106 super.WriteVarsToCTX(ctx);
12107
12108
12110 {
12112 }
12113
12115 {
12117 }
12118
12120 {
12122 }
12123
12125 {
12126 int r,g,b,a;
12132 }
12133
12135 {
12137 }
12138 }
12139
12141 {
12142 if (!super.ReadVarsFromCTX(ctx,version))
12143 return false;
12144
12145 int intValue;
12146 float value;
12147
12148 if (version < 140)
12149 {
12150 if (!ctx.
Read(intValue))
12151 return false;
12152
12153 m_VariablesMask = intValue;
12154 }
12155
12157 {
12158 if (!ctx.
Read(value))
12159 return false;
12160
12162 {
12164 }
12165 else
12166 {
12168 }
12169 }
12170
12171 if (version < 140)
12172 {
12174 {
12175 if (!ctx.
Read(value))
12176 return false;
12177 SetTemperatureDirect(value);
12178 }
12179 }
12180
12182 {
12183 if (!ctx.
Read(value))
12184 return false;
12186 }
12187
12189 {
12190 if (!ctx.
Read(intValue))
12191 return false;
12193 }
12194
12196 {
12197 int r,g,b,a;
12199 return false;
12201 return false;
12203 return false;
12205 return false;
12206
12208 }
12209
12211 {
12212 if (!ctx.
Read(intValue))
12213 return false;
12215 }
12216
12217 if (version >= 138 && version < 140)
12218 {
12220 {
12221 if (!ctx.
Read(intValue))
12222 return false;
12223 SetFrozen(intValue);
12224 }
12225 }
12226
12227 return true;
12228 }
12229
12230
12232 {
12235 {
12237 }
12238
12239 if (!super.OnStoreLoad(ctx, version))
12240 {
12242 return false;
12243 }
12244
12245 if (version >= 114)
12246 {
12247 bool hasQuickBarIndexSaved;
12248
12249 if (!ctx.
Read(hasQuickBarIndexSaved))
12250 {
12252 return false;
12253 }
12254
12255 if (hasQuickBarIndexSaved)
12256 {
12257 int itmQBIndex;
12258
12259
12260 if (!ctx.
Read(itmQBIndex))
12261 {
12263 return false;
12264 }
12265
12266 PlayerBase parentPlayer = PlayerBase.Cast(GetHierarchyRootPlayer());
12267 if (itmQBIndex != -1 && parentPlayer)
12268 parentPlayer.SetLoadedQuickBarItemBind(this, itmQBIndex);
12269 }
12270 }
12271 else
12272 {
12273
12274 PlayerBase player;
12275 int itemQBIndex;
12276 if (version ==
int.
MAX)
12277 {
12278 if (!ctx.
Read(itemQBIndex))
12279 {
12281 return false;
12282 }
12283 }
12284 else if (Class.CastTo(player, GetHierarchyRootPlayer()))
12285 {
12286
12287 if (!ctx.
Read(itemQBIndex))
12288 {
12290 return false;
12291 }
12292 if (itemQBIndex != -1 && player)
12293 player.SetLoadedQuickBarItemBind(this,itemQBIndex);
12294 }
12295 }
12296
12297 if (version < 140)
12298 {
12299
12300 if (!LoadVariables(ctx, version))
12301 {
12303 return false;
12304 }
12305 }
12306
12307
12309 {
12311 return false;
12312 }
12313 if (version >= 132)
12314 {
12316 if (raib)
12317 {
12319 {
12321 return false;
12322 }
12323 }
12324 }
12325
12327 return true;
12328 }
12329
12330
12331
12333 {
12334 super.OnStoreSave(ctx);
12335
12336 PlayerBase player;
12337 if (PlayerBase.CastTo(player,GetHierarchyRootPlayer()))
12338 {
12340
12341 int itemQBIndex = -1;
12342 itemQBIndex = player.FindQuickBarEntityIndex(this);
12343 ctx.
Write(itemQBIndex);
12344 }
12345 else
12346 {
12348 }
12349
12351
12353 if (raib)
12354 {
12356 }
12357 }
12358
12359
12361 {
12362 super.AfterStoreLoad();
12363
12365 {
12367 }
12368
12370 {
12373 }
12374 }
12375
12377 {
12378 super.EEOnAfterLoad();
12379
12381 {
12383 }
12384
12387 }
12388
12390 {
12391 return false;
12392 }
12393
12394
12395
12397 {
12399 {
12400 #ifdef PLATFORM_CONSOLE
12401
12403 {
12405 if (menu)
12406 {
12408 }
12409 }
12410 #endif
12411 }
12412
12414 {
12417 }
12418
12420 {
12421 SetWeightDirty();
12423 }
12425 {
12428 }
12429
12431 {
12434 }
12436 {
12439 }
12440
12441 super.OnVariablesSynchronized();
12442 }
12443
12444
12445
12447 override bool SetQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false,
bool allow_client =
false,
bool clamp_to_stack_max =
true)
12448 {
12449 if (!IsServerCheck(allow_client))
12450 return false;
12451
12453 return false;
12454
12457
12458 if (value <= (min + 0.001))
12459 value = min;
12460
12461 if (value == min)
12462 {
12463 if (destroy_config)
12464 {
12465 bool dstr = ConfigGetBool("varQuantityDestroyOnMin");
12466 if (dstr)
12467 {
12469 this.Delete();
12470 return true;
12471 }
12472 }
12473 else if (destroy_forced)
12474 {
12476 this.Delete();
12477 return true;
12478 }
12479
12481 }
12482
12485
12487 {
12489
12490 if (delta)
12492 }
12493
12495
12496 return false;
12497 }
12498
12499
12501 bool AddQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
12502 {
12504 }
12505
12507 {
12510 }
12511
12513 {
12516 }
12517
12519 override void SetQuantityNormalized(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
12520 {
12521 float value_clamped = Math.Clamp(value, 0, 1);
12523 SetQuantity(result, destroy_config, destroy_forced);
12524 }
12525
12526
12529 {
12531 }
12532
12534 {
12536 }
12537
12538
12539
12540
12541
12542
12543
12544
12545
12546
12548 {
12549 int slot = -1;
12550 if (GetInventory())
12551 {
12552 InventoryLocation il = new InventoryLocation;
12553 GetInventory().GetCurrentInventoryLocation(il);
12555 }
12556
12558 }
12559
12561 {
12562 float quantity_max = 0;
12563
12565 {
12566 if (attSlotID != -1)
12567 quantity_max = InventorySlots.GetStackMaxForSlotId(attSlotID);
12568
12569 if (quantity_max <= 0)
12571 }
12572
12573 if (quantity_max <= 0)
12575
12576 return quantity_max;
12577 }
12578
12580 {
12582 }
12583
12585 {
12587 }
12588
12589
12591 {
12593 }
12594
12596 {
12598 }
12599
12601 {
12603 }
12604
12605
12607 {
12608
12609 float weightEx = GetWeightEx();
12610 float special = GetInventoryAndCargoWeight();
12611 return weightEx - special;
12612 }
12613
12614
12616 {
12618 }
12619
12621 {
12623 {
12624 #ifdef DEVELOPER
12625 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
12626 {
12627 WeightDebugData data1 = WeightDebug.GetWeightDebug(this);
12629 }
12630 #endif
12631
12632 return GetQuantity() * GetConfigWeightModified();
12633 }
12634 else if (HasEnergyManager())
12635 {
12636 #ifdef DEVELOPER
12637 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
12638 {
12639 WeightDebugData data2 = WeightDebug.GetWeightDebug(this);
12640 data2.
SetCalcDetails(
"TIB2: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " + GetCompEM().
GetEnergy()+
"(energy) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit)");
12641 }
12642 #endif
12643 return super.GetWeightSpecialized(forceRecalc) + (GetCompEM().GetEnergy() * ConfigGetFloat("weightPerQuantityUnit")) + GetConfigWeightModified();
12644 }
12645 else
12646 {
12647 #ifdef DEVELOPER
12648 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
12649 {
12650 WeightDebugData data3 = WeightDebug.GetWeightDebug(this);
12651 data3.
SetCalcDetails(
"TIB3: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " +
GetQuantity()+
"(quantity) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit))");
12652 }
12653 #endif
12654 return super.GetWeightSpecialized(forceRecalc) + (
GetQuantity() * ConfigGetFloat(
"weightPerQuantityUnit")) + GetConfigWeightModified();
12655 }
12656 }
12657
12660 {
12661 int item_count = 0;
12663
12664 if (GetInventory().GetCargo() != NULL)
12665 {
12666 item_count = GetInventory().GetCargo().GetItemCount();
12667 }
12668
12669 for (int i = 0; i < GetInventory().AttachmentCount(); i++)
12670 {
12671 Class.CastTo(item,GetInventory().GetAttachmentFromIndex(i));
12672 if (item)
12673 item_count += item.GetNumberOfItems();
12674 }
12675 return item_count;
12676 }
12677
12680 {
12681 float weight = 0;
12682 float wetness = 1;
12683 if (include_wetness)
12686 {
12687 weight = wetness * m_ConfigWeight;
12688 }
12690 {
12691 weight = 1;
12692 }
12693 return weight;
12694 }
12695
12696
12697
12699 {
12700 if ((
GetGame().IsServer() || !
GetGame().IsMultiplayer()) && GetInventory())
12701 {
12702 GameInventory inv = GetInventory();
12703 array<EntityAI> items = new array<EntityAI>;
12705 for (int i = 0; i < items.Count(); i++)
12706 {
12708 if (item)
12709 {
12711 }
12712 }
12713 }
12714 }
12715
12716
12717
12718
12720 {
12721 float energy = 0;
12722 if (HasEnergyManager())
12723 {
12724 energy = GetCompEM().GetEnergy();
12725 }
12726 return energy;
12727 }
12728
12729
12731 {
12732 super.OnEnergyConsumed();
12733
12735 }
12736
12738 {
12739 super.OnEnergyAdded();
12740
12742 }
12743
12744
12746 {
12747 if (
GetGame().IsServer() && HasEnergyManager() && GetCompEM().HasConversionOfEnergyToQuantity())
12748 {
12750 {
12751 float energy_0to1 = GetCompEM().GetEnergy0To1();
12753 }
12754 }
12755 }
12756
12757
12759 {
12760 return ConfigGetFloat("heatIsolation");
12761 }
12762
12764 {
12766 }
12767
12769 {
12770 string paramPath =
string.Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Drying %2",
GetType(), pIncrementName);
12771 if (
GetGame().ConfigIsExisting(paramPath))
12773
12774 return 0.0;
12775 }
12776
12778 {
12779 string paramPath =
string.
Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Soaking %2",
GetType(), pIncrementName);
12780 if (
GetGame().ConfigIsExisting(paramPath))
12782
12783 return 0.0;
12784 }
12785
12786 override void SetWet(
float value,
bool allow_client =
false)
12787 {
12788 if (!IsServerCheck(allow_client))
12789 return;
12790
12793
12795
12796 m_VarWet = Math.Clamp(value, min, max);
12797
12799 {
12802 }
12803 }
12804
12805 override void AddWet(
float value)
12806 {
12808 }
12809
12811 {
12813 }
12814
12816 {
12818 }
12819
12821 {
12823 }
12824
12826 {
12828 }
12829
12831 {
12833 }
12834
12835 override void OnWetChanged(
float newVal,
float oldVal)
12836 {
12839 if (newLevel != oldLevel)
12840 {
12842 }
12843 }
12844
12846 {
12847 SetWeightDirty();
12848 }
12849
12851 {
12852 return GetWetLevelInternal(
m_VarWet);
12853 }
12854
12855
12856
12858 {
12860 }
12861
12863 {
12865 }
12866
12868 {
12870 }
12871
12873 {
12875 }
12876
12877
12878
12880 {
12881 if (ConfigIsExisting("itemModelLength"))
12882 {
12883 return ConfigGetFloat("itemModelLength");
12884 }
12885 return 0;
12886 }
12887
12889 {
12890 if (ConfigIsExisting("itemAttachOffset"))
12891 {
12892 return ConfigGetFloat("itemAttachOffset");
12893 }
12894 return 0;
12895 }
12896
12897 override void SetCleanness(
int value,
bool allow_client =
false)
12898 {
12899 if (!IsServerCheck(allow_client))
12900 return;
12901
12903
12905
12908 }
12909
12911 {
12913 }
12914
12916 {
12917 return true;
12918 }
12919
12920
12921
12922
12924 {
12926 }
12927
12929 {
12931 }
12932
12933
12934
12935
12936 override void SetColor(
int r,
int g,
int b,
int a)
12937 {
12943 }
12945 override void GetColor(out
int r,out
int g,out
int b,out
int a)
12946 {
12951 }
12952
12954 {
12956 }
12957
12960 {
12961 int r,g,b,a;
12963 r = r/255;
12964 g = g/255;
12965 b = b/255;
12966 a = a/255;
12967 return MiscGameplayFunctions.GetColorString(r, g, b, a);
12968 }
12969
12970
12971
12972 override void SetLiquidType(
int value,
bool allow_client =
false)
12973 {
12974 if (!IsServerCheck(allow_client))
12975 return;
12976
12981 }
12982
12984 {
12985 return ConfigGetInt("varLiquidTypeInit");
12986 }
12987
12989 {
12991 }
12992
12994 {
12996 SetFrozen(false);
12997 }
12998
13001 {
13002 player.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
13003 }
13004
13005
13008 {
13009 PlayerBase nplayer;
13010 if (PlayerBase.CastTo(nplayer, player))
13011 {
13013
13014 nplayer.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
13015 }
13016 }
13017
13018
13021 {
13022 PlayerBase nplayer;
13023 if (PlayerBase.CastTo(nplayer,player))
13024 {
13025
13026 nplayer.SetEnableQuickBarEntityShortcut(this,false);
13027
13028 }
13029
13030
13031 player.GetHumanInventory().ClearUserReservedLocationForContainer(this);
13032
13033
13034 if (HasEnergyManager())
13035 {
13036 GetCompEM().UpdatePlugState();
13037 }
13038 }
13039
13040
13042 {
13043 super.OnPlacementStarted(player);
13044
13046 }
13047
13048 override void OnPlacementComplete(Man player, vector position =
"0 0 0", vector orientation =
"0 0 0")
13049 {
13051 {
13052 m_AdminLog.OnPlacementComplete(player,
this);
13053 }
13054
13055 super.OnPlacementComplete(player, position, orientation);
13056 }
13057
13058
13059
13060
13061
13063 {
13065 {
13066 return true;
13067 }
13068 else
13069 {
13070 return false;
13071 }
13072 }
13073
13074
13076 {
13078 {
13080 }
13081 }
13082
13083
13085 {
13087 }
13088
13090 {
13092 }
13093
13094 override void InsertAgent(
int agent,
float count = 1)
13095 {
13096 if (count < 1)
13097 return;
13098
13100 }
13101
13104 {
13106 }
13107
13108
13110 {
13112 }
13113
13114
13115
13116
13117
13118
13119
13120
13121
13122
13123
13124
13125
13126
13127
13128
13129
13130
13131
13132
13133
13134
13135
13136
13137
13138
13139
13140
13141
13142
13143
13144
13145
13146
13147
13148
13149
13150
13151
13152
13153
13154
13156 {
13158 return false;
13159 return true;
13160 }
13161
13163 {
13164
13166 }
13167
13168
13171 {
13172 super.CheckForRoofLimited(timeTresholdMS);
13173
13175 if ((time - m_PreviousRoofTestTime) >= timeTresholdMS)
13176 {
13177 m_PreviousRoofTestTime = time;
13178 SetRoofAbove(MiscGameplayFunctions.IsUnderRoof(this));
13179 }
13180 }
13181
13182
13184 {
13186 {
13187 return 0;
13188 }
13189
13190 if (GetInventory().GetAttachmentSlotsCount() != 0)
13191 {
13192 ItemBase filter =
ItemBase.Cast(FindAttachmentBySlotName(
"GasMaskFilter"));
13193 if (filter)
13194 return filter.GetProtectionLevel(type, false, system);
13195 else
13196 return 0;
13197 }
13198
13199 string subclassPath, entryName;
13200
13201 switch (type)
13202 {
13204 entryName = "biological";
13205 break;
13207 entryName = "chemical";
13208 break;
13209 default:
13210 entryName = "biological";
13211 break;
13212 }
13213
13214 subclassPath =
"CfgVehicles " + this.
GetType() +
" Protection ";
13215
13217 }
13218
13219
13220
13223 {
13224 if (!IsMagazine())
13226
13228 }
13229
13230
13231
13232
13233
13238 {
13239 return true;
13240 }
13241
13243 {
13245 }
13246
13247
13248
13249
13250
13252 {
13253 if (parent)
13254 {
13255 if (parent.IsInherited(DayZInfected))
13256 return true;
13257
13258 if (!parent.IsRuined())
13259 return true;
13260 }
13261
13262 return true;
13263 }
13264
13266 {
13267 if (!super.CanPutAsAttachment(parent))
13268 {
13269 return false;
13270 }
13271
13272 if (!IsRuined() && !parent.IsRuined())
13273 {
13274 return true;
13275 }
13276
13277 return false;
13278 }
13279
13281 {
13282
13283
13284
13285
13286 return super.CanReceiveItemIntoCargo(item);
13287 }
13288
13290 {
13291
13292
13293
13294
13295 GameInventory attachmentInv = attachment.GetInventory();
13297 {
13298 if (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase))
13299 return false;
13300 }
13301
13302 InventoryLocation loc = new InventoryLocation();
13303 attachment.GetInventory().GetCurrentInventoryLocation(loc);
13304 if (loc && loc.
IsValid() && !GetInventory().AreChildrenAccessible())
13305 return false;
13306
13307 return super.CanReceiveAttachment(attachment, slotId);
13308 }
13309
13311 {
13312 if (!super.CanReleaseAttachment(attachment))
13313 return false;
13314
13315 return GetInventory().AreChildrenAccessible();
13316 }
13317
13318
13319
13320
13321
13322
13323
13324
13325
13326
13327
13328
13329
13330
13331
13332
13333
13334
13335
13336
13337
13339 {
13340 int id = muzzle_owner.GetMuzzleID();
13341 array<ref WeaponParticlesOnFire> WPOF_array =
m_OnFireEffect.Get(
id);
13342
13343 if (WPOF_array)
13344 {
13345 for (int i = 0; i < WPOF_array.Count(); i++)
13346 {
13347 WeaponParticlesOnFire WPOF = WPOF_array.Get(i);
13348
13349 if (WPOF)
13350 {
13351 WPOF.OnActivate(weapon, muzzle_index, ammoType, muzzle_owner, suppressor, config_to_search);
13352 }
13353 }
13354 }
13355 }
13356
13357
13359 {
13360 int id = muzzle_owner.GetMuzzleID();
13362
13363 if (WPOBE_array)
13364 {
13365 for (int i = 0; i < WPOBE_array.Count(); i++)
13366 {
13367 WeaponParticlesOnBulletCasingEject WPOBE = WPOBE_array.Get(i);
13368
13369 if (WPOBE)
13370 {
13371 WPOBE.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
13372 }
13373 }
13374 }
13375 }
13376
13377
13379 {
13380 int id = muzzle_owner.GetMuzzleID();
13381 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
13382
13383 if (WPOOH_array)
13384 {
13385 for (int i = 0; i < WPOOH_array.Count(); i++)
13386 {
13387 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
13388
13389 if (WPOOH)
13390 {
13391 WPOOH.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
13392 }
13393 }
13394 }
13395 }
13396
13397
13399 {
13400 int id = muzzle_owner.GetMuzzleID();
13401 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
13402
13403 if (WPOOH_array)
13404 {
13405 for (int i = 0; i < WPOOH_array.Count(); i++)
13406 {
13407 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
13408
13409 if (WPOOH)
13410 {
13411 WPOOH.OnUpdate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
13412 }
13413 }
13414 }
13415 }
13416
13417
13419 {
13420 int id = muzzle_owner.GetMuzzleID();
13421 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
13422
13423 if (WPOOH_array)
13424 {
13425 for (int i = 0; i < WPOOH_array.Count(); i++)
13426 {
13427 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
13428
13429 if (WPOOH)
13430 {
13431 WPOOH.OnDeactivate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
13432 }
13433 }
13434 }
13435 }
13436
13437
13438
13440 {
13442 {
13443 return true;
13444 }
13445
13446 return false;
13447 }
13448
13450 {
13452 {
13453 return true;
13454 }
13455
13456 return false;
13457 }
13458
13460 {
13462 {
13463 return true;
13464 }
13465
13466 return false;
13467 }
13468
13470 {
13471 return false;
13472 }
13473
13476 {
13477 return UATimeSpent.DEFAULT_DEPLOY;
13478 }
13479
13480
13481
13482
13484 {
13486 SetSynchDirty();
13487 }
13488
13490 {
13492 }
13493
13494
13496 {
13497 return false;
13498 }
13499
13502 {
13503 string att_type = "None";
13504
13505 if (ConfigIsExisting("soundAttType"))
13506 {
13507 att_type = ConfigGetString("soundAttType");
13508 }
13509
13511 }
13512
13514 {
13516 }
13517
13518
13519
13520
13521
13527
13529 {
13532
13534 }
13535
13536
13538 {
13540 return;
13541
13543
13546
13549
13550 SoundParameters params = new SoundParameters();
13554 }
13555
13556
13558 {
13560 return;
13561
13563 SetSynchDirty();
13564
13567 }
13568
13569
13571 {
13573 return;
13574
13576 SetSynchDirty();
13577
13580 }
13581
13583 {
13585 }
13586
13588 {
13590 }
13591
13594 {
13595 if (!
GetGame().IsDedicatedServer())
13596 {
13597 if (ConfigIsExisting("attachSoundSet"))
13598 {
13599 string cfg_path = "";
13600 string soundset = "";
13601 string type_name =
GetType();
13602
13605 ConfigGetTextArray("attachSoundSet",cfg_soundset_array);
13606 ConfigGetTextArray("attachSoundSlot",cfg_slot_array);
13607
13608 if (cfg_soundset_array.Count() > 0 && cfg_soundset_array.Count() == cfg_slot_array.Count())
13609 {
13610 for (int i = 0; i < cfg_soundset_array.Count(); i++)
13611 {
13612 if (cfg_slot_array[i] == slot_type)
13613 {
13614 soundset = cfg_soundset_array[i];
13615 break;
13616 }
13617 }
13618 }
13619
13620 if (soundset != "")
13621 {
13622 EffectSound sound = SEffectManager.PlaySound(soundset,
GetPosition());
13624 }
13625 }
13626 }
13627 }
13628
13630 {
13631
13632 }
13633
13634 void OnApply(PlayerBase player);
13635
13637 {
13638 return 1.0;
13639 };
13640
13642 {
13644 }
13645
13647 {
13649 }
13650
13652
13654 {
13655 SetDynamicPhysicsLifeTime(0.01);
13657 }
13658
13660 {
13661 array<string> zone_names = new array<string>;
13662 GetDamageZones(zone_names);
13663 for (int i = 0; i < zone_names.Count(); i++)
13664 {
13665 SetHealthMax(zone_names.Get(i),"Health");
13666 }
13667 SetHealthMax("","Health");
13668 }
13669
13672 {
13673 float global_health = GetHealth01("","Health");
13674 array<string> zones = new array<string>;
13675 GetDamageZones(zones);
13676
13677 for (int i = 0; i < zones.Count(); i++)
13678 {
13679 SetHealth01(zones.Get(i),"Health",global_health);
13680 }
13681 }
13682
13685 {
13686 return IsExclusionFlagPresent(PlayerBase.GetFaceCoverageShaveValues());
13687 }
13688
13690 {
13691 if (!hasRootAsPlayer)
13692 {
13693 if (refParentIB)
13694 {
13695
13696 if ((refParentIB.GetWet() >= GameConstants.STATE_SOAKING_WET) && (
m_VarWet <
m_VarWetMax))
13697 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_INSIDE);
13698
13699 else if ((refParentIB.GetLiquidType() != 0) && (refParentIB.GetQuantity() > 0) && (
m_VarWet <
m_VarWetMax))
13700 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_LIQUID);
13701
13704 }
13705 else
13706 {
13707
13710 }
13711 }
13712 }
13713
13715 {
13717 {
13718 float target =
g_Game.GetMission().GetWorldData().GetBaseEnvTemperatureAtObject(
this);
13719 if (
GetTemperature() != target || !IsFreezeThawProgressFinished())
13720 {
13721 float heatPermCoef = 1.0;
13723 while (ent)
13724 {
13725 heatPermCoef *= ent.GetHeatPermeabilityCoef();
13726 ent = ent.GetHierarchyParent();
13727 }
13728
13729 SetTemperatureEx(
new TemperatureDataInterpolated(target,
ETemperatureAccessTypes.ACCESS_WORLD,delta,GameConstants.TEMP_COEF_WORLD,heatPermCoef));
13730 }
13731 }
13732 }
13733
13735 {
13736
13737 EntityAI parent = GetHierarchyParent();
13738 if (!parent)
13739 {
13740 hasParent = false;
13741 hasRootAsPlayer = false;
13742 }
13743 else
13744 {
13745 hasParent = true;
13746 hasRootAsPlayer = (GetHierarchyRootPlayer() != null);
13747 refParentIB =
ItemBase.Cast(parent);
13748 }
13749 }
13750
13751 protected void ProcessDecay(
float delta,
bool hasRootAsPlayer)
13752 {
13753
13754 }
13755
13757 {
13758
13759 return false;
13760 }
13761
13763 {
13764
13765
13766 return false;
13767 }
13768
13770 {
13771
13772 return false;
13773 }
13774
13777 {
13778 return !GetIsFrozen() &&
IsOpen();
13779 }
13780
13782 {
13783 bool hasParent = false, hasRootAsPlayer = false;
13785
13786 bool wwtu =
g_Game.IsWorldWetTempUpdateEnabled();
13787 bool foodDecay =
g_Game.IsFoodDecayEnabled();
13788
13789 if (wwtu || foodDecay)
13790 {
13794
13795 if (processWetness || processTemperature || processDecay)
13796 {
13798
13799 if (processWetness)
13800 ProcessItemWetness(m_ElapsedSinceLastUpdate, hasParent, hasRootAsPlayer, refParentIB);
13801
13802 if (processTemperature)
13804
13805 if (processDecay)
13806 ProcessDecay(m_ElapsedSinceLastUpdate, hasRootAsPlayer);
13807 }
13808 }
13809 }
13810
13813 {
13815 }
13816
13818 {
13821
13822 return super.GetTemperatureFreezeThreshold();
13823 }
13824
13826 {
13829
13830 return super.GetTemperatureThawThreshold();
13831 }
13832
13834 {
13837
13838 return super.GetItemOverheatThreshold();
13839 }
13840
13842 {
13844 return Math.Lerp(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureFreezeTime()),
GetQuantityNormalized());
13845
13846 return super.GetTemperatureFreezeTime();
13847 }
13848
13850 {
13852 return Math.Lerp(GameConstants.TEMPERATURE_TIME_THAW_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureThawTime()),
GetQuantityNormalized());
13853
13854 return super.GetTemperatureThawTime();
13855 }
13856
13861
13863 {
13864 return (item.IsKindOf("Cauldron") || item.IsKindOf("Pot") || item.IsKindOf("FryingPan") || item.IsKindOf("SmallProtectorCase") || (item.IsKindOf("PortableGasStove") && item.FindAttachmentBySlotName("CookingEquipment")));
13865 }
13866
13868 {
13869 MiscGameplayFunctions.TransferItemProperties(oldItem, this);
13870 }
13871
13874 {
13876 }
13877
13879 {
13881 }
13882
13884 {
13886 }
13887
13890 {
13891 return null;
13892 }
13893
13896 {
13897 return false;
13898 }
13899
13901 {
13903 {
13906 if (!trg)
13907 {
13909 explosive = this;
13910 }
13911
13912 explosive.PairRemote(trg);
13914
13915 int persistentID = RemotelyActivatedItemBehaviour.GeneratePersistentID();
13916 trg.SetPersistentPairID(persistentID);
13917 explosive.SetPersistentPairID(persistentID);
13918
13919 return true;
13920 }
13921 return false;
13922 }
13923
13926 {
13927 float ret = 1.0;
13930 ret *= GetHealth01();
13931
13932 return ret;
13933 }
13934
13935 #ifdef DEVELOPER
13936 override void SetDebugItem()
13937 {
13938 super.SetDebugItem();
13939 _itemBase = this;
13940 }
13941
13943 {
13944 string text = super.GetDebugText();
13945
13947 text +=
string.
Format(
"Heat isolation(modified): %1\n", MiscGameplayFunctions.GetCurrentItemHeatIsolation(
this));
13948
13949 return text;
13950 }
13951 #endif
13952
13954 {
13955 return true;
13956 }
13957
13959
13961
13963 {
13966 }
13967
13968
13976
13992}
13993
13995{
13997 if (entity)
13998 {
13999 bool is_item = entity.IsInherited(
ItemBase);
14000 if (is_item && full_quantity)
14001 {
14004 }
14005 }
14006 else
14007 {
14009 return NULL;
14010 }
14011 return entity;
14012}
14013
14015{
14016 if (item)
14017 {
14018 if (health > 0)
14019 item.SetHealth("", "", health);
14020
14021 if (item.CanHaveTemperature())
14022 {
14024 if (item.CanFreeze())
14025 item.SetFrozen(false);
14026 }
14027
14028 if (item.HasEnergyManager())
14029 {
14030 if (quantity >= 0)
14031 {
14032 item.GetCompEM().SetEnergy0To1(quantity);
14033 }
14034 else
14035 {
14037 }
14038 }
14039 else if (item.IsMagazine())
14040 {
14041 Magazine mag = Magazine.Cast(item);
14042 if (quantity >= 0)
14043 {
14044 mag.ServerSetAmmoCount(mag.GetAmmoMax() * quantity);
14045 }
14046 else
14047 {
14049 }
14050
14051 }
14052 else
14053 {
14054 if (quantity >= 0)
14055 {
14056 item.SetQuantityNormalized(quantity, false);
14057 }
14058 else
14059 {
14061 }
14062
14063 }
14064 }
14065}
14066
14067#ifdef DEVELOPER
14069#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.