9467{
9469 {
9470 return true;
9471 }
9472};
9473
9474
9475
9477{
9481
9483
9486
9487
9488
9489
9490
9499
9505
9510
9515
9536 protected bool m_IsResultOfSplit
9537
9539
9544
9545
9546
9548
9552
9553
9554
9556
9559
9560
9561
9567
9568
9576
9579
9580
9582
9583
9585
9586
9591
9592
9597
9598
9600
9601
9603 {
9608
9609 if (!
GetGame().IsDedicatedServer())
9610 {
9612 {
9614
9616 {
9618 }
9619 }
9620
9623 }
9624
9625 m_OldLocation = null;
9626
9628 {
9630 }
9631
9632 if (ConfigIsExisting("headSelectionsToHide"))
9633 {
9636 }
9637
9639 if (ConfigIsExisting("hideSelectionsByinventorySlot"))
9640 {
9642 }
9643
9645
9646 m_IsResultOfSplit = false;
9647
9649 }
9650
9652 {
9653 super.InitItemVariables();
9654
9660 m_Count = ConfigGetInt(
"count");
9661
9664
9669
9672
9677
9689
9693
9694
9697 if (ConfigIsExisting("canBeSplit"))
9698 {
9701 }
9702
9704 if (ConfigIsExisting("itemBehaviour"))
9706
9707
9710 RegisterNetSyncVariableInt("m_VarLiquidType");
9711 RegisterNetSyncVariableInt("m_Cleanness",0,1);
9712
9713 RegisterNetSyncVariableBoolSignal("m_WantPlayImpactSound");
9714 RegisterNetSyncVariableFloat("m_ImpactSpeed");
9715 RegisterNetSyncVariableInt("m_ImpactSoundSurfaceHash");
9716
9717 RegisterNetSyncVariableInt("m_ColorComponentR", 0, 255);
9718 RegisterNetSyncVariableInt("m_ColorComponentG", 0, 255);
9719 RegisterNetSyncVariableInt("m_ColorComponentB", 0, 255);
9720 RegisterNetSyncVariableInt("m_ColorComponentA", 0, 255);
9721
9722 RegisterNetSyncVariableBool("m_IsBeingPlaced");
9723 RegisterNetSyncVariableBool("m_IsTakeable");
9724 RegisterNetSyncVariableBool("m_IsHologram");
9725
9728 {
9731 }
9732
9734
9736 if (ConfigIsExisting("temperaturePerQuantityWeight"))
9738
9739 }
9740
9742 {
9744 }
9745
9747 {
9750 {
9755 }
9756 }
9757
9758 override void GetActions(
typename action_input_type, out array<ActionBase_Basic> actions)
9759 {
9761 {
9764 }
9765
9767 }
9768
9770 {
9776 }
9777
9779
9781 {
9783
9784 if (!action)
9785 {
9786 Debug.LogError(
"Action " + actionName +
" dosn't exist!");
9787 return;
9788 }
9789
9791 if (!ai)
9792 {
9794 return;
9795 }
9796
9798 if (!action_array)
9799 {
9800 action_array = new array<ActionBase_Basic>;
9802 }
9803 if (LogManager.IsActionLogEnable())
9804 {
9805 Debug.ActionLog(action.ToString() +
" -> " + ai,
this.ToString() ,
"n/a",
"Add action");
9806 }
9807
9808 if (action_array.Find(action) != -1)
9809 {
9810 Debug.Log(
"Action " + action.Type() +
" already added to " +
this +
", skipping!");
9811 }
9812 else
9813 {
9814 action_array.Insert(action);
9815 }
9816 }
9817
9819 {
9821 ActionBase action = player.GetActionManager().GetAction(actionName);
9824
9825 if (action_array)
9826 {
9827 action_array.RemoveItem(action);
9828 }
9829 }
9830
9831
9832
9834 {
9835 ActionOverrideData overrideData = new ActionOverrideData();
9839
9841 if (!actionMap)
9842 {
9845 }
9846
9847 actionMap.Insert(this.
Type(), overrideData);
9848
9849 }
9850
9852
9854
9855
9857 {
9860
9863
9864 string config_to_search = "CfgVehicles";
9865 string muzzle_owner_config;
9866
9868 {
9869 if (IsInherited(Weapon))
9870 config_to_search = "CfgWeapons";
9871
9872 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
9873
9874 string config_OnFire_class = muzzle_owner_config + "Particles " + "OnFire ";
9875
9877
9878 if (config_OnFire_subclass_count > 0)
9879 {
9880 array<ref WeaponParticlesOnFire> WPOF_array = new array<ref WeaponParticlesOnFire>;
9881
9882 for (int i = 0; i < config_OnFire_subclass_count; i++)
9883 {
9884 string particle_class = "";
9886 string config_OnFire_entry = config_OnFire_class + particle_class;
9887 WeaponParticlesOnFire WPOF = new WeaponParticlesOnFire(this, config_OnFire_entry);
9888 WPOF_array.Insert(WPOF);
9889 }
9890
9891
9893 }
9894 }
9895
9897 {
9898 config_to_search = "CfgWeapons";
9899 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
9900
9901 string config_OnBulletCasingEject_class = muzzle_owner_config + "Particles " + "OnBulletCasingEject ";
9902
9904
9905 if (config_OnBulletCasingEject_count > 0 && IsInherited(Weapon))
9906 {
9907 array<ref WeaponParticlesOnBulletCasingEject> WPOBE_array = new array<ref WeaponParticlesOnBulletCasingEject>;
9908
9909 for (i = 0; i < config_OnBulletCasingEject_count; i++)
9910 {
9911 string particle_class2 = "";
9913 string config_OnBulletCasingEject_entry = config_OnBulletCasingEject_class + particle_class2;
9914 WeaponParticlesOnBulletCasingEject WPOBE = new WeaponParticlesOnBulletCasingEject(this, config_OnBulletCasingEject_entry);
9915 WPOBE_array.Insert(WPOBE);
9916 }
9917
9918
9920 }
9921 }
9922 }
9923
9924
9926 {
9929
9931 {
9932 string config_to_search = "CfgVehicles";
9933
9934 if (IsInherited(Weapon))
9935 config_to_search = "CfgWeapons";
9936
9937 string muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
9938 string config_OnOverheating_class = muzzle_owner_config + "Particles " + "OnOverheating ";
9939
9940 if (
GetGame().ConfigIsExisting(config_OnOverheating_class))
9941 {
9942
9944
9946 {
9948 string error =
"Error reading config " +
GetType() +
">Particles>OnOverheating - Parameter shotsToStartOverheating is configured wrong or is missing! Its value must be 1 or higher!";
9950 return;
9951 }
9952
9955
9956
9957
9959 array<ref WeaponParticlesOnOverheating> WPOOH_array = new array<ref WeaponParticlesOnOverheating>;
9960
9961 for (int i = 0; i < config_OnOverheating_subclass_count; i++)
9962 {
9963 string particle_class = "";
9965 string config_OnOverheating_entry = config_OnOverheating_class + particle_class;
9967
9968 if (entry_type == CT_CLASS)
9969 {
9970 WeaponParticlesOnOverheating WPOF = new WeaponParticlesOnOverheating(this, config_OnOverheating_entry);
9971 WPOOH_array.Insert(WPOF);
9972 }
9973 }
9974
9975
9977 }
9978 }
9979 }
9980
9982 {
9984 }
9985
9987 {
9989 {
9991
9994
9997
9998 CheckOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9999 }
10000 }
10001
10003 {
10005 UpdateOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
10006
10008 StartOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
10009
10011 StopOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
10012
10014 {
10016 }
10017 }
10018
10020 {
10022 }
10023
10025 {
10028 else
10030
10032 {
10035 }
10036 else
10037 {
10040
10043 }
10044
10046 }
10047
10049 {
10051 ItemBase.PlayOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
10052 }
10053
10055 {
10057 ItemBase.UpdateOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
10059 }
10060
10062 {
10064 ItemBase.StopOverheatingParticles(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
10065 }
10066
10068 {
10071
10072 OverheatingParticle OP = new OverheatingParticle();
10077
10079 }
10080
10082 {
10085
10086 return -1;
10087 }
10088
10090 {
10092 {
10095
10096 for (int i = count; i > 0; --i)
10097 {
10098 int id = i - 1;
10101
10104
10105 if (overheat_coef < overheat_min && overheat_coef >= overheat_max)
10106 {
10107 if (p)
10108 {
10111 }
10112 }
10113 }
10114 }
10115 }
10116
10118 {
10120 {
10122 {
10123 int id = i - 1;
10125
10126 if (OP)
10127 {
10129
10130 if (p)
10131 {
10133 }
10134
10135 delete OP;
10136 }
10137 }
10138
10141 }
10142 }
10143
10146 {
10147 return 0.0;
10148 }
10149
10150
10152 {
10153 return 250;
10154 }
10155
10157 {
10158 return 0;
10159 }
10160
10163 {
10165 return true;
10166
10167 return false;
10168 }
10169
10172 {
10175
10177 {
10179 }
10180 else
10181 {
10182
10184 }
10185
10187 }
10188
10195 {
10196 return -1;
10197 }
10198
10199
10200
10201
10203 {
10205 {
10207 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
10208
10209 if (r_index >= 0)
10210 {
10211 InventoryLocation r_il = new InventoryLocation;
10212 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
10213
10214 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
10217 {
10218 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
10219 }
10221 {
10222 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
10223 }
10224
10225 }
10226
10227 player.GetHumanInventory().ClearUserReservedLocation(this);
10228 }
10229
10232 }
10233
10234
10235
10236
10238 {
10239 return ItemBase.m_DebugActionsMask;
10240 }
10241
10243 {
10244 return ItemBase.m_DebugActionsMask & mask;
10245 }
10246
10248 {
10249 ItemBase.m_DebugActionsMask = mask;
10250 }
10251
10253 {
10254 ItemBase.m_DebugActionsMask |= mask;
10255 }
10256
10258 {
10259 ItemBase.m_DebugActionsMask &= ~mask;
10260 }
10261
10263 {
10265 {
10267 }
10268 else
10269 {
10271 }
10272 }
10273
10274
10276 {
10277 if (GetEconomyProfile())
10278 {
10279 float q_max = GetEconomyProfile().GetQuantityMax();
10280 if (q_max > 0)
10281 {
10282 float q_min = GetEconomyProfile().GetQuantityMin();
10283 float quantity_randomized = Math.RandomFloatInclusive(q_min, q_max);
10284
10286 {
10287 ComponentEnergyManager comp = GetCompEM();
10289 {
10291 }
10292 }
10294 {
10296
10297 }
10298
10299 }
10300 }
10301 }
10302
10305 {
10306 EntityAI parent = GetHierarchyParent();
10307
10308 if (parent)
10309 {
10310 InventoryLocation inventory_location_to_lock = new InventoryLocation;
10311 GetInventory().GetCurrentInventoryLocation(inventory_location_to_lock);
10312 parent.GetInventory().SetSlotLock(inventory_location_to_lock.
GetSlot(),
true);
10313 }
10314 }
10315
10318 {
10319 EntityAI parent = GetHierarchyParent();
10320
10321 if (parent)
10322 {
10323 InventoryLocation inventory_location_to_unlock = new InventoryLocation;
10324 GetInventory().GetCurrentInventoryLocation(inventory_location_to_unlock);
10325 parent.GetInventory().SetSlotLock(inventory_location_to_unlock.
GetSlot(),
false);
10326 }
10327 }
10328
10330 {
10331
10332
10333
10334
10336
10338 {
10339 if (ScriptInputUserData.CanStoreInputUserData())
10340 {
10341 ScriptInputUserData ctx = new ScriptInputUserData;
10347 ctx.
Write(use_stack_max);
10350
10352 {
10353 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(item2,null,GameInventory.c_InventoryReservationTimeoutShortMS);
10354 }
10355 }
10356 }
10357 else if (!
GetGame().IsMultiplayer())
10358 {
10360 }
10361 }
10362
10364 {
10366 }
10367
10369 {
10371 }
10372
10374 {
10376 }
10377
10379 {
10380
10381 return false;
10382 }
10383
10385 {
10386 return false;
10387 }
10388
10392 {
10393 return false;
10394 }
10395
10397 {
10398 return "";
10399 }
10400
10402
10404 {
10405 return false;
10406 }
10407
10409 {
10410 return true;
10411 }
10412
10413
10414
10416 {
10417 return true;
10418 }
10419
10421 {
10422 return true;
10423 }
10424
10426 {
10427 PlayerBase player = PlayerBase.Cast(
g_Game.GetPlayer());
10429 }
10430
10432 {
10434 }
10435
10437 {
10439 if (!is_being_placed)
10441 SetSynchDirty();
10442 }
10443
10444
10446
10448 {
10450 }
10451
10453 {
10455 }
10456
10458 {
10459 return 1;
10460 }
10461
10463 {
10464 return false;
10465 }
10466
10468 {
10470 SetSynchDirty();
10471 }
10472
10473
10474
10475
10476
10477
10478
10479
10480
10481
10482
10483
10484
10485
10486
10487
10488
10489
10490
10491
10492
10493
10494
10495
10496
10497
10498
10499
10500
10501
10502
10503
10504
10505
10506
10508 {
10509 super.OnMovedInsideCargo(container);
10510
10511 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
10512 }
10513
10514 override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
10515 {
10516 super.EEItemLocationChanged(oldLoc,newLoc);
10517
10518 PlayerBase new_player = null;
10519 PlayerBase old_player = null;
10520
10521 if (newLoc.GetParent())
10522 new_player = PlayerBase.Cast(newLoc.GetParent().GetHierarchyRootPlayer());
10523
10524 if (oldLoc.GetParent())
10525 old_player = PlayerBase.Cast(oldLoc.GetParent().GetHierarchyRootPlayer());
10526
10528 {
10529 int r_index = old_player.GetHumanInventory().FindUserReservedLocationIndex(this);
10530
10531 if (r_index >= 0)
10532 {
10533 InventoryLocation r_il = new InventoryLocation;
10534 old_player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
10535
10536 old_player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
10539 {
10540 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
10541 }
10543 {
10544 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
10545 }
10546
10547 }
10548 }
10549
10551 {
10552 if (new_player)
10553 new_player.ForceStandUpForHeavyItems(newLoc.GetItem());
10554
10555 if (new_player == old_player)
10556 {
10557
10558 if (oldLoc.GetParent() && new_player.GetHumanInventory().LocationGetEntity(oldLoc) == NULL)
10559 {
10561 {
10562 if (oldLoc.GetParent().GetInventory().TestAddEntityInCargoExLoc(oldLoc, false, false, false, true, false, false))
10563 {
10564 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
10565 }
10566 }
10567 else
10568 {
10569 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
10570 }
10571 }
10572
10573 if (new_player.GetHumanInventory().FindUserReservedLocationIndex(this) >= 0)
10574 {
10575 int type = oldLoc.GetType();
10577 {
10578 oldLoc.GetParent().GetOnSetLock().Invoke(this);
10579 }
10581 {
10582 oldLoc.GetParent().GetOnAttachmentSetLock().Invoke(this, oldLoc.GetSlot());
10583 }
10584 }
10585 if (!m_OldLocation)
10586 {
10587 m_OldLocation = new InventoryLocation;
10588 }
10589 m_OldLocation.Copy(oldLoc);
10590 }
10591 else
10592 {
10593 if (m_OldLocation)
10594 {
10595 m_OldLocation.Reset();
10596 }
10597 }
10598
10600 }
10601 else
10602 {
10603 if (new_player)
10604 {
10605 int res_index = new_player.GetHumanInventory().FindCollidingUserReservedLocationIndex(this, newLoc);
10606 if (res_index >= 0)
10607 {
10608 InventoryLocation il = new InventoryLocation;
10609 new_player.GetHumanInventory().GetUserReservedLocation(res_index,il);
10611 new_player.GetHumanInventory().ClearUserReservedLocationAtIndex(res_index);
10614 {
10615 il.
GetParent().GetOnReleaseLock().Invoke(it);
10616 }
10618 {
10620 }
10621
10622 }
10623 }
10625 {
10626
10628 }
10629
10630 if (m_OldLocation)
10631 {
10632 m_OldLocation.Reset();
10633 }
10634 }
10635 }
10636
10637 override void EOnContact(IEntity other, Contact extra)
10638 {
10640 {
10641 int liquidType = -1;
10643 if (impactSpeed > 0.0)
10644 {
10646 #ifndef SERVER
10648 #else
10650 SetSynchDirty();
10651 #endif
10653 }
10654 }
10655
10656 #ifdef SERVER
10657 if (GetCompEM() && GetCompEM().IsPlugged())
10658 {
10659 if (GetCompEM().GetCordLength() < vector.Distance(
GetPosition(), GetCompEM().GetEnergySource().
GetPosition()))
10660 GetCompEM().UnplugThis();
10661 }
10662 #endif
10663 }
10664
10666
10668 {
10670 }
10671
10673 {
10674
10675 }
10676
10678 {
10679 super.OnItemLocationChanged(old_owner, new_owner);
10680
10681 PlayerBase relatedPlayer = PlayerBase.Cast(old_owner);
10682 PlayerBase playerNew = PlayerBase.Cast(new_owner);
10683
10684 if (!relatedPlayer && playerNew)
10685 relatedPlayer = playerNew;
10686
10687 if (relatedPlayer && relatedPlayer.GetPerformedActionID() != -1)
10688 {
10690 if (actionMgr)
10691 {
10692 ActionBase currentAction = actionMgr.GetRunningAction();
10693 if (currentAction)
10695 }
10696 }
10697
10698 Man ownerPlayerOld = null;
10699 Man ownerPlayerNew = null;
10700
10701 if (old_owner)
10702 {
10703 if (old_owner.
IsMan())
10704 {
10705 ownerPlayerOld = Man.Cast(old_owner);
10706 }
10707 else
10708 {
10709 ownerPlayerOld = Man.Cast(old_owner.GetHierarchyRootPlayer());
10710 }
10711 }
10712 else
10713 {
10715 {
10717
10718 if (!action || !playerNew || playerNew.GetPerformedActionID() != action.
GetID())
10719 {
10720 GetCompEM().UnplugThis();
10721 }
10722 }
10723 }
10724
10725 if (new_owner)
10726 {
10727 if (new_owner.
IsMan())
10728 {
10729 ownerPlayerNew = Man.Cast(new_owner);
10730 }
10731 else
10732 {
10733 ownerPlayerNew = Man.Cast(new_owner.GetHierarchyRootPlayer());
10734 }
10735 }
10736
10737 if (ownerPlayerOld != ownerPlayerNew)
10738 {
10739 if (ownerPlayerOld)
10740 {
10741 array<EntityAI> subItemsExit = new array<EntityAI>;
10743 for (int i = 0; i < subItemsExit.Count(); i++)
10744 {
10747 }
10748 }
10749
10750 if (ownerPlayerNew)
10751 {
10752 array<EntityAI> subItemsEnter = new array<EntityAI>;
10754 for (int j = 0; j < subItemsEnter.Count(); j++)
10755 {
10758 }
10759 }
10760 }
10761 else if (ownerPlayerNew != null)
10762 {
10763 PlayerBase nplayer;
10764 if (PlayerBase.CastTo(nplayer, ownerPlayerNew))
10765 {
10766 array<EntityAI> subItemsUpdate = new array<EntityAI>;
10768 for (int k = 0; k < subItemsUpdate.Count(); k++)
10769 {
10771 itemUpdate.UpdateQuickbarShortcutVisibility(nplayer);
10772 }
10773 }
10774 }
10775
10776 if (old_owner)
10777 old_owner.OnChildItemRemoved(this);
10778 if (new_owner)
10779 new_owner.OnChildItemReceived(this);
10780 }
10781
10782
10784 {
10785 super.EEDelete(parent);
10786 PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
10787 if (player)
10788 {
10790
10791 if (player.IsAlive())
10792 {
10793 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
10794 if (r_index >= 0)
10795 {
10796 InventoryLocation r_il = new InventoryLocation;
10797 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
10798
10799 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
10802 {
10803 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
10804 }
10806 {
10807 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
10808 }
10809
10810 }
10811
10812 player.RemoveQuickBarEntityShortcut(this);
10813 }
10814 }
10815 }
10816
10818 {
10819 super.EEKilled(killer);
10820
10823 {
10824 if (
GetTemperature() >= GameConstants.ITEM_TEMPERATURE_TO_EXPLODE_MIN)
10825 {
10826 if (IsMagazine())
10827 {
10828 if (Magazine.Cast(this).GetAmmoCount() > 0)
10829 {
10831 }
10832 }
10833 else
10834 {
10836 }
10837 }
10838 }
10839 }
10840
10842 {
10843 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
10844
10845 super.OnWasAttached(parent, slot_id);
10846
10849
10851 }
10852
10854 {
10855 super.OnWasDetached(parent, slot_id);
10856
10859 }
10860
10862 {
10863 int idx;
10866
10867 ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
10868 if (inventory_slots.Count() < 1)
10869 {
10870 inventory_slots.Insert(ConfigGetString("ChangeInventorySlot"));
10871 attach_types.Insert(ConfigGetString("ChangeIntoOnAttach"));
10872 }
10873 else
10874 {
10875 ConfigGetTextArray("ChangeIntoOnAttach",attach_types);
10876 }
10877
10878 idx = inventory_slots.Find(slot);
10879 if (idx < 0)
10880 return "";
10881
10882 return attach_types.Get(idx);
10883 }
10884
10886 {
10887 int idx = -1;
10888 string slot;
10889
10892
10893 this.ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
10894 if (inventory_slots.Count() < 1)
10895 {
10896 inventory_slots.Insert(this.ConfigGetString("ChangeInventorySlot"));
10897 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
10898 }
10899 else
10900 {
10901 this.ConfigGetTextArray("ChangeIntoOnDetach",detach_types);
10902 if (detach_types.Count() < 1)
10903 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
10904 }
10905
10906 for (int i = 0; i < inventory_slots.Count(); i++)
10907 {
10908 slot = inventory_slots.Get(i);
10909 }
10910
10911 if (slot != "")
10912 {
10913 if (detach_types.Count() == 1)
10914 idx = 0;
10915 else
10916 idx = inventory_slots.Find(slot);
10917 }
10918 if (idx < 0)
10919 return "";
10920
10921 return detach_types.Get(idx);
10922 }
10923
10925 {
10926
10928
10929
10930 float min_time = 1;
10931 float max_time = 3;
10932 float delay = Math.RandomFloat(min_time, max_time);
10933
10934 explode_timer.Run(delay, this, "DoAmmoExplosion");
10935 }
10936
10938 {
10939 Magazine magazine = Magazine.Cast(this);
10940 int pop_sounds_count = 6;
10941 string pop_sounds[ 6 ] = { "ammopops_1","ammopops_2","ammopops_3","ammopops_4","ammopops_5","ammopops_6" };
10942
10943
10944 int sound_idx = Math.RandomInt(0, pop_sounds_count - 1);
10945 string sound_name = pop_sounds[ sound_idx ];
10947
10948
10949 magazine.ServerAddAmmoCount(-1);
10950
10951
10952 float min_temp_to_explode = 100;
10953
10954 if (magazine.GetAmmoCount() > 0 &&
GetTemperature() >= min_temp_to_explode)
10955 {
10957 }
10958 }
10959
10960
10961 override void EEHitBy(TotalDamageResult damageResult,
int damageType,
EntityAI source,
int component,
string dmgZone,
string ammo, vector modelPos,
float speedCoef)
10962 {
10963 super.EEHitBy(damageResult, damageType, source,
component, dmgZone, ammo, modelPos, speedCoef);
10964
10965 const int CHANCE_DAMAGE_CARGO = 4;
10966 const int CHANCE_DAMAGE_ATTACHMENT = 1;
10967 const int CHANCE_DAMAGE_NOTHING = 2;
10968
10970 {
10971 float dmg = damageResult.
GetDamage(
"",
"Health") * -0.5;
10972 int chances;
10973 int rnd;
10974
10975 if (GetInventory().GetCargo())
10976 {
10977 chances = CHANCE_DAMAGE_CARGO + CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
10978 rnd = Math.RandomInt(0,chances);
10979
10980 if (rnd < CHANCE_DAMAGE_CARGO)
10981 {
10983 }
10984 else if (rnd < (chances - CHANCE_DAMAGE_NOTHING))
10985 {
10987 }
10988 }
10989 else
10990 {
10991 chances = CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
10992 rnd = Math.RandomInt(0,chances);
10993
10994 if (rnd < CHANCE_DAMAGE_ATTACHMENT)
10995 {
10997 }
10998 }
10999 }
11000 }
11001
11003 {
11004 if (GetInventory().GetCargo())
11005 {
11006 int item_count = GetInventory().GetCargo().GetItemCount();
11007 if (item_count > 0)
11008 {
11009 int random_pick = Math.RandomInt(0, item_count);
11011 if (!item.IsExplosive())
11012 {
11013 item.AddHealth("","",damage);
11014 return true;
11015 }
11016 }
11017 }
11018 return false;
11019 }
11020
11022 {
11023 int attachment_count = GetInventory().AttachmentCount();
11024 if (attachment_count > 0)
11025 {
11026 int random_pick = Math.RandomInt(0, attachment_count);
11027 ItemBase attachment =
ItemBase.Cast(GetInventory().GetAttachmentFromIndex(random_pick));
11028 if (!attachment.IsExplosive())
11029 {
11030 attachment.AddHealth("","",damage);
11031 return true;
11032 }
11033 }
11034 return false;
11035 }
11036
11038 {
11040 }
11041
11043 {
11045 return GetInventory().CanRemoveEntity();
11046
11047 return false;
11048 }
11049
11051 {
11052
11054 return false;
11055
11056
11058 return false;
11059
11060
11061
11063 if (delta == 0)
11064 return false;
11065
11066
11067 return true;
11068 }
11069
11071 {
11073 {
11074 if (ScriptInputUserData.CanStoreInputUserData())
11075 {
11076 ScriptInputUserData ctx = new ScriptInputUserData;
11081 ctx.
Write(destination_entity);
11083 ctx.
Write(slot_id);
11085 }
11086 }
11087 else if (!
GetGame().IsMultiplayer())
11088 {
11090 }
11091 }
11092
11094 {
11095 float split_quantity_new;
11099 InventoryLocation loc = new InventoryLocation;
11100
11101 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
11102 {
11104 split_quantity_new = stack_max;
11105 else
11107
11109 {
11110 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
11111 if (new_item)
11112 {
11113 new_item.SetResultOfSplit(true);
11114 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11116 new_item.
SetQuantity(split_quantity_new,
false,
true);
11117 }
11118 }
11119 }
11120 else if (destination_entity && slot_id == -1)
11121 {
11122 if (quantity > stack_max)
11123 split_quantity_new = stack_max;
11124 else
11125 split_quantity_new = quantity;
11126
11128 {
11130 {
11133 }
11134
11135 if (new_item)
11136 {
11137 new_item.SetResultOfSplit(true);
11138 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11140 new_item.
SetQuantity(split_quantity_new,
false,
true);
11141 }
11142 }
11143 }
11144 else
11145 {
11146 if (stack_max != 0)
11147 {
11149 {
11151 }
11152
11153 if (split_quantity_new == 0)
11154 {
11155 if (!
GetGame().IsMultiplayer())
11156 player.PhysicalPredictiveDropItem(this);
11157 else
11158 player.ServerDropEntity(this);
11159 return;
11160 }
11161
11163 {
11165
11166 if (new_item)
11167 {
11168 new_item.SetResultOfSplit(true);
11169 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11172 new_item.PlaceOnSurface();
11173 }
11174 }
11175 }
11176 }
11177 }
11178
11180 {
11181 float split_quantity_new;
11185 InventoryLocation loc = new InventoryLocation;
11186
11187 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
11188 {
11190 split_quantity_new = stack_max;
11191 else
11193
11195 {
11196 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
11197 if (new_item)
11198 {
11199 new_item.SetResultOfSplit(true);
11200 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11202 new_item.
SetQuantity(split_quantity_new,
false,
true);
11203 }
11204 }
11205 }
11206 else if (destination_entity && slot_id == -1)
11207 {
11208 if (quantity > stack_max)
11209 split_quantity_new = stack_max;
11210 else
11211 split_quantity_new = quantity;
11212
11214 {
11216 {
11219 }
11220
11221 if (new_item)
11222 {
11223 new_item.SetResultOfSplit(true);
11224 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11226 new_item.
SetQuantity(split_quantity_new,
false,
true);
11227 }
11228 }
11229 }
11230 else
11231 {
11232 if (stack_max != 0)
11233 {
11235 {
11237 }
11238
11240 {
11242
11243 if (new_item)
11244 {
11245 new_item.SetResultOfSplit(true);
11246 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11249 new_item.PlaceOnSurface();
11250 }
11251 }
11252 }
11253 }
11254 }
11255
11257 {
11259 {
11260 if (ScriptInputUserData.CanStoreInputUserData())
11261 {
11262 ScriptInputUserData ctx = new ScriptInputUserData;
11267 dst.WriteToContext(ctx);
11269 }
11270 }
11271 else if (!
GetGame().IsMultiplayer())
11272 {
11274 }
11275 }
11276
11278 {
11280 {
11281 if (ScriptInputUserData.CanStoreInputUserData())
11282 {
11283 ScriptInputUserData ctx = new ScriptInputUserData;
11288 ctx.
Write(destination_entity);
11294 }
11295 }
11296 else if (!
GetGame().IsMultiplayer())
11297 {
11299 }
11300 }
11301
11303 {
11305 }
11306
11308 {
11310 float split_quantity_new;
11312 if (dst.IsValid())
11313 {
11314 int slot_id = dst.GetSlot();
11316
11317 if (quantity > stack_max)
11318 split_quantity_new = stack_max;
11319 else
11320 split_quantity_new = quantity;
11321
11323 {
11325
11326 if (new_item)
11327 {
11328 new_item.SetResultOfSplit(true);
11329 MiscGameplayFunctions.TransferItemProperties(this,new_item);
11331 new_item.
SetQuantity(split_quantity_new,
false,
true);
11332 }
11333
11334 return new_item;
11335 }
11336 }
11337
11338 return null;
11339 }
11340
11342 {
11344 float split_quantity_new;
11346 if (destination_entity)
11347 {
11349 if (quantity > stackable)
11350 split_quantity_new = stackable;
11351 else
11352 split_quantity_new = quantity;
11353
11355 {
11356 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateEntityInCargoEx(
this.GetType(), idx, row, col,
false));
11357 if (new_item)
11358 {
11359 new_item.SetResultOfSplit(true);
11360 MiscGameplayFunctions.TransferItemProperties(this,new_item);
11362 new_item.
SetQuantity(split_quantity_new,
false,
true);
11363 }
11364 }
11365 }
11366 }
11367
11369 {
11371 {
11372 if (ScriptInputUserData.CanStoreInputUserData())
11373 {
11374 ScriptInputUserData ctx = new ScriptInputUserData;
11379 ItemBase destination_entity =
this;
11380 ctx.
Write(destination_entity);
11384 }
11385 }
11386 else if (!
GetGame().IsMultiplayer())
11387 {
11389 }
11390 }
11391
11393 {
11395 float split_quantity_new;
11397 if (player)
11398 {
11400 if (quantity > stackable)
11401 split_quantity_new = stackable;
11402 else
11403 split_quantity_new = quantity;
11404
11406 {
11407 EntityAI in_hands = player.GetHumanInventory().CreateInHands(this.
GetType());
11408 new_item =
ItemBase.Cast(in_hands);
11409 if (new_item)
11410 {
11411 new_item.SetResultOfSplit(true);
11412 MiscGameplayFunctions.TransferItemProperties(this,new_item);
11414 new_item.SetQuantity(split_quantity_new, false, true);
11415 }
11416 }
11417 }
11418 }
11419
11421 {
11423 float split_quantity_new = Math.Floor(quantity * 0.5);
11424
11426 return;
11427
11429
11430 if (new_item)
11431 {
11432 if (new_item.GetQuantityMax() < split_quantity_new)
11433 {
11434 split_quantity_new = new_item.GetQuantityMax();
11435 }
11436
11437 new_item.SetResultOfSplit(true);
11438 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11439
11441 {
11444 }
11445 else
11446 {
11448 new_item.
SetQuantity(split_quantity_new,
false,
true);
11449 }
11450 }
11451 }
11452
11454 {
11456 float split_quantity_new = Math.Floor(quantity / 2);
11457
11459 return;
11460
11461 InventoryLocation invloc = new InventoryLocation;
11463
11465 new_item = player.CreateCopyOfItemInInventoryOrGroundEx(this, true);
11466
11467 if (new_item)
11468 {
11469 if (new_item.GetQuantityMax() < split_quantity_new)
11470 {
11471 split_quantity_new = new_item.GetQuantityMax();
11472 }
11474 {
11477 }
11478 else if (split_quantity_new > 1)
11479 {
11481 new_item.
SetQuantity(split_quantity_new,
false,
true);
11482 }
11483 }
11484 }
11485
11488 {
11489 SetWeightDirty();
11491
11492 if (parent)
11493 parent.OnAttachmentQuantityChangedEx(this, delta);
11494
11496 {
11498 {
11500 }
11502 {
11503 ErrorEx(
"Undefined liquid type quantity changed, please define liquid type first! Using init value.",
ErrorExSeverity.INFO);
11505 }
11506 }
11507
11508 }
11509
11512 {
11513
11514 }
11515
11518 {
11520 }
11521
11523 {
11524 super.EEHealthLevelChanged(oldLevel,newLevel,zone);
11525
11527 {
11528 if (newLevel == GameConstants.STATE_RUINED)
11529 {
11531 EntityAI parent = GetHierarchyParent();
11532 if (parent && parent.IsFireplace())
11533 {
11534 CargoBase cargo = GetInventory().GetCargo();
11535 if (cargo)
11536 {
11538 {
11540 }
11541 }
11542 }
11543 }
11544
11546 {
11547
11549 return;
11550 }
11551
11552 if (
m_Cleanness != 0 && oldLevel < newLevel && newLevel != 0)
11553 {
11555 }
11556 }
11557 }
11558
11559
11561 {
11562 super.OnRightClick();
11563
11565 {
11567 {
11568 if (ScriptInputUserData.CanStoreInputUserData())
11569 {
11570 EntityAI root = GetHierarchyRoot();
11571 Man playerOwner = GetHierarchyRootPlayer();
11572 InventoryLocation dst = new InventoryLocation;
11573
11574
11575 if (!playerOwner && root && root == this)
11576 {
11578 }
11579 else
11580 {
11581
11582 GetInventory().GetCurrentInventoryLocation(dst);
11584 {
11587 {
11589 }
11590 else
11591 {
11593
11594
11595 if (
GetGame().
GetPlayer().GetInventory().HasInventoryReservation(
this, dst))
11596 {
11598 }
11599 else
11600 {
11601 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(null, dst, GameInventory.c_InventoryReservationTimeoutShortMS);
11602 }
11603 }
11604 }
11605 }
11606
11607 ScriptInputUserData ctx = new ScriptInputUserData;
11615 }
11616 }
11617 else if (!
GetGame().IsMultiplayer())
11618 {
11620 }
11621 }
11622 }
11623
11625 {
11626 if (root)
11627 {
11628 vector m4[4];
11629 root.GetTransform(m4);
11630 dst.SetGround(this, m4);
11631 }
11632 else
11633 {
11634 GetInventory().GetCurrentInventoryLocation(dst);
11635 }
11636 }
11637
11638 override bool CanBeCombined(
EntityAI other_item,
bool reservation_check =
true,
bool stack_max_limit =
false)
11639 {
11640
11641 if (!other_item ||
GetType() != other_item.GetType() || (
IsFullQuantity() && other_item.GetQuantity() > 0) || other_item ==
this)
11642 return false;
11643
11644 if (GetHealthLevel() == GameConstants.STATE_RUINED || other_item.GetHealthLevel() == GameConstants.STATE_RUINED)
11645 return false;
11646
11647
11649 return false;
11650
11651
11652 Magazine mag = Magazine.Cast(this);
11653 if (mag)
11654 {
11655 if (mag.GetAmmoCount() >= mag.GetAmmoMax())
11656 return false;
11657
11658 if (stack_max_limit)
11659 {
11660 Magazine other_mag = Magazine.Cast(other_item);
11661 if (other_item)
11662 {
11663 if (mag.GetAmmoCount() + other_mag.GetAmmoCount() > mag.GetAmmoMax())
11664 return false;
11665 }
11666
11667 }
11668 }
11669 else
11670 {
11671
11673 return false;
11674
11676 return false;
11677 }
11678
11679 PlayerBase player = null;
11680 if (CastTo(player, GetHierarchyRootPlayer()))
11681 {
11682 if (player.GetInventory().HasAttachment(this))
11683 return false;
11684
11685 if (player.IsItemsToDelete())
11686 return false;
11687 }
11688
11689 if (reservation_check && (GetInventory().HasInventoryReservation(this, null) || other_item.GetInventory().HasInventoryReservation(other_item, null)))
11690 return false;
11691
11692 int slotID;
11694 if (GetInventory().GetCurrentAttachmentSlotInfo(slotID,
slotName) && GetHierarchyParent().GetInventory().GetSlotLock(slotID))
11695 return false;
11696
11697 return true;
11698 }
11699
11701 {
11703 }
11704
11706 {
11707 return m_IsResultOfSplit;
11708 }
11709
11711 {
11712 m_IsResultOfSplit = value;
11713 }
11714
11716 {
11718 }
11719
11721 {
11722 float other_item_quantity = other_item.GetQuantity();
11723 float this_free_space;
11724
11726
11728
11729 if (other_item_quantity > this_free_space)
11730 {
11731 return this_free_space;
11732 }
11733 else
11734 {
11735 return other_item_quantity;
11736 }
11737 }
11738
11740 {
11742 }
11743
11745 {
11747 return;
11748
11749 if (!IsMagazine() && other_item)
11750 {
11752 if (quantity_used != 0)
11753 {
11754 float hp1 = GetHealth01("","");
11755 float hp2 = other_item.GetHealth01("","");
11756 float hpResult = ((hp1*
GetQuantity()) + (hp2*quantity_used));
11757 hpResult = hpResult / (
GetQuantity() + quantity_used);
11758
11759 hpResult *= GetMaxHealth();
11760 Math.Round(hpResult);
11761 SetHealth("", "Health", hpResult);
11762
11764 other_item.AddQuantity(-quantity_used);
11765 }
11766 }
11768 }
11769
11771 {
11772 #ifdef SERVER
11773 if (!GetHierarchyRootPlayer() && GetHierarchyParent())
11774 GetHierarchyParent().IncreaseLifetimeUp();
11775 #endif
11776 };
11777
11779 {
11780 PlayerBase p = PlayerBase.Cast(player);
11781
11782 array<int> recipesIds = p.m_Recipes;
11783 PluginRecipesManager moduleRecipesManager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
11784 if (moduleRecipesManager)
11785 {
11786 EntityAI itemInHands = player.GetHumanInventory().GetEntityInHands();
11787 moduleRecipesManager.GetValidRecipes(
ItemBase.Cast(
this),
ItemBase.Cast(itemInHands), recipesIds, p);
11788 }
11789
11790 for (int i = 0;i < recipesIds.Count(); i++)
11791 {
11792 int key = recipesIds.Get(i);
11793 string recipeName = moduleRecipesManager.GetRecipeName(key);
11795 }
11796 }
11797
11798
11799 override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
11800 {
11801 super.GetDebugActions(outputList);
11802
11803
11809
11810
11815
11820
11821
11825
11826
11828 {
11832 }
11833
11836
11837
11841
11843
11844 InventoryLocation loc = new InventoryLocation();
11845 GetInventory().GetCurrentInventoryLocation(loc);
11847 {
11848 if (Gizmo_IsSupported())
11851 }
11852
11854 }
11855
11856
11857
11858
11860 {
11861 super.OnAction(action_id, player, ctx);
11862
11864 {
11865 switch (action_id)
11866 {
11869 return true;
11872 return true;
11873 }
11874 }
11875
11877 {
11878 switch (action_id)
11879 {
11881 Delete();
11882 return true;
11883 }
11884 }
11885
11886 if (action_id >=
EActions.RECIPES_RANGE_START && action_id <
EActions.RECIPES_RANGE_END)
11887 {
11888 PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
11889 int idWithoutOffset = action_id -
EActions.RECIPES_RANGE_START;
11890 PlayerBase p = PlayerBase.Cast(player);
11891 if (
EActions.RECIPES_RANGE_START < 1000)
11892 {
11893 float anim_length = plugin_recipes_manager.GetRecipeLengthInSecs(idWithoutOffset);
11894 float specialty_weight = plugin_recipes_manager.GetRecipeSpecialty(idWithoutOffset);
11895 }
11896 }
11897 #ifndef SERVER
11898 else if (action_id ==
EActions.WATCH_PLAYER)
11899 {
11900 PluginDeveloper.SetDeveloperItemClientEx(player);
11901 }
11902 #endif
11904 {
11905 if (action_id >=
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START && action_id <
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_END)
11906 {
11907 int id = action_id -
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START;
11908 OnDebugButtonPressServer(id + 1);
11909 }
11910
11911 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_INJECT_START && action_id <
EActions.DEBUG_AGENTS_RANGE_INJECT_END)
11912 {
11913 int agent_id = action_id -
EActions.DEBUG_AGENTS_RANGE_INJECT_START;
11915 }
11916
11917 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_REMOVE_START && action_id <
EActions.DEBUG_AGENTS_RANGE_REMOVE_END)
11918 {
11919 int agent_id2 = action_id -
EActions.DEBUG_AGENTS_RANGE_REMOVE_START;
11921 }
11922
11923 else if (action_id ==
EActions.ADD_QUANTITY)
11924 {
11925 if (IsMagazine())
11926 {
11927 Magazine mag = Magazine.Cast(this);
11928 mag.ServerSetAmmoCount(mag.GetAmmoCount() + mag.GetAmmoMax() * 0.2);
11929 }
11930 else
11931 {
11933 }
11934
11935 if (m_EM)
11936 {
11937 m_EM.AddEnergy(m_EM.GetEnergyMax() * 0.2);
11938 }
11939
11940 }
11941
11942 else if (action_id ==
EActions.REMOVE_QUANTITY)
11943 {
11944 if (IsMagazine())
11945 {
11946 Magazine mag2 = Magazine.Cast(this);
11947 mag2.ServerSetAmmoCount(mag2.GetAmmoCount() - mag2.GetAmmoMax() * 0.2);
11948 }
11949 else
11950 {
11952 }
11953 if (m_EM)
11954 {
11955 m_EM.AddEnergy(- m_EM.GetEnergyMax() * 0.2);
11956 }
11957
11958 }
11959
11960 else if (action_id ==
EActions.SET_QUANTITY_0)
11961 {
11963
11964 if (m_EM)
11965 {
11966 m_EM.SetEnergy(0);
11967 }
11968 }
11969
11970 else if (action_id ==
EActions.SET_MAX_QUANTITY)
11971 {
11973
11974 if (m_EM)
11975 {
11976 m_EM.SetEnergy(m_EM.GetEnergyMax());
11977 }
11978 }
11979
11980 else if (action_id ==
EActions.ADD_HEALTH)
11981 {
11982 AddHealth("","",GetMaxHealth("","Health")/5);
11983 }
11984 else if (action_id ==
EActions.REMOVE_HEALTH)
11985 {
11986 AddHealth("","",-GetMaxHealth("","Health")/5);
11987 }
11988 else if (action_id ==
EActions.DESTROY_HEALTH)
11989 {
11990 SetHealth01("","",0);
11991 }
11992 else if (action_id ==
EActions.WATCH_ITEM)
11993 {
11995 mid.RegisterDebugItem(
ItemBase.Cast(
this), PlayerBase.Cast(player));
11996 #ifdef DEVELOPER
11997 SetDebugDeveloper_item(this);
11998 #endif
11999 }
12000
12001 else if (action_id ==
EActions.ADD_TEMPERATURE)
12002 {
12003 AddTemperature(20);
12004
12005 }
12006
12007 else if (action_id ==
EActions.REMOVE_TEMPERATURE)
12008 {
12009 AddTemperature(-20);
12010
12011 }
12012
12013 else if (action_id ==
EActions.FLIP_FROZEN)
12014 {
12015 SetFrozen(!GetIsFrozen());
12016
12017 }
12018
12019 else if (action_id ==
EActions.ADD_WETNESS)
12020 {
12022
12023 }
12024
12025 else if (action_id ==
EActions.REMOVE_WETNESS)
12026 {
12028
12029 }
12030
12031 else if (action_id ==
EActions.LIQUIDTYPE_UP)
12032 {
12035
12036
12037 }
12038
12039 else if (action_id ==
EActions.LIQUIDTYPE_DOWN)
12040 {
12043 }
12044
12045 else if (action_id ==
EActions.MAKE_SPECIAL)
12046 {
12047 auto debugParams = DebugSpawnParams.WithPlayer(player);
12048 OnDebugSpawnEx(debugParams);
12049 }
12050
12051 }
12052
12053
12054 return false;
12055 }
12056
12057
12058
12059
12063
12066
12067
12068
12070 {
12071 return false;
12072 }
12073
12074
12076 {
12077 return true;
12078 }
12079
12080
12082 {
12083 return true;
12084 }
12085
12086
12087
12089 {
12090 string config_path =
string.Format(
"CfgVehicles %1 Food FoodStages",
GetType());
12092 }
12093
12096 {
12097 return null;
12098 }
12099
12101 {
12102 return false;
12103 }
12104
12106 {
12107 return false;
12108 }
12109
12113
12114
12116 {
12117 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
12118 return module_repairing.CanRepair(this, item_repair_kit);
12119 }
12120
12121
12122 bool Repair(PlayerBase player,
ItemBase item_repair_kit,
float specialty_weight)
12123 {
12124 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
12125 return module_repairing.Repair(player, this, item_repair_kit, specialty_weight);
12126 }
12127
12128
12130 {
12131
12132
12133
12134
12135
12136
12137
12138
12139 return 1;
12140 }
12141
12142
12143
12145 {
12147 }
12148
12149
12150
12152 {
12154 }
12155
12156
12165 {
12166 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
12167
12168 if (player)
12169 {
12170 player.MessageStatus(text);
12171 }
12172 }
12173
12174
12183 {
12184 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
12185
12186 if (player)
12187 {
12188 player.MessageAction(text);
12189 }
12190 }
12191
12192
12201 {
12202 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
12203
12204 if (player)
12205 {
12206 player.MessageFriendly(text);
12207 }
12208 }
12209
12210
12219 {
12220 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
12221
12222 if (player)
12223 {
12224 player.MessageImportant(text);
12225 }
12226 }
12227
12229 {
12230 return true;
12231 }
12232
12233
12234 override bool KindOf(
string tag)
12235 {
12236 bool found = false;
12237 string item_name = this.
GetType();
12240
12241 int array_size = item_tag_array.Count();
12242 for (int i = 0; i < array_size; i++)
12243 {
12244 if (item_tag_array.Get(i) == tag)
12245 {
12246 found = true;
12247 break;
12248 }
12249 }
12250 return found;
12251 }
12252
12253
12255 {
12256
12257 super.OnRPC(sender, rpc_type,ctx);
12258
12259
12260 switch (rpc_type)
12261 {
12262 #ifndef SERVER
12263 case ERPCs.RPC_SOUND_LOCK_ATTACH:
12264 Param2<bool, string> p = new Param2<bool, string>(false, "");
12265
12267 return;
12268
12269 bool play = p.param1;
12270 string soundSet = p.param2;
12271
12272 if (play)
12273 {
12275 {
12277 {
12279 }
12280 }
12281 else
12282 {
12284 }
12285 }
12286 else
12287 {
12289 }
12290
12291 break;
12292 #endif
12293
12294 }
12295
12297 {
12299 }
12300 }
12301
12302
12303
12304
12306 {
12307 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
12308 return plugin.GetID(
name);
12309 }
12310
12312 {
12313 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
12314 return plugin.GetName(id);
12315 }
12316
12319 {
12320
12321
12322 int varFlags;
12323 if (!ctx.
Read(varFlags))
12324 return;
12325
12326 if (varFlags & ItemVariableFlags.FLOAT)
12327 {
12329 }
12330 }
12331
12333 {
12334
12335 super.SerializeNumericalVars(floats_out);
12336
12337
12338
12340 {
12342 }
12343
12345 {
12347 }
12348
12350 {
12352 }
12353
12355 {
12360 }
12361
12363 {
12365 }
12366 }
12367
12369 {
12370
12371 super.DeSerializeNumericalVars(floats);
12372
12373
12374 int index = 0;
12375 int mask = Math.Round(floats.Get(index));
12376
12377 index++;
12378
12380 {
12382 {
12384 }
12385 else
12386 {
12387 float quantity = floats.Get(index);
12388 SetQuantity(quantity,
true,
false,
false,
false);
12389 }
12390 index++;
12391 }
12392
12394 {
12395 float wet = floats.Get(index);
12397 index++;
12398 }
12399
12401 {
12402 int liquidtype = Math.Round(floats.Get(index));
12404 index++;
12405 }
12406
12408 {
12410 index++;
12412 index++;
12414 index++;
12416 index++;
12417 }
12418
12420 {
12421 int cleanness = Math.Round(floats.Get(index));
12423 index++;
12424 }
12425 }
12426
12428 {
12429 super.WriteVarsToCTX(ctx);
12430
12431
12433 {
12435 }
12436
12438 {
12440 }
12441
12443 {
12445 }
12446
12448 {
12449 int r,g,b,a;
12455 }
12456
12458 {
12460 }
12461 }
12462
12464 {
12465 if (!super.ReadVarsFromCTX(ctx,version))
12466 return false;
12467
12468 int intValue;
12469 float value;
12470
12471 if (version < 140)
12472 {
12473 if (!ctx.
Read(intValue))
12474 return false;
12475
12476 m_VariablesMask = intValue;
12477 }
12478
12480 {
12481 if (!ctx.
Read(value))
12482 return false;
12483
12485 {
12487 }
12488 else
12489 {
12491 }
12492 }
12493
12494 if (version < 140)
12495 {
12497 {
12498 if (!ctx.
Read(value))
12499 return false;
12500 SetTemperatureDirect(value);
12501 }
12502 }
12503
12505 {
12506 if (!ctx.
Read(value))
12507 return false;
12509 }
12510
12512 {
12513 if (!ctx.
Read(intValue))
12514 return false;
12516 }
12517
12519 {
12520 int r,g,b,a;
12522 return false;
12524 return false;
12526 return false;
12528 return false;
12529
12531 }
12532
12534 {
12535 if (!ctx.
Read(intValue))
12536 return false;
12538 }
12539
12540 if (version >= 138 && version < 140)
12541 {
12543 {
12544 if (!ctx.
Read(intValue))
12545 return false;
12546 SetFrozen(intValue);
12547 }
12548 }
12549
12550 return true;
12551 }
12552
12553
12555 {
12558 {
12560 }
12561
12562 if (!super.OnStoreLoad(ctx, version))
12563 {
12565 return false;
12566 }
12567
12568 if (version >= 114)
12569 {
12570 bool hasQuickBarIndexSaved;
12571
12572 if (!ctx.
Read(hasQuickBarIndexSaved))
12573 {
12575 return false;
12576 }
12577
12578 if (hasQuickBarIndexSaved)
12579 {
12580 int itmQBIndex;
12581
12582
12583 if (!ctx.
Read(itmQBIndex))
12584 {
12586 return false;
12587 }
12588
12589 PlayerBase parentPlayer = PlayerBase.Cast(GetHierarchyRootPlayer());
12590 if (itmQBIndex != -1 && parentPlayer)
12591 parentPlayer.SetLoadedQuickBarItemBind(this, itmQBIndex);
12592 }
12593 }
12594 else
12595 {
12596
12597 PlayerBase player;
12598 int itemQBIndex;
12599 if (version ==
int.
MAX)
12600 {
12601 if (!ctx.
Read(itemQBIndex))
12602 {
12604 return false;
12605 }
12606 }
12607 else if (Class.CastTo(player, GetHierarchyRootPlayer()))
12608 {
12609
12610 if (!ctx.
Read(itemQBIndex))
12611 {
12613 return false;
12614 }
12615 if (itemQBIndex != -1 && player)
12616 player.SetLoadedQuickBarItemBind(this,itemQBIndex);
12617 }
12618 }
12619
12620 if (version < 140)
12621 {
12622
12623 if (!LoadVariables(ctx, version))
12624 {
12626 return false;
12627 }
12628 }
12629
12630
12632 {
12634 return false;
12635 }
12636 if (version >= 132)
12637 {
12639 if (raib)
12640 {
12642 {
12644 return false;
12645 }
12646 }
12647 }
12648
12650 return true;
12651 }
12652
12653
12654
12656 {
12657 super.OnStoreSave(ctx);
12658
12659 PlayerBase player;
12660 if (PlayerBase.CastTo(player,GetHierarchyRootPlayer()))
12661 {
12663
12664 int itemQBIndex = -1;
12665 itemQBIndex = player.FindQuickBarEntityIndex(this);
12666 ctx.
Write(itemQBIndex);
12667 }
12668 else
12669 {
12671 }
12672
12674
12676 if (raib)
12677 {
12679 }
12680 }
12681
12682
12684 {
12685 super.AfterStoreLoad();
12686
12688 {
12690 }
12691
12693 {
12696 }
12697 }
12698
12700 {
12701 super.EEOnAfterLoad();
12702
12704 {
12706 }
12707
12710 }
12711
12713 {
12714 return false;
12715 }
12716
12717
12718
12720 {
12722 {
12723 #ifdef PLATFORM_CONSOLE
12724
12726 {
12728 if (menu)
12729 {
12731 }
12732 }
12733 #endif
12734 }
12735
12737 {
12740 }
12741
12743 {
12744 SetWeightDirty();
12746 }
12748 {
12751 }
12752
12754 {
12757 }
12759 {
12762 }
12763
12764 super.OnVariablesSynchronized();
12765 }
12766
12767
12768
12770 override bool SetQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false,
bool allow_client =
false,
bool clamp_to_stack_max =
true)
12771 {
12772 if (!IsServerCheck(allow_client))
12773 return false;
12774
12776 return false;
12777
12780
12781 if (value <= (min + 0.001))
12782 value = min;
12783
12784 if (value == min)
12785 {
12786 if (destroy_config)
12787 {
12788 bool dstr = ConfigGetBool("varQuantityDestroyOnMin");
12789 if (dstr)
12790 {
12792 this.Delete();
12793 return true;
12794 }
12795 }
12796 else if (destroy_forced)
12797 {
12799 this.Delete();
12800 return true;
12801 }
12802
12804 }
12805
12808
12810 {
12812
12813 if (delta)
12815 }
12816
12818
12819 return false;
12820 }
12821
12822
12824 bool AddQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
12825 {
12827 }
12828
12830 {
12833 }
12834
12836 {
12839 }
12840
12842 override void SetQuantityNormalized(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
12843 {
12844 float value_clamped = Math.Clamp(value, 0, 1);
12846 SetQuantity(result, destroy_config, destroy_forced);
12847 }
12848
12849
12852 {
12854 }
12855
12857 {
12859 }
12860
12861
12862
12863
12864
12865
12866
12867
12868
12869
12871 {
12872 int slot = -1;
12873 if (GetInventory())
12874 {
12875 InventoryLocation il = new InventoryLocation;
12876 GetInventory().GetCurrentInventoryLocation(il);
12878 }
12879
12881 }
12882
12884 {
12885 float quantity_max = 0;
12886
12888 {
12889 if (attSlotID != -1)
12890 quantity_max = InventorySlots.GetStackMaxForSlotId(attSlotID);
12891
12892 if (quantity_max <= 0)
12894 }
12895
12896 if (quantity_max <= 0)
12898
12899 return quantity_max;
12900 }
12901
12903 {
12905 }
12906
12908 {
12910 }
12911
12912
12914 {
12916 }
12917
12919 {
12921 }
12922
12924 {
12926 }
12927
12928
12930 {
12931
12932 float weightEx = GetWeightEx();
12933 float special = GetInventoryAndCargoWeight();
12934 return weightEx - special;
12935 }
12936
12937
12939 {
12941 }
12942
12944 {
12946 {
12947 #ifdef DEVELOPER
12948 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
12949 {
12950 WeightDebugData data1 = WeightDebug.GetWeightDebug(this);
12952 }
12953 #endif
12954
12955 return GetQuantity() * GetConfigWeightModified();
12956 }
12957 else if (HasEnergyManager())
12958 {
12959 #ifdef DEVELOPER
12960 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
12961 {
12962 WeightDebugData data2 = WeightDebug.GetWeightDebug(this);
12963 data2.
SetCalcDetails(
"TIB2: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " + GetCompEM().
GetEnergy()+
"(energy) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit)");
12964 }
12965 #endif
12966 return super.GetWeightSpecialized(forceRecalc) + (GetCompEM().GetEnergy() * ConfigGetFloat("weightPerQuantityUnit")) + GetConfigWeightModified();
12967 }
12968 else
12969 {
12970 #ifdef DEVELOPER
12971 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
12972 {
12973 WeightDebugData data3 = WeightDebug.GetWeightDebug(this);
12974 data3.
SetCalcDetails(
"TIB3: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " +
GetQuantity()+
"(quantity) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit))");
12975 }
12976 #endif
12977 return super.GetWeightSpecialized(forceRecalc) + (
GetQuantity() * ConfigGetFloat(
"weightPerQuantityUnit")) + GetConfigWeightModified();
12978 }
12979 }
12980
12983 {
12984 int item_count = 0;
12986
12987 if (GetInventory().GetCargo() != NULL)
12988 {
12989 item_count = GetInventory().GetCargo().GetItemCount();
12990 }
12991
12992 for (int i = 0; i < GetInventory().AttachmentCount(); i++)
12993 {
12994 Class.CastTo(item,GetInventory().GetAttachmentFromIndex(i));
12995 if (item)
12996 item_count += item.GetNumberOfItems();
12997 }
12998 return item_count;
12999 }
13000
13003 {
13004 float weight = 0;
13005 float wetness = 1;
13006 if (include_wetness)
13009 {
13010 weight = wetness * m_ConfigWeight;
13011 }
13013 {
13014 weight = 1;
13015 }
13016 return weight;
13017 }
13018
13019
13020
13022 {
13023 if ((
GetGame().IsServer() || !
GetGame().IsMultiplayer()) && GetInventory())
13024 {
13025 GameInventory inv = GetInventory();
13026 array<EntityAI> items = new array<EntityAI>;
13028 for (int i = 0; i < items.Count(); i++)
13029 {
13031 if (item)
13032 {
13034 }
13035 }
13036 }
13037 }
13038
13039
13040
13041
13043 {
13044 float energy = 0;
13045 if (HasEnergyManager())
13046 {
13047 energy = GetCompEM().GetEnergy();
13048 }
13049 return energy;
13050 }
13051
13052
13054 {
13055 super.OnEnergyConsumed();
13056
13058 }
13059
13061 {
13062 super.OnEnergyAdded();
13063
13065 }
13066
13067
13069 {
13070 if (
GetGame().IsServer() && HasEnergyManager() && GetCompEM().HasConversionOfEnergyToQuantity())
13071 {
13073 {
13074 float energy_0to1 = GetCompEM().GetEnergy0To1();
13076 }
13077 }
13078 }
13079
13080
13082 {
13083 return ConfigGetFloat("heatIsolation");
13084 }
13085
13087 {
13089 }
13090
13092 {
13093 string paramPath =
string.Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Drying %2",
GetType(), pIncrementName);
13094 if (
GetGame().ConfigIsExisting(paramPath))
13096
13097 return 0.0;
13098 }
13099
13101 {
13102 string paramPath =
string.
Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Soaking %2",
GetType(), pIncrementName);
13103 if (
GetGame().ConfigIsExisting(paramPath))
13105
13106 return 0.0;
13107 }
13108
13109 override void SetWet(
float value,
bool allow_client =
false)
13110 {
13111 if (!IsServerCheck(allow_client))
13112 return;
13113
13116
13118
13119 m_VarWet = Math.Clamp(value, min, max);
13120
13122 {
13125 }
13126 }
13127
13128 override void AddWet(
float value)
13129 {
13131 }
13132
13134 {
13136 }
13137
13139 {
13141 }
13142
13144 {
13146 }
13147
13149 {
13151 }
13152
13154 {
13156 }
13157
13158 override void OnWetChanged(
float newVal,
float oldVal)
13159 {
13162 if (newLevel != oldLevel)
13163 {
13165 }
13166 }
13167
13169 {
13170 SetWeightDirty();
13171 }
13172
13174 {
13175 return GetWetLevelInternal(
m_VarWet);
13176 }
13177
13178
13179
13181 {
13183 }
13184
13186 {
13188 }
13189
13191 {
13193 }
13194
13196 {
13198 }
13199
13200
13201
13203 {
13204 if (ConfigIsExisting("itemModelLength"))
13205 {
13206 return ConfigGetFloat("itemModelLength");
13207 }
13208 return 0;
13209 }
13210
13212 {
13213 if (ConfigIsExisting("itemAttachOffset"))
13214 {
13215 return ConfigGetFloat("itemAttachOffset");
13216 }
13217 return 0;
13218 }
13219
13220 override void SetCleanness(
int value,
bool allow_client =
false)
13221 {
13222 if (!IsServerCheck(allow_client))
13223 return;
13224
13226
13228
13231 }
13232
13234 {
13236 }
13237
13239 {
13240 return true;
13241 }
13242
13243
13244
13245
13247 {
13249 }
13250
13252 {
13254 }
13255
13256
13257
13258
13259 override void SetColor(
int r,
int g,
int b,
int a)
13260 {
13266 }
13268 override void GetColor(out
int r,out
int g,out
int b,out
int a)
13269 {
13274 }
13275
13277 {
13279 }
13280
13283 {
13284 int r,g,b,a;
13286 r = r/255;
13287 g = g/255;
13288 b = b/255;
13289 a = a/255;
13290 return MiscGameplayFunctions.GetColorString(r, g, b, a);
13291 }
13292
13293
13294
13295 override void SetLiquidType(
int value,
bool allow_client =
false)
13296 {
13297 if (!IsServerCheck(allow_client))
13298 return;
13299
13304 }
13305
13307 {
13308 return ConfigGetInt("varLiquidTypeInit");
13309 }
13310
13312 {
13314 }
13315
13317 {
13319 SetFrozen(false);
13320 }
13321
13324 {
13325 player.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
13326 }
13327
13328
13331 {
13332 PlayerBase nplayer;
13333 if (PlayerBase.CastTo(nplayer, player))
13334 {
13336
13337 nplayer.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
13338 }
13339 }
13340
13341
13344 {
13345 PlayerBase nplayer;
13346 if (PlayerBase.CastTo(nplayer,player))
13347 {
13348
13349 nplayer.SetEnableQuickBarEntityShortcut(this,false);
13350
13351 }
13352
13353
13354 player.GetHumanInventory().ClearUserReservedLocationForContainer(this);
13355
13356
13357 if (HasEnergyManager())
13358 {
13359 GetCompEM().UpdatePlugState();
13360 }
13361 }
13362
13363
13365 {
13366 super.OnPlacementStarted(player);
13367
13369 }
13370
13371 override void OnPlacementComplete(Man player, vector position =
"0 0 0", vector orientation =
"0 0 0")
13372 {
13374 {
13375 m_AdminLog.OnPlacementComplete(player,
this);
13376 }
13377
13378 super.OnPlacementComplete(player, position, orientation);
13379 }
13380
13381
13382
13383
13384
13386 {
13388 {
13389 return true;
13390 }
13391 else
13392 {
13393 return false;
13394 }
13395 }
13396
13397
13399 {
13401 {
13403 }
13404 }
13405
13406
13408 {
13410 }
13411
13413 {
13415 }
13416
13417 override void InsertAgent(
int agent,
float count = 1)
13418 {
13419 if (count < 1)
13420 return;
13421
13423 }
13424
13427 {
13429 }
13430
13431
13433 {
13435 }
13436
13437
13438
13439
13440
13441
13442
13443
13444
13445
13446
13447
13448
13449
13450
13451
13452
13453
13454
13455
13456
13457
13458
13459
13460
13461
13462
13463
13464
13465
13466
13467
13468
13469
13470
13471
13472
13473
13474
13475
13476
13477
13479 {
13481 return false;
13482 return true;
13483 }
13484
13486 {
13487
13489 }
13490
13491
13494 {
13495 super.CheckForRoofLimited(timeTresholdMS);
13496
13498 if ((time - m_PreviousRoofTestTime) >= timeTresholdMS)
13499 {
13500 m_PreviousRoofTestTime = time;
13501 SetRoofAbove(MiscGameplayFunctions.IsUnderRoof(this));
13502 }
13503 }
13504
13505
13507 {
13509 {
13510 return 0;
13511 }
13512
13513 if (GetInventory().GetAttachmentSlotsCount() != 0)
13514 {
13515 ItemBase filter =
ItemBase.Cast(FindAttachmentBySlotName(
"GasMaskFilter"));
13516 if (filter)
13517 return filter.GetProtectionLevel(type, false, system);
13518 else
13519 return 0;
13520 }
13521
13522 string subclassPath, entryName;
13523
13524 switch (type)
13525 {
13527 entryName = "biological";
13528 break;
13530 entryName = "chemical";
13531 break;
13532 default:
13533 entryName = "biological";
13534 break;
13535 }
13536
13537 subclassPath =
"CfgVehicles " + this.
GetType() +
" Protection ";
13538
13540 }
13541
13542
13543
13546 {
13547 if (!IsMagazine())
13549
13551 }
13552
13553
13554
13555
13556
13561 {
13562 return true;
13563 }
13564
13566 {
13568 }
13569
13570
13571
13572
13573
13575 {
13576 if (parent)
13577 {
13578 if (parent.IsInherited(DayZInfected))
13579 return true;
13580
13581 if (!parent.IsRuined())
13582 return true;
13583 }
13584
13585 return true;
13586 }
13587
13589 {
13590 if (!super.CanPutAsAttachment(parent))
13591 {
13592 return false;
13593 }
13594
13595 if (!IsRuined() && !parent.IsRuined())
13596 {
13597 return true;
13598 }
13599
13600 return false;
13601 }
13602
13604 {
13605
13606
13607
13608
13609 return super.CanReceiveItemIntoCargo(item);
13610 }
13611
13613 {
13614
13615
13616
13617
13618 GameInventory attachmentInv = attachment.GetInventory();
13620 {
13621 if (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase))
13622 return false;
13623 }
13624
13625 InventoryLocation loc = new InventoryLocation();
13626 attachment.GetInventory().GetCurrentInventoryLocation(loc);
13627 if (loc && loc.
IsValid() && !GetInventory().AreChildrenAccessible())
13628 return false;
13629
13630 return super.CanReceiveAttachment(attachment, slotId);
13631 }
13632
13634 {
13635 if (!super.CanReleaseAttachment(attachment))
13636 return false;
13637
13638 return GetInventory().AreChildrenAccessible();
13639 }
13640
13641
13642
13643
13644
13645
13646
13647
13648
13649
13650
13651
13652
13653
13654
13655
13656
13657
13658
13659
13660
13662 {
13663 int id = muzzle_owner.GetMuzzleID();
13664 array<ref WeaponParticlesOnFire> WPOF_array =
m_OnFireEffect.Get(
id);
13665
13666 if (WPOF_array)
13667 {
13668 for (int i = 0; i < WPOF_array.Count(); i++)
13669 {
13670 WeaponParticlesOnFire WPOF = WPOF_array.Get(i);
13671
13672 if (WPOF)
13673 {
13674 WPOF.OnActivate(weapon, muzzle_index, ammoType, muzzle_owner, suppressor, config_to_search);
13675 }
13676 }
13677 }
13678 }
13679
13680
13682 {
13683 int id = muzzle_owner.GetMuzzleID();
13685
13686 if (WPOBE_array)
13687 {
13688 for (int i = 0; i < WPOBE_array.Count(); i++)
13689 {
13690 WeaponParticlesOnBulletCasingEject WPOBE = WPOBE_array.Get(i);
13691
13692 if (WPOBE)
13693 {
13694 WPOBE.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
13695 }
13696 }
13697 }
13698 }
13699
13700
13702 {
13703 int id = muzzle_owner.GetMuzzleID();
13704 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
13705
13706 if (WPOOH_array)
13707 {
13708 for (int i = 0; i < WPOOH_array.Count(); i++)
13709 {
13710 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
13711
13712 if (WPOOH)
13713 {
13714 WPOOH.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
13715 }
13716 }
13717 }
13718 }
13719
13720
13722 {
13723 int id = muzzle_owner.GetMuzzleID();
13724 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
13725
13726 if (WPOOH_array)
13727 {
13728 for (int i = 0; i < WPOOH_array.Count(); i++)
13729 {
13730 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
13731
13732 if (WPOOH)
13733 {
13734 WPOOH.OnUpdate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
13735 }
13736 }
13737 }
13738 }
13739
13740
13742 {
13743 int id = muzzle_owner.GetMuzzleID();
13744 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
13745
13746 if (WPOOH_array)
13747 {
13748 for (int i = 0; i < WPOOH_array.Count(); i++)
13749 {
13750 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
13751
13752 if (WPOOH)
13753 {
13754 WPOOH.OnDeactivate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
13755 }
13756 }
13757 }
13758 }
13759
13760
13761
13763 {
13765 {
13766 return true;
13767 }
13768
13769 return false;
13770 }
13771
13773 {
13775 {
13776 return true;
13777 }
13778
13779 return false;
13780 }
13781
13783 {
13785 {
13786 return true;
13787 }
13788
13789 return false;
13790 }
13791
13793 {
13794 return false;
13795 }
13796
13799 {
13800 return UATimeSpent.DEFAULT_DEPLOY;
13801 }
13802
13803
13804
13805
13807 {
13809 SetSynchDirty();
13810 }
13811
13813 {
13815 }
13816
13817
13819 {
13820 return false;
13821 }
13822
13825 {
13826 string att_type = "None";
13827
13828 if (ConfigIsExisting("soundAttType"))
13829 {
13830 att_type = ConfigGetString("soundAttType");
13831 }
13832
13834 }
13835
13837 {
13839 }
13840
13841
13842
13843
13844
13850
13852 {
13855
13857 }
13858
13859
13861 {
13863 return;
13864
13866
13869
13872
13873 SoundParameters params = new SoundParameters();
13877 }
13878
13879
13881 {
13883 return;
13884
13886 SetSynchDirty();
13887
13890 }
13891
13892
13894 {
13896 return;
13897
13899 SetSynchDirty();
13900
13903 }
13904
13906 {
13908 }
13909
13911 {
13913 }
13914
13917 {
13918 if (!
GetGame().IsDedicatedServer())
13919 {
13920 if (ConfigIsExisting("attachSoundSet"))
13921 {
13922 string cfg_path = "";
13923 string soundset = "";
13924 string type_name =
GetType();
13925
13928 ConfigGetTextArray("attachSoundSet",cfg_soundset_array);
13929 ConfigGetTextArray("attachSoundSlot",cfg_slot_array);
13930
13931 if (cfg_soundset_array.Count() > 0 && cfg_soundset_array.Count() == cfg_slot_array.Count())
13932 {
13933 for (int i = 0; i < cfg_soundset_array.Count(); i++)
13934 {
13935 if (cfg_slot_array[i] == slot_type)
13936 {
13937 soundset = cfg_soundset_array[i];
13938 break;
13939 }
13940 }
13941 }
13942
13943 if (soundset != "")
13944 {
13945 EffectSound sound = SEffectManager.PlaySound(soundset,
GetPosition());
13947 }
13948 }
13949 }
13950 }
13951
13953 {
13954
13955 }
13956
13957 void OnApply(PlayerBase player);
13958
13960 {
13961 return 1.0;
13962 };
13963
13965 {
13967 }
13968
13970 {
13972 }
13973
13975
13977 {
13978 SetDynamicPhysicsLifeTime(0.01);
13980 }
13981
13983 {
13984 array<string> zone_names = new array<string>;
13985 GetDamageZones(zone_names);
13986 for (int i = 0; i < zone_names.Count(); i++)
13987 {
13988 SetHealthMax(zone_names.Get(i),"Health");
13989 }
13990 SetHealthMax("","Health");
13991 }
13992
13995 {
13996 float global_health = GetHealth01("","Health");
13997 array<string> zones = new array<string>;
13998 GetDamageZones(zones);
13999
14000 for (int i = 0; i < zones.Count(); i++)
14001 {
14002 SetHealth01(zones.Get(i),"Health",global_health);
14003 }
14004 }
14005
14008 {
14009 return IsExclusionFlagPresent(PlayerBase.GetFaceCoverageShaveValues());
14010 }
14011
14013 {
14014 if (!hasRootAsPlayer)
14015 {
14016 if (refParentIB)
14017 {
14018
14019 if ((refParentIB.GetWet() >= GameConstants.STATE_SOAKING_WET) && (
m_VarWet <
m_VarWetMax))
14020 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_INSIDE);
14021
14022 else if ((refParentIB.GetLiquidType() != 0) && (refParentIB.GetQuantity() > 0) && (
m_VarWet <
m_VarWetMax))
14023 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_LIQUID);
14024
14027 }
14028 else
14029 {
14030
14033 }
14034 }
14035 }
14036
14038 {
14040 {
14041 float target =
g_Game.GetMission().GetWorldData().GetBaseEnvTemperatureAtObject(
this);
14042 if (
GetTemperature() != target || !IsFreezeThawProgressFinished())
14043 {
14044 float heatPermCoef = 1.0;
14046 while (ent)
14047 {
14048 heatPermCoef *= ent.GetHeatPermeabilityCoef();
14049 ent = ent.GetHierarchyParent();
14050 }
14051
14052 SetTemperatureEx(
new TemperatureDataInterpolated(target,
ETemperatureAccessTypes.ACCESS_WORLD,delta,GameConstants.TEMP_COEF_WORLD,heatPermCoef));
14053 }
14054 }
14055 }
14056
14058 {
14059
14060 EntityAI parent = GetHierarchyParent();
14061 if (!parent)
14062 {
14063 hasParent = false;
14064 hasRootAsPlayer = false;
14065 }
14066 else
14067 {
14068 hasParent = true;
14069 hasRootAsPlayer = (GetHierarchyRootPlayer() != null);
14070 refParentIB =
ItemBase.Cast(parent);
14071 }
14072 }
14073
14074 protected void ProcessDecay(
float delta,
bool hasRootAsPlayer)
14075 {
14076
14077 }
14078
14080 {
14081
14082 return false;
14083 }
14084
14086 {
14087
14088
14089 return false;
14090 }
14091
14093 {
14094
14095 return false;
14096 }
14097
14100 {
14101 return !GetIsFrozen() &&
IsOpen();
14102 }
14103
14105 {
14106 bool hasParent = false, hasRootAsPlayer = false;
14108
14109 bool wwtu =
g_Game.IsWorldWetTempUpdateEnabled();
14110 bool foodDecay =
g_Game.IsFoodDecayEnabled();
14111
14112 if (wwtu || foodDecay)
14113 {
14117
14118 if (processWetness || processTemperature || processDecay)
14119 {
14121
14122 if (processWetness)
14123 ProcessItemWetness(m_ElapsedSinceLastUpdate, hasParent, hasRootAsPlayer, refParentIB);
14124
14125 if (processTemperature)
14127
14128 if (processDecay)
14129 ProcessDecay(m_ElapsedSinceLastUpdate, hasRootAsPlayer);
14130 }
14131 }
14132 }
14133
14136 {
14138 }
14139
14141 {
14144
14145 return super.GetTemperatureFreezeThreshold();
14146 }
14147
14149 {
14152
14153 return super.GetTemperatureThawThreshold();
14154 }
14155
14157 {
14160
14161 return super.GetItemOverheatThreshold();
14162 }
14163
14165 {
14167 return Math.Lerp(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureFreezeTime()),
GetQuantityNormalized());
14168
14169 return super.GetTemperatureFreezeTime();
14170 }
14171
14173 {
14175 return Math.Lerp(GameConstants.TEMPERATURE_TIME_THAW_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureThawTime()),
GetQuantityNormalized());
14176
14177 return super.GetTemperatureThawTime();
14178 }
14179
14184
14186 {
14187 return (item.IsKindOf("Cauldron") || item.IsKindOf("Pot") || item.IsKindOf("FryingPan") || item.IsKindOf("SmallProtectorCase") || (item.IsKindOf("PortableGasStove") && item.FindAttachmentBySlotName("CookingEquipment")));
14188 }
14189
14191 {
14192 MiscGameplayFunctions.TransferItemProperties(oldItem, this);
14193 }
14194
14197 {
14199 }
14200
14202 {
14204 }
14205
14207 {
14209 }
14210
14213 {
14214 return null;
14215 }
14216
14219 {
14220 return false;
14221 }
14222
14224 {
14226 {
14229 if (!trg)
14230 {
14232 explosive = this;
14233 }
14234
14235 explosive.PairRemote(trg);
14237
14238 int persistentID = RemotelyActivatedItemBehaviour.GeneratePersistentID();
14239 trg.SetPersistentPairID(persistentID);
14240 explosive.SetPersistentPairID(persistentID);
14241
14242 return true;
14243 }
14244 return false;
14245 }
14246
14249 {
14250 float ret = 1.0;
14253 ret *= GetHealth01();
14254
14255 return ret;
14256 }
14257
14258 #ifdef DEVELOPER
14259 override void SetDebugItem()
14260 {
14261 super.SetDebugItem();
14262 _itemBase = this;
14263 }
14264
14266 {
14267 string text = super.GetDebugText();
14268
14270 text +=
string.
Format(
"Heat isolation(modified): %1\n", MiscGameplayFunctions.GetCurrentItemHeatIsolation(
this));
14271
14272 return text;
14273 }
14274 #endif
14275
14277 {
14278 return true;
14279 }
14280
14282
14284
14286 {
14289 }
14290
14291
14299
14315}
14316
14318{
14320 if (entity)
14321 {
14322 bool is_item = entity.IsInherited(
ItemBase);
14323 if (is_item && full_quantity)
14324 {
14327 }
14328 }
14329 else
14330 {
14332 return NULL;
14333 }
14334 return entity;
14335}
14336
14338{
14339 if (item)
14340 {
14341 if (health > 0)
14342 item.SetHealth("", "", health);
14343
14344 if (item.CanHaveTemperature())
14345 {
14347 if (item.CanFreeze())
14348 item.SetFrozen(false);
14349 }
14350
14351 if (item.HasEnergyManager())
14352 {
14353 if (quantity >= 0)
14354 {
14355 item.GetCompEM().SetEnergy0To1(quantity);
14356 }
14357 else
14358 {
14360 }
14361 }
14362 else if (item.IsMagazine())
14363 {
14364 Magazine mag = Magazine.Cast(item);
14365 if (quantity >= 0)
14366 {
14367 mag.ServerSetAmmoCount(mag.GetAmmoMax() * quantity);
14368 }
14369 else
14370 {
14372 }
14373
14374 }
14375 else
14376 {
14377 if (quantity >= 0)
14378 {
14379 item.SetQuantityNormalized(quantity, false);
14380 }
14381 else
14382 {
14384 }
14385
14386 }
14387 }
14388}
14389
14390#ifdef DEVELOPER
14392#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.