9358{
9360 {
9361 return true;
9362 }
9363};
9364
9365
9366
9368{
9372
9374
9377
9378
9379
9380
9381
9390
9396
9401
9406
9427 protected bool m_IsResultOfSplit
9428
9430
9435
9436
9437
9439
9443
9444
9445
9447
9450
9451
9452
9458
9459
9467
9470
9471
9473
9474
9476
9477
9482
9483
9488
9489
9491
9492
9494 {
9499
9500 if (!
GetGame().IsDedicatedServer())
9501 {
9503 {
9505
9507 {
9509 }
9510 }
9511
9514 }
9515
9516 m_OldLocation = null;
9517
9519 {
9521 }
9522
9523 if (ConfigIsExisting("headSelectionsToHide"))
9524 {
9527 }
9528
9530 if (ConfigIsExisting("hideSelectionsByinventorySlot"))
9531 {
9533 }
9534
9536
9537 m_IsResultOfSplit = false;
9538
9540 }
9541
9543 {
9544 super.InitItemVariables();
9545
9551 m_Count = ConfigGetInt(
"count");
9552
9555
9560
9563
9568
9580
9584
9585
9588 if (ConfigIsExisting("canBeSplit"))
9589 {
9592 }
9593
9595 if (ConfigIsExisting("itemBehaviour"))
9597
9598
9601 RegisterNetSyncVariableInt("m_VarLiquidType");
9602 RegisterNetSyncVariableInt("m_Cleanness",0,1);
9603
9604 RegisterNetSyncVariableBoolSignal("m_WantPlayImpactSound");
9605 RegisterNetSyncVariableFloat("m_ImpactSpeed");
9606 RegisterNetSyncVariableInt("m_ImpactSoundSurfaceHash");
9607
9608 RegisterNetSyncVariableInt("m_ColorComponentR", 0, 255);
9609 RegisterNetSyncVariableInt("m_ColorComponentG", 0, 255);
9610 RegisterNetSyncVariableInt("m_ColorComponentB", 0, 255);
9611 RegisterNetSyncVariableInt("m_ColorComponentA", 0, 255);
9612
9613 RegisterNetSyncVariableBool("m_IsBeingPlaced");
9614 RegisterNetSyncVariableBool("m_IsTakeable");
9615 RegisterNetSyncVariableBool("m_IsHologram");
9616
9619 {
9622 }
9623
9625
9627 if (ConfigIsExisting("temperaturePerQuantityWeight"))
9629
9630 }
9631
9633 {
9635 }
9636
9638 {
9641 {
9646 }
9647 }
9648
9649 override void GetActions(
typename action_input_type, out array<ActionBase_Basic> actions)
9650 {
9652 {
9655 }
9656
9658 }
9659
9661 {
9667 }
9668
9670
9672 {
9674
9675 if (!action)
9676 {
9677 Debug.LogError(
"Action " + actionName +
" dosn't exist!");
9678 return;
9679 }
9680
9682 if (!ai)
9683 {
9685 return;
9686 }
9687
9689 if (!action_array)
9690 {
9691 action_array = new array<ActionBase_Basic>;
9693 }
9694 if (LogManager.IsActionLogEnable())
9695 {
9696 Debug.ActionLog(action.ToString() +
" -> " + ai,
this.ToString() ,
"n/a",
"Add action");
9697 }
9698
9699 if (action_array.Find(action) != -1)
9700 {
9701 Debug.Log(
"Action " + action.Type() +
" already added to " +
this +
", skipping!");
9702 }
9703 else
9704 {
9705 action_array.Insert(action);
9706 }
9707 }
9708
9710 {
9712 ActionBase action = player.GetActionManager().GetAction(actionName);
9715
9716 if (action_array)
9717 {
9718 action_array.RemoveItem(action);
9719 }
9720 }
9721
9722
9723
9725 {
9726 ActionOverrideData overrideData = new ActionOverrideData();
9730
9732 if (!actionMap)
9733 {
9736 }
9737
9738 actionMap.Insert(this.
Type(), overrideData);
9739
9740 }
9741
9743
9745
9746
9748 {
9751
9754
9755 string config_to_search = "CfgVehicles";
9756 string muzzle_owner_config;
9757
9759 {
9760 if (IsInherited(Weapon))
9761 config_to_search = "CfgWeapons";
9762
9763 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
9764
9765 string config_OnFire_class = muzzle_owner_config + "Particles " + "OnFire ";
9766
9768
9769 if (config_OnFire_subclass_count > 0)
9770 {
9771 array<ref WeaponParticlesOnFire> WPOF_array = new array<ref WeaponParticlesOnFire>;
9772
9773 for (int i = 0; i < config_OnFire_subclass_count; i++)
9774 {
9775 string particle_class = "";
9777 string config_OnFire_entry = config_OnFire_class + particle_class;
9778 WeaponParticlesOnFire WPOF = new WeaponParticlesOnFire(this, config_OnFire_entry);
9779 WPOF_array.Insert(WPOF);
9780 }
9781
9782
9784 }
9785 }
9786
9788 {
9789 config_to_search = "CfgWeapons";
9790 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
9791
9792 string config_OnBulletCasingEject_class = muzzle_owner_config + "Particles " + "OnBulletCasingEject ";
9793
9795
9796 if (config_OnBulletCasingEject_count > 0 && IsInherited(Weapon))
9797 {
9798 array<ref WeaponParticlesOnBulletCasingEject> WPOBE_array = new array<ref WeaponParticlesOnBulletCasingEject>;
9799
9800 for (i = 0; i < config_OnBulletCasingEject_count; i++)
9801 {
9802 string particle_class2 = "";
9804 string config_OnBulletCasingEject_entry = config_OnBulletCasingEject_class + particle_class2;
9805 WeaponParticlesOnBulletCasingEject WPOBE = new WeaponParticlesOnBulletCasingEject(this, config_OnBulletCasingEject_entry);
9806 WPOBE_array.Insert(WPOBE);
9807 }
9808
9809
9811 }
9812 }
9813 }
9814
9815
9817 {
9820
9822 {
9823 string config_to_search = "CfgVehicles";
9824
9825 if (IsInherited(Weapon))
9826 config_to_search = "CfgWeapons";
9827
9828 string muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
9829 string config_OnOverheating_class = muzzle_owner_config + "Particles " + "OnOverheating ";
9830
9831 if (
GetGame().ConfigIsExisting(config_OnOverheating_class))
9832 {
9833
9835
9837 {
9839 string error =
"Error reading config " +
GetType() +
">Particles>OnOverheating - Parameter shotsToStartOverheating is configured wrong or is missing! Its value must be 1 or higher!";
9841 return;
9842 }
9843
9846
9847
9848
9850 array<ref WeaponParticlesOnOverheating> WPOOH_array = new array<ref WeaponParticlesOnOverheating>;
9851
9852 for (int i = 0; i < config_OnOverheating_subclass_count; i++)
9853 {
9854 string particle_class = "";
9856 string config_OnOverheating_entry = config_OnOverheating_class + particle_class;
9858
9859 if (entry_type == CT_CLASS)
9860 {
9861 WeaponParticlesOnOverheating WPOF = new WeaponParticlesOnOverheating(this, config_OnOverheating_entry);
9862 WPOOH_array.Insert(WPOF);
9863 }
9864 }
9865
9866
9868 }
9869 }
9870 }
9871
9873 {
9875 }
9876
9878 {
9880 {
9882
9885
9888
9889 CheckOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9890 }
9891 }
9892
9894 {
9896 UpdateOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9897
9899 StartOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9900
9902 StopOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9903
9905 {
9907 }
9908 }
9909
9911 {
9913 }
9914
9916 {
9919 else
9921
9923 {
9926 }
9927 else
9928 {
9931
9934 }
9935
9937 }
9938
9940 {
9942 ItemBase.PlayOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
9943 }
9944
9946 {
9948 ItemBase.UpdateOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
9950 }
9951
9953 {
9955 ItemBase.StopOverheatingParticles(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9956 }
9957
9959 {
9962
9963 OverheatingParticle OP = new OverheatingParticle();
9968
9970 }
9971
9973 {
9976
9977 return -1;
9978 }
9979
9981 {
9983 {
9986
9987 for (int i = count; i > 0; --i)
9988 {
9989 int id = i - 1;
9992
9995
9996 if (overheat_coef < overheat_min && overheat_coef >= overheat_max)
9997 {
9998 if (p)
9999 {
10002 }
10003 }
10004 }
10005 }
10006 }
10007
10009 {
10011 {
10013 {
10014 int id = i - 1;
10016
10017 if (OP)
10018 {
10020
10021 if (p)
10022 {
10024 }
10025
10026 delete OP;
10027 }
10028 }
10029
10032 }
10033 }
10034
10037 {
10038 return 0.0;
10039 }
10040
10041
10043 {
10044 return 250;
10045 }
10046
10048 {
10049 return 0;
10050 }
10051
10054 {
10056 return true;
10057
10058 return false;
10059 }
10060
10063 {
10066
10068 {
10070 }
10071 else
10072 {
10073
10075 }
10076
10078 }
10079
10086 {
10087 return -1;
10088 }
10089
10090
10091
10092
10094 {
10096 {
10098 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
10099
10100 if (r_index >= 0)
10101 {
10102 InventoryLocation r_il = new InventoryLocation;
10103 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
10104
10105 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
10108 {
10109 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
10110 }
10112 {
10113 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
10114 }
10115
10116 }
10117
10118 player.GetHumanInventory().ClearUserReservedLocation(this);
10119 }
10120
10123 }
10124
10125
10126
10127
10129 {
10130 return ItemBase.m_DebugActionsMask;
10131 }
10132
10134 {
10135 return ItemBase.m_DebugActionsMask & mask;
10136 }
10137
10139 {
10140 ItemBase.m_DebugActionsMask = mask;
10141 }
10142
10144 {
10145 ItemBase.m_DebugActionsMask |= mask;
10146 }
10147
10149 {
10150 ItemBase.m_DebugActionsMask &= ~mask;
10151 }
10152
10154 {
10156 {
10158 }
10159 else
10160 {
10162 }
10163 }
10164
10165
10167 {
10168 if (GetEconomyProfile())
10169 {
10170 float q_max = GetEconomyProfile().GetQuantityMax();
10171 if (q_max > 0)
10172 {
10173 float q_min = GetEconomyProfile().GetQuantityMin();
10174 float quantity_randomized = Math.RandomFloatInclusive(q_min, q_max);
10175
10177 {
10178 ComponentEnergyManager comp = GetCompEM();
10180 {
10182 }
10183 }
10185 {
10187
10188 }
10189
10190 }
10191 }
10192 }
10193
10196 {
10197 EntityAI parent = GetHierarchyParent();
10198
10199 if (parent)
10200 {
10201 InventoryLocation inventory_location_to_lock = new InventoryLocation;
10202 GetInventory().GetCurrentInventoryLocation(inventory_location_to_lock);
10203 parent.GetInventory().SetSlotLock(inventory_location_to_lock.
GetSlot(),
true);
10204 }
10205 }
10206
10209 {
10210 EntityAI parent = GetHierarchyParent();
10211
10212 if (parent)
10213 {
10214 InventoryLocation inventory_location_to_unlock = new InventoryLocation;
10215 GetInventory().GetCurrentInventoryLocation(inventory_location_to_unlock);
10216 parent.GetInventory().SetSlotLock(inventory_location_to_unlock.
GetSlot(),
false);
10217 }
10218 }
10219
10221 {
10222
10223
10224
10225
10227
10229 {
10230 if (ScriptInputUserData.CanStoreInputUserData())
10231 {
10232 ScriptInputUserData ctx = new ScriptInputUserData;
10238 ctx.
Write(use_stack_max);
10241
10243 {
10244 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(item2,null,GameInventory.c_InventoryReservationTimeoutShortMS);
10245 }
10246 }
10247 }
10248 else if (!
GetGame().IsMultiplayer())
10249 {
10251 }
10252 }
10253
10255 {
10257 }
10258
10260 {
10262 }
10263
10265 {
10267 }
10268
10270 {
10271
10272 return false;
10273 }
10274
10276 {
10277 return false;
10278 }
10279
10283 {
10284 return false;
10285 }
10286
10288 {
10289 return "";
10290 }
10291
10293
10295 {
10296 return false;
10297 }
10298
10300 {
10301 return true;
10302 }
10303
10304
10305
10307 {
10308 return true;
10309 }
10310
10312 {
10313 return true;
10314 }
10315
10317 {
10318 PlayerBase player = PlayerBase.Cast(
g_Game.GetPlayer());
10320 }
10321
10323 {
10325 }
10326
10328 {
10330 if (!is_being_placed)
10332 SetSynchDirty();
10333 }
10334
10335
10337
10339 {
10341 }
10342
10344 {
10346 }
10347
10349 {
10350 return 1;
10351 }
10352
10354 {
10355 return false;
10356 }
10357
10359 {
10361 SetSynchDirty();
10362 }
10363
10364
10365
10366
10367
10368
10369
10370
10371
10372
10373
10374
10375
10376
10377
10378
10379
10380
10381
10382
10383
10384
10385
10386
10387
10388
10389
10390
10391
10392
10393
10394
10395
10396
10397
10399 {
10400 super.OnMovedInsideCargo(container);
10401
10402 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
10403 }
10404
10405 override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
10406 {
10407 super.EEItemLocationChanged(oldLoc,newLoc);
10408
10409 PlayerBase new_player = null;
10410 PlayerBase old_player = null;
10411
10412 if (newLoc.GetParent())
10413 new_player = PlayerBase.Cast(newLoc.GetParent().GetHierarchyRootPlayer());
10414
10415 if (oldLoc.GetParent())
10416 old_player = PlayerBase.Cast(oldLoc.GetParent().GetHierarchyRootPlayer());
10417
10419 {
10420 int r_index = old_player.GetHumanInventory().FindUserReservedLocationIndex(this);
10421
10422 if (r_index >= 0)
10423 {
10424 InventoryLocation r_il = new InventoryLocation;
10425 old_player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
10426
10427 old_player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
10430 {
10431 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
10432 }
10434 {
10435 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
10436 }
10437
10438 }
10439 }
10440
10442 {
10443 if (new_player)
10444 new_player.ForceStandUpForHeavyItems(newLoc.GetItem());
10445
10446 if (new_player == old_player)
10447 {
10448
10449 if (oldLoc.GetParent() && new_player.GetHumanInventory().LocationGetEntity(oldLoc) == NULL)
10450 {
10452 {
10453 if (oldLoc.GetParent().GetInventory().TestAddEntityInCargoExLoc(oldLoc, false, false, false, true, false, false))
10454 {
10455 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
10456 }
10457 }
10458 else
10459 {
10460 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
10461 }
10462 }
10463
10464 if (new_player.GetHumanInventory().FindUserReservedLocationIndex(this) >= 0)
10465 {
10466 int type = oldLoc.GetType();
10468 {
10469 oldLoc.GetParent().GetOnSetLock().Invoke(this);
10470 }
10472 {
10473 oldLoc.GetParent().GetOnAttachmentSetLock().Invoke(this, oldLoc.GetSlot());
10474 }
10475 }
10476 if (!m_OldLocation)
10477 {
10478 m_OldLocation = new InventoryLocation;
10479 }
10480 m_OldLocation.Copy(oldLoc);
10481 }
10482 else
10483 {
10484 if (m_OldLocation)
10485 {
10486 m_OldLocation.Reset();
10487 }
10488 }
10489
10491 }
10492 else
10493 {
10494 if (new_player)
10495 {
10496 int res_index = new_player.GetHumanInventory().FindCollidingUserReservedLocationIndex(this, newLoc);
10497 if (res_index >= 0)
10498 {
10499 InventoryLocation il = new InventoryLocation;
10500 new_player.GetHumanInventory().GetUserReservedLocation(res_index,il);
10502 new_player.GetHumanInventory().ClearUserReservedLocationAtIndex(res_index);
10505 {
10506 il.
GetParent().GetOnReleaseLock().Invoke(it);
10507 }
10509 {
10511 }
10512
10513 }
10514 }
10516 {
10517
10519 }
10520
10521 if (m_OldLocation)
10522 {
10523 m_OldLocation.Reset();
10524 }
10525 }
10526 }
10527
10528 override void EOnContact(IEntity other, Contact extra)
10529 {
10531 {
10532 int liquidType = -1;
10534 if (impactSpeed > 0.0)
10535 {
10537 #ifndef SERVER
10539 #else
10541 SetSynchDirty();
10542 #endif
10544 }
10545 }
10546
10547 #ifdef SERVER
10548 if (GetCompEM() && GetCompEM().IsPlugged())
10549 {
10550 if (GetCompEM().GetCordLength() < vector.Distance(
GetPosition(), GetCompEM().GetEnergySource().
GetPosition()))
10551 GetCompEM().UnplugThis();
10552 }
10553 #endif
10554 }
10555
10557
10559 {
10561 }
10562
10564 {
10565
10566 }
10567
10569 {
10570 super.OnItemLocationChanged(old_owner, new_owner);
10571
10572 PlayerBase relatedPlayer = PlayerBase.Cast(old_owner);
10573 PlayerBase playerNew = PlayerBase.Cast(new_owner);
10574
10575 if (!relatedPlayer && playerNew)
10576 relatedPlayer = playerNew;
10577
10578 if (relatedPlayer && relatedPlayer.GetPerformedActionID() != -1)
10579 {
10581 if (actionMgr)
10582 {
10583 ActionBase currentAction = actionMgr.GetRunningAction();
10584 if (currentAction)
10586 }
10587 }
10588
10589 Man ownerPlayerOld = null;
10590 Man ownerPlayerNew = null;
10591
10592 if (old_owner)
10593 {
10594 if (old_owner.
IsMan())
10595 {
10596 ownerPlayerOld = Man.Cast(old_owner);
10597 }
10598 else
10599 {
10600 ownerPlayerOld = Man.Cast(old_owner.GetHierarchyRootPlayer());
10601 }
10602 }
10603 else
10604 {
10606 {
10608
10609 if (!action || !playerNew || playerNew.GetPerformedActionID() != action.
GetID())
10610 {
10611 GetCompEM().UnplugThis();
10612 }
10613 }
10614 }
10615
10616 if (new_owner)
10617 {
10618 if (new_owner.
IsMan())
10619 {
10620 ownerPlayerNew = Man.Cast(new_owner);
10621 }
10622 else
10623 {
10624 ownerPlayerNew = Man.Cast(new_owner.GetHierarchyRootPlayer());
10625 }
10626 }
10627
10628 if (ownerPlayerOld != ownerPlayerNew)
10629 {
10630 if (ownerPlayerOld)
10631 {
10632 array<EntityAI> subItemsExit = new array<EntityAI>;
10634 for (int i = 0; i < subItemsExit.Count(); i++)
10635 {
10638 }
10639 }
10640
10641 if (ownerPlayerNew)
10642 {
10643 array<EntityAI> subItemsEnter = new array<EntityAI>;
10645 for (int j = 0; j < subItemsEnter.Count(); j++)
10646 {
10649 }
10650 }
10651 }
10652 else if (ownerPlayerNew != null)
10653 {
10654 PlayerBase nplayer;
10655 if (PlayerBase.CastTo(nplayer, ownerPlayerNew))
10656 {
10657 array<EntityAI> subItemsUpdate = new array<EntityAI>;
10659 for (int k = 0; k < subItemsUpdate.Count(); k++)
10660 {
10662 itemUpdate.UpdateQuickbarShortcutVisibility(nplayer);
10663 }
10664 }
10665 }
10666
10667 if (old_owner)
10668 old_owner.OnChildItemRemoved(this);
10669 if (new_owner)
10670 new_owner.OnChildItemReceived(this);
10671 }
10672
10673
10675 {
10676 super.EEDelete(parent);
10677 PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
10678 if (player)
10679 {
10681
10682 if (player.IsAlive())
10683 {
10684 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
10685 if (r_index >= 0)
10686 {
10687 InventoryLocation r_il = new InventoryLocation;
10688 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
10689
10690 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
10693 {
10694 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
10695 }
10697 {
10698 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
10699 }
10700
10701 }
10702
10703 player.RemoveQuickBarEntityShortcut(this);
10704 }
10705 }
10706 }
10707
10709 {
10710 super.EEKilled(killer);
10711
10714 {
10715 if (
GetTemperature() >= GameConstants.ITEM_TEMPERATURE_TO_EXPLODE_MIN)
10716 {
10717 if (IsMagazine())
10718 {
10719 if (Magazine.Cast(this).GetAmmoCount() > 0)
10720 {
10722 }
10723 }
10724 else
10725 {
10727 }
10728 }
10729 }
10730 }
10731
10733 {
10734 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
10735
10736 super.OnWasAttached(parent, slot_id);
10737
10740
10742 }
10743
10745 {
10746 super.OnWasDetached(parent, slot_id);
10747
10750 }
10751
10753 {
10754 int idx;
10757
10758 ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
10759 if (inventory_slots.Count() < 1)
10760 {
10761 inventory_slots.Insert(ConfigGetString("ChangeInventorySlot"));
10762 attach_types.Insert(ConfigGetString("ChangeIntoOnAttach"));
10763 }
10764 else
10765 {
10766 ConfigGetTextArray("ChangeIntoOnAttach",attach_types);
10767 }
10768
10769 idx = inventory_slots.Find(slot);
10770 if (idx < 0)
10771 return "";
10772
10773 return attach_types.Get(idx);
10774 }
10775
10777 {
10778 int idx = -1;
10779 string slot;
10780
10783
10784 this.ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
10785 if (inventory_slots.Count() < 1)
10786 {
10787 inventory_slots.Insert(this.ConfigGetString("ChangeInventorySlot"));
10788 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
10789 }
10790 else
10791 {
10792 this.ConfigGetTextArray("ChangeIntoOnDetach",detach_types);
10793 if (detach_types.Count() < 1)
10794 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
10795 }
10796
10797 for (int i = 0; i < inventory_slots.Count(); i++)
10798 {
10799 slot = inventory_slots.Get(i);
10800 }
10801
10802 if (slot != "")
10803 {
10804 if (detach_types.Count() == 1)
10805 idx = 0;
10806 else
10807 idx = inventory_slots.Find(slot);
10808 }
10809 if (idx < 0)
10810 return "";
10811
10812 return detach_types.Get(idx);
10813 }
10814
10816 {
10817
10819
10820
10821 float min_time = 1;
10822 float max_time = 3;
10823 float delay = Math.RandomFloat(min_time, max_time);
10824
10825 explode_timer.Run(delay, this, "DoAmmoExplosion");
10826 }
10827
10829 {
10830 Magazine magazine = Magazine.Cast(this);
10831 int pop_sounds_count = 6;
10832 string pop_sounds[ 6 ] = { "ammopops_1","ammopops_2","ammopops_3","ammopops_4","ammopops_5","ammopops_6" };
10833
10834
10835 int sound_idx = Math.RandomInt(0, pop_sounds_count - 1);
10836 string sound_name = pop_sounds[ sound_idx ];
10838
10839
10840 magazine.ServerAddAmmoCount(-1);
10841
10842
10843 float min_temp_to_explode = 100;
10844
10845 if (magazine.GetAmmoCount() > 0 &&
GetTemperature() >= min_temp_to_explode)
10846 {
10848 }
10849 }
10850
10851
10852 override void EEHitBy(TotalDamageResult damageResult,
int damageType,
EntityAI source,
int component,
string dmgZone,
string ammo, vector modelPos,
float speedCoef)
10853 {
10854 super.EEHitBy(damageResult, damageType, source,
component, dmgZone, ammo, modelPos, speedCoef);
10855
10856 const int CHANCE_DAMAGE_CARGO = 4;
10857 const int CHANCE_DAMAGE_ATTACHMENT = 1;
10858 const int CHANCE_DAMAGE_NOTHING = 2;
10859
10861 {
10862 float dmg = damageResult.
GetDamage(
"",
"Health") * -0.5;
10863 int chances;
10864 int rnd;
10865
10866 if (GetInventory().GetCargo())
10867 {
10868 chances = CHANCE_DAMAGE_CARGO + CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
10869 rnd = Math.RandomInt(0,chances);
10870
10871 if (rnd < CHANCE_DAMAGE_CARGO)
10872 {
10874 }
10875 else if (rnd < (chances - CHANCE_DAMAGE_NOTHING))
10876 {
10878 }
10879 }
10880 else
10881 {
10882 chances = CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
10883 rnd = Math.RandomInt(0,chances);
10884
10885 if (rnd < CHANCE_DAMAGE_ATTACHMENT)
10886 {
10888 }
10889 }
10890 }
10891 }
10892
10894 {
10895 if (GetInventory().GetCargo())
10896 {
10897 int item_count = GetInventory().GetCargo().GetItemCount();
10898 if (item_count > 0)
10899 {
10900 int random_pick = Math.RandomInt(0, item_count);
10902 if (!item.IsExplosive())
10903 {
10904 item.AddHealth("","",damage);
10905 return true;
10906 }
10907 }
10908 }
10909 return false;
10910 }
10911
10913 {
10914 int attachment_count = GetInventory().AttachmentCount();
10915 if (attachment_count > 0)
10916 {
10917 int random_pick = Math.RandomInt(0, attachment_count);
10918 ItemBase attachment =
ItemBase.Cast(GetInventory().GetAttachmentFromIndex(random_pick));
10919 if (!attachment.IsExplosive())
10920 {
10921 attachment.AddHealth("","",damage);
10922 return true;
10923 }
10924 }
10925 return false;
10926 }
10927
10929 {
10931 }
10932
10934 {
10936 return GetInventory().CanRemoveEntity();
10937
10938 return false;
10939 }
10940
10942 {
10943
10945 return false;
10946
10947
10949 return false;
10950
10951
10952
10954 if (delta == 0)
10955 return false;
10956
10957
10958 return true;
10959 }
10960
10962 {
10964 {
10965 if (ScriptInputUserData.CanStoreInputUserData())
10966 {
10967 ScriptInputUserData ctx = new ScriptInputUserData;
10972 ctx.
Write(destination_entity);
10974 ctx.
Write(slot_id);
10976 }
10977 }
10978 else if (!
GetGame().IsMultiplayer())
10979 {
10981 }
10982 }
10983
10985 {
10986 float split_quantity_new;
10990 InventoryLocation loc = new InventoryLocation;
10991
10992 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
10993 {
10995 split_quantity_new = stack_max;
10996 else
10998
11000 {
11001 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
11002 if (new_item)
11003 {
11004 new_item.SetResultOfSplit(true);
11005 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11007 new_item.
SetQuantity(split_quantity_new,
false,
true);
11008 }
11009 }
11010 }
11011 else if (destination_entity && slot_id == -1)
11012 {
11013 if (quantity > stack_max)
11014 split_quantity_new = stack_max;
11015 else
11016 split_quantity_new = quantity;
11017
11019 {
11021 {
11024 }
11025
11026 if (new_item)
11027 {
11028 new_item.SetResultOfSplit(true);
11029 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11031 new_item.
SetQuantity(split_quantity_new,
false,
true);
11032 }
11033 }
11034 }
11035 else
11036 {
11037 if (stack_max != 0)
11038 {
11040 {
11042 }
11043
11044 if (split_quantity_new == 0)
11045 {
11046 if (!
GetGame().IsMultiplayer())
11047 player.PhysicalPredictiveDropItem(this);
11048 else
11049 player.ServerDropEntity(this);
11050 return;
11051 }
11052
11054 {
11056
11057 if (new_item)
11058 {
11059 new_item.SetResultOfSplit(true);
11060 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11063 new_item.PlaceOnSurface();
11064 }
11065 }
11066 }
11067 }
11068 }
11069
11071 {
11072 float split_quantity_new;
11076 InventoryLocation loc = new InventoryLocation;
11077
11078 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
11079 {
11081 split_quantity_new = stack_max;
11082 else
11084
11086 {
11087 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
11088 if (new_item)
11089 {
11090 new_item.SetResultOfSplit(true);
11091 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11093 new_item.
SetQuantity(split_quantity_new,
false,
true);
11094 }
11095 }
11096 }
11097 else if (destination_entity && slot_id == -1)
11098 {
11099 if (quantity > stack_max)
11100 split_quantity_new = stack_max;
11101 else
11102 split_quantity_new = quantity;
11103
11105 {
11107 {
11110 }
11111
11112 if (new_item)
11113 {
11114 new_item.SetResultOfSplit(true);
11115 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11117 new_item.
SetQuantity(split_quantity_new,
false,
true);
11118 }
11119 }
11120 }
11121 else
11122 {
11123 if (stack_max != 0)
11124 {
11126 {
11128 }
11129
11131 {
11133
11134 if (new_item)
11135 {
11136 new_item.SetResultOfSplit(true);
11137 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11140 new_item.PlaceOnSurface();
11141 }
11142 }
11143 }
11144 }
11145 }
11146
11148 {
11150 {
11151 if (ScriptInputUserData.CanStoreInputUserData())
11152 {
11153 ScriptInputUserData ctx = new ScriptInputUserData;
11158 dst.WriteToContext(ctx);
11160 }
11161 }
11162 else if (!
GetGame().IsMultiplayer())
11163 {
11165 }
11166 }
11167
11169 {
11171 {
11172 if (ScriptInputUserData.CanStoreInputUserData())
11173 {
11174 ScriptInputUserData ctx = new ScriptInputUserData;
11179 ctx.
Write(destination_entity);
11185 }
11186 }
11187 else if (!
GetGame().IsMultiplayer())
11188 {
11190 }
11191 }
11192
11194 {
11196 }
11197
11199 {
11201 float split_quantity_new;
11203 if (dst.IsValid())
11204 {
11205 int slot_id = dst.GetSlot();
11207
11208 if (quantity > stack_max)
11209 split_quantity_new = stack_max;
11210 else
11211 split_quantity_new = quantity;
11212
11214 {
11216
11217 if (new_item)
11218 {
11219 new_item.SetResultOfSplit(true);
11220 MiscGameplayFunctions.TransferItemProperties(this,new_item);
11222 new_item.
SetQuantity(split_quantity_new,
false,
true);
11223 }
11224
11225 return new_item;
11226 }
11227 }
11228
11229 return null;
11230 }
11231
11233 {
11235 float split_quantity_new;
11237 if (destination_entity)
11238 {
11240 if (quantity > stackable)
11241 split_quantity_new = stackable;
11242 else
11243 split_quantity_new = quantity;
11244
11246 {
11247 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateEntityInCargoEx(
this.GetType(), idx, row, col,
false));
11248 if (new_item)
11249 {
11250 new_item.SetResultOfSplit(true);
11251 MiscGameplayFunctions.TransferItemProperties(this,new_item);
11253 new_item.
SetQuantity(split_quantity_new,
false,
true);
11254 }
11255 }
11256 }
11257 }
11258
11260 {
11262 {
11263 if (ScriptInputUserData.CanStoreInputUserData())
11264 {
11265 ScriptInputUserData ctx = new ScriptInputUserData;
11270 ItemBase destination_entity =
this;
11271 ctx.
Write(destination_entity);
11275 }
11276 }
11277 else if (!
GetGame().IsMultiplayer())
11278 {
11280 }
11281 }
11282
11284 {
11286 float split_quantity_new;
11288 if (player)
11289 {
11291 if (quantity > stackable)
11292 split_quantity_new = stackable;
11293 else
11294 split_quantity_new = quantity;
11295
11297 {
11298 EntityAI in_hands = player.GetHumanInventory().CreateInHands(this.
GetType());
11299 new_item =
ItemBase.Cast(in_hands);
11300 if (new_item)
11301 {
11302 new_item.SetResultOfSplit(true);
11303 MiscGameplayFunctions.TransferItemProperties(this,new_item);
11305 new_item.SetQuantity(split_quantity_new, false, true);
11306 }
11307 }
11308 }
11309 }
11310
11312 {
11314 float split_quantity_new = Math.Floor(quantity * 0.5);
11315
11317 return;
11318
11320
11321 if (new_item)
11322 {
11323 if (new_item.GetQuantityMax() < split_quantity_new)
11324 {
11325 split_quantity_new = new_item.GetQuantityMax();
11326 }
11327
11328 new_item.SetResultOfSplit(true);
11329 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11330
11332 {
11335 }
11336 else
11337 {
11339 new_item.
SetQuantity(split_quantity_new,
false,
true);
11340 }
11341 }
11342 }
11343
11345 {
11347 float split_quantity_new = Math.Floor(quantity / 2);
11348
11350 return;
11351
11352 InventoryLocation invloc = new InventoryLocation;
11354
11356 new_item = player.CreateCopyOfItemInInventoryOrGroundEx(this, true);
11357
11358 if (new_item)
11359 {
11360 if (new_item.GetQuantityMax() < split_quantity_new)
11361 {
11362 split_quantity_new = new_item.GetQuantityMax();
11363 }
11365 {
11368 }
11369 else if (split_quantity_new > 1)
11370 {
11372 new_item.
SetQuantity(split_quantity_new,
false,
true);
11373 }
11374 }
11375 }
11376
11379 {
11380 SetWeightDirty();
11382
11383 if (parent)
11384 parent.OnAttachmentQuantityChangedEx(this, delta);
11385
11387 {
11389 {
11391 }
11393 {
11394 ErrorEx(
"Undefined liquid type quantity changed, please define liquid type first! Using init value.",
ErrorExSeverity.INFO);
11396 }
11397 }
11398
11399 }
11400
11403 {
11404
11405 }
11406
11409 {
11411 }
11412
11414 {
11415 super.EEHealthLevelChanged(oldLevel,newLevel,zone);
11416
11418 {
11419 if (newLevel == GameConstants.STATE_RUINED)
11420 {
11422 EntityAI parent = GetHierarchyParent();
11423 if (parent && parent.IsFireplace())
11424 {
11425 CargoBase cargo = GetInventory().GetCargo();
11426 if (cargo)
11427 {
11429 {
11431 }
11432 }
11433 }
11434 }
11435
11437 {
11438
11440 return;
11441 }
11442
11443 if (
m_Cleanness != 0 && oldLevel < newLevel && newLevel != 0)
11444 {
11446 }
11447 }
11448 }
11449
11450
11452 {
11453 super.OnRightClick();
11454
11456 {
11458 {
11459 if (ScriptInputUserData.CanStoreInputUserData())
11460 {
11461 EntityAI root = GetHierarchyRoot();
11462 Man playerOwner = GetHierarchyRootPlayer();
11463 InventoryLocation dst = new InventoryLocation;
11464
11465
11466 if (!playerOwner && root && root == this)
11467 {
11469 }
11470 else
11471 {
11472
11473 GetInventory().GetCurrentInventoryLocation(dst);
11475 {
11478 {
11480 }
11481 else
11482 {
11484
11485
11486 if (
GetGame().
GetPlayer().GetInventory().HasInventoryReservation(
this, dst))
11487 {
11489 }
11490 else
11491 {
11492 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(null, dst, GameInventory.c_InventoryReservationTimeoutShortMS);
11493 }
11494 }
11495 }
11496 }
11497
11498 ScriptInputUserData ctx = new ScriptInputUserData;
11506 }
11507 }
11508 else if (!
GetGame().IsMultiplayer())
11509 {
11511 }
11512 }
11513 }
11514
11516 {
11517 if (root)
11518 {
11519 vector m4[4];
11520 root.GetTransform(m4);
11521 dst.SetGround(this, m4);
11522 }
11523 else
11524 {
11525 GetInventory().GetCurrentInventoryLocation(dst);
11526 }
11527 }
11528
11529 override bool CanBeCombined(
EntityAI other_item,
bool reservation_check =
true,
bool stack_max_limit =
false)
11530 {
11531
11532 if (!other_item ||
GetType() != other_item.GetType() || (
IsFullQuantity() && other_item.GetQuantity() > 0) || other_item ==
this)
11533 return false;
11534
11535 if (GetHealthLevel() == GameConstants.STATE_RUINED || other_item.GetHealthLevel() == GameConstants.STATE_RUINED)
11536 return false;
11537
11538
11540 return false;
11541
11542
11543 Magazine mag = Magazine.Cast(this);
11544 if (mag)
11545 {
11546 if (mag.GetAmmoCount() >= mag.GetAmmoMax())
11547 return false;
11548
11549 if (stack_max_limit)
11550 {
11551 Magazine other_mag = Magazine.Cast(other_item);
11552 if (other_item)
11553 {
11554 if (mag.GetAmmoCount() + other_mag.GetAmmoCount() > mag.GetAmmoMax())
11555 return false;
11556 }
11557
11558 }
11559 }
11560 else
11561 {
11562
11564 return false;
11565
11567 return false;
11568 }
11569
11570 PlayerBase player = null;
11571 if (CastTo(player, GetHierarchyRootPlayer()))
11572 {
11573 if (player.GetInventory().HasAttachment(this))
11574 return false;
11575
11576 if (player.IsItemsToDelete())
11577 return false;
11578 }
11579
11580 if (reservation_check && (GetInventory().HasInventoryReservation(this, null) || other_item.GetInventory().HasInventoryReservation(other_item, null)))
11581 return false;
11582
11583 int slotID;
11585 if (GetInventory().GetCurrentAttachmentSlotInfo(slotID,
slotName) && GetHierarchyParent().GetInventory().GetSlotLock(slotID))
11586 return false;
11587
11588 return true;
11589 }
11590
11592 {
11594 }
11595
11597 {
11598 return m_IsResultOfSplit;
11599 }
11600
11602 {
11603 m_IsResultOfSplit = value;
11604 }
11605
11607 {
11609 }
11610
11612 {
11613 float other_item_quantity = other_item.GetQuantity();
11614 float this_free_space;
11615
11617
11619
11620 if (other_item_quantity > this_free_space)
11621 {
11622 return this_free_space;
11623 }
11624 else
11625 {
11626 return other_item_quantity;
11627 }
11628 }
11629
11631 {
11633 }
11634
11636 {
11638 return;
11639
11640 if (!IsMagazine() && other_item)
11641 {
11643 if (quantity_used != 0)
11644 {
11645 float hp1 = GetHealth01("","");
11646 float hp2 = other_item.GetHealth01("","");
11647 float hpResult = ((hp1*
GetQuantity()) + (hp2*quantity_used));
11648 hpResult = hpResult / (
GetQuantity() + quantity_used);
11649
11650 hpResult *= GetMaxHealth();
11651 Math.Round(hpResult);
11652 SetHealth("", "Health", hpResult);
11653
11655 other_item.AddQuantity(-quantity_used);
11656 }
11657 }
11659 }
11660
11662 {
11663 #ifdef SERVER
11664 if (!GetHierarchyRootPlayer() && GetHierarchyParent())
11665 GetHierarchyParent().IncreaseLifetimeUp();
11666 #endif
11667 };
11668
11670 {
11671 PlayerBase p = PlayerBase.Cast(player);
11672
11673 array<int> recipesIds = p.m_Recipes;
11674 PluginRecipesManager moduleRecipesManager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
11675 if (moduleRecipesManager)
11676 {
11677 EntityAI itemInHands = player.GetHumanInventory().GetEntityInHands();
11678 moduleRecipesManager.GetValidRecipes(
ItemBase.Cast(
this),
ItemBase.Cast(itemInHands), recipesIds, p);
11679 }
11680
11681 for (int i = 0;i < recipesIds.Count(); i++)
11682 {
11683 int key = recipesIds.Get(i);
11684 string recipeName = moduleRecipesManager.GetRecipeName(key);
11686 }
11687 }
11688
11689
11690 override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
11691 {
11692 super.GetDebugActions(outputList);
11693
11694
11700
11701
11706
11711
11712
11716
11717
11719 {
11723 }
11724
11727
11728
11732
11734
11735 InventoryLocation loc = new InventoryLocation();
11736 GetInventory().GetCurrentInventoryLocation(loc);
11738 {
11739 if (Gizmo_IsSupported())
11742 }
11743
11745 }
11746
11747
11748
11749
11751 {
11752 super.OnAction(action_id, player, ctx);
11753
11755 {
11756 switch (action_id)
11757 {
11760 return true;
11763 return true;
11764 }
11765 }
11766
11768 {
11769 switch (action_id)
11770 {
11772 Delete();
11773 return true;
11774 }
11775 }
11776
11777 if (action_id >=
EActions.RECIPES_RANGE_START && action_id <
EActions.RECIPES_RANGE_END)
11778 {
11779 PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
11780 int idWithoutOffset = action_id -
EActions.RECIPES_RANGE_START;
11781 PlayerBase p = PlayerBase.Cast(player);
11782 if (
EActions.RECIPES_RANGE_START < 1000)
11783 {
11784 float anim_length = plugin_recipes_manager.GetRecipeLengthInSecs(idWithoutOffset);
11785 float specialty_weight = plugin_recipes_manager.GetRecipeSpecialty(idWithoutOffset);
11786 }
11787 }
11788 #ifndef SERVER
11789 else if (action_id ==
EActions.WATCH_PLAYER)
11790 {
11791 PluginDeveloper.SetDeveloperItemClientEx(player);
11792 }
11793 #endif
11795 {
11796 if (action_id >=
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START && action_id <
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_END)
11797 {
11798 int id = action_id -
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START;
11799 OnDebugButtonPressServer(id + 1);
11800 }
11801
11802 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_INJECT_START && action_id <
EActions.DEBUG_AGENTS_RANGE_INJECT_END)
11803 {
11804 int agent_id = action_id -
EActions.DEBUG_AGENTS_RANGE_INJECT_START;
11806 }
11807
11808 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_REMOVE_START && action_id <
EActions.DEBUG_AGENTS_RANGE_REMOVE_END)
11809 {
11810 int agent_id2 = action_id -
EActions.DEBUG_AGENTS_RANGE_REMOVE_START;
11812 }
11813
11814 else if (action_id ==
EActions.ADD_QUANTITY)
11815 {
11816 if (IsMagazine())
11817 {
11818 Magazine mag = Magazine.Cast(this);
11819 mag.ServerSetAmmoCount(mag.GetAmmoCount() + mag.GetAmmoMax() * 0.2);
11820 }
11821 else
11822 {
11824 }
11825
11826 if (m_EM)
11827 {
11828 m_EM.AddEnergy(m_EM.GetEnergyMax() * 0.2);
11829 }
11830
11831 }
11832
11833 else if (action_id ==
EActions.REMOVE_QUANTITY)
11834 {
11835 if (IsMagazine())
11836 {
11837 Magazine mag2 = Magazine.Cast(this);
11838 mag2.ServerSetAmmoCount(mag2.GetAmmoCount() - mag2.GetAmmoMax() * 0.2);
11839 }
11840 else
11841 {
11843 }
11844 if (m_EM)
11845 {
11846 m_EM.AddEnergy(- m_EM.GetEnergyMax() * 0.2);
11847 }
11848
11849 }
11850
11851 else if (action_id ==
EActions.SET_QUANTITY_0)
11852 {
11854
11855 if (m_EM)
11856 {
11857 m_EM.SetEnergy(0);
11858 }
11859 }
11860
11861 else if (action_id ==
EActions.SET_MAX_QUANTITY)
11862 {
11864
11865 if (m_EM)
11866 {
11867 m_EM.SetEnergy(m_EM.GetEnergyMax());
11868 }
11869 }
11870
11871 else if (action_id ==
EActions.ADD_HEALTH)
11872 {
11873 AddHealth("","",GetMaxHealth("","Health")/5);
11874 }
11875 else if (action_id ==
EActions.REMOVE_HEALTH)
11876 {
11877 AddHealth("","",-GetMaxHealth("","Health")/5);
11878 }
11879 else if (action_id ==
EActions.DESTROY_HEALTH)
11880 {
11881 SetHealth01("","",0);
11882 }
11883 else if (action_id ==
EActions.WATCH_ITEM)
11884 {
11886 mid.RegisterDebugItem(
ItemBase.Cast(
this), PlayerBase.Cast(player));
11887 #ifdef DEVELOPER
11888 SetDebugDeveloper_item(this);
11889 #endif
11890 }
11891
11892 else if (action_id ==
EActions.ADD_TEMPERATURE)
11893 {
11894 AddTemperature(20);
11895
11896 }
11897
11898 else if (action_id ==
EActions.REMOVE_TEMPERATURE)
11899 {
11900 AddTemperature(-20);
11901
11902 }
11903
11904 else if (action_id ==
EActions.FLIP_FROZEN)
11905 {
11906 SetFrozen(!GetIsFrozen());
11907
11908 }
11909
11910 else if (action_id ==
EActions.ADD_WETNESS)
11911 {
11913
11914 }
11915
11916 else if (action_id ==
EActions.REMOVE_WETNESS)
11917 {
11919
11920 }
11921
11922 else if (action_id ==
EActions.LIQUIDTYPE_UP)
11923 {
11926
11927
11928 }
11929
11930 else if (action_id ==
EActions.LIQUIDTYPE_DOWN)
11931 {
11934 }
11935
11936 else if (action_id ==
EActions.MAKE_SPECIAL)
11937 {
11938 auto debugParams = DebugSpawnParams.WithPlayer(player);
11939 OnDebugSpawnEx(debugParams);
11940 }
11941
11942 }
11943
11944
11945 return false;
11946 }
11947
11948
11949
11950
11954
11957
11958
11959
11961 {
11962 return false;
11963 }
11964
11965
11967 {
11968 return true;
11969 }
11970
11971
11973 {
11974 return true;
11975 }
11976
11977
11978
11980 {
11981 string config_path =
string.Format(
"CfgVehicles %1 Food FoodStages",
GetType());
11983 }
11984
11987 {
11988 return null;
11989 }
11990
11992 {
11993 return false;
11994 }
11995
11997 {
11998 return false;
11999 }
12000
12004
12005
12007 {
12008 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
12009 return module_repairing.CanRepair(this, item_repair_kit);
12010 }
12011
12012
12013 bool Repair(PlayerBase player,
ItemBase item_repair_kit,
float specialty_weight)
12014 {
12015 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
12016 return module_repairing.Repair(player, this, item_repair_kit, specialty_weight);
12017 }
12018
12019
12021 {
12022
12023
12024
12025
12026
12027
12028
12029
12030 return 1;
12031 }
12032
12033
12034
12036 {
12038 }
12039
12040
12041
12043 {
12045 }
12046
12047
12056 {
12057 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
12058
12059 if (player)
12060 {
12061 player.MessageStatus(text);
12062 }
12063 }
12064
12065
12074 {
12075 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
12076
12077 if (player)
12078 {
12079 player.MessageAction(text);
12080 }
12081 }
12082
12083
12092 {
12093 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
12094
12095 if (player)
12096 {
12097 player.MessageFriendly(text);
12098 }
12099 }
12100
12101
12110 {
12111 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
12112
12113 if (player)
12114 {
12115 player.MessageImportant(text);
12116 }
12117 }
12118
12120 {
12121 return true;
12122 }
12123
12124
12125 override bool KindOf(
string tag)
12126 {
12127 bool found = false;
12128 string item_name = this.
GetType();
12131
12132 int array_size = item_tag_array.Count();
12133 for (int i = 0; i < array_size; i++)
12134 {
12135 if (item_tag_array.Get(i) == tag)
12136 {
12137 found = true;
12138 break;
12139 }
12140 }
12141 return found;
12142 }
12143
12144
12146 {
12147
12148 super.OnRPC(sender, rpc_type,ctx);
12149
12150
12151 switch (rpc_type)
12152 {
12153 #ifndef SERVER
12154 case ERPCs.RPC_SOUND_LOCK_ATTACH:
12155 Param2<bool, string> p = new Param2<bool, string>(false, "");
12156
12158 return;
12159
12160 bool play = p.param1;
12161 string soundSet = p.param2;
12162
12163 if (play)
12164 {
12166 {
12168 {
12170 }
12171 }
12172 else
12173 {
12175 }
12176 }
12177 else
12178 {
12180 }
12181
12182 break;
12183 #endif
12184
12185 }
12186
12188 {
12190 }
12191 }
12192
12193
12194
12195
12197 {
12198 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
12199 return plugin.GetID(
name);
12200 }
12201
12203 {
12204 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
12205 return plugin.GetName(id);
12206 }
12207
12210 {
12211
12212
12213 int varFlags;
12214 if (!ctx.
Read(varFlags))
12215 return;
12216
12217 if (varFlags & ItemVariableFlags.FLOAT)
12218 {
12220 }
12221 }
12222
12224 {
12225
12226 super.SerializeNumericalVars(floats_out);
12227
12228
12229
12231 {
12233 }
12234
12236 {
12238 }
12239
12241 {
12243 }
12244
12246 {
12251 }
12252
12254 {
12256 }
12257 }
12258
12260 {
12261
12262 super.DeSerializeNumericalVars(floats);
12263
12264
12265 int index = 0;
12266 int mask = Math.Round(floats.Get(index));
12267
12268 index++;
12269
12271 {
12273 {
12275 }
12276 else
12277 {
12278 float quantity = floats.Get(index);
12279 SetQuantity(quantity,
true,
false,
false,
false);
12280 }
12281 index++;
12282 }
12283
12285 {
12286 float wet = floats.Get(index);
12288 index++;
12289 }
12290
12292 {
12293 int liquidtype = Math.Round(floats.Get(index));
12295 index++;
12296 }
12297
12299 {
12301 index++;
12303 index++;
12305 index++;
12307 index++;
12308 }
12309
12311 {
12312 int cleanness = Math.Round(floats.Get(index));
12314 index++;
12315 }
12316 }
12317
12319 {
12320 super.WriteVarsToCTX(ctx);
12321
12322
12324 {
12326 }
12327
12329 {
12331 }
12332
12334 {
12336 }
12337
12339 {
12340 int r,g,b,a;
12346 }
12347
12349 {
12351 }
12352 }
12353
12355 {
12356 if (!super.ReadVarsFromCTX(ctx,version))
12357 return false;
12358
12359 int intValue;
12360 float value;
12361
12362 if (version < 140)
12363 {
12364 if (!ctx.
Read(intValue))
12365 return false;
12366
12367 m_VariablesMask = intValue;
12368 }
12369
12371 {
12372 if (!ctx.
Read(value))
12373 return false;
12374
12376 {
12378 }
12379 else
12380 {
12382 }
12383 }
12384
12385 if (version < 140)
12386 {
12388 {
12389 if (!ctx.
Read(value))
12390 return false;
12391 SetTemperatureDirect(value);
12392 }
12393 }
12394
12396 {
12397 if (!ctx.
Read(value))
12398 return false;
12400 }
12401
12403 {
12404 if (!ctx.
Read(intValue))
12405 return false;
12407 }
12408
12410 {
12411 int r,g,b,a;
12413 return false;
12415 return false;
12417 return false;
12419 return false;
12420
12422 }
12423
12425 {
12426 if (!ctx.
Read(intValue))
12427 return false;
12429 }
12430
12431 if (version >= 138 && version < 140)
12432 {
12434 {
12435 if (!ctx.
Read(intValue))
12436 return false;
12437 SetFrozen(intValue);
12438 }
12439 }
12440
12441 return true;
12442 }
12443
12444
12446 {
12449 {
12451 }
12452
12453 if (!super.OnStoreLoad(ctx, version))
12454 {
12456 return false;
12457 }
12458
12459 if (version >= 114)
12460 {
12461 bool hasQuickBarIndexSaved;
12462
12463 if (!ctx.
Read(hasQuickBarIndexSaved))
12464 {
12466 return false;
12467 }
12468
12469 if (hasQuickBarIndexSaved)
12470 {
12471 int itmQBIndex;
12472
12473
12474 if (!ctx.
Read(itmQBIndex))
12475 {
12477 return false;
12478 }
12479
12480 PlayerBase parentPlayer = PlayerBase.Cast(GetHierarchyRootPlayer());
12481 if (itmQBIndex != -1 && parentPlayer)
12482 parentPlayer.SetLoadedQuickBarItemBind(this, itmQBIndex);
12483 }
12484 }
12485 else
12486 {
12487
12488 PlayerBase player;
12489 int itemQBIndex;
12490 if (version ==
int.
MAX)
12491 {
12492 if (!ctx.
Read(itemQBIndex))
12493 {
12495 return false;
12496 }
12497 }
12498 else if (Class.CastTo(player, GetHierarchyRootPlayer()))
12499 {
12500
12501 if (!ctx.
Read(itemQBIndex))
12502 {
12504 return false;
12505 }
12506 if (itemQBIndex != -1 && player)
12507 player.SetLoadedQuickBarItemBind(this,itemQBIndex);
12508 }
12509 }
12510
12511 if (version < 140)
12512 {
12513
12514 if (!LoadVariables(ctx, version))
12515 {
12517 return false;
12518 }
12519 }
12520
12521
12523 {
12525 return false;
12526 }
12527 if (version >= 132)
12528 {
12530 if (raib)
12531 {
12533 {
12535 return false;
12536 }
12537 }
12538 }
12539
12541 return true;
12542 }
12543
12544
12545
12547 {
12548 super.OnStoreSave(ctx);
12549
12550 PlayerBase player;
12551 if (PlayerBase.CastTo(player,GetHierarchyRootPlayer()))
12552 {
12554
12555 int itemQBIndex = -1;
12556 itemQBIndex = player.FindQuickBarEntityIndex(this);
12557 ctx.
Write(itemQBIndex);
12558 }
12559 else
12560 {
12562 }
12563
12565
12567 if (raib)
12568 {
12570 }
12571 }
12572
12573
12575 {
12576 super.AfterStoreLoad();
12577
12579 {
12581 }
12582
12584 {
12587 }
12588 }
12589
12591 {
12592 super.EEOnAfterLoad();
12593
12595 {
12597 }
12598
12601 }
12602
12604 {
12605 return false;
12606 }
12607
12608
12609
12611 {
12613 {
12614 #ifdef PLATFORM_CONSOLE
12615
12617 {
12619 if (menu)
12620 {
12622 }
12623 }
12624 #endif
12625 }
12626
12628 {
12631 }
12632
12634 {
12635 SetWeightDirty();
12637 }
12639 {
12642 }
12643
12645 {
12648 }
12650 {
12653 }
12654
12655 super.OnVariablesSynchronized();
12656 }
12657
12658
12659
12661 override bool SetQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false,
bool allow_client =
false,
bool clamp_to_stack_max =
true)
12662 {
12663 if (!IsServerCheck(allow_client))
12664 return false;
12665
12667 return false;
12668
12671
12672 if (value <= (min + 0.001))
12673 value = min;
12674
12675 if (value == min)
12676 {
12677 if (destroy_config)
12678 {
12679 bool dstr = ConfigGetBool("varQuantityDestroyOnMin");
12680 if (dstr)
12681 {
12683 this.Delete();
12684 return true;
12685 }
12686 }
12687 else if (destroy_forced)
12688 {
12690 this.Delete();
12691 return true;
12692 }
12693
12695 }
12696
12699
12701 {
12703
12704 if (delta)
12706 }
12707
12709
12710 return false;
12711 }
12712
12713
12715 bool AddQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
12716 {
12718 }
12719
12721 {
12724 }
12725
12727 {
12730 }
12731
12733 override void SetQuantityNormalized(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
12734 {
12735 float value_clamped = Math.Clamp(value, 0, 1);
12737 SetQuantity(result, destroy_config, destroy_forced);
12738 }
12739
12740
12743 {
12745 }
12746
12748 {
12750 }
12751
12752
12753
12754
12755
12756
12757
12758
12759
12760
12762 {
12763 int slot = -1;
12764 if (GetInventory())
12765 {
12766 InventoryLocation il = new InventoryLocation;
12767 GetInventory().GetCurrentInventoryLocation(il);
12769 }
12770
12772 }
12773
12775 {
12776 float quantity_max = 0;
12777
12779 {
12780 if (attSlotID != -1)
12781 quantity_max = InventorySlots.GetStackMaxForSlotId(attSlotID);
12782
12783 if (quantity_max <= 0)
12785 }
12786
12787 if (quantity_max <= 0)
12789
12790 return quantity_max;
12791 }
12792
12794 {
12796 }
12797
12799 {
12801 }
12802
12803
12805 {
12807 }
12808
12810 {
12812 }
12813
12815 {
12817 }
12818
12819
12821 {
12822
12823 float weightEx = GetWeightEx();
12824 float special = GetInventoryAndCargoWeight();
12825 return weightEx - special;
12826 }
12827
12828
12830 {
12832 }
12833
12835 {
12837 {
12838 #ifdef DEVELOPER
12839 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
12840 {
12841 WeightDebugData data1 = WeightDebug.GetWeightDebug(this);
12843 }
12844 #endif
12845
12846 return GetQuantity() * GetConfigWeightModified();
12847 }
12848 else if (HasEnergyManager())
12849 {
12850 #ifdef DEVELOPER
12851 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
12852 {
12853 WeightDebugData data2 = WeightDebug.GetWeightDebug(this);
12854 data2.
SetCalcDetails(
"TIB2: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " + GetCompEM().
GetEnergy()+
"(energy) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit)");
12855 }
12856 #endif
12857 return super.GetWeightSpecialized(forceRecalc) + (GetCompEM().GetEnergy() * ConfigGetFloat("weightPerQuantityUnit")) + GetConfigWeightModified();
12858 }
12859 else
12860 {
12861 #ifdef DEVELOPER
12862 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
12863 {
12864 WeightDebugData data3 = WeightDebug.GetWeightDebug(this);
12865 data3.
SetCalcDetails(
"TIB3: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " +
GetQuantity()+
"(quantity) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit))");
12866 }
12867 #endif
12868 return super.GetWeightSpecialized(forceRecalc) + (
GetQuantity() * ConfigGetFloat(
"weightPerQuantityUnit")) + GetConfigWeightModified();
12869 }
12870 }
12871
12874 {
12875 int item_count = 0;
12877
12878 if (GetInventory().GetCargo() != NULL)
12879 {
12880 item_count = GetInventory().GetCargo().GetItemCount();
12881 }
12882
12883 for (int i = 0; i < GetInventory().AttachmentCount(); i++)
12884 {
12885 Class.CastTo(item,GetInventory().GetAttachmentFromIndex(i));
12886 if (item)
12887 item_count += item.GetNumberOfItems();
12888 }
12889 return item_count;
12890 }
12891
12894 {
12895 float weight = 0;
12896 float wetness = 1;
12897 if (include_wetness)
12900 {
12901 weight = wetness * m_ConfigWeight;
12902 }
12904 {
12905 weight = 1;
12906 }
12907 return weight;
12908 }
12909
12910
12911
12913 {
12914 if ((
GetGame().IsServer() || !
GetGame().IsMultiplayer()) && GetInventory())
12915 {
12916 GameInventory inv = GetInventory();
12917 array<EntityAI> items = new array<EntityAI>;
12919 for (int i = 0; i < items.Count(); i++)
12920 {
12922 if (item)
12923 {
12925 }
12926 }
12927 }
12928 }
12929
12930
12931
12932
12934 {
12935 float energy = 0;
12936 if (HasEnergyManager())
12937 {
12938 energy = GetCompEM().GetEnergy();
12939 }
12940 return energy;
12941 }
12942
12943
12945 {
12946 super.OnEnergyConsumed();
12947
12949 }
12950
12952 {
12953 super.OnEnergyAdded();
12954
12956 }
12957
12958
12960 {
12961 if (
GetGame().IsServer() && HasEnergyManager() && GetCompEM().HasConversionOfEnergyToQuantity())
12962 {
12964 {
12965 float energy_0to1 = GetCompEM().GetEnergy0To1();
12967 }
12968 }
12969 }
12970
12971
12973 {
12974 return ConfigGetFloat("heatIsolation");
12975 }
12976
12978 {
12980 }
12981
12983 {
12984 string paramPath =
string.Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Drying %2",
GetType(), pIncrementName);
12985 if (
GetGame().ConfigIsExisting(paramPath))
12987
12988 return 0.0;
12989 }
12990
12992 {
12993 string paramPath =
string.
Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Soaking %2",
GetType(), pIncrementName);
12994 if (
GetGame().ConfigIsExisting(paramPath))
12996
12997 return 0.0;
12998 }
12999
13000 override void SetWet(
float value,
bool allow_client =
false)
13001 {
13002 if (!IsServerCheck(allow_client))
13003 return;
13004
13007
13009
13010 m_VarWet = Math.Clamp(value, min, max);
13011
13013 {
13016 }
13017 }
13018
13019 override void AddWet(
float value)
13020 {
13022 }
13023
13025 {
13027 }
13028
13030 {
13032 }
13033
13035 {
13037 }
13038
13040 {
13042 }
13043
13045 {
13047 }
13048
13049 override void OnWetChanged(
float newVal,
float oldVal)
13050 {
13053 if (newLevel != oldLevel)
13054 {
13056 }
13057 }
13058
13060 {
13061 SetWeightDirty();
13062 }
13063
13065 {
13066 return GetWetLevelInternal(
m_VarWet);
13067 }
13068
13069
13070
13072 {
13074 }
13075
13077 {
13079 }
13080
13082 {
13084 }
13085
13087 {
13089 }
13090
13091
13092
13094 {
13095 if (ConfigIsExisting("itemModelLength"))
13096 {
13097 return ConfigGetFloat("itemModelLength");
13098 }
13099 return 0;
13100 }
13101
13103 {
13104 if (ConfigIsExisting("itemAttachOffset"))
13105 {
13106 return ConfigGetFloat("itemAttachOffset");
13107 }
13108 return 0;
13109 }
13110
13111 override void SetCleanness(
int value,
bool allow_client =
false)
13112 {
13113 if (!IsServerCheck(allow_client))
13114 return;
13115
13117
13119
13122 }
13123
13125 {
13127 }
13128
13130 {
13131 return true;
13132 }
13133
13134
13135
13136
13138 {
13140 }
13141
13143 {
13145 }
13146
13147
13148
13149
13150 override void SetColor(
int r,
int g,
int b,
int a)
13151 {
13157 }
13159 override void GetColor(out
int r,out
int g,out
int b,out
int a)
13160 {
13165 }
13166
13168 {
13170 }
13171
13174 {
13175 int r,g,b,a;
13177 r = r/255;
13178 g = g/255;
13179 b = b/255;
13180 a = a/255;
13181 return MiscGameplayFunctions.GetColorString(r, g, b, a);
13182 }
13183
13184
13185
13186 override void SetLiquidType(
int value,
bool allow_client =
false)
13187 {
13188 if (!IsServerCheck(allow_client))
13189 return;
13190
13195 }
13196
13198 {
13199 return ConfigGetInt("varLiquidTypeInit");
13200 }
13201
13203 {
13205 }
13206
13208 {
13210 SetFrozen(false);
13211 }
13212
13215 {
13216 player.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
13217 }
13218
13219
13222 {
13223 PlayerBase nplayer;
13224 if (PlayerBase.CastTo(nplayer, player))
13225 {
13227
13228 nplayer.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
13229 }
13230 }
13231
13232
13235 {
13236 PlayerBase nplayer;
13237 if (PlayerBase.CastTo(nplayer,player))
13238 {
13239
13240 nplayer.SetEnableQuickBarEntityShortcut(this,false);
13241
13242 }
13243
13244
13245 player.GetHumanInventory().ClearUserReservedLocationForContainer(this);
13246
13247
13248 if (HasEnergyManager())
13249 {
13250 GetCompEM().UpdatePlugState();
13251 }
13252 }
13253
13254
13256 {
13257 super.OnPlacementStarted(player);
13258
13260 }
13261
13262 override void OnPlacementComplete(Man player, vector position =
"0 0 0", vector orientation =
"0 0 0")
13263 {
13265 {
13266 m_AdminLog.OnPlacementComplete(player,
this);
13267 }
13268
13269 super.OnPlacementComplete(player, position, orientation);
13270 }
13271
13272
13273
13274
13275
13277 {
13279 {
13280 return true;
13281 }
13282 else
13283 {
13284 return false;
13285 }
13286 }
13287
13288
13290 {
13292 {
13294 }
13295 }
13296
13297
13299 {
13301 }
13302
13304 {
13306 }
13307
13308 override void InsertAgent(
int agent,
float count = 1)
13309 {
13310 if (count < 1)
13311 return;
13312
13314 }
13315
13318 {
13320 }
13321
13322
13324 {
13326 }
13327
13328
13329
13330
13331
13332
13333
13334
13335
13336
13337
13338
13339
13340
13341
13342
13343
13344
13345
13346
13347
13348
13349
13350
13351
13352
13353
13354
13355
13356
13357
13358
13359
13360
13361
13362
13363
13364
13365
13366
13367
13368
13370 {
13372 return false;
13373 return true;
13374 }
13375
13377 {
13378
13380 }
13381
13382
13385 {
13386 super.CheckForRoofLimited(timeTresholdMS);
13387
13389 if ((time - m_PreviousRoofTestTime) >= timeTresholdMS)
13390 {
13391 m_PreviousRoofTestTime = time;
13392 SetRoofAbove(MiscGameplayFunctions.IsUnderRoof(this));
13393 }
13394 }
13395
13396
13398 {
13400 {
13401 return 0;
13402 }
13403
13404 if (GetInventory().GetAttachmentSlotsCount() != 0)
13405 {
13406 ItemBase filter =
ItemBase.Cast(FindAttachmentBySlotName(
"GasMaskFilter"));
13407 if (filter)
13408 return filter.GetProtectionLevel(type, false, system);
13409 else
13410 return 0;
13411 }
13412
13413 string subclassPath, entryName;
13414
13415 switch (type)
13416 {
13418 entryName = "biological";
13419 break;
13421 entryName = "chemical";
13422 break;
13423 default:
13424 entryName = "biological";
13425 break;
13426 }
13427
13428 subclassPath =
"CfgVehicles " + this.
GetType() +
" Protection ";
13429
13431 }
13432
13433
13434
13437 {
13438 if (!IsMagazine())
13440
13442 }
13443
13444
13445
13446
13447
13452 {
13453 return true;
13454 }
13455
13457 {
13459 }
13460
13461
13462
13463
13464
13466 {
13467 if (parent)
13468 {
13469 if (parent.IsInherited(DayZInfected))
13470 return true;
13471
13472 if (!parent.IsRuined())
13473 return true;
13474 }
13475
13476 return true;
13477 }
13478
13480 {
13481 if (!super.CanPutAsAttachment(parent))
13482 {
13483 return false;
13484 }
13485
13486 if (!IsRuined() && !parent.IsRuined())
13487 {
13488 return true;
13489 }
13490
13491 return false;
13492 }
13493
13495 {
13496
13497
13498
13499
13500 return super.CanReceiveItemIntoCargo(item);
13501 }
13502
13504 {
13505
13506
13507
13508
13509 GameInventory attachmentInv = attachment.GetInventory();
13511 {
13512 if (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase))
13513 return false;
13514 }
13515
13516 InventoryLocation loc = new InventoryLocation();
13517 attachment.GetInventory().GetCurrentInventoryLocation(loc);
13518 if (loc && loc.
IsValid() && !GetInventory().AreChildrenAccessible())
13519 return false;
13520
13521 return super.CanReceiveAttachment(attachment, slotId);
13522 }
13523
13525 {
13526 if (!super.CanReleaseAttachment(attachment))
13527 return false;
13528
13529 return GetInventory().AreChildrenAccessible();
13530 }
13531
13532
13533
13534
13535
13536
13537
13538
13539
13540
13541
13542
13543
13544
13545
13546
13547
13548
13549
13550
13551
13553 {
13554 int id = muzzle_owner.GetMuzzleID();
13555 array<ref WeaponParticlesOnFire> WPOF_array =
m_OnFireEffect.Get(
id);
13556
13557 if (WPOF_array)
13558 {
13559 for (int i = 0; i < WPOF_array.Count(); i++)
13560 {
13561 WeaponParticlesOnFire WPOF = WPOF_array.Get(i);
13562
13563 if (WPOF)
13564 {
13565 WPOF.OnActivate(weapon, muzzle_index, ammoType, muzzle_owner, suppressor, config_to_search);
13566 }
13567 }
13568 }
13569 }
13570
13571
13573 {
13574 int id = muzzle_owner.GetMuzzleID();
13576
13577 if (WPOBE_array)
13578 {
13579 for (int i = 0; i < WPOBE_array.Count(); i++)
13580 {
13581 WeaponParticlesOnBulletCasingEject WPOBE = WPOBE_array.Get(i);
13582
13583 if (WPOBE)
13584 {
13585 WPOBE.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
13586 }
13587 }
13588 }
13589 }
13590
13591
13593 {
13594 int id = muzzle_owner.GetMuzzleID();
13595 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
13596
13597 if (WPOOH_array)
13598 {
13599 for (int i = 0; i < WPOOH_array.Count(); i++)
13600 {
13601 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
13602
13603 if (WPOOH)
13604 {
13605 WPOOH.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
13606 }
13607 }
13608 }
13609 }
13610
13611
13613 {
13614 int id = muzzle_owner.GetMuzzleID();
13615 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
13616
13617 if (WPOOH_array)
13618 {
13619 for (int i = 0; i < WPOOH_array.Count(); i++)
13620 {
13621 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
13622
13623 if (WPOOH)
13624 {
13625 WPOOH.OnUpdate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
13626 }
13627 }
13628 }
13629 }
13630
13631
13633 {
13634 int id = muzzle_owner.GetMuzzleID();
13635 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
13636
13637 if (WPOOH_array)
13638 {
13639 for (int i = 0; i < WPOOH_array.Count(); i++)
13640 {
13641 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
13642
13643 if (WPOOH)
13644 {
13645 WPOOH.OnDeactivate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
13646 }
13647 }
13648 }
13649 }
13650
13651
13652
13654 {
13656 {
13657 return true;
13658 }
13659
13660 return false;
13661 }
13662
13664 {
13666 {
13667 return true;
13668 }
13669
13670 return false;
13671 }
13672
13674 {
13676 {
13677 return true;
13678 }
13679
13680 return false;
13681 }
13682
13684 {
13685 return false;
13686 }
13687
13690 {
13691 return UATimeSpent.DEFAULT_DEPLOY;
13692 }
13693
13694
13695
13696
13698 {
13700 SetSynchDirty();
13701 }
13702
13704 {
13706 }
13707
13708
13710 {
13711 return false;
13712 }
13713
13716 {
13717 string att_type = "None";
13718
13719 if (ConfigIsExisting("soundAttType"))
13720 {
13721 att_type = ConfigGetString("soundAttType");
13722 }
13723
13725 }
13726
13728 {
13730 }
13731
13732
13733
13734
13735
13741
13743 {
13746
13748 }
13749
13750
13752 {
13754 return;
13755
13757
13760
13763
13764 SoundParameters params = new SoundParameters();
13768 }
13769
13770
13772 {
13774 return;
13775
13777 SetSynchDirty();
13778
13781 }
13782
13783
13785 {
13787 return;
13788
13790 SetSynchDirty();
13791
13794 }
13795
13797 {
13799 }
13800
13802 {
13804 }
13805
13808 {
13809 if (!
GetGame().IsDedicatedServer())
13810 {
13811 if (ConfigIsExisting("attachSoundSet"))
13812 {
13813 string cfg_path = "";
13814 string soundset = "";
13815 string type_name =
GetType();
13816
13819 ConfigGetTextArray("attachSoundSet",cfg_soundset_array);
13820 ConfigGetTextArray("attachSoundSlot",cfg_slot_array);
13821
13822 if (cfg_soundset_array.Count() > 0 && cfg_soundset_array.Count() == cfg_slot_array.Count())
13823 {
13824 for (int i = 0; i < cfg_soundset_array.Count(); i++)
13825 {
13826 if (cfg_slot_array[i] == slot_type)
13827 {
13828 soundset = cfg_soundset_array[i];
13829 break;
13830 }
13831 }
13832 }
13833
13834 if (soundset != "")
13835 {
13836 EffectSound sound = SEffectManager.PlaySound(soundset,
GetPosition());
13838 }
13839 }
13840 }
13841 }
13842
13844 {
13845
13846 }
13847
13848 void OnApply(PlayerBase player);
13849
13851 {
13852 return 1.0;
13853 };
13854
13856 {
13858 }
13859
13861 {
13863 }
13864
13866
13868 {
13869 SetDynamicPhysicsLifeTime(0.01);
13871 }
13872
13874 {
13875 array<string> zone_names = new array<string>;
13876 GetDamageZones(zone_names);
13877 for (int i = 0; i < zone_names.Count(); i++)
13878 {
13879 SetHealthMax(zone_names.Get(i),"Health");
13880 }
13881 SetHealthMax("","Health");
13882 }
13883
13886 {
13887 float global_health = GetHealth01("","Health");
13888 array<string> zones = new array<string>;
13889 GetDamageZones(zones);
13890
13891 for (int i = 0; i < zones.Count(); i++)
13892 {
13893 SetHealth01(zones.Get(i),"Health",global_health);
13894 }
13895 }
13896
13899 {
13900 return IsExclusionFlagPresent(PlayerBase.GetFaceCoverageShaveValues());
13901 }
13902
13904 {
13905 if (!hasRootAsPlayer)
13906 {
13907 if (refParentIB)
13908 {
13909
13910 if ((refParentIB.GetWet() >= GameConstants.STATE_SOAKING_WET) && (
m_VarWet <
m_VarWetMax))
13911 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_INSIDE);
13912
13913 else if ((refParentIB.GetLiquidType() != 0) && (refParentIB.GetQuantity() > 0) && (
m_VarWet <
m_VarWetMax))
13914 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_LIQUID);
13915
13918 }
13919 else
13920 {
13921
13924 }
13925 }
13926 }
13927
13929 {
13931 {
13932 float target =
g_Game.GetMission().GetWorldData().GetBaseEnvTemperatureAtObject(
this);
13933 if (
GetTemperature() != target || !IsFreezeThawProgressFinished())
13934 {
13935 float heatPermCoef = 1.0;
13937 while (ent)
13938 {
13939 heatPermCoef *= ent.GetHeatPermeabilityCoef();
13940 ent = ent.GetHierarchyParent();
13941 }
13942
13943 SetTemperatureEx(
new TemperatureDataInterpolated(target,
ETemperatureAccessTypes.ACCESS_WORLD,delta,GameConstants.TEMP_COEF_WORLD,heatPermCoef));
13944 }
13945 }
13946 }
13947
13949 {
13950
13951 EntityAI parent = GetHierarchyParent();
13952 if (!parent)
13953 {
13954 hasParent = false;
13955 hasRootAsPlayer = false;
13956 }
13957 else
13958 {
13959 hasParent = true;
13960 hasRootAsPlayer = (GetHierarchyRootPlayer() != null);
13961 refParentIB =
ItemBase.Cast(parent);
13962 }
13963 }
13964
13965 protected void ProcessDecay(
float delta,
bool hasRootAsPlayer)
13966 {
13967
13968 }
13969
13971 {
13972
13973 return false;
13974 }
13975
13977 {
13978
13979
13980 return false;
13981 }
13982
13984 {
13985
13986 return false;
13987 }
13988
13991 {
13992 return !GetIsFrozen() &&
IsOpen();
13993 }
13994
13996 {
13997 bool hasParent = false, hasRootAsPlayer = false;
13999
14000 bool wwtu =
g_Game.IsWorldWetTempUpdateEnabled();
14001 bool foodDecay =
g_Game.IsFoodDecayEnabled();
14002
14003 if (wwtu || foodDecay)
14004 {
14008
14009 if (processWetness || processTemperature || processDecay)
14010 {
14012
14013 if (processWetness)
14014 ProcessItemWetness(m_ElapsedSinceLastUpdate, hasParent, hasRootAsPlayer, refParentIB);
14015
14016 if (processTemperature)
14018
14019 if (processDecay)
14020 ProcessDecay(m_ElapsedSinceLastUpdate, hasRootAsPlayer);
14021 }
14022 }
14023 }
14024
14027 {
14029 }
14030
14032 {
14035
14036 return super.GetTemperatureFreezeThreshold();
14037 }
14038
14040 {
14043
14044 return super.GetTemperatureThawThreshold();
14045 }
14046
14048 {
14051
14052 return super.GetItemOverheatThreshold();
14053 }
14054
14056 {
14058 return Math.Lerp(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureFreezeTime()),
GetQuantityNormalized());
14059
14060 return super.GetTemperatureFreezeTime();
14061 }
14062
14064 {
14066 return Math.Lerp(GameConstants.TEMPERATURE_TIME_THAW_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureThawTime()),
GetQuantityNormalized());
14067
14068 return super.GetTemperatureThawTime();
14069 }
14070
14075
14077 {
14078 return (item.IsKindOf("Cauldron") || item.IsKindOf("Pot") || item.IsKindOf("FryingPan") || item.IsKindOf("SmallProtectorCase") || (item.IsKindOf("PortableGasStove") && item.FindAttachmentBySlotName("CookingEquipment")));
14079 }
14080
14082 {
14083 MiscGameplayFunctions.TransferItemProperties(oldItem, this);
14084 }
14085
14088 {
14090 }
14091
14093 {
14095 }
14096
14098 {
14100 }
14101
14104 {
14105 return null;
14106 }
14107
14110 {
14111 return false;
14112 }
14113
14115 {
14117 {
14120 if (!trg)
14121 {
14123 explosive = this;
14124 }
14125
14126 explosive.PairRemote(trg);
14128
14129 int persistentID = RemotelyActivatedItemBehaviour.GeneratePersistentID();
14130 trg.SetPersistentPairID(persistentID);
14131 explosive.SetPersistentPairID(persistentID);
14132
14133 return true;
14134 }
14135 return false;
14136 }
14137
14140 {
14141 float ret = 1.0;
14144 ret *= GetHealth01();
14145
14146 return ret;
14147 }
14148
14149 #ifdef DEVELOPER
14150 override void SetDebugItem()
14151 {
14152 super.SetDebugItem();
14153 _itemBase = this;
14154 }
14155
14157 {
14158 string text = super.GetDebugText();
14159
14161 text +=
string.
Format(
"Heat isolation(modified): %1\n", MiscGameplayFunctions.GetCurrentItemHeatIsolation(
this));
14162
14163 return text;
14164 }
14165 #endif
14166
14168 {
14169 return true;
14170 }
14171
14173
14175
14177 {
14180 }
14181
14182
14190
14206}
14207
14209{
14211 if (entity)
14212 {
14213 bool is_item = entity.IsInherited(
ItemBase);
14214 if (is_item && full_quantity)
14215 {
14218 }
14219 }
14220 else
14221 {
14223 return NULL;
14224 }
14225 return entity;
14226}
14227
14229{
14230 if (item)
14231 {
14232 if (health > 0)
14233 item.SetHealth("", "", health);
14234
14235 if (item.CanHaveTemperature())
14236 {
14238 if (item.CanFreeze())
14239 item.SetFrozen(false);
14240 }
14241
14242 if (item.HasEnergyManager())
14243 {
14244 if (quantity >= 0)
14245 {
14246 item.GetCompEM().SetEnergy0To1(quantity);
14247 }
14248 else
14249 {
14251 }
14252 }
14253 else if (item.IsMagazine())
14254 {
14255 Magazine mag = Magazine.Cast(item);
14256 if (quantity >= 0)
14257 {
14258 mag.ServerSetAmmoCount(mag.GetAmmoMax() * quantity);
14259 }
14260 else
14261 {
14263 }
14264
14265 }
14266 else
14267 {
14268 if (quantity >= 0)
14269 {
14270 item.SetQuantityNormalized(quantity, false);
14271 }
14272 else
14273 {
14275 }
14276
14277 }
14278 }
14279}
14280
14281#ifdef DEVELOPER
14283#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.