Plays sound on item attach. Be advised, the config structure may slightly change in 1.11 update to allow for more complex use.
9298{
9300 {
9301 return true;
9302 }
9303};
9304
9305
9306
9308{
9312
9314
9317
9318
9319
9320
9321
9330
9336
9341
9346
9367 protected bool m_IsResultOfSplit
9368
9370
9375
9376
9377
9379
9383
9384
9385
9387
9390
9391
9392
9398
9399
9407
9410
9411
9413
9414
9416
9417
9422
9423
9428
9429
9431
9432
9434 {
9439
9440 if (!
GetGame().IsDedicatedServer())
9441 {
9443 {
9445
9447 {
9449 }
9450 }
9451
9454 }
9455
9456 m_OldLocation = null;
9457
9459 {
9461 }
9462
9463 if (ConfigIsExisting("headSelectionsToHide"))
9464 {
9467 }
9468
9470 if (ConfigIsExisting("hideSelectionsByinventorySlot"))
9471 {
9473 }
9474
9476
9477 m_IsResultOfSplit = false;
9478
9480 }
9481
9483 {
9484 super.InitItemVariables();
9485
9491 m_Count = ConfigGetInt(
"count");
9492
9495
9500
9503
9508
9520
9524
9525
9528 if (ConfigIsExisting("canBeSplit"))
9529 {
9532 }
9533
9535 if (ConfigIsExisting("itemBehaviour"))
9537
9538
9541 RegisterNetSyncVariableInt("m_VarLiquidType");
9542 RegisterNetSyncVariableInt("m_Cleanness",0,1);
9543
9544 RegisterNetSyncVariableBoolSignal("m_WantPlayImpactSound");
9545 RegisterNetSyncVariableFloat("m_ImpactSpeed");
9546 RegisterNetSyncVariableInt("m_ImpactSoundSurfaceHash");
9547
9548 RegisterNetSyncVariableInt("m_ColorComponentR", 0, 255);
9549 RegisterNetSyncVariableInt("m_ColorComponentG", 0, 255);
9550 RegisterNetSyncVariableInt("m_ColorComponentB", 0, 255);
9551 RegisterNetSyncVariableInt("m_ColorComponentA", 0, 255);
9552
9553 RegisterNetSyncVariableBool("m_IsBeingPlaced");
9554 RegisterNetSyncVariableBool("m_IsTakeable");
9555 RegisterNetSyncVariableBool("m_IsHologram");
9556
9559 {
9562 }
9563
9565
9567 if (ConfigIsExisting("temperaturePerQuantityWeight"))
9569
9570 }
9571
9573 {
9575 }
9576
9578 {
9581 {
9586 }
9587 }
9588
9589 override void GetActions(
typename action_input_type, out array<ActionBase_Basic> actions)
9590 {
9592 {
9595 }
9596
9598 }
9599
9601 {
9607 }
9608
9610
9612 {
9614
9615 if (!action)
9616 {
9617 Debug.LogError(
"Action " + actionName +
" dosn't exist!");
9618 return;
9619 }
9620
9622 if (!ai)
9623 {
9625 return;
9626 }
9627
9629 if (!action_array)
9630 {
9631 action_array = new array<ActionBase_Basic>;
9633 }
9634 if (LogManager.IsActionLogEnable())
9635 {
9636 Debug.ActionLog(action.ToString() +
" -> " + ai,
this.ToString() ,
"n/a",
"Add action");
9637 }
9638
9639 if (action_array.Find(action) != -1)
9640 {
9641 Debug.Log(
"Action " + action.Type() +
" already added to " +
this +
", skipping!");
9642 }
9643 else
9644 {
9645 action_array.Insert(action);
9646 }
9647 }
9648
9650 {
9652 ActionBase action = player.GetActionManager().GetAction(actionName);
9655
9656 if (action_array)
9657 {
9658 action_array.RemoveItem(action);
9659 }
9660 }
9661
9662
9663
9665 {
9666 ActionOverrideData overrideData = new ActionOverrideData();
9670
9672 if (!actionMap)
9673 {
9676 }
9677
9678 actionMap.Insert(this.
Type(), overrideData);
9679
9680 }
9681
9683
9685
9686
9688 {
9691
9694
9695 string config_to_search = "CfgVehicles";
9696 string muzzle_owner_config;
9697
9699 {
9700 if (IsInherited(Weapon))
9701 config_to_search = "CfgWeapons";
9702
9703 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
9704
9705 string config_OnFire_class = muzzle_owner_config + "Particles " + "OnFire ";
9706
9708
9709 if (config_OnFire_subclass_count > 0)
9710 {
9711 array<ref WeaponParticlesOnFire> WPOF_array = new array<ref WeaponParticlesOnFire>;
9712
9713 for (int i = 0; i < config_OnFire_subclass_count; i++)
9714 {
9715 string particle_class = "";
9717 string config_OnFire_entry = config_OnFire_class + particle_class;
9718 WeaponParticlesOnFire WPOF = new WeaponParticlesOnFire(this, config_OnFire_entry);
9719 WPOF_array.Insert(WPOF);
9720 }
9721
9722
9724 }
9725 }
9726
9728 {
9729 config_to_search = "CfgWeapons";
9730 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
9731
9732 string config_OnBulletCasingEject_class = muzzle_owner_config + "Particles " + "OnBulletCasingEject ";
9733
9735
9736 if (config_OnBulletCasingEject_count > 0 && IsInherited(Weapon))
9737 {
9738 array<ref WeaponParticlesOnBulletCasingEject> WPOBE_array = new array<ref WeaponParticlesOnBulletCasingEject>;
9739
9740 for (i = 0; i < config_OnBulletCasingEject_count; i++)
9741 {
9742 string particle_class2 = "";
9744 string config_OnBulletCasingEject_entry = config_OnBulletCasingEject_class + particle_class2;
9745 WeaponParticlesOnBulletCasingEject WPOBE = new WeaponParticlesOnBulletCasingEject(this, config_OnBulletCasingEject_entry);
9746 WPOBE_array.Insert(WPOBE);
9747 }
9748
9749
9751 }
9752 }
9753 }
9754
9755
9757 {
9760
9762 {
9763 string config_to_search = "CfgVehicles";
9764
9765 if (IsInherited(Weapon))
9766 config_to_search = "CfgWeapons";
9767
9768 string muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
9769 string config_OnOverheating_class = muzzle_owner_config + "Particles " + "OnOverheating ";
9770
9771 if (
GetGame().ConfigIsExisting(config_OnOverheating_class))
9772 {
9773
9775
9777 {
9779 string error =
"Error reading config " +
GetType() +
">Particles>OnOverheating - Parameter shotsToStartOverheating is configured wrong or is missing! Its value must be 1 or higher!";
9781 return;
9782 }
9783
9786
9787
9788
9790 array<ref WeaponParticlesOnOverheating> WPOOH_array = new array<ref WeaponParticlesOnOverheating>;
9791
9792 for (int i = 0; i < config_OnOverheating_subclass_count; i++)
9793 {
9794 string particle_class = "";
9796 string config_OnOverheating_entry = config_OnOverheating_class + particle_class;
9798
9799 if (entry_type == CT_CLASS)
9800 {
9801 WeaponParticlesOnOverheating WPOF = new WeaponParticlesOnOverheating(this, config_OnOverheating_entry);
9802 WPOOH_array.Insert(WPOF);
9803 }
9804 }
9805
9806
9808 }
9809 }
9810 }
9811
9813 {
9815 }
9816
9818 {
9820 {
9822
9825
9828
9829 CheckOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9830 }
9831 }
9832
9834 {
9836 UpdateOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9837
9839 StartOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9840
9842 StopOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9843
9845 {
9847 }
9848 }
9849
9851 {
9853 }
9854
9856 {
9859 else
9861
9863 {
9866 }
9867 else
9868 {
9871
9874 }
9875
9877 }
9878
9880 {
9882 ItemBase.PlayOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
9883 }
9884
9886 {
9888 ItemBase.UpdateOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
9890 }
9891
9893 {
9895 ItemBase.StopOverheatingParticles(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9896 }
9897
9899 {
9902
9903 OverheatingParticle OP = new OverheatingParticle();
9908
9910 }
9911
9913 {
9916
9917 return -1;
9918 }
9919
9921 {
9923 {
9926
9927 for (int i = count; i > 0; --i)
9928 {
9929 int id = i - 1;
9932
9935
9936 if (overheat_coef < overheat_min && overheat_coef >= overheat_max)
9937 {
9938 if (p)
9939 {
9942 }
9943 }
9944 }
9945 }
9946 }
9947
9949 {
9951 {
9953 {
9954 int id = i - 1;
9956
9957 if (OP)
9958 {
9960
9961 if (p)
9962 {
9964 }
9965
9966 delete OP;
9967 }
9968 }
9969
9972 }
9973 }
9974
9977 {
9978 return 0.0;
9979 }
9980
9981
9983 {
9984 return 250;
9985 }
9986
9988 {
9989 return 0;
9990 }
9991
9994 {
9996 return true;
9997
9998 return false;
9999 }
10000
10003 {
10006
10008 {
10010 }
10011 else
10012 {
10013
10015 }
10016
10018 }
10019
10026 {
10027 return -1;
10028 }
10029
10030
10031
10032
10034 {
10036 {
10038 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
10039
10040 if (r_index >= 0)
10041 {
10042 InventoryLocation r_il = new InventoryLocation;
10043 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
10044
10045 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
10048 {
10049 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
10050 }
10052 {
10053 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
10054 }
10055
10056 }
10057
10058 player.GetHumanInventory().ClearUserReservedLocation(this);
10059 }
10060
10063 }
10064
10065
10066
10067
10069 {
10070 return ItemBase.m_DebugActionsMask;
10071 }
10072
10074 {
10075 return ItemBase.m_DebugActionsMask & mask;
10076 }
10077
10079 {
10080 ItemBase.m_DebugActionsMask = mask;
10081 }
10082
10084 {
10085 ItemBase.m_DebugActionsMask |= mask;
10086 }
10087
10089 {
10090 ItemBase.m_DebugActionsMask &= ~mask;
10091 }
10092
10094 {
10096 {
10098 }
10099 else
10100 {
10102 }
10103 }
10104
10105
10107 {
10108 if (GetEconomyProfile())
10109 {
10110 float q_max = GetEconomyProfile().GetQuantityMax();
10111 if (q_max > 0)
10112 {
10113 float q_min = GetEconomyProfile().GetQuantityMin();
10114 float quantity_randomized = Math.RandomFloatInclusive(q_min, q_max);
10115
10117 {
10118 ComponentEnergyManager comp = GetCompEM();
10120 {
10122 }
10123 }
10125 {
10127
10128 }
10129
10130 }
10131 }
10132 }
10133
10136 {
10137 EntityAI parent = GetHierarchyParent();
10138
10139 if (parent)
10140 {
10141 InventoryLocation inventory_location_to_lock = new InventoryLocation;
10142 GetInventory().GetCurrentInventoryLocation(inventory_location_to_lock);
10143 parent.GetInventory().SetSlotLock(inventory_location_to_lock.
GetSlot(),
true);
10144 }
10145 }
10146
10149 {
10150 EntityAI parent = GetHierarchyParent();
10151
10152 if (parent)
10153 {
10154 InventoryLocation inventory_location_to_unlock = new InventoryLocation;
10155 GetInventory().GetCurrentInventoryLocation(inventory_location_to_unlock);
10156 parent.GetInventory().SetSlotLock(inventory_location_to_unlock.
GetSlot(),
false);
10157 }
10158 }
10159
10161 {
10162
10163
10164
10165
10167
10169 {
10170 if (ScriptInputUserData.CanStoreInputUserData())
10171 {
10172 ScriptInputUserData ctx = new ScriptInputUserData;
10178 ctx.
Write(use_stack_max);
10181
10183 {
10184 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(item2,null,GameInventory.c_InventoryReservationTimeoutShortMS);
10185 }
10186 }
10187 }
10188 else if (!
GetGame().IsMultiplayer())
10189 {
10191 }
10192 }
10193
10195 {
10197 }
10198
10200 {
10202 }
10203
10205 {
10207 }
10208
10210 {
10211
10212 return false;
10213 }
10214
10216 {
10217 return false;
10218 }
10219
10223 {
10224 return false;
10225 }
10226
10228 {
10229 return "";
10230 }
10231
10233
10235 {
10236 return false;
10237 }
10238
10240 {
10241 return true;
10242 }
10243
10244
10245
10247 {
10248 return true;
10249 }
10250
10252 {
10253 return true;
10254 }
10255
10257 {
10258 PlayerBase player = PlayerBase.Cast(
g_Game.GetPlayer());
10260 }
10261
10263 {
10265 }
10266
10268 {
10270 if (!is_being_placed)
10272 SetSynchDirty();
10273 }
10274
10275
10277
10279 {
10281 }
10282
10284 {
10286 }
10287
10289 {
10290 return 1;
10291 }
10292
10294 {
10295 return false;
10296 }
10297
10299 {
10301 SetSynchDirty();
10302 }
10303
10304
10305
10306
10307
10308
10309
10310
10311
10312
10313
10314
10315
10316
10317
10318
10319
10320
10321
10322
10323
10324
10325
10326
10327
10328
10329
10330
10331
10332
10333
10334
10335
10336
10337
10339 {
10340 super.OnMovedInsideCargo(container);
10341
10342 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
10343 }
10344
10345 override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
10346 {
10347 super.EEItemLocationChanged(oldLoc,newLoc);
10348
10349 PlayerBase new_player = null;
10350 PlayerBase old_player = null;
10351
10352 if (newLoc.GetParent())
10353 new_player = PlayerBase.Cast(newLoc.GetParent().GetHierarchyRootPlayer());
10354
10355 if (oldLoc.GetParent())
10356 old_player = PlayerBase.Cast(oldLoc.GetParent().GetHierarchyRootPlayer());
10357
10359 {
10360 int r_index = old_player.GetHumanInventory().FindUserReservedLocationIndex(this);
10361
10362 if (r_index >= 0)
10363 {
10364 InventoryLocation r_il = new InventoryLocation;
10365 old_player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
10366
10367 old_player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
10370 {
10371 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
10372 }
10374 {
10375 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
10376 }
10377
10378 }
10379 }
10380
10382 {
10383 if (new_player)
10384 new_player.ForceStandUpForHeavyItems(newLoc.GetItem());
10385
10386 if (new_player == old_player)
10387 {
10388
10389 if (oldLoc.GetParent() && new_player.GetHumanInventory().LocationGetEntity(oldLoc) == NULL)
10390 {
10392 {
10393 if (oldLoc.GetParent().GetInventory().TestAddEntityInCargoExLoc(oldLoc, false, false, false, true, false, false))
10394 {
10395 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
10396 }
10397 }
10398 else
10399 {
10400 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
10401 }
10402 }
10403
10404 if (new_player.GetHumanInventory().FindUserReservedLocationIndex(this) >= 0)
10405 {
10406 int type = oldLoc.GetType();
10408 {
10409 oldLoc.GetParent().GetOnSetLock().Invoke(this);
10410 }
10412 {
10413 oldLoc.GetParent().GetOnAttachmentSetLock().Invoke(this, oldLoc.GetSlot());
10414 }
10415 }
10416 if (!m_OldLocation)
10417 {
10418 m_OldLocation = new InventoryLocation;
10419 }
10420 m_OldLocation.Copy(oldLoc);
10421 }
10422 else
10423 {
10424 if (m_OldLocation)
10425 {
10426 m_OldLocation.Reset();
10427 }
10428 }
10429
10431 }
10432 else
10433 {
10434 if (new_player)
10435 {
10436 int res_index = new_player.GetHumanInventory().FindCollidingUserReservedLocationIndex(this, newLoc);
10437 if (res_index >= 0)
10438 {
10439 InventoryLocation il = new InventoryLocation;
10440 new_player.GetHumanInventory().GetUserReservedLocation(res_index,il);
10442 new_player.GetHumanInventory().ClearUserReservedLocationAtIndex(res_index);
10445 {
10446 il.
GetParent().GetOnReleaseLock().Invoke(it);
10447 }
10449 {
10451 }
10452
10453 }
10454 }
10456 {
10457
10459 }
10460
10461 if (m_OldLocation)
10462 {
10463 m_OldLocation.Reset();
10464 }
10465 }
10466 }
10467
10468 override void EOnContact(IEntity other, Contact extra)
10469 {
10471 {
10472 int liquidType = -1;
10474 if (impactSpeed > 0.0)
10475 {
10477 #ifndef SERVER
10479 #else
10481 SetSynchDirty();
10482 #endif
10484 }
10485 }
10486
10487 #ifdef SERVER
10488 if (GetCompEM() && GetCompEM().IsPlugged())
10489 {
10490 if (GetCompEM().GetCordLength() < vector.Distance(
GetPosition(), GetCompEM().GetEnergySource().
GetPosition()))
10491 GetCompEM().UnplugThis();
10492 }
10493 #endif
10494 }
10495
10497
10499 {
10501 }
10502
10504 {
10505
10506 }
10507
10509 {
10510 super.OnItemLocationChanged(old_owner, new_owner);
10511
10512 PlayerBase relatedPlayer = PlayerBase.Cast(old_owner);
10513 PlayerBase playerNew = PlayerBase.Cast(new_owner);
10514
10515 if (!relatedPlayer && playerNew)
10516 relatedPlayer = playerNew;
10517
10518 if (relatedPlayer && relatedPlayer.GetPerformedActionID() != -1)
10519 {
10521 if (actionMgr)
10522 {
10523 ActionBase currentAction = actionMgr.GetRunningAction();
10524 if (currentAction)
10526 }
10527 }
10528
10529 Man ownerPlayerOld = null;
10530 Man ownerPlayerNew = null;
10531
10532 if (old_owner)
10533 {
10534 if (old_owner.
IsMan())
10535 {
10536 ownerPlayerOld = Man.Cast(old_owner);
10537 }
10538 else
10539 {
10540 ownerPlayerOld = Man.Cast(old_owner.GetHierarchyRootPlayer());
10541 }
10542 }
10543 else
10544 {
10546 {
10548
10549 if (!action || !playerNew || playerNew.GetPerformedActionID() != action.
GetID())
10550 {
10551 GetCompEM().UnplugThis();
10552 }
10553 }
10554 }
10555
10556 if (new_owner)
10557 {
10558 if (new_owner.
IsMan())
10559 {
10560 ownerPlayerNew = Man.Cast(new_owner);
10561 }
10562 else
10563 {
10564 ownerPlayerNew = Man.Cast(new_owner.GetHierarchyRootPlayer());
10565 }
10566 }
10567
10568 if (ownerPlayerOld != ownerPlayerNew)
10569 {
10570 if (ownerPlayerOld)
10571 {
10572 array<EntityAI> subItemsExit = new array<EntityAI>;
10574 for (int i = 0; i < subItemsExit.Count(); i++)
10575 {
10578 }
10579 }
10580
10581 if (ownerPlayerNew)
10582 {
10583 array<EntityAI> subItemsEnter = new array<EntityAI>;
10585 for (int j = 0; j < subItemsEnter.Count(); j++)
10586 {
10589 }
10590 }
10591 }
10592 else if (ownerPlayerNew != null)
10593 {
10594 PlayerBase nplayer;
10595 if (PlayerBase.CastTo(nplayer, ownerPlayerNew))
10596 {
10597 array<EntityAI> subItemsUpdate = new array<EntityAI>;
10599 for (int k = 0; k < subItemsUpdate.Count(); k++)
10600 {
10602 itemUpdate.UpdateQuickbarShortcutVisibility(nplayer);
10603 }
10604 }
10605 }
10606
10607 if (old_owner)
10608 old_owner.OnChildItemRemoved(this);
10609 if (new_owner)
10610 new_owner.OnChildItemReceived(this);
10611 }
10612
10613
10615 {
10616 super.EEDelete(parent);
10617 PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
10618 if (player)
10619 {
10621
10622 if (player.IsAlive())
10623 {
10624 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
10625 if (r_index >= 0)
10626 {
10627 InventoryLocation r_il = new InventoryLocation;
10628 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
10629
10630 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
10633 {
10634 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
10635 }
10637 {
10638 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
10639 }
10640
10641 }
10642
10643 player.RemoveQuickBarEntityShortcut(this);
10644 }
10645 }
10646 }
10647
10649 {
10650 super.EEKilled(killer);
10651
10654 {
10655 if (
GetTemperature() >= GameConstants.ITEM_TEMPERATURE_TO_EXPLODE_MIN)
10656 {
10657 if (IsMagazine())
10658 {
10659 if (Magazine.Cast(this).GetAmmoCount() > 0)
10660 {
10662 }
10663 }
10664 else
10665 {
10667 }
10668 }
10669 }
10670 }
10671
10673 {
10674 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
10675
10676 super.OnWasAttached(parent, slot_id);
10677
10680
10682 }
10683
10685 {
10686 super.OnWasDetached(parent, slot_id);
10687
10690 }
10691
10693 {
10694 int idx;
10697
10698 ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
10699 if (inventory_slots.Count() < 1)
10700 {
10701 inventory_slots.Insert(ConfigGetString("ChangeInventorySlot"));
10702 attach_types.Insert(ConfigGetString("ChangeIntoOnAttach"));
10703 }
10704 else
10705 {
10706 ConfigGetTextArray("ChangeIntoOnAttach",attach_types);
10707 }
10708
10709 idx = inventory_slots.Find(slot);
10710 if (idx < 0)
10711 return "";
10712
10713 return attach_types.Get(idx);
10714 }
10715
10717 {
10718 int idx = -1;
10719 string slot;
10720
10723
10724 this.ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
10725 if (inventory_slots.Count() < 1)
10726 {
10727 inventory_slots.Insert(this.ConfigGetString("ChangeInventorySlot"));
10728 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
10729 }
10730 else
10731 {
10732 this.ConfigGetTextArray("ChangeIntoOnDetach",detach_types);
10733 if (detach_types.Count() < 1)
10734 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
10735 }
10736
10737 for (int i = 0; i < inventory_slots.Count(); i++)
10738 {
10739 slot = inventory_slots.Get(i);
10740 }
10741
10742 if (slot != "")
10743 {
10744 if (detach_types.Count() == 1)
10745 idx = 0;
10746 else
10747 idx = inventory_slots.Find(slot);
10748 }
10749 if (idx < 0)
10750 return "";
10751
10752 return detach_types.Get(idx);
10753 }
10754
10756 {
10757
10759
10760
10761 float min_time = 1;
10762 float max_time = 3;
10763 float delay = Math.RandomFloat(min_time, max_time);
10764
10765 explode_timer.Run(delay, this, "DoAmmoExplosion");
10766 }
10767
10769 {
10770 Magazine magazine = Magazine.Cast(this);
10771 int pop_sounds_count = 6;
10772 string pop_sounds[ 6 ] = { "ammopops_1","ammopops_2","ammopops_3","ammopops_4","ammopops_5","ammopops_6" };
10773
10774
10775 int sound_idx = Math.RandomInt(0, pop_sounds_count - 1);
10776 string sound_name = pop_sounds[ sound_idx ];
10778
10779
10780 magazine.ServerAddAmmoCount(-1);
10781
10782
10783 float min_temp_to_explode = 100;
10784
10785 if (magazine.GetAmmoCount() > 0 &&
GetTemperature() >= min_temp_to_explode)
10786 {
10788 }
10789 }
10790
10791
10792 override void EEHitBy(TotalDamageResult damageResult,
int damageType,
EntityAI source,
int component,
string dmgZone,
string ammo, vector modelPos,
float speedCoef)
10793 {
10794 super.EEHitBy(damageResult, damageType, source,
component, dmgZone, ammo, modelPos, speedCoef);
10795
10796 const int CHANCE_DAMAGE_CARGO = 4;
10797 const int CHANCE_DAMAGE_ATTACHMENT = 1;
10798 const int CHANCE_DAMAGE_NOTHING = 2;
10799
10801 {
10802 float dmg = damageResult.
GetDamage(
"",
"Health") * -0.5;
10803 int chances;
10804 int rnd;
10805
10806 if (GetInventory().GetCargo())
10807 {
10808 chances = CHANCE_DAMAGE_CARGO + CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
10809 rnd = Math.RandomInt(0,chances);
10810
10811 if (rnd < CHANCE_DAMAGE_CARGO)
10812 {
10814 }
10815 else if (rnd < (chances - CHANCE_DAMAGE_NOTHING))
10816 {
10818 }
10819 }
10820 else
10821 {
10822 chances = CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
10823 rnd = Math.RandomInt(0,chances);
10824
10825 if (rnd < CHANCE_DAMAGE_ATTACHMENT)
10826 {
10828 }
10829 }
10830 }
10831 }
10832
10834 {
10835 if (GetInventory().GetCargo())
10836 {
10837 int item_count = GetInventory().GetCargo().GetItemCount();
10838 if (item_count > 0)
10839 {
10840 int random_pick = Math.RandomInt(0, item_count);
10842 if (!item.IsExplosive())
10843 {
10844 item.AddHealth("","",damage);
10845 return true;
10846 }
10847 }
10848 }
10849 return false;
10850 }
10851
10853 {
10854 int attachment_count = GetInventory().AttachmentCount();
10855 if (attachment_count > 0)
10856 {
10857 int random_pick = Math.RandomInt(0, attachment_count);
10858 ItemBase attachment =
ItemBase.Cast(GetInventory().GetAttachmentFromIndex(random_pick));
10859 if (!attachment.IsExplosive())
10860 {
10861 attachment.AddHealth("","",damage);
10862 return true;
10863 }
10864 }
10865 return false;
10866 }
10867
10869 {
10871 }
10872
10874 {
10876 return GetInventory().CanRemoveEntity();
10877
10878 return false;
10879 }
10880
10882 {
10883
10885 return false;
10886
10887
10889 return false;
10890
10891
10892
10894 if (delta == 0)
10895 return false;
10896
10897
10898 return true;
10899 }
10900
10902 {
10904 {
10905 if (ScriptInputUserData.CanStoreInputUserData())
10906 {
10907 ScriptInputUserData ctx = new ScriptInputUserData;
10912 ctx.
Write(destination_entity);
10914 ctx.
Write(slot_id);
10916 }
10917 }
10918 else if (!
GetGame().IsMultiplayer())
10919 {
10921 }
10922 }
10923
10925 {
10926 float split_quantity_new;
10930 InventoryLocation loc = new InventoryLocation;
10931
10932 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
10933 {
10935 split_quantity_new = stack_max;
10936 else
10938
10940 {
10941 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
10942 if (new_item)
10943 {
10944 new_item.SetResultOfSplit(true);
10945 MiscGameplayFunctions.TransferItemProperties(this, new_item);
10947 new_item.
SetQuantity(split_quantity_new,
false,
true);
10948 }
10949 }
10950 }
10951 else if (destination_entity && slot_id == -1)
10952 {
10953 if (quantity > stack_max)
10954 split_quantity_new = stack_max;
10955 else
10956 split_quantity_new = quantity;
10957
10959 {
10961 {
10964 }
10965
10966 if (new_item)
10967 {
10968 new_item.SetResultOfSplit(true);
10969 MiscGameplayFunctions.TransferItemProperties(this, new_item);
10971 new_item.
SetQuantity(split_quantity_new,
false,
true);
10972 }
10973 }
10974 }
10975 else
10976 {
10977 if (stack_max != 0)
10978 {
10980 {
10982 }
10983
10984 if (split_quantity_new == 0)
10985 {
10986 if (!
GetGame().IsMultiplayer())
10987 player.PhysicalPredictiveDropItem(this);
10988 else
10989 player.ServerDropEntity(this);
10990 return;
10991 }
10992
10994 {
10996
10997 if (new_item)
10998 {
10999 new_item.SetResultOfSplit(true);
11000 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11003 new_item.PlaceOnSurface();
11004 }
11005 }
11006 }
11007 }
11008 }
11009
11011 {
11012 float split_quantity_new;
11016 InventoryLocation loc = new InventoryLocation;
11017
11018 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
11019 {
11021 split_quantity_new = stack_max;
11022 else
11024
11026 {
11027 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
11028 if (new_item)
11029 {
11030 new_item.SetResultOfSplit(true);
11031 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11033 new_item.
SetQuantity(split_quantity_new,
false,
true);
11034 }
11035 }
11036 }
11037 else if (destination_entity && slot_id == -1)
11038 {
11039 if (quantity > stack_max)
11040 split_quantity_new = stack_max;
11041 else
11042 split_quantity_new = quantity;
11043
11045 {
11047 {
11050 }
11051
11052 if (new_item)
11053 {
11054 new_item.SetResultOfSplit(true);
11055 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11057 new_item.
SetQuantity(split_quantity_new,
false,
true);
11058 }
11059 }
11060 }
11061 else
11062 {
11063 if (stack_max != 0)
11064 {
11066 {
11068 }
11069
11071 {
11073
11074 if (new_item)
11075 {
11076 new_item.SetResultOfSplit(true);
11077 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11080 new_item.PlaceOnSurface();
11081 }
11082 }
11083 }
11084 }
11085 }
11086
11088 {
11090 {
11091 if (ScriptInputUserData.CanStoreInputUserData())
11092 {
11093 ScriptInputUserData ctx = new ScriptInputUserData;
11098 dst.WriteToContext(ctx);
11100 }
11101 }
11102 else if (!
GetGame().IsMultiplayer())
11103 {
11105 }
11106 }
11107
11109 {
11111 {
11112 if (ScriptInputUserData.CanStoreInputUserData())
11113 {
11114 ScriptInputUserData ctx = new ScriptInputUserData;
11119 ctx.
Write(destination_entity);
11125 }
11126 }
11127 else if (!
GetGame().IsMultiplayer())
11128 {
11130 }
11131 }
11132
11134 {
11136 }
11137
11139 {
11141 float split_quantity_new;
11143 if (dst.IsValid())
11144 {
11145 int slot_id = dst.GetSlot();
11147
11148 if (quantity > stack_max)
11149 split_quantity_new = stack_max;
11150 else
11151 split_quantity_new = quantity;
11152
11154 {
11156
11157 if (new_item)
11158 {
11159 new_item.SetResultOfSplit(true);
11160 MiscGameplayFunctions.TransferItemProperties(this,new_item);
11162 new_item.
SetQuantity(split_quantity_new,
false,
true);
11163 }
11164
11165 return new_item;
11166 }
11167 }
11168
11169 return null;
11170 }
11171
11173 {
11175 float split_quantity_new;
11177 if (destination_entity)
11178 {
11180 if (quantity > stackable)
11181 split_quantity_new = stackable;
11182 else
11183 split_quantity_new = quantity;
11184
11186 {
11187 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateEntityInCargoEx(
this.GetType(), idx, row, col,
false));
11188 if (new_item)
11189 {
11190 new_item.SetResultOfSplit(true);
11191 MiscGameplayFunctions.TransferItemProperties(this,new_item);
11193 new_item.
SetQuantity(split_quantity_new,
false,
true);
11194 }
11195 }
11196 }
11197 }
11198
11200 {
11202 {
11203 if (ScriptInputUserData.CanStoreInputUserData())
11204 {
11205 ScriptInputUserData ctx = new ScriptInputUserData;
11210 ItemBase destination_entity =
this;
11211 ctx.
Write(destination_entity);
11215 }
11216 }
11217 else if (!
GetGame().IsMultiplayer())
11218 {
11220 }
11221 }
11222
11224 {
11226 float split_quantity_new;
11228 if (player)
11229 {
11231 if (quantity > stackable)
11232 split_quantity_new = stackable;
11233 else
11234 split_quantity_new = quantity;
11235
11237 {
11238 EntityAI in_hands = player.GetHumanInventory().CreateInHands(this.
GetType());
11239 new_item =
ItemBase.Cast(in_hands);
11240 if (new_item)
11241 {
11242 new_item.SetResultOfSplit(true);
11243 MiscGameplayFunctions.TransferItemProperties(this,new_item);
11245 new_item.SetQuantity(split_quantity_new, false, true);
11246 }
11247 }
11248 }
11249 }
11250
11252 {
11254 float split_quantity_new = Math.Floor(quantity * 0.5);
11255
11257 return;
11258
11260
11261 if (new_item)
11262 {
11263 if (new_item.GetQuantityMax() < split_quantity_new)
11264 {
11265 split_quantity_new = new_item.GetQuantityMax();
11266 }
11267
11268 new_item.SetResultOfSplit(true);
11269 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11270
11272 {
11275 }
11276 else
11277 {
11279 new_item.
SetQuantity(split_quantity_new,
false,
true);
11280 }
11281 }
11282 }
11283
11285 {
11287 float split_quantity_new = Math.Floor(quantity / 2);
11288
11290 return;
11291
11292 InventoryLocation invloc = new InventoryLocation;
11294
11296 new_item = player.CreateCopyOfItemInInventoryOrGroundEx(this, true);
11297
11298 if (new_item)
11299 {
11300 if (new_item.GetQuantityMax() < split_quantity_new)
11301 {
11302 split_quantity_new = new_item.GetQuantityMax();
11303 }
11305 {
11308 }
11309 else if (split_quantity_new > 1)
11310 {
11312 new_item.
SetQuantity(split_quantity_new,
false,
true);
11313 }
11314 }
11315 }
11316
11319 {
11320 SetWeightDirty();
11322
11323 if (parent)
11324 parent.OnAttachmentQuantityChangedEx(this, delta);
11325
11327 {
11329 {
11331 }
11333 {
11334 ErrorEx(
"Undefined liquid type quantity changed, please define liquid type first! Using init value.",
ErrorExSeverity.INFO);
11336 }
11337 }
11338
11339 }
11340
11343 {
11344
11345 }
11346
11349 {
11351 }
11352
11354 {
11355 super.EEHealthLevelChanged(oldLevel,newLevel,zone);
11356
11358 {
11359 if (newLevel == GameConstants.STATE_RUINED)
11360 {
11362 EntityAI parent = GetHierarchyParent();
11363 if (parent && parent.IsFireplace())
11364 {
11365 CargoBase cargo = GetInventory().GetCargo();
11366 if (cargo)
11367 {
11369 {
11371 }
11372 }
11373 }
11374 }
11375
11377 {
11378
11380 return;
11381 }
11382
11383 if (
m_Cleanness != 0 && oldLevel < newLevel && newLevel != 0)
11384 {
11386 }
11387 }
11388 }
11389
11390
11392 {
11393 super.OnRightClick();
11394
11396 {
11398 {
11399 if (ScriptInputUserData.CanStoreInputUserData())
11400 {
11401 EntityAI root = GetHierarchyRoot();
11402 Man playerOwner = GetHierarchyRootPlayer();
11403 InventoryLocation dst = new InventoryLocation;
11404
11405
11406 if (!playerOwner && root && root == this)
11407 {
11409 }
11410 else
11411 {
11412
11413 GetInventory().GetCurrentInventoryLocation(dst);
11415 {
11418 {
11420 }
11421 else
11422 {
11424
11425
11426 if (
GetGame().
GetPlayer().GetInventory().HasInventoryReservation(
this, dst))
11427 {
11429 }
11430 else
11431 {
11432 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(null, dst, GameInventory.c_InventoryReservationTimeoutShortMS);
11433 }
11434 }
11435 }
11436 }
11437
11438 ScriptInputUserData ctx = new ScriptInputUserData;
11446 }
11447 }
11448 else if (!
GetGame().IsMultiplayer())
11449 {
11451 }
11452 }
11453 }
11454
11456 {
11457 if (root)
11458 {
11459 vector m4[4];
11460 root.GetTransform(m4);
11461 dst.SetGround(this, m4);
11462 }
11463 else
11464 {
11465 GetInventory().GetCurrentInventoryLocation(dst);
11466 }
11467 }
11468
11469 override bool CanBeCombined(
EntityAI other_item,
bool reservation_check =
true,
bool stack_max_limit =
false)
11470 {
11471
11472 if (!other_item ||
GetType() != other_item.GetType() || (
IsFullQuantity() && other_item.GetQuantity() > 0) || other_item ==
this)
11473 return false;
11474
11475 if (GetHealthLevel() == GameConstants.STATE_RUINED || other_item.GetHealthLevel() == GameConstants.STATE_RUINED)
11476 return false;
11477
11478
11480 return false;
11481
11482
11483 Magazine mag = Magazine.Cast(this);
11484 if (mag)
11485 {
11486 if (mag.GetAmmoCount() >= mag.GetAmmoMax())
11487 return false;
11488
11489 if (stack_max_limit)
11490 {
11491 Magazine other_mag = Magazine.Cast(other_item);
11492 if (other_item)
11493 {
11494 if (mag.GetAmmoCount() + other_mag.GetAmmoCount() > mag.GetAmmoMax())
11495 return false;
11496 }
11497
11498 }
11499 }
11500 else
11501 {
11502
11504 return false;
11505
11507 return false;
11508 }
11509
11510 PlayerBase player = null;
11511 if (CastTo(player, GetHierarchyRootPlayer()))
11512 {
11513 if (player.GetInventory().HasAttachment(this))
11514 return false;
11515
11516 if (player.IsItemsToDelete())
11517 return false;
11518 }
11519
11520 if (reservation_check && (GetInventory().HasInventoryReservation(this, null) || other_item.GetInventory().HasInventoryReservation(other_item, null)))
11521 return false;
11522
11523 int slotID;
11525 if (GetInventory().GetCurrentAttachmentSlotInfo(slotID,
slotName) && GetHierarchyParent().GetInventory().GetSlotLock(slotID))
11526 return false;
11527
11528 return true;
11529 }
11530
11532 {
11534 }
11535
11537 {
11538 return m_IsResultOfSplit;
11539 }
11540
11542 {
11543 m_IsResultOfSplit = value;
11544 }
11545
11547 {
11549 }
11550
11552 {
11553 float other_item_quantity = other_item.GetQuantity();
11554 float this_free_space;
11555
11557
11559
11560 if (other_item_quantity > this_free_space)
11561 {
11562 return this_free_space;
11563 }
11564 else
11565 {
11566 return other_item_quantity;
11567 }
11568 }
11569
11571 {
11573 }
11574
11576 {
11578 return;
11579
11580 if (!IsMagazine() && other_item)
11581 {
11583 if (quantity_used != 0)
11584 {
11585 float hp1 = GetHealth01("","");
11586 float hp2 = other_item.GetHealth01("","");
11587 float hpResult = ((hp1*
GetQuantity()) + (hp2*quantity_used));
11588 hpResult = hpResult / (
GetQuantity() + quantity_used);
11589
11590 hpResult *= GetMaxHealth();
11591 Math.Round(hpResult);
11592 SetHealth("", "Health", hpResult);
11593
11595 other_item.AddQuantity(-quantity_used);
11596 }
11597 }
11599 }
11600
11602 {
11603 #ifdef SERVER
11604 if (!GetHierarchyRootPlayer() && GetHierarchyParent())
11605 GetHierarchyParent().IncreaseLifetimeUp();
11606 #endif
11607 };
11608
11610 {
11611 PlayerBase p = PlayerBase.Cast(player);
11612
11613 array<int> recipesIds = p.m_Recipes;
11614 PluginRecipesManager moduleRecipesManager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
11615 if (moduleRecipesManager)
11616 {
11617 EntityAI itemInHands = player.GetHumanInventory().GetEntityInHands();
11618 moduleRecipesManager.GetValidRecipes(
ItemBase.Cast(
this),
ItemBase.Cast(itemInHands), recipesIds, p);
11619 }
11620
11621 for (int i = 0;i < recipesIds.Count(); i++)
11622 {
11623 int key = recipesIds.Get(i);
11624 string recipeName = moduleRecipesManager.GetRecipeName(key);
11626 }
11627 }
11628
11629
11630 override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
11631 {
11632 super.GetDebugActions(outputList);
11633
11634
11640
11641
11646
11651
11652
11656
11657
11659 {
11663 }
11664
11667
11668
11672
11674
11675 InventoryLocation loc = new InventoryLocation();
11676 GetInventory().GetCurrentInventoryLocation(loc);
11678 {
11679 if (Gizmo_IsSupported())
11682 }
11683
11685 }
11686
11687
11688
11689
11691 {
11692 super.OnAction(action_id, player, ctx);
11693
11695 {
11696 switch (action_id)
11697 {
11700 return true;
11703 return true;
11704 }
11705 }
11706
11708 {
11709 switch (action_id)
11710 {
11712 Delete();
11713 return true;
11714 }
11715 }
11716
11717 if (action_id >=
EActions.RECIPES_RANGE_START && action_id <
EActions.RECIPES_RANGE_END)
11718 {
11719 PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
11720 int idWithoutOffset = action_id -
EActions.RECIPES_RANGE_START;
11721 PlayerBase p = PlayerBase.Cast(player);
11722 if (
EActions.RECIPES_RANGE_START < 1000)
11723 {
11724 float anim_length = plugin_recipes_manager.GetRecipeLengthInSecs(idWithoutOffset);
11725 float specialty_weight = plugin_recipes_manager.GetRecipeSpecialty(idWithoutOffset);
11726 }
11727 }
11728 #ifndef SERVER
11729 else if (action_id ==
EActions.WATCH_PLAYER)
11730 {
11731 PluginDeveloper.SetDeveloperItemClientEx(player);
11732 }
11733 #endif
11735 {
11736 if (action_id >=
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START && action_id <
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_END)
11737 {
11738 int id = action_id -
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START;
11739 OnDebugButtonPressServer(id + 1);
11740 }
11741
11742 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_INJECT_START && action_id <
EActions.DEBUG_AGENTS_RANGE_INJECT_END)
11743 {
11744 int agent_id = action_id -
EActions.DEBUG_AGENTS_RANGE_INJECT_START;
11746 }
11747
11748 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_REMOVE_START && action_id <
EActions.DEBUG_AGENTS_RANGE_REMOVE_END)
11749 {
11750 int agent_id2 = action_id -
EActions.DEBUG_AGENTS_RANGE_REMOVE_START;
11752 }
11753
11754 else if (action_id ==
EActions.ADD_QUANTITY)
11755 {
11756 if (IsMagazine())
11757 {
11758 Magazine mag = Magazine.Cast(this);
11759 mag.ServerSetAmmoCount(mag.GetAmmoCount() + mag.GetAmmoMax() * 0.2);
11760 }
11761 else
11762 {
11764 }
11765
11766 if (m_EM)
11767 {
11768 m_EM.AddEnergy(m_EM.GetEnergyMax() * 0.2);
11769 }
11770
11771 }
11772
11773 else if (action_id ==
EActions.REMOVE_QUANTITY)
11774 {
11775 if (IsMagazine())
11776 {
11777 Magazine mag2 = Magazine.Cast(this);
11778 mag2.ServerSetAmmoCount(mag2.GetAmmoCount() - mag2.GetAmmoMax() * 0.2);
11779 }
11780 else
11781 {
11783 }
11784 if (m_EM)
11785 {
11786 m_EM.AddEnergy(- m_EM.GetEnergyMax() * 0.2);
11787 }
11788
11789 }
11790
11791 else if (action_id ==
EActions.SET_QUANTITY_0)
11792 {
11794
11795 if (m_EM)
11796 {
11797 m_EM.SetEnergy(0);
11798 }
11799 }
11800
11801 else if (action_id ==
EActions.SET_MAX_QUANTITY)
11802 {
11804
11805 if (m_EM)
11806 {
11807 m_EM.SetEnergy(m_EM.GetEnergyMax());
11808 }
11809 }
11810
11811 else if (action_id ==
EActions.ADD_HEALTH)
11812 {
11813 AddHealth("","",GetMaxHealth("","Health")/5);
11814 }
11815 else if (action_id ==
EActions.REMOVE_HEALTH)
11816 {
11817 AddHealth("","",-GetMaxHealth("","Health")/5);
11818 }
11819 else if (action_id ==
EActions.DESTROY_HEALTH)
11820 {
11821 SetHealth01("","",0);
11822 }
11823 else if (action_id ==
EActions.WATCH_ITEM)
11824 {
11826 mid.RegisterDebugItem(
ItemBase.Cast(
this), PlayerBase.Cast(player));
11827 #ifdef DEVELOPER
11828 SetDebugDeveloper_item(this);
11829 #endif
11830 }
11831
11832 else if (action_id ==
EActions.ADD_TEMPERATURE)
11833 {
11834 AddTemperature(20);
11835
11836 }
11837
11838 else if (action_id ==
EActions.REMOVE_TEMPERATURE)
11839 {
11840 AddTemperature(-20);
11841
11842 }
11843
11844 else if (action_id ==
EActions.FLIP_FROZEN)
11845 {
11846 SetFrozen(!GetIsFrozen());
11847
11848 }
11849
11850 else if (action_id ==
EActions.ADD_WETNESS)
11851 {
11853
11854 }
11855
11856 else if (action_id ==
EActions.REMOVE_WETNESS)
11857 {
11859
11860 }
11861
11862 else if (action_id ==
EActions.LIQUIDTYPE_UP)
11863 {
11866
11867
11868 }
11869
11870 else if (action_id ==
EActions.LIQUIDTYPE_DOWN)
11871 {
11874 }
11875
11876 else if (action_id ==
EActions.MAKE_SPECIAL)
11877 {
11878 auto debugParams = DebugSpawnParams.WithPlayer(player);
11879 OnDebugSpawnEx(debugParams);
11880 }
11881
11882 }
11883
11884
11885 return false;
11886 }
11887
11888
11889
11890
11894
11897
11898
11899
11901 {
11902 return false;
11903 }
11904
11905
11907 {
11908 return true;
11909 }
11910
11911
11913 {
11914 return true;
11915 }
11916
11917
11918
11920 {
11921 string config_path =
string.Format(
"CfgVehicles %1 Food FoodStages",
GetType());
11923 }
11924
11927 {
11928 return null;
11929 }
11930
11932 {
11933 return false;
11934 }
11935
11937 {
11938 return false;
11939 }
11940
11944
11945
11947 {
11948 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
11949 return module_repairing.CanRepair(this, item_repair_kit);
11950 }
11951
11952
11953 bool Repair(PlayerBase player,
ItemBase item_repair_kit,
float specialty_weight)
11954 {
11955 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
11956 return module_repairing.Repair(player, this, item_repair_kit, specialty_weight);
11957 }
11958
11959
11961 {
11962
11963
11964
11965
11966
11967
11968
11969
11970 return 1;
11971 }
11972
11973
11974
11976 {
11978 }
11979
11980
11981
11983 {
11985 }
11986
11987
11996 {
11997 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
11998
11999 if (player)
12000 {
12001 player.MessageStatus(text);
12002 }
12003 }
12004
12005
12014 {
12015 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
12016
12017 if (player)
12018 {
12019 player.MessageAction(text);
12020 }
12021 }
12022
12023
12032 {
12033 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
12034
12035 if (player)
12036 {
12037 player.MessageFriendly(text);
12038 }
12039 }
12040
12041
12050 {
12051 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
12052
12053 if (player)
12054 {
12055 player.MessageImportant(text);
12056 }
12057 }
12058
12060 {
12061 return true;
12062 }
12063
12064
12065 override bool KindOf(
string tag)
12066 {
12067 bool found = false;
12068 string item_name = this.
GetType();
12071
12072 int array_size = item_tag_array.Count();
12073 for (int i = 0; i < array_size; i++)
12074 {
12075 if (item_tag_array.Get(i) == tag)
12076 {
12077 found = true;
12078 break;
12079 }
12080 }
12081 return found;
12082 }
12083
12084
12086 {
12087
12088 super.OnRPC(sender, rpc_type,ctx);
12089
12090
12091 switch (rpc_type)
12092 {
12093 #ifndef SERVER
12094 case ERPCs.RPC_SOUND_LOCK_ATTACH:
12095 Param2<bool, string> p = new Param2<bool, string>(false, "");
12096
12098 return;
12099
12100 bool play = p.param1;
12101 string soundSet = p.param2;
12102
12103 if (play)
12104 {
12106 {
12108 {
12110 }
12111 }
12112 else
12113 {
12115 }
12116 }
12117 else
12118 {
12120 }
12121
12122 break;
12123 #endif
12124
12125 }
12126
12128 {
12130 }
12131 }
12132
12133
12134
12135
12137 {
12138 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
12139 return plugin.GetID(
name);
12140 }
12141
12143 {
12144 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
12145 return plugin.GetName(id);
12146 }
12147
12150 {
12151
12152
12153 int varFlags;
12154 if (!ctx.
Read(varFlags))
12155 return;
12156
12157 if (varFlags & ItemVariableFlags.FLOAT)
12158 {
12160 }
12161 }
12162
12164 {
12165
12166 super.SerializeNumericalVars(floats_out);
12167
12168
12169
12171 {
12173 }
12174
12176 {
12178 }
12179
12181 {
12183 }
12184
12186 {
12191 }
12192
12194 {
12196 }
12197 }
12198
12200 {
12201
12202 super.DeSerializeNumericalVars(floats);
12203
12204
12205 int index = 0;
12206 int mask = Math.Round(floats.Get(index));
12207
12208 index++;
12209
12211 {
12213 {
12215 }
12216 else
12217 {
12218 float quantity = floats.Get(index);
12219 SetQuantity(quantity,
true,
false,
false,
false);
12220 }
12221 index++;
12222 }
12223
12225 {
12226 float wet = floats.Get(index);
12228 index++;
12229 }
12230
12232 {
12233 int liquidtype = Math.Round(floats.Get(index));
12235 index++;
12236 }
12237
12239 {
12241 index++;
12243 index++;
12245 index++;
12247 index++;
12248 }
12249
12251 {
12252 int cleanness = Math.Round(floats.Get(index));
12254 index++;
12255 }
12256 }
12257
12259 {
12260 super.WriteVarsToCTX(ctx);
12261
12262
12264 {
12266 }
12267
12269 {
12271 }
12272
12274 {
12276 }
12277
12279 {
12280 int r,g,b,a;
12286 }
12287
12289 {
12291 }
12292 }
12293
12295 {
12296 if (!super.ReadVarsFromCTX(ctx,version))
12297 return false;
12298
12299 int intValue;
12300 float value;
12301
12302 if (version < 140)
12303 {
12304 if (!ctx.
Read(intValue))
12305 return false;
12306
12307 m_VariablesMask = intValue;
12308 }
12309
12311 {
12312 if (!ctx.
Read(value))
12313 return false;
12314
12316 {
12318 }
12319 else
12320 {
12322 }
12323 }
12324
12325 if (version < 140)
12326 {
12328 {
12329 if (!ctx.
Read(value))
12330 return false;
12331 SetTemperatureDirect(value);
12332 }
12333 }
12334
12336 {
12337 if (!ctx.
Read(value))
12338 return false;
12340 }
12341
12343 {
12344 if (!ctx.
Read(intValue))
12345 return false;
12347 }
12348
12350 {
12351 int r,g,b,a;
12353 return false;
12355 return false;
12357 return false;
12359 return false;
12360
12362 }
12363
12365 {
12366 if (!ctx.
Read(intValue))
12367 return false;
12369 }
12370
12371 if (version >= 138 && version < 140)
12372 {
12374 {
12375 if (!ctx.
Read(intValue))
12376 return false;
12377 SetFrozen(intValue);
12378 }
12379 }
12380
12381 return true;
12382 }
12383
12384
12386 {
12389 {
12391 }
12392
12393 if (!super.OnStoreLoad(ctx, version))
12394 {
12396 return false;
12397 }
12398
12399 if (version >= 114)
12400 {
12401 bool hasQuickBarIndexSaved;
12402
12403 if (!ctx.
Read(hasQuickBarIndexSaved))
12404 {
12406 return false;
12407 }
12408
12409 if (hasQuickBarIndexSaved)
12410 {
12411 int itmQBIndex;
12412
12413
12414 if (!ctx.
Read(itmQBIndex))
12415 {
12417 return false;
12418 }
12419
12420 PlayerBase parentPlayer = PlayerBase.Cast(GetHierarchyRootPlayer());
12421 if (itmQBIndex != -1 && parentPlayer)
12422 parentPlayer.SetLoadedQuickBarItemBind(this, itmQBIndex);
12423 }
12424 }
12425 else
12426 {
12427
12428 PlayerBase player;
12429 int itemQBIndex;
12430 if (version ==
int.
MAX)
12431 {
12432 if (!ctx.
Read(itemQBIndex))
12433 {
12435 return false;
12436 }
12437 }
12438 else if (Class.CastTo(player, GetHierarchyRootPlayer()))
12439 {
12440
12441 if (!ctx.
Read(itemQBIndex))
12442 {
12444 return false;
12445 }
12446 if (itemQBIndex != -1 && player)
12447 player.SetLoadedQuickBarItemBind(this,itemQBIndex);
12448 }
12449 }
12450
12451 if (version < 140)
12452 {
12453
12454 if (!LoadVariables(ctx, version))
12455 {
12457 return false;
12458 }
12459 }
12460
12461
12463 {
12465 return false;
12466 }
12467 if (version >= 132)
12468 {
12470 if (raib)
12471 {
12473 {
12475 return false;
12476 }
12477 }
12478 }
12479
12481 return true;
12482 }
12483
12484
12485
12487 {
12488 super.OnStoreSave(ctx);
12489
12490 PlayerBase player;
12491 if (PlayerBase.CastTo(player,GetHierarchyRootPlayer()))
12492 {
12494
12495 int itemQBIndex = -1;
12496 itemQBIndex = player.FindQuickBarEntityIndex(this);
12497 ctx.
Write(itemQBIndex);
12498 }
12499 else
12500 {
12502 }
12503
12505
12507 if (raib)
12508 {
12510 }
12511 }
12512
12513
12515 {
12516 super.AfterStoreLoad();
12517
12519 {
12521 }
12522
12524 {
12527 }
12528 }
12529
12531 {
12532 super.EEOnAfterLoad();
12533
12535 {
12537 }
12538
12541 }
12542
12544 {
12545 return false;
12546 }
12547
12548
12549
12551 {
12553 {
12554 #ifdef PLATFORM_CONSOLE
12555
12557 {
12559 if (menu)
12560 {
12562 }
12563 }
12564 #endif
12565 }
12566
12568 {
12571 }
12572
12574 {
12575 SetWeightDirty();
12577 }
12579 {
12582 }
12583
12585 {
12588 }
12590 {
12593 }
12594
12595 super.OnVariablesSynchronized();
12596 }
12597
12598
12599
12601 override bool SetQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false,
bool allow_client =
false,
bool clamp_to_stack_max =
true)
12602 {
12603 if (!IsServerCheck(allow_client))
12604 return false;
12605
12607 return false;
12608
12611
12612 if (value <= (min + 0.001))
12613 value = min;
12614
12615 if (value == min)
12616 {
12617 if (destroy_config)
12618 {
12619 bool dstr = ConfigGetBool("varQuantityDestroyOnMin");
12620 if (dstr)
12621 {
12623 this.Delete();
12624 return true;
12625 }
12626 }
12627 else if (destroy_forced)
12628 {
12630 this.Delete();
12631 return true;
12632 }
12633
12635 }
12636
12639
12641 {
12643
12644 if (delta)
12646 }
12647
12649
12650 return false;
12651 }
12652
12653
12655 bool AddQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
12656 {
12658 }
12659
12661 {
12664 }
12665
12667 {
12670 }
12671
12673 override void SetQuantityNormalized(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
12674 {
12675 float value_clamped = Math.Clamp(value, 0, 1);
12677 SetQuantity(result, destroy_config, destroy_forced);
12678 }
12679
12680
12683 {
12685 }
12686
12688 {
12690 }
12691
12692
12693
12694
12695
12696
12697
12698
12699
12700
12702 {
12703 int slot = -1;
12704 if (GetInventory())
12705 {
12706 InventoryLocation il = new InventoryLocation;
12707 GetInventory().GetCurrentInventoryLocation(il);
12709 }
12710
12712 }
12713
12715 {
12716 float quantity_max = 0;
12717
12719 {
12720 if (attSlotID != -1)
12721 quantity_max = InventorySlots.GetStackMaxForSlotId(attSlotID);
12722
12723 if (quantity_max <= 0)
12725 }
12726
12727 if (quantity_max <= 0)
12729
12730 return quantity_max;
12731 }
12732
12734 {
12736 }
12737
12739 {
12741 }
12742
12743
12745 {
12747 }
12748
12750 {
12752 }
12753
12755 {
12757 }
12758
12759
12761 {
12762
12763 float weightEx = GetWeightEx();
12764 float special = GetInventoryAndCargoWeight();
12765 return weightEx - special;
12766 }
12767
12768
12770 {
12772 }
12773
12775 {
12777 {
12778 #ifdef DEVELOPER
12779 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
12780 {
12781 WeightDebugData data1 = WeightDebug.GetWeightDebug(this);
12783 }
12784 #endif
12785
12786 return GetQuantity() * GetConfigWeightModified();
12787 }
12788 else if (HasEnergyManager())
12789 {
12790 #ifdef DEVELOPER
12791 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
12792 {
12793 WeightDebugData data2 = WeightDebug.GetWeightDebug(this);
12794 data2.
SetCalcDetails(
"TIB2: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " + GetCompEM().
GetEnergy()+
"(energy) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit)");
12795 }
12796 #endif
12797 return super.GetWeightSpecialized(forceRecalc) + (GetCompEM().GetEnergy() * ConfigGetFloat("weightPerQuantityUnit")) + GetConfigWeightModified();
12798 }
12799 else
12800 {
12801 #ifdef DEVELOPER
12802 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
12803 {
12804 WeightDebugData data3 = WeightDebug.GetWeightDebug(this);
12805 data3.
SetCalcDetails(
"TIB3: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " +
GetQuantity()+
"(quantity) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit))");
12806 }
12807 #endif
12808 return super.GetWeightSpecialized(forceRecalc) + (
GetQuantity() * ConfigGetFloat(
"weightPerQuantityUnit")) + GetConfigWeightModified();
12809 }
12810 }
12811
12814 {
12815 int item_count = 0;
12817
12818 if (GetInventory().GetCargo() != NULL)
12819 {
12820 item_count = GetInventory().GetCargo().GetItemCount();
12821 }
12822
12823 for (int i = 0; i < GetInventory().AttachmentCount(); i++)
12824 {
12825 Class.CastTo(item,GetInventory().GetAttachmentFromIndex(i));
12826 if (item)
12827 item_count += item.GetNumberOfItems();
12828 }
12829 return item_count;
12830 }
12831
12834 {
12835 float weight = 0;
12836 float wetness = 1;
12837 if (include_wetness)
12840 {
12841 weight = wetness * m_ConfigWeight;
12842 }
12844 {
12845 weight = 1;
12846 }
12847 return weight;
12848 }
12849
12850
12851
12853 {
12854 if ((
GetGame().IsServer() || !
GetGame().IsMultiplayer()) && GetInventory())
12855 {
12856 GameInventory inv = GetInventory();
12857 array<EntityAI> items = new array<EntityAI>;
12859 for (int i = 0; i < items.Count(); i++)
12860 {
12862 if (item)
12863 {
12865 }
12866 }
12867 }
12868 }
12869
12870
12871
12872
12874 {
12875 float energy = 0;
12876 if (HasEnergyManager())
12877 {
12878 energy = GetCompEM().GetEnergy();
12879 }
12880 return energy;
12881 }
12882
12883
12885 {
12886 super.OnEnergyConsumed();
12887
12889 }
12890
12892 {
12893 super.OnEnergyAdded();
12894
12896 }
12897
12898
12900 {
12901 if (
GetGame().IsServer() && HasEnergyManager() && GetCompEM().HasConversionOfEnergyToQuantity())
12902 {
12904 {
12905 float energy_0to1 = GetCompEM().GetEnergy0To1();
12907 }
12908 }
12909 }
12910
12911
12913 {
12914 return ConfigGetFloat("heatIsolation");
12915 }
12916
12918 {
12920 }
12921
12923 {
12924 string paramPath =
string.Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Drying %2",
GetType(), pIncrementName);
12925 if (
GetGame().ConfigIsExisting(paramPath))
12927
12928 return 0.0;
12929 }
12930
12932 {
12933 string paramPath =
string.
Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Soaking %2",
GetType(), pIncrementName);
12934 if (
GetGame().ConfigIsExisting(paramPath))
12936
12937 return 0.0;
12938 }
12939
12940 override void SetWet(
float value,
bool allow_client =
false)
12941 {
12942 if (!IsServerCheck(allow_client))
12943 return;
12944
12947
12949
12950 m_VarWet = Math.Clamp(value, min, max);
12951
12953 {
12956 }
12957 }
12958
12959 override void AddWet(
float value)
12960 {
12962 }
12963
12965 {
12967 }
12968
12970 {
12972 }
12973
12975 {
12977 }
12978
12980 {
12982 }
12983
12985 {
12987 }
12988
12989 override void OnWetChanged(
float newVal,
float oldVal)
12990 {
12993 if (newLevel != oldLevel)
12994 {
12996 }
12997 }
12998
13000 {
13001 SetWeightDirty();
13002 }
13003
13005 {
13006 return GetWetLevelInternal(
m_VarWet);
13007 }
13008
13009
13010
13012 {
13014 }
13015
13017 {
13019 }
13020
13022 {
13024 }
13025
13027 {
13029 }
13030
13031
13032
13034 {
13035 if (ConfigIsExisting("itemModelLength"))
13036 {
13037 return ConfigGetFloat("itemModelLength");
13038 }
13039 return 0;
13040 }
13041
13043 {
13044 if (ConfigIsExisting("itemAttachOffset"))
13045 {
13046 return ConfigGetFloat("itemAttachOffset");
13047 }
13048 return 0;
13049 }
13050
13051 override void SetCleanness(
int value,
bool allow_client =
false)
13052 {
13053 if (!IsServerCheck(allow_client))
13054 return;
13055
13057
13059
13062 }
13063
13065 {
13067 }
13068
13070 {
13071 return true;
13072 }
13073
13074
13075
13076
13078 {
13080 }
13081
13083 {
13085 }
13086
13087
13088
13089
13090 override void SetColor(
int r,
int g,
int b,
int a)
13091 {
13097 }
13099 override void GetColor(out
int r,out
int g,out
int b,out
int a)
13100 {
13105 }
13106
13108 {
13110 }
13111
13114 {
13115 int r,g,b,a;
13117 r = r/255;
13118 g = g/255;
13119 b = b/255;
13120 a = a/255;
13121 return MiscGameplayFunctions.GetColorString(r, g, b, a);
13122 }
13123
13124
13125
13126 override void SetLiquidType(
int value,
bool allow_client =
false)
13127 {
13128 if (!IsServerCheck(allow_client))
13129 return;
13130
13135 }
13136
13138 {
13139 return ConfigGetInt("varLiquidTypeInit");
13140 }
13141
13143 {
13145 }
13146
13148 {
13150 SetFrozen(false);
13151 }
13152
13155 {
13156 player.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
13157 }
13158
13159
13162 {
13163 PlayerBase nplayer;
13164 if (PlayerBase.CastTo(nplayer, player))
13165 {
13167
13168 nplayer.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
13169 }
13170 }
13171
13172
13175 {
13176 PlayerBase nplayer;
13177 if (PlayerBase.CastTo(nplayer,player))
13178 {
13179
13180 nplayer.SetEnableQuickBarEntityShortcut(this,false);
13181
13182 }
13183
13184
13185 player.GetHumanInventory().ClearUserReservedLocationForContainer(this);
13186
13187
13188 if (HasEnergyManager())
13189 {
13190 GetCompEM().UpdatePlugState();
13191 }
13192 }
13193
13194
13196 {
13197 super.OnPlacementStarted(player);
13198
13200 }
13201
13202 override void OnPlacementComplete(Man player, vector position =
"0 0 0", vector orientation =
"0 0 0")
13203 {
13205 {
13206 m_AdminLog.OnPlacementComplete(player,
this);
13207 }
13208
13209 super.OnPlacementComplete(player, position, orientation);
13210 }
13211
13212
13213
13214
13215
13217 {
13219 {
13220 return true;
13221 }
13222 else
13223 {
13224 return false;
13225 }
13226 }
13227
13228
13230 {
13232 {
13234 }
13235 }
13236
13237
13239 {
13241 }
13242
13244 {
13246 }
13247
13248 override void InsertAgent(
int agent,
float count = 1)
13249 {
13250 if (count < 1)
13251 return;
13252
13254 }
13255
13258 {
13260 }
13261
13262
13264 {
13266 }
13267
13268
13269
13270
13271
13272
13273
13274
13275
13276
13277
13278
13279
13280
13281
13282
13283
13284
13285
13286
13287
13288
13289
13290
13291
13292
13293
13294
13295
13296
13297
13298
13299
13300
13301
13302
13303
13304
13305
13306
13307
13308
13310 {
13312 return false;
13313 return true;
13314 }
13315
13317 {
13318
13320 }
13321
13322
13325 {
13326 super.CheckForRoofLimited(timeTresholdMS);
13327
13329 if ((time - m_PreviousRoofTestTime) >= timeTresholdMS)
13330 {
13331 m_PreviousRoofTestTime = time;
13332 SetRoofAbove(MiscGameplayFunctions.IsUnderRoof(this));
13333 }
13334 }
13335
13336
13338 {
13340 {
13341 return 0;
13342 }
13343
13344 if (GetInventory().GetAttachmentSlotsCount() != 0)
13345 {
13346 ItemBase filter =
ItemBase.Cast(FindAttachmentBySlotName(
"GasMaskFilter"));
13347 if (filter)
13348 return filter.GetProtectionLevel(type, false, system);
13349 else
13350 return 0;
13351 }
13352
13353 string subclassPath, entryName;
13354
13355 switch (type)
13356 {
13358 entryName = "biological";
13359 break;
13361 entryName = "chemical";
13362 break;
13363 default:
13364 entryName = "biological";
13365 break;
13366 }
13367
13368 subclassPath =
"CfgVehicles " + this.
GetType() +
" Protection ";
13369
13371 }
13372
13373
13374
13377 {
13378 if (!IsMagazine())
13380
13382 }
13383
13384
13385
13386
13387
13392 {
13393 return true;
13394 }
13395
13397 {
13399 }
13400
13401
13402
13403
13404
13406 {
13407 if (parent)
13408 {
13409 if (parent.IsInherited(DayZInfected))
13410 return true;
13411
13412 if (!parent.IsRuined())
13413 return true;
13414 }
13415
13416 return true;
13417 }
13418
13420 {
13421 if (!super.CanPutAsAttachment(parent))
13422 {
13423 return false;
13424 }
13425
13426 if (!IsRuined() && !parent.IsRuined())
13427 {
13428 return true;
13429 }
13430
13431 return false;
13432 }
13433
13435 {
13436
13437
13438
13439
13440 return super.CanReceiveItemIntoCargo(item);
13441 }
13442
13444 {
13445
13446
13447
13448
13449 GameInventory attachmentInv = attachment.GetInventory();
13451 {
13452 if (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase))
13453 return false;
13454 }
13455
13456 InventoryLocation loc = new InventoryLocation();
13457 attachment.GetInventory().GetCurrentInventoryLocation(loc);
13458 if (loc && loc.
IsValid() && !GetInventory().AreChildrenAccessible())
13459 return false;
13460
13461 return super.CanReceiveAttachment(attachment, slotId);
13462 }
13463
13465 {
13466 if (!super.CanReleaseAttachment(attachment))
13467 return false;
13468
13469 return GetInventory().AreChildrenAccessible();
13470 }
13471
13472
13473
13474
13475
13476
13477
13478
13479
13480
13481
13482
13483
13484
13485
13486
13487
13488
13489
13490
13491
13493 {
13494 int id = muzzle_owner.GetMuzzleID();
13495 array<ref WeaponParticlesOnFire> WPOF_array =
m_OnFireEffect.Get(
id);
13496
13497 if (WPOF_array)
13498 {
13499 for (int i = 0; i < WPOF_array.Count(); i++)
13500 {
13501 WeaponParticlesOnFire WPOF = WPOF_array.Get(i);
13502
13503 if (WPOF)
13504 {
13505 WPOF.OnActivate(weapon, muzzle_index, ammoType, muzzle_owner, suppressor, config_to_search);
13506 }
13507 }
13508 }
13509 }
13510
13511
13513 {
13514 int id = muzzle_owner.GetMuzzleID();
13516
13517 if (WPOBE_array)
13518 {
13519 for (int i = 0; i < WPOBE_array.Count(); i++)
13520 {
13521 WeaponParticlesOnBulletCasingEject WPOBE = WPOBE_array.Get(i);
13522
13523 if (WPOBE)
13524 {
13525 WPOBE.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
13526 }
13527 }
13528 }
13529 }
13530
13531
13533 {
13534 int id = muzzle_owner.GetMuzzleID();
13535 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
13536
13537 if (WPOOH_array)
13538 {
13539 for (int i = 0; i < WPOOH_array.Count(); i++)
13540 {
13541 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
13542
13543 if (WPOOH)
13544 {
13545 WPOOH.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
13546 }
13547 }
13548 }
13549 }
13550
13551
13553 {
13554 int id = muzzle_owner.GetMuzzleID();
13555 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
13556
13557 if (WPOOH_array)
13558 {
13559 for (int i = 0; i < WPOOH_array.Count(); i++)
13560 {
13561 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
13562
13563 if (WPOOH)
13564 {
13565 WPOOH.OnUpdate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
13566 }
13567 }
13568 }
13569 }
13570
13571
13573 {
13574 int id = muzzle_owner.GetMuzzleID();
13575 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
13576
13577 if (WPOOH_array)
13578 {
13579 for (int i = 0; i < WPOOH_array.Count(); i++)
13580 {
13581 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
13582
13583 if (WPOOH)
13584 {
13585 WPOOH.OnDeactivate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
13586 }
13587 }
13588 }
13589 }
13590
13591
13592
13594 {
13596 {
13597 return true;
13598 }
13599
13600 return false;
13601 }
13602
13604 {
13606 {
13607 return true;
13608 }
13609
13610 return false;
13611 }
13612
13614 {
13616 {
13617 return true;
13618 }
13619
13620 return false;
13621 }
13622
13624 {
13625 return false;
13626 }
13627
13630 {
13631 return UATimeSpent.DEFAULT_DEPLOY;
13632 }
13633
13634
13635
13636
13638 {
13640 SetSynchDirty();
13641 }
13642
13644 {
13646 }
13647
13648
13650 {
13651 return false;
13652 }
13653
13656 {
13657 string att_type = "None";
13658
13659 if (ConfigIsExisting("soundAttType"))
13660 {
13661 att_type = ConfigGetString("soundAttType");
13662 }
13663
13665 }
13666
13668 {
13670 }
13671
13672
13673
13674
13675
13681
13683 {
13686
13688 }
13689
13690
13692 {
13694 return;
13695
13697
13700
13703
13704 SoundParameters params = new SoundParameters();
13708 }
13709
13710
13712 {
13714 return;
13715
13717 SetSynchDirty();
13718
13721 }
13722
13723
13725 {
13727 return;
13728
13730 SetSynchDirty();
13731
13734 }
13735
13737 {
13739 }
13740
13742 {
13744 }
13745
13748 {
13749 if (!
GetGame().IsDedicatedServer())
13750 {
13751 if (ConfigIsExisting("attachSoundSet"))
13752 {
13753 string cfg_path = "";
13754 string soundset = "";
13755 string type_name =
GetType();
13756
13759 ConfigGetTextArray("attachSoundSet",cfg_soundset_array);
13760 ConfigGetTextArray("attachSoundSlot",cfg_slot_array);
13761
13762 if (cfg_soundset_array.Count() > 0 && cfg_soundset_array.Count() == cfg_slot_array.Count())
13763 {
13764 for (int i = 0; i < cfg_soundset_array.Count(); i++)
13765 {
13766 if (cfg_slot_array[i] == slot_type)
13767 {
13768 soundset = cfg_soundset_array[i];
13769 break;
13770 }
13771 }
13772 }
13773
13774 if (soundset != "")
13775 {
13776 EffectSound sound = SEffectManager.PlaySound(soundset,
GetPosition());
13778 }
13779 }
13780 }
13781 }
13782
13784 {
13785
13786 }
13787
13788 void OnApply(PlayerBase player);
13789
13791 {
13792 return 1.0;
13793 };
13794
13796 {
13798 }
13799
13801 {
13803 }
13804
13806
13808 {
13809 SetDynamicPhysicsLifeTime(0.01);
13811 }
13812
13814 {
13815 array<string> zone_names = new array<string>;
13816 GetDamageZones(zone_names);
13817 for (int i = 0; i < zone_names.Count(); i++)
13818 {
13819 SetHealthMax(zone_names.Get(i),"Health");
13820 }
13821 SetHealthMax("","Health");
13822 }
13823
13826 {
13827 float global_health = GetHealth01("","Health");
13828 array<string> zones = new array<string>;
13829 GetDamageZones(zones);
13830
13831 for (int i = 0; i < zones.Count(); i++)
13832 {
13833 SetHealth01(zones.Get(i),"Health",global_health);
13834 }
13835 }
13836
13839 {
13840 return IsExclusionFlagPresent(PlayerBase.GetFaceCoverageShaveValues());
13841 }
13842
13844 {
13845 if (!hasRootAsPlayer)
13846 {
13847 if (refParentIB)
13848 {
13849
13850 if ((refParentIB.GetWet() >= GameConstants.STATE_SOAKING_WET) && (
m_VarWet <
m_VarWetMax))
13851 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_INSIDE);
13852
13853 else if ((refParentIB.GetLiquidType() != 0) && (refParentIB.GetQuantity() > 0) && (
m_VarWet <
m_VarWetMax))
13854 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_LIQUID);
13855
13858 }
13859 else
13860 {
13861
13864 }
13865 }
13866 }
13867
13869 {
13871 {
13872 float target =
g_Game.GetMission().GetWorldData().GetBaseEnvTemperatureAtObject(
this);
13873 if (
GetTemperature() != target || !IsFreezeThawProgressFinished())
13874 {
13875 float heatPermCoef = 1.0;
13877 while (ent)
13878 {
13879 heatPermCoef *= ent.GetHeatPermeabilityCoef();
13880 ent = ent.GetHierarchyParent();
13881 }
13882
13883 SetTemperatureEx(
new TemperatureDataInterpolated(target,
ETemperatureAccessTypes.ACCESS_WORLD,delta,GameConstants.TEMP_COEF_WORLD,heatPermCoef));
13884 }
13885 }
13886 }
13887
13889 {
13890
13891 EntityAI parent = GetHierarchyParent();
13892 if (!parent)
13893 {
13894 hasParent = false;
13895 hasRootAsPlayer = false;
13896 }
13897 else
13898 {
13899 hasParent = true;
13900 hasRootAsPlayer = (GetHierarchyRootPlayer() != null);
13901 refParentIB =
ItemBase.Cast(parent);
13902 }
13903 }
13904
13905 protected void ProcessDecay(
float delta,
bool hasRootAsPlayer)
13906 {
13907
13908 }
13909
13911 {
13912
13913 return false;
13914 }
13915
13917 {
13918
13919
13920 return false;
13921 }
13922
13924 {
13925
13926 return false;
13927 }
13928
13931 {
13932 return !GetIsFrozen() &&
IsOpen();
13933 }
13934
13936 {
13937 bool hasParent = false, hasRootAsPlayer = false;
13939
13940 bool wwtu =
g_Game.IsWorldWetTempUpdateEnabled();
13941 bool foodDecay =
g_Game.IsFoodDecayEnabled();
13942
13943 if (wwtu || foodDecay)
13944 {
13948
13949 if (processWetness || processTemperature || processDecay)
13950 {
13952
13953 if (processWetness)
13954 ProcessItemWetness(m_ElapsedSinceLastUpdate, hasParent, hasRootAsPlayer, refParentIB);
13955
13956 if (processTemperature)
13958
13959 if (processDecay)
13960 ProcessDecay(m_ElapsedSinceLastUpdate, hasRootAsPlayer);
13961 }
13962 }
13963 }
13964
13967 {
13969 }
13970
13972 {
13975
13976 return super.GetTemperatureFreezeThreshold();
13977 }
13978
13980 {
13983
13984 return super.GetTemperatureThawThreshold();
13985 }
13986
13988 {
13991
13992 return super.GetItemOverheatThreshold();
13993 }
13994
13996 {
13998 return Math.Lerp(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureFreezeTime()),
GetQuantityNormalized());
13999
14000 return super.GetTemperatureFreezeTime();
14001 }
14002
14004 {
14006 return Math.Lerp(GameConstants.TEMPERATURE_TIME_THAW_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureThawTime()),
GetQuantityNormalized());
14007
14008 return super.GetTemperatureThawTime();
14009 }
14010
14015
14017 {
14018 return (item.IsKindOf("Cauldron") || item.IsKindOf("Pot") || item.IsKindOf("FryingPan") || item.IsKindOf("SmallProtectorCase") || (item.IsKindOf("PortableGasStove") && item.FindAttachmentBySlotName("CookingEquipment")));
14019 }
14020
14022 {
14023 MiscGameplayFunctions.TransferItemProperties(oldItem, this);
14024 }
14025
14028 {
14030 }
14031
14033 {
14035 }
14036
14038 {
14040 }
14041
14044 {
14045 return null;
14046 }
14047
14050 {
14051 return false;
14052 }
14053
14055 {
14057 {
14060 if (!trg)
14061 {
14063 explosive = this;
14064 }
14065
14066 explosive.PairRemote(trg);
14068
14069 int persistentID = RemotelyActivatedItemBehaviour.GeneratePersistentID();
14070 trg.SetPersistentPairID(persistentID);
14071 explosive.SetPersistentPairID(persistentID);
14072
14073 return true;
14074 }
14075 return false;
14076 }
14077
14080 {
14081 float ret = 1.0;
14084 ret *= GetHealth01();
14085
14086 return ret;
14087 }
14088
14089 #ifdef DEVELOPER
14090 override void SetDebugItem()
14091 {
14092 super.SetDebugItem();
14093 _itemBase = this;
14094 }
14095
14097 {
14098 string text = super.GetDebugText();
14099
14101 text +=
string.
Format(
"Heat isolation(modified): %1\n", MiscGameplayFunctions.GetCurrentItemHeatIsolation(
this));
14102
14103 return text;
14104 }
14105 #endif
14106
14108 {
14109 return true;
14110 }
14111
14113
14115
14117 {
14120 }
14121
14122
14130
14146}
14147
14149{
14151 if (entity)
14152 {
14153 bool is_item = entity.IsInherited(
ItemBase);
14154 if (is_item && full_quantity)
14155 {
14158 }
14159 }
14160 else
14161 {
14163 return NULL;
14164 }
14165 return entity;
14166}
14167
14169{
14170 if (item)
14171 {
14172 if (health > 0)
14173 item.SetHealth("", "", health);
14174
14175 if (item.CanHaveTemperature())
14176 {
14178 if (item.CanFreeze())
14179 item.SetFrozen(false);
14180 }
14181
14182 if (item.HasEnergyManager())
14183 {
14184 if (quantity >= 0)
14185 {
14186 item.GetCompEM().SetEnergy0To1(quantity);
14187 }
14188 else
14189 {
14191 }
14192 }
14193 else if (item.IsMagazine())
14194 {
14195 Magazine mag = Magazine.Cast(item);
14196 if (quantity >= 0)
14197 {
14198 mag.ServerSetAmmoCount(mag.GetAmmoMax() * quantity);
14199 }
14200 else
14201 {
14203 }
14204
14205 }
14206 else
14207 {
14208 if (quantity >= 0)
14209 {
14210 item.SetQuantityNormalized(quantity, false);
14211 }
14212 else
14213 {
14215 }
14216
14217 }
14218 }
14219}
14220
14221#ifdef DEVELOPER
14223#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.