9364{
9366 {
9367 return true;
9368 }
9369};
9370
9371
9372
9374{
9378
9380
9383
9384
9385
9386
9387
9396
9402
9407
9412
9433 protected bool m_IsResultOfSplit
9434
9436
9441
9442
9443
9445
9449
9450
9451
9453
9456
9457
9458
9464
9465
9473
9476
9477
9479
9480
9482
9483
9488
9489
9494
9495
9497
9498
9500 {
9505
9506 if (!
GetGame().IsDedicatedServer())
9507 {
9509 {
9511
9513 {
9515 }
9516 }
9517
9520 }
9521
9522 m_OldLocation = null;
9523
9525 {
9527 }
9528
9529 if (ConfigIsExisting("headSelectionsToHide"))
9530 {
9533 }
9534
9536 if (ConfigIsExisting("hideSelectionsByinventorySlot"))
9537 {
9539 }
9540
9542
9543 m_IsResultOfSplit = false;
9544
9546 }
9547
9549 {
9550 super.InitItemVariables();
9551
9557 m_Count = ConfigGetInt(
"count");
9558
9561
9566
9569
9574
9586
9590
9591
9594 if (ConfigIsExisting("canBeSplit"))
9595 {
9598 }
9599
9601 if (ConfigIsExisting("itemBehaviour"))
9603
9604
9607 RegisterNetSyncVariableInt("m_VarLiquidType");
9608 RegisterNetSyncVariableInt("m_Cleanness",0,1);
9609
9610 RegisterNetSyncVariableBoolSignal("m_WantPlayImpactSound");
9611 RegisterNetSyncVariableFloat("m_ImpactSpeed");
9612 RegisterNetSyncVariableInt("m_ImpactSoundSurfaceHash");
9613
9614 RegisterNetSyncVariableInt("m_ColorComponentR", 0, 255);
9615 RegisterNetSyncVariableInt("m_ColorComponentG", 0, 255);
9616 RegisterNetSyncVariableInt("m_ColorComponentB", 0, 255);
9617 RegisterNetSyncVariableInt("m_ColorComponentA", 0, 255);
9618
9619 RegisterNetSyncVariableBool("m_IsBeingPlaced");
9620 RegisterNetSyncVariableBool("m_IsTakeable");
9621 RegisterNetSyncVariableBool("m_IsHologram");
9622
9625 {
9628 }
9629
9631
9633 if (ConfigIsExisting("temperaturePerQuantityWeight"))
9635
9636 }
9637
9639 {
9641 }
9642
9644 {
9647 {
9652 }
9653 }
9654
9655 override void GetActions(
typename action_input_type, out array<ActionBase_Basic> actions)
9656 {
9658 {
9661 }
9662
9664 }
9665
9667 {
9673 }
9674
9676
9678 {
9680
9681 if (!action)
9682 {
9683 Debug.LogError(
"Action " + actionName +
" dosn't exist!");
9684 return;
9685 }
9686
9688 if (!ai)
9689 {
9691 return;
9692 }
9693
9695 if (!action_array)
9696 {
9697 action_array = new array<ActionBase_Basic>;
9699 }
9700 if (LogManager.IsActionLogEnable())
9701 {
9702 Debug.ActionLog(action.ToString() +
" -> " + ai,
this.ToString() ,
"n/a",
"Add action");
9703 }
9704
9705 if (action_array.Find(action) != -1)
9706 {
9707 Debug.Log(
"Action " + action.Type() +
" already added to " +
this +
", skipping!");
9708 }
9709 else
9710 {
9711 action_array.Insert(action);
9712 }
9713 }
9714
9716 {
9718 ActionBase action = player.GetActionManager().GetAction(actionName);
9721
9722 if (action_array)
9723 {
9724 action_array.RemoveItem(action);
9725 }
9726 }
9727
9728
9729
9731 {
9732 ActionOverrideData overrideData = new ActionOverrideData();
9736
9738 if (!actionMap)
9739 {
9742 }
9743
9744 actionMap.Insert(this.
Type(), overrideData);
9745
9746 }
9747
9749
9751
9752
9754 {
9757
9760
9761 string config_to_search = "CfgVehicles";
9762 string muzzle_owner_config;
9763
9765 {
9766 if (IsInherited(Weapon))
9767 config_to_search = "CfgWeapons";
9768
9769 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
9770
9771 string config_OnFire_class = muzzle_owner_config + "Particles " + "OnFire ";
9772
9774
9775 if (config_OnFire_subclass_count > 0)
9776 {
9777 array<ref WeaponParticlesOnFire> WPOF_array = new array<ref WeaponParticlesOnFire>;
9778
9779 for (int i = 0; i < config_OnFire_subclass_count; i++)
9780 {
9781 string particle_class = "";
9783 string config_OnFire_entry = config_OnFire_class + particle_class;
9784 WeaponParticlesOnFire WPOF = new WeaponParticlesOnFire(this, config_OnFire_entry);
9785 WPOF_array.Insert(WPOF);
9786 }
9787
9788
9790 }
9791 }
9792
9794 {
9795 config_to_search = "CfgWeapons";
9796 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
9797
9798 string config_OnBulletCasingEject_class = muzzle_owner_config + "Particles " + "OnBulletCasingEject ";
9799
9801
9802 if (config_OnBulletCasingEject_count > 0 && IsInherited(Weapon))
9803 {
9804 array<ref WeaponParticlesOnBulletCasingEject> WPOBE_array = new array<ref WeaponParticlesOnBulletCasingEject>;
9805
9806 for (i = 0; i < config_OnBulletCasingEject_count; i++)
9807 {
9808 string particle_class2 = "";
9810 string config_OnBulletCasingEject_entry = config_OnBulletCasingEject_class + particle_class2;
9811 WeaponParticlesOnBulletCasingEject WPOBE = new WeaponParticlesOnBulletCasingEject(this, config_OnBulletCasingEject_entry);
9812 WPOBE_array.Insert(WPOBE);
9813 }
9814
9815
9817 }
9818 }
9819 }
9820
9821
9823 {
9826
9828 {
9829 string config_to_search = "CfgVehicles";
9830
9831 if (IsInherited(Weapon))
9832 config_to_search = "CfgWeapons";
9833
9834 string muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
9835 string config_OnOverheating_class = muzzle_owner_config + "Particles " + "OnOverheating ";
9836
9837 if (
GetGame().ConfigIsExisting(config_OnOverheating_class))
9838 {
9839
9841
9843 {
9845 string error =
"Error reading config " +
GetType() +
">Particles>OnOverheating - Parameter shotsToStartOverheating is configured wrong or is missing! Its value must be 1 or higher!";
9847 return;
9848 }
9849
9852
9853
9854
9856 array<ref WeaponParticlesOnOverheating> WPOOH_array = new array<ref WeaponParticlesOnOverheating>;
9857
9858 for (int i = 0; i < config_OnOverheating_subclass_count; i++)
9859 {
9860 string particle_class = "";
9862 string config_OnOverheating_entry = config_OnOverheating_class + particle_class;
9864
9865 if (entry_type == CT_CLASS)
9866 {
9867 WeaponParticlesOnOverheating WPOF = new WeaponParticlesOnOverheating(this, config_OnOverheating_entry);
9868 WPOOH_array.Insert(WPOF);
9869 }
9870 }
9871
9872
9874 }
9875 }
9876 }
9877
9879 {
9881 }
9882
9884 {
9886 {
9888
9891
9894
9895 CheckOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9896 }
9897 }
9898
9900 {
9902 UpdateOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9903
9905 StartOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9906
9908 StopOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9909
9911 {
9913 }
9914 }
9915
9917 {
9919 }
9920
9922 {
9925 else
9927
9929 {
9932 }
9933 else
9934 {
9937
9940 }
9941
9943 }
9944
9946 {
9948 ItemBase.PlayOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
9949 }
9950
9952 {
9954 ItemBase.UpdateOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
9956 }
9957
9959 {
9961 ItemBase.StopOverheatingParticles(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9962 }
9963
9965 {
9968
9969 OverheatingParticle OP = new OverheatingParticle();
9974
9976 }
9977
9979 {
9982
9983 return -1;
9984 }
9985
9987 {
9989 {
9992
9993 for (int i = count; i > 0; --i)
9994 {
9995 int id = i - 1;
9998
10001
10002 if (overheat_coef < overheat_min && overheat_coef >= overheat_max)
10003 {
10004 if (p)
10005 {
10008 }
10009 }
10010 }
10011 }
10012 }
10013
10015 {
10017 {
10019 {
10020 int id = i - 1;
10022
10023 if (OP)
10024 {
10026
10027 if (p)
10028 {
10030 }
10031
10032 delete OP;
10033 }
10034 }
10035
10038 }
10039 }
10040
10043 {
10044 return 0.0;
10045 }
10046
10047
10049 {
10050 return 250;
10051 }
10052
10054 {
10055 return 0;
10056 }
10057
10060 {
10062 return true;
10063
10064 return false;
10065 }
10066
10069 {
10072
10074 {
10076 }
10077 else
10078 {
10079
10081 }
10082
10084 }
10085
10092 {
10093 return -1;
10094 }
10095
10096
10097
10098
10100 {
10102 {
10104 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
10105
10106 if (r_index >= 0)
10107 {
10108 InventoryLocation r_il = new InventoryLocation;
10109 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
10110
10111 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
10114 {
10115 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
10116 }
10118 {
10119 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
10120 }
10121
10122 }
10123
10124 player.GetHumanInventory().ClearUserReservedLocation(this);
10125 }
10126
10129 }
10130
10131
10132
10133
10135 {
10136 return ItemBase.m_DebugActionsMask;
10137 }
10138
10140 {
10141 return ItemBase.m_DebugActionsMask & mask;
10142 }
10143
10145 {
10146 ItemBase.m_DebugActionsMask = mask;
10147 }
10148
10150 {
10151 ItemBase.m_DebugActionsMask |= mask;
10152 }
10153
10155 {
10156 ItemBase.m_DebugActionsMask &= ~mask;
10157 }
10158
10160 {
10162 {
10164 }
10165 else
10166 {
10168 }
10169 }
10170
10171
10173 {
10174 if (GetEconomyProfile())
10175 {
10176 float q_max = GetEconomyProfile().GetQuantityMax();
10177 if (q_max > 0)
10178 {
10179 float q_min = GetEconomyProfile().GetQuantityMin();
10180 float quantity_randomized = Math.RandomFloatInclusive(q_min, q_max);
10181
10183 {
10184 ComponentEnergyManager comp = GetCompEM();
10186 {
10188 }
10189 }
10191 {
10193
10194 }
10195
10196 }
10197 }
10198 }
10199
10202 {
10203 EntityAI parent = GetHierarchyParent();
10204
10205 if (parent)
10206 {
10207 InventoryLocation inventory_location_to_lock = new InventoryLocation;
10208 GetInventory().GetCurrentInventoryLocation(inventory_location_to_lock);
10209 parent.GetInventory().SetSlotLock(inventory_location_to_lock.
GetSlot(),
true);
10210 }
10211 }
10212
10215 {
10216 EntityAI parent = GetHierarchyParent();
10217
10218 if (parent)
10219 {
10220 InventoryLocation inventory_location_to_unlock = new InventoryLocation;
10221 GetInventory().GetCurrentInventoryLocation(inventory_location_to_unlock);
10222 parent.GetInventory().SetSlotLock(inventory_location_to_unlock.
GetSlot(),
false);
10223 }
10224 }
10225
10227 {
10228
10229
10230
10231
10233
10235 {
10236 if (ScriptInputUserData.CanStoreInputUserData())
10237 {
10238 ScriptInputUserData ctx = new ScriptInputUserData;
10244 ctx.
Write(use_stack_max);
10247
10249 {
10250 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(item2,null,GameInventory.c_InventoryReservationTimeoutShortMS);
10251 }
10252 }
10253 }
10254 else if (!
GetGame().IsMultiplayer())
10255 {
10257 }
10258 }
10259
10261 {
10263 }
10264
10266 {
10268 }
10269
10271 {
10273 }
10274
10276 {
10277
10278 return false;
10279 }
10280
10282 {
10283 return false;
10284 }
10285
10289 {
10290 return false;
10291 }
10292
10294 {
10295 return "";
10296 }
10297
10299
10301 {
10302 return false;
10303 }
10304
10306 {
10307 return true;
10308 }
10309
10310
10311
10313 {
10314 return true;
10315 }
10316
10318 {
10319 return true;
10320 }
10321
10323 {
10324 PlayerBase player = PlayerBase.Cast(
g_Game.GetPlayer());
10326 }
10327
10329 {
10331 }
10332
10334 {
10336 if (!is_being_placed)
10338 SetSynchDirty();
10339 }
10340
10341
10343
10345 {
10347 }
10348
10350 {
10352 }
10353
10355 {
10356 return 1;
10357 }
10358
10360 {
10361 return false;
10362 }
10363
10365 {
10367 SetSynchDirty();
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
10398
10399
10400
10401
10402
10403
10405 {
10406 super.OnMovedInsideCargo(container);
10407
10408 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
10409 }
10410
10411 override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
10412 {
10413 super.EEItemLocationChanged(oldLoc,newLoc);
10414
10415 PlayerBase new_player = null;
10416 PlayerBase old_player = null;
10417
10418 if (newLoc.GetParent())
10419 new_player = PlayerBase.Cast(newLoc.GetParent().GetHierarchyRootPlayer());
10420
10421 if (oldLoc.GetParent())
10422 old_player = PlayerBase.Cast(oldLoc.GetParent().GetHierarchyRootPlayer());
10423
10425 {
10426 int r_index = old_player.GetHumanInventory().FindUserReservedLocationIndex(this);
10427
10428 if (r_index >= 0)
10429 {
10430 InventoryLocation r_il = new InventoryLocation;
10431 old_player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
10432
10433 old_player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
10436 {
10437 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
10438 }
10440 {
10441 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
10442 }
10443
10444 }
10445 }
10446
10448 {
10449 if (new_player)
10450 new_player.ForceStandUpForHeavyItems(newLoc.GetItem());
10451
10452 if (new_player == old_player)
10453 {
10454
10455 if (oldLoc.GetParent() && new_player.GetHumanInventory().LocationGetEntity(oldLoc) == NULL)
10456 {
10458 {
10459 if (oldLoc.GetParent().GetInventory().TestAddEntityInCargoExLoc(oldLoc, false, false, false, true, false, false))
10460 {
10461 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
10462 }
10463 }
10464 else
10465 {
10466 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
10467 }
10468 }
10469
10470 if (new_player.GetHumanInventory().FindUserReservedLocationIndex(this) >= 0)
10471 {
10472 int type = oldLoc.GetType();
10474 {
10475 oldLoc.GetParent().GetOnSetLock().Invoke(this);
10476 }
10478 {
10479 oldLoc.GetParent().GetOnAttachmentSetLock().Invoke(this, oldLoc.GetSlot());
10480 }
10481 }
10482 if (!m_OldLocation)
10483 {
10484 m_OldLocation = new InventoryLocation;
10485 }
10486 m_OldLocation.Copy(oldLoc);
10487 }
10488 else
10489 {
10490 if (m_OldLocation)
10491 {
10492 m_OldLocation.Reset();
10493 }
10494 }
10495
10497 }
10498 else
10499 {
10500 if (new_player)
10501 {
10502 int res_index = new_player.GetHumanInventory().FindCollidingUserReservedLocationIndex(this, newLoc);
10503 if (res_index >= 0)
10504 {
10505 InventoryLocation il = new InventoryLocation;
10506 new_player.GetHumanInventory().GetUserReservedLocation(res_index,il);
10508 new_player.GetHumanInventory().ClearUserReservedLocationAtIndex(res_index);
10511 {
10512 il.
GetParent().GetOnReleaseLock().Invoke(it);
10513 }
10515 {
10517 }
10518
10519 }
10520 }
10522 {
10523
10525 }
10526
10527 if (m_OldLocation)
10528 {
10529 m_OldLocation.Reset();
10530 }
10531 }
10532 }
10533
10534 override void EOnContact(IEntity other, Contact extra)
10535 {
10537 {
10538 int liquidType = -1;
10540 if (impactSpeed > 0.0)
10541 {
10543 #ifndef SERVER
10545 #else
10547 SetSynchDirty();
10548 #endif
10550 }
10551 }
10552
10553 #ifdef SERVER
10554 if (GetCompEM() && GetCompEM().IsPlugged())
10555 {
10556 if (GetCompEM().GetCordLength() < vector.Distance(
GetPosition(), GetCompEM().GetEnergySource().
GetPosition()))
10557 GetCompEM().UnplugThis();
10558 }
10559 #endif
10560 }
10561
10563
10565 {
10567 }
10568
10570 {
10571
10572 }
10573
10575 {
10576 super.OnItemLocationChanged(old_owner, new_owner);
10577
10578 PlayerBase relatedPlayer = PlayerBase.Cast(old_owner);
10579 PlayerBase playerNew = PlayerBase.Cast(new_owner);
10580
10581 if (!relatedPlayer && playerNew)
10582 relatedPlayer = playerNew;
10583
10584 if (relatedPlayer && relatedPlayer.GetPerformedActionID() != -1)
10585 {
10587 if (actionMgr)
10588 {
10589 ActionBase currentAction = actionMgr.GetRunningAction();
10590 if (currentAction)
10592 }
10593 }
10594
10595 Man ownerPlayerOld = null;
10596 Man ownerPlayerNew = null;
10597
10598 if (old_owner)
10599 {
10600 if (old_owner.
IsMan())
10601 {
10602 ownerPlayerOld = Man.Cast(old_owner);
10603 }
10604 else
10605 {
10606 ownerPlayerOld = Man.Cast(old_owner.GetHierarchyRootPlayer());
10607 }
10608 }
10609 else
10610 {
10612 {
10614
10615 if (!action || !playerNew || playerNew.GetPerformedActionID() != action.
GetID())
10616 {
10617 GetCompEM().UnplugThis();
10618 }
10619 }
10620 }
10621
10622 if (new_owner)
10623 {
10624 if (new_owner.
IsMan())
10625 {
10626 ownerPlayerNew = Man.Cast(new_owner);
10627 }
10628 else
10629 {
10630 ownerPlayerNew = Man.Cast(new_owner.GetHierarchyRootPlayer());
10631 }
10632 }
10633
10634 if (ownerPlayerOld != ownerPlayerNew)
10635 {
10636 if (ownerPlayerOld)
10637 {
10638 array<EntityAI> subItemsExit = new array<EntityAI>;
10640 for (int i = 0; i < subItemsExit.Count(); i++)
10641 {
10644 }
10645 }
10646
10647 if (ownerPlayerNew)
10648 {
10649 array<EntityAI> subItemsEnter = new array<EntityAI>;
10651 for (int j = 0; j < subItemsEnter.Count(); j++)
10652 {
10655 }
10656 }
10657 }
10658 else if (ownerPlayerNew != null)
10659 {
10660 PlayerBase nplayer;
10661 if (PlayerBase.CastTo(nplayer, ownerPlayerNew))
10662 {
10663 array<EntityAI> subItemsUpdate = new array<EntityAI>;
10665 for (int k = 0; k < subItemsUpdate.Count(); k++)
10666 {
10668 itemUpdate.UpdateQuickbarShortcutVisibility(nplayer);
10669 }
10670 }
10671 }
10672
10673 if (old_owner)
10674 old_owner.OnChildItemRemoved(this);
10675 if (new_owner)
10676 new_owner.OnChildItemReceived(this);
10677 }
10678
10679
10681 {
10682 super.EEDelete(parent);
10683 PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
10684 if (player)
10685 {
10687
10688 if (player.IsAlive())
10689 {
10690 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
10691 if (r_index >= 0)
10692 {
10693 InventoryLocation r_il = new InventoryLocation;
10694 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
10695
10696 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
10699 {
10700 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
10701 }
10703 {
10704 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
10705 }
10706
10707 }
10708
10709 player.RemoveQuickBarEntityShortcut(this);
10710 }
10711 }
10712 }
10713
10715 {
10716 super.EEKilled(killer);
10717
10720 {
10721 if (
GetTemperature() >= GameConstants.ITEM_TEMPERATURE_TO_EXPLODE_MIN)
10722 {
10723 if (IsMagazine())
10724 {
10725 if (Magazine.Cast(this).GetAmmoCount() > 0)
10726 {
10728 }
10729 }
10730 else
10731 {
10733 }
10734 }
10735 }
10736 }
10737
10739 {
10740 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
10741
10742 super.OnWasAttached(parent, slot_id);
10743
10746
10748 }
10749
10751 {
10752 super.OnWasDetached(parent, slot_id);
10753
10756 }
10757
10759 {
10760 int idx;
10763
10764 ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
10765 if (inventory_slots.Count() < 1)
10766 {
10767 inventory_slots.Insert(ConfigGetString("ChangeInventorySlot"));
10768 attach_types.Insert(ConfigGetString("ChangeIntoOnAttach"));
10769 }
10770 else
10771 {
10772 ConfigGetTextArray("ChangeIntoOnAttach",attach_types);
10773 }
10774
10775 idx = inventory_slots.Find(slot);
10776 if (idx < 0)
10777 return "";
10778
10779 return attach_types.Get(idx);
10780 }
10781
10783 {
10784 int idx = -1;
10785 string slot;
10786
10789
10790 this.ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
10791 if (inventory_slots.Count() < 1)
10792 {
10793 inventory_slots.Insert(this.ConfigGetString("ChangeInventorySlot"));
10794 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
10795 }
10796 else
10797 {
10798 this.ConfigGetTextArray("ChangeIntoOnDetach",detach_types);
10799 if (detach_types.Count() < 1)
10800 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
10801 }
10802
10803 for (int i = 0; i < inventory_slots.Count(); i++)
10804 {
10805 slot = inventory_slots.Get(i);
10806 }
10807
10808 if (slot != "")
10809 {
10810 if (detach_types.Count() == 1)
10811 idx = 0;
10812 else
10813 idx = inventory_slots.Find(slot);
10814 }
10815 if (idx < 0)
10816 return "";
10817
10818 return detach_types.Get(idx);
10819 }
10820
10822 {
10823
10825
10826
10827 float min_time = 1;
10828 float max_time = 3;
10829 float delay = Math.RandomFloat(min_time, max_time);
10830
10831 explode_timer.Run(delay, this, "DoAmmoExplosion");
10832 }
10833
10835 {
10836 Magazine magazine = Magazine.Cast(this);
10837 int pop_sounds_count = 6;
10838 string pop_sounds[ 6 ] = { "ammopops_1","ammopops_2","ammopops_3","ammopops_4","ammopops_5","ammopops_6" };
10839
10840
10841 int sound_idx = Math.RandomInt(0, pop_sounds_count - 1);
10842 string sound_name = pop_sounds[ sound_idx ];
10844
10845
10846 magazine.ServerAddAmmoCount(-1);
10847
10848
10849 float min_temp_to_explode = 100;
10850
10851 if (magazine.GetAmmoCount() > 0 &&
GetTemperature() >= min_temp_to_explode)
10852 {
10854 }
10855 }
10856
10857
10858 override void EEHitBy(TotalDamageResult damageResult,
int damageType,
EntityAI source,
int component,
string dmgZone,
string ammo, vector modelPos,
float speedCoef)
10859 {
10860 super.EEHitBy(damageResult, damageType, source,
component, dmgZone, ammo, modelPos, speedCoef);
10861
10862 const int CHANCE_DAMAGE_CARGO = 4;
10863 const int CHANCE_DAMAGE_ATTACHMENT = 1;
10864 const int CHANCE_DAMAGE_NOTHING = 2;
10865
10867 {
10868 float dmg = damageResult.
GetDamage(
"",
"Health") * -0.5;
10869 int chances;
10870 int rnd;
10871
10872 if (GetInventory().GetCargo())
10873 {
10874 chances = CHANCE_DAMAGE_CARGO + CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
10875 rnd = Math.RandomInt(0,chances);
10876
10877 if (rnd < CHANCE_DAMAGE_CARGO)
10878 {
10880 }
10881 else if (rnd < (chances - CHANCE_DAMAGE_NOTHING))
10882 {
10884 }
10885 }
10886 else
10887 {
10888 chances = CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
10889 rnd = Math.RandomInt(0,chances);
10890
10891 if (rnd < CHANCE_DAMAGE_ATTACHMENT)
10892 {
10894 }
10895 }
10896 }
10897 }
10898
10900 {
10901 if (GetInventory().GetCargo())
10902 {
10903 int item_count = GetInventory().GetCargo().GetItemCount();
10904 if (item_count > 0)
10905 {
10906 int random_pick = Math.RandomInt(0, item_count);
10908 if (!item.IsExplosive())
10909 {
10910 item.AddHealth("","",damage);
10911 return true;
10912 }
10913 }
10914 }
10915 return false;
10916 }
10917
10919 {
10920 int attachment_count = GetInventory().AttachmentCount();
10921 if (attachment_count > 0)
10922 {
10923 int random_pick = Math.RandomInt(0, attachment_count);
10924 ItemBase attachment =
ItemBase.Cast(GetInventory().GetAttachmentFromIndex(random_pick));
10925 if (!attachment.IsExplosive())
10926 {
10927 attachment.AddHealth("","",damage);
10928 return true;
10929 }
10930 }
10931 return false;
10932 }
10933
10935 {
10937 }
10938
10940 {
10942 return GetInventory().CanRemoveEntity();
10943
10944 return false;
10945 }
10946
10948 {
10949
10951 return false;
10952
10953
10955 return false;
10956
10957
10958
10960 if (delta == 0)
10961 return false;
10962
10963
10964 return true;
10965 }
10966
10968 {
10970 {
10971 if (ScriptInputUserData.CanStoreInputUserData())
10972 {
10973 ScriptInputUserData ctx = new ScriptInputUserData;
10978 ctx.
Write(destination_entity);
10980 ctx.
Write(slot_id);
10982 }
10983 }
10984 else if (!
GetGame().IsMultiplayer())
10985 {
10987 }
10988 }
10989
10991 {
10992 float split_quantity_new;
10996 InventoryLocation loc = new InventoryLocation;
10997
10998 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
10999 {
11001 split_quantity_new = stack_max;
11002 else
11004
11006 {
11007 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
11008 if (new_item)
11009 {
11010 new_item.SetResultOfSplit(true);
11011 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11013 new_item.
SetQuantity(split_quantity_new,
false,
true);
11014 }
11015 }
11016 }
11017 else if (destination_entity && slot_id == -1)
11018 {
11019 if (quantity > stack_max)
11020 split_quantity_new = stack_max;
11021 else
11022 split_quantity_new = quantity;
11023
11025 {
11027 {
11030 }
11031
11032 if (new_item)
11033 {
11034 new_item.SetResultOfSplit(true);
11035 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11037 new_item.
SetQuantity(split_quantity_new,
false,
true);
11038 }
11039 }
11040 }
11041 else
11042 {
11043 if (stack_max != 0)
11044 {
11046 {
11048 }
11049
11050 if (split_quantity_new == 0)
11051 {
11052 if (!
GetGame().IsMultiplayer())
11053 player.PhysicalPredictiveDropItem(this);
11054 else
11055 player.ServerDropEntity(this);
11056 return;
11057 }
11058
11060 {
11062
11063 if (new_item)
11064 {
11065 new_item.SetResultOfSplit(true);
11066 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11069 new_item.PlaceOnSurface();
11070 }
11071 }
11072 }
11073 }
11074 }
11075
11077 {
11078 float split_quantity_new;
11082 InventoryLocation loc = new InventoryLocation;
11083
11084 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
11085 {
11087 split_quantity_new = stack_max;
11088 else
11090
11092 {
11093 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
11094 if (new_item)
11095 {
11096 new_item.SetResultOfSplit(true);
11097 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11099 new_item.
SetQuantity(split_quantity_new,
false,
true);
11100 }
11101 }
11102 }
11103 else if (destination_entity && slot_id == -1)
11104 {
11105 if (quantity > stack_max)
11106 split_quantity_new = stack_max;
11107 else
11108 split_quantity_new = quantity;
11109
11111 {
11113 {
11116 }
11117
11118 if (new_item)
11119 {
11120 new_item.SetResultOfSplit(true);
11121 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11123 new_item.
SetQuantity(split_quantity_new,
false,
true);
11124 }
11125 }
11126 }
11127 else
11128 {
11129 if (stack_max != 0)
11130 {
11132 {
11134 }
11135
11137 {
11139
11140 if (new_item)
11141 {
11142 new_item.SetResultOfSplit(true);
11143 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11146 new_item.PlaceOnSurface();
11147 }
11148 }
11149 }
11150 }
11151 }
11152
11154 {
11156 {
11157 if (ScriptInputUserData.CanStoreInputUserData())
11158 {
11159 ScriptInputUserData ctx = new ScriptInputUserData;
11164 dst.WriteToContext(ctx);
11166 }
11167 }
11168 else if (!
GetGame().IsMultiplayer())
11169 {
11171 }
11172 }
11173
11175 {
11177 {
11178 if (ScriptInputUserData.CanStoreInputUserData())
11179 {
11180 ScriptInputUserData ctx = new ScriptInputUserData;
11185 ctx.
Write(destination_entity);
11191 }
11192 }
11193 else if (!
GetGame().IsMultiplayer())
11194 {
11196 }
11197 }
11198
11200 {
11202 }
11203
11205 {
11207 float split_quantity_new;
11209 if (dst.IsValid())
11210 {
11211 int slot_id = dst.GetSlot();
11213
11214 if (quantity > stack_max)
11215 split_quantity_new = stack_max;
11216 else
11217 split_quantity_new = quantity;
11218
11220 {
11222
11223 if (new_item)
11224 {
11225 new_item.SetResultOfSplit(true);
11226 MiscGameplayFunctions.TransferItemProperties(this,new_item);
11228 new_item.
SetQuantity(split_quantity_new,
false,
true);
11229 }
11230
11231 return new_item;
11232 }
11233 }
11234
11235 return null;
11236 }
11237
11239 {
11241 float split_quantity_new;
11243 if (destination_entity)
11244 {
11246 if (quantity > stackable)
11247 split_quantity_new = stackable;
11248 else
11249 split_quantity_new = quantity;
11250
11252 {
11253 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateEntityInCargoEx(
this.GetType(), idx, row, col,
false));
11254 if (new_item)
11255 {
11256 new_item.SetResultOfSplit(true);
11257 MiscGameplayFunctions.TransferItemProperties(this,new_item);
11259 new_item.
SetQuantity(split_quantity_new,
false,
true);
11260 }
11261 }
11262 }
11263 }
11264
11266 {
11268 {
11269 if (ScriptInputUserData.CanStoreInputUserData())
11270 {
11271 ScriptInputUserData ctx = new ScriptInputUserData;
11276 ItemBase destination_entity =
this;
11277 ctx.
Write(destination_entity);
11281 }
11282 }
11283 else if (!
GetGame().IsMultiplayer())
11284 {
11286 }
11287 }
11288
11290 {
11292 float split_quantity_new;
11294 if (player)
11295 {
11297 if (quantity > stackable)
11298 split_quantity_new = stackable;
11299 else
11300 split_quantity_new = quantity;
11301
11303 {
11304 EntityAI in_hands = player.GetHumanInventory().CreateInHands(this.
GetType());
11305 new_item =
ItemBase.Cast(in_hands);
11306 if (new_item)
11307 {
11308 new_item.SetResultOfSplit(true);
11309 MiscGameplayFunctions.TransferItemProperties(this,new_item);
11311 new_item.SetQuantity(split_quantity_new, false, true);
11312 }
11313 }
11314 }
11315 }
11316
11318 {
11320 float split_quantity_new = Math.Floor(quantity * 0.5);
11321
11323 return;
11324
11326
11327 if (new_item)
11328 {
11329 if (new_item.GetQuantityMax() < split_quantity_new)
11330 {
11331 split_quantity_new = new_item.GetQuantityMax();
11332 }
11333
11334 new_item.SetResultOfSplit(true);
11335 MiscGameplayFunctions.TransferItemProperties(this, new_item);
11336
11338 {
11341 }
11342 else
11343 {
11345 new_item.
SetQuantity(split_quantity_new,
false,
true);
11346 }
11347 }
11348 }
11349
11351 {
11353 float split_quantity_new = Math.Floor(quantity / 2);
11354
11356 return;
11357
11358 InventoryLocation invloc = new InventoryLocation;
11360
11362 new_item = player.CreateCopyOfItemInInventoryOrGroundEx(this, true);
11363
11364 if (new_item)
11365 {
11366 if (new_item.GetQuantityMax() < split_quantity_new)
11367 {
11368 split_quantity_new = new_item.GetQuantityMax();
11369 }
11371 {
11374 }
11375 else if (split_quantity_new > 1)
11376 {
11378 new_item.
SetQuantity(split_quantity_new,
false,
true);
11379 }
11380 }
11381 }
11382
11385 {
11386 SetWeightDirty();
11388
11389 if (parent)
11390 parent.OnAttachmentQuantityChangedEx(this, delta);
11391
11393 {
11395 {
11397 }
11399 {
11400 ErrorEx(
"Undefined liquid type quantity changed, please define liquid type first! Using init value.",
ErrorExSeverity.INFO);
11402 }
11403 }
11404
11405 }
11406
11409 {
11410
11411 }
11412
11415 {
11417 }
11418
11420 {
11421 super.EEHealthLevelChanged(oldLevel,newLevel,zone);
11422
11424 {
11425 if (newLevel == GameConstants.STATE_RUINED)
11426 {
11428 EntityAI parent = GetHierarchyParent();
11429 if (parent && parent.IsFireplace())
11430 {
11431 CargoBase cargo = GetInventory().GetCargo();
11432 if (cargo)
11433 {
11435 {
11437 }
11438 }
11439 }
11440 }
11441
11443 {
11444
11446 return;
11447 }
11448
11449 if (
m_Cleanness != 0 && oldLevel < newLevel && newLevel != 0)
11450 {
11452 }
11453 }
11454 }
11455
11456
11458 {
11459 super.OnRightClick();
11460
11462 {
11464 {
11465 if (ScriptInputUserData.CanStoreInputUserData())
11466 {
11467 EntityAI root = GetHierarchyRoot();
11468 Man playerOwner = GetHierarchyRootPlayer();
11469 InventoryLocation dst = new InventoryLocation;
11470
11471
11472 if (!playerOwner && root && root == this)
11473 {
11475 }
11476 else
11477 {
11478
11479 GetInventory().GetCurrentInventoryLocation(dst);
11481 {
11484 {
11486 }
11487 else
11488 {
11490
11491
11492 if (
GetGame().
GetPlayer().GetInventory().HasInventoryReservation(
this, dst))
11493 {
11495 }
11496 else
11497 {
11498 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(null, dst, GameInventory.c_InventoryReservationTimeoutShortMS);
11499 }
11500 }
11501 }
11502 }
11503
11504 ScriptInputUserData ctx = new ScriptInputUserData;
11512 }
11513 }
11514 else if (!
GetGame().IsMultiplayer())
11515 {
11517 }
11518 }
11519 }
11520
11522 {
11523 if (root)
11524 {
11525 vector m4[4];
11526 root.GetTransform(m4);
11527 dst.SetGround(this, m4);
11528 }
11529 else
11530 {
11531 GetInventory().GetCurrentInventoryLocation(dst);
11532 }
11533 }
11534
11535 override bool CanBeCombined(
EntityAI other_item,
bool reservation_check =
true,
bool stack_max_limit =
false)
11536 {
11537
11538 if (!other_item ||
GetType() != other_item.GetType() || (
IsFullQuantity() && other_item.GetQuantity() > 0) || other_item ==
this)
11539 return false;
11540
11541 if (GetHealthLevel() == GameConstants.STATE_RUINED || other_item.GetHealthLevel() == GameConstants.STATE_RUINED)
11542 return false;
11543
11544
11546 return false;
11547
11548
11549 Magazine mag = Magazine.Cast(this);
11550 if (mag)
11551 {
11552 if (mag.GetAmmoCount() >= mag.GetAmmoMax())
11553 return false;
11554
11555 if (stack_max_limit)
11556 {
11557 Magazine other_mag = Magazine.Cast(other_item);
11558 if (other_item)
11559 {
11560 if (mag.GetAmmoCount() + other_mag.GetAmmoCount() > mag.GetAmmoMax())
11561 return false;
11562 }
11563
11564 }
11565 }
11566 else
11567 {
11568
11570 return false;
11571
11573 return false;
11574 }
11575
11576 PlayerBase player = null;
11577 if (CastTo(player, GetHierarchyRootPlayer()))
11578 {
11579 if (player.GetInventory().HasAttachment(this))
11580 return false;
11581
11582 if (player.IsItemsToDelete())
11583 return false;
11584 }
11585
11586 if (reservation_check && (GetInventory().HasInventoryReservation(this, null) || other_item.GetInventory().HasInventoryReservation(other_item, null)))
11587 return false;
11588
11589 int slotID;
11591 if (GetInventory().GetCurrentAttachmentSlotInfo(slotID,
slotName) && GetHierarchyParent().GetInventory().GetSlotLock(slotID))
11592 return false;
11593
11594 return true;
11595 }
11596
11598 {
11600 }
11601
11603 {
11604 return m_IsResultOfSplit;
11605 }
11606
11608 {
11609 m_IsResultOfSplit = value;
11610 }
11611
11613 {
11615 }
11616
11618 {
11619 float other_item_quantity = other_item.GetQuantity();
11620 float this_free_space;
11621
11623
11625
11626 if (other_item_quantity > this_free_space)
11627 {
11628 return this_free_space;
11629 }
11630 else
11631 {
11632 return other_item_quantity;
11633 }
11634 }
11635
11637 {
11639 }
11640
11642 {
11644 return;
11645
11646 if (!IsMagazine() && other_item)
11647 {
11649 if (quantity_used != 0)
11650 {
11651 float hp1 = GetHealth01("","");
11652 float hp2 = other_item.GetHealth01("","");
11653 float hpResult = ((hp1*
GetQuantity()) + (hp2*quantity_used));
11654 hpResult = hpResult / (
GetQuantity() + quantity_used);
11655
11656 hpResult *= GetMaxHealth();
11657 Math.Round(hpResult);
11658 SetHealth("", "Health", hpResult);
11659
11661 other_item.AddQuantity(-quantity_used);
11662 }
11663 }
11665 }
11666
11668 {
11669 #ifdef SERVER
11670 if (!GetHierarchyRootPlayer() && GetHierarchyParent())
11671 GetHierarchyParent().IncreaseLifetimeUp();
11672 #endif
11673 };
11674
11676 {
11677 PlayerBase p = PlayerBase.Cast(player);
11678
11679 array<int> recipesIds = p.m_Recipes;
11680 PluginRecipesManager moduleRecipesManager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
11681 if (moduleRecipesManager)
11682 {
11683 EntityAI itemInHands = player.GetHumanInventory().GetEntityInHands();
11684 moduleRecipesManager.GetValidRecipes(
ItemBase.Cast(
this),
ItemBase.Cast(itemInHands), recipesIds, p);
11685 }
11686
11687 for (int i = 0;i < recipesIds.Count(); i++)
11688 {
11689 int key = recipesIds.Get(i);
11690 string recipeName = moduleRecipesManager.GetRecipeName(key);
11692 }
11693 }
11694
11695
11696 override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
11697 {
11698 super.GetDebugActions(outputList);
11699
11700
11706
11707
11712
11717
11718
11722
11723
11725 {
11729 }
11730
11733
11734
11738
11740
11741 InventoryLocation loc = new InventoryLocation();
11742 GetInventory().GetCurrentInventoryLocation(loc);
11744 {
11745 if (Gizmo_IsSupported())
11748 }
11749
11751 }
11752
11753
11754
11755
11757 {
11758 super.OnAction(action_id, player, ctx);
11759
11761 {
11762 switch (action_id)
11763 {
11766 return true;
11769 return true;
11770 }
11771 }
11772
11774 {
11775 switch (action_id)
11776 {
11778 Delete();
11779 return true;
11780 }
11781 }
11782
11783 if (action_id >=
EActions.RECIPES_RANGE_START && action_id <
EActions.RECIPES_RANGE_END)
11784 {
11785 PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
11786 int idWithoutOffset = action_id -
EActions.RECIPES_RANGE_START;
11787 PlayerBase p = PlayerBase.Cast(player);
11788 if (
EActions.RECIPES_RANGE_START < 1000)
11789 {
11790 float anim_length = plugin_recipes_manager.GetRecipeLengthInSecs(idWithoutOffset);
11791 float specialty_weight = plugin_recipes_manager.GetRecipeSpecialty(idWithoutOffset);
11792 }
11793 }
11794 #ifndef SERVER
11795 else if (action_id ==
EActions.WATCH_PLAYER)
11796 {
11797 PluginDeveloper.SetDeveloperItemClientEx(player);
11798 }
11799 #endif
11801 {
11802 if (action_id >=
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START && action_id <
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_END)
11803 {
11804 int id = action_id -
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START;
11805 OnDebugButtonPressServer(id + 1);
11806 }
11807
11808 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_INJECT_START && action_id <
EActions.DEBUG_AGENTS_RANGE_INJECT_END)
11809 {
11810 int agent_id = action_id -
EActions.DEBUG_AGENTS_RANGE_INJECT_START;
11812 }
11813
11814 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_REMOVE_START && action_id <
EActions.DEBUG_AGENTS_RANGE_REMOVE_END)
11815 {
11816 int agent_id2 = action_id -
EActions.DEBUG_AGENTS_RANGE_REMOVE_START;
11818 }
11819
11820 else if (action_id ==
EActions.ADD_QUANTITY)
11821 {
11822 if (IsMagazine())
11823 {
11824 Magazine mag = Magazine.Cast(this);
11825 mag.ServerSetAmmoCount(mag.GetAmmoCount() + mag.GetAmmoMax() * 0.2);
11826 }
11827 else
11828 {
11830 }
11831
11832 if (m_EM)
11833 {
11834 m_EM.AddEnergy(m_EM.GetEnergyMax() * 0.2);
11835 }
11836
11837 }
11838
11839 else if (action_id ==
EActions.REMOVE_QUANTITY)
11840 {
11841 if (IsMagazine())
11842 {
11843 Magazine mag2 = Magazine.Cast(this);
11844 mag2.ServerSetAmmoCount(mag2.GetAmmoCount() - mag2.GetAmmoMax() * 0.2);
11845 }
11846 else
11847 {
11849 }
11850 if (m_EM)
11851 {
11852 m_EM.AddEnergy(- m_EM.GetEnergyMax() * 0.2);
11853 }
11854
11855 }
11856
11857 else if (action_id ==
EActions.SET_QUANTITY_0)
11858 {
11860
11861 if (m_EM)
11862 {
11863 m_EM.SetEnergy(0);
11864 }
11865 }
11866
11867 else if (action_id ==
EActions.SET_MAX_QUANTITY)
11868 {
11870
11871 if (m_EM)
11872 {
11873 m_EM.SetEnergy(m_EM.GetEnergyMax());
11874 }
11875 }
11876
11877 else if (action_id ==
EActions.ADD_HEALTH)
11878 {
11879 AddHealth("","",GetMaxHealth("","Health")/5);
11880 }
11881 else if (action_id ==
EActions.REMOVE_HEALTH)
11882 {
11883 AddHealth("","",-GetMaxHealth("","Health")/5);
11884 }
11885 else if (action_id ==
EActions.DESTROY_HEALTH)
11886 {
11887 SetHealth01("","",0);
11888 }
11889 else if (action_id ==
EActions.WATCH_ITEM)
11890 {
11892 mid.RegisterDebugItem(
ItemBase.Cast(
this), PlayerBase.Cast(player));
11893 #ifdef DEVELOPER
11894 SetDebugDeveloper_item(this);
11895 #endif
11896 }
11897
11898 else if (action_id ==
EActions.ADD_TEMPERATURE)
11899 {
11900 AddTemperature(20);
11901
11902 }
11903
11904 else if (action_id ==
EActions.REMOVE_TEMPERATURE)
11905 {
11906 AddTemperature(-20);
11907
11908 }
11909
11910 else if (action_id ==
EActions.FLIP_FROZEN)
11911 {
11912 SetFrozen(!GetIsFrozen());
11913
11914 }
11915
11916 else if (action_id ==
EActions.ADD_WETNESS)
11917 {
11919
11920 }
11921
11922 else if (action_id ==
EActions.REMOVE_WETNESS)
11923 {
11925
11926 }
11927
11928 else if (action_id ==
EActions.LIQUIDTYPE_UP)
11929 {
11932
11933
11934 }
11935
11936 else if (action_id ==
EActions.LIQUIDTYPE_DOWN)
11937 {
11940 }
11941
11942 else if (action_id ==
EActions.MAKE_SPECIAL)
11943 {
11944 auto debugParams = DebugSpawnParams.WithPlayer(player);
11945 OnDebugSpawnEx(debugParams);
11946 }
11947
11948 }
11949
11950
11951 return false;
11952 }
11953
11954
11955
11956
11960
11963
11964
11965
11967 {
11968 return false;
11969 }
11970
11971
11973 {
11974 return true;
11975 }
11976
11977
11979 {
11980 return true;
11981 }
11982
11983
11984
11986 {
11987 string config_path =
string.Format(
"CfgVehicles %1 Food FoodStages",
GetType());
11989 }
11990
11993 {
11994 return null;
11995 }
11996
11998 {
11999 return false;
12000 }
12001
12003 {
12004 return false;
12005 }
12006
12010
12011
12013 {
12014 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
12015 return module_repairing.CanRepair(this, item_repair_kit);
12016 }
12017
12018
12019 bool Repair(PlayerBase player,
ItemBase item_repair_kit,
float specialty_weight)
12020 {
12021 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
12022 return module_repairing.Repair(player, this, item_repair_kit, specialty_weight);
12023 }
12024
12025
12027 {
12028
12029
12030
12031
12032
12033
12034
12035
12036 return 1;
12037 }
12038
12039
12040
12042 {
12044 }
12045
12046
12047
12049 {
12051 }
12052
12053
12062 {
12063 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
12064
12065 if (player)
12066 {
12067 player.MessageStatus(text);
12068 }
12069 }
12070
12071
12080 {
12081 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
12082
12083 if (player)
12084 {
12085 player.MessageAction(text);
12086 }
12087 }
12088
12089
12098 {
12099 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
12100
12101 if (player)
12102 {
12103 player.MessageFriendly(text);
12104 }
12105 }
12106
12107
12116 {
12117 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
12118
12119 if (player)
12120 {
12121 player.MessageImportant(text);
12122 }
12123 }
12124
12126 {
12127 return true;
12128 }
12129
12130
12131 override bool KindOf(
string tag)
12132 {
12133 bool found = false;
12134 string item_name = this.
GetType();
12137
12138 int array_size = item_tag_array.Count();
12139 for (int i = 0; i < array_size; i++)
12140 {
12141 if (item_tag_array.Get(i) == tag)
12142 {
12143 found = true;
12144 break;
12145 }
12146 }
12147 return found;
12148 }
12149
12150
12152 {
12153
12154 super.OnRPC(sender, rpc_type,ctx);
12155
12156
12157 switch (rpc_type)
12158 {
12159 #ifndef SERVER
12160 case ERPCs.RPC_SOUND_LOCK_ATTACH:
12161 Param2<bool, string> p = new Param2<bool, string>(false, "");
12162
12164 return;
12165
12166 bool play = p.param1;
12167 string soundSet = p.param2;
12168
12169 if (play)
12170 {
12172 {
12174 {
12176 }
12177 }
12178 else
12179 {
12181 }
12182 }
12183 else
12184 {
12186 }
12187
12188 break;
12189 #endif
12190
12191 }
12192
12194 {
12196 }
12197 }
12198
12199
12200
12201
12203 {
12204 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
12205 return plugin.GetID(
name);
12206 }
12207
12209 {
12210 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
12211 return plugin.GetName(id);
12212 }
12213
12216 {
12217
12218
12219 int varFlags;
12220 if (!ctx.
Read(varFlags))
12221 return;
12222
12223 if (varFlags & ItemVariableFlags.FLOAT)
12224 {
12226 }
12227 }
12228
12230 {
12231
12232 super.SerializeNumericalVars(floats_out);
12233
12234
12235
12237 {
12239 }
12240
12242 {
12244 }
12245
12247 {
12249 }
12250
12252 {
12257 }
12258
12260 {
12262 }
12263 }
12264
12266 {
12267
12268 super.DeSerializeNumericalVars(floats);
12269
12270
12271 int index = 0;
12272 int mask = Math.Round(floats.Get(index));
12273
12274 index++;
12275
12277 {
12279 {
12281 }
12282 else
12283 {
12284 float quantity = floats.Get(index);
12285 SetQuantity(quantity,
true,
false,
false,
false);
12286 }
12287 index++;
12288 }
12289
12291 {
12292 float wet = floats.Get(index);
12294 index++;
12295 }
12296
12298 {
12299 int liquidtype = Math.Round(floats.Get(index));
12301 index++;
12302 }
12303
12305 {
12307 index++;
12309 index++;
12311 index++;
12313 index++;
12314 }
12315
12317 {
12318 int cleanness = Math.Round(floats.Get(index));
12320 index++;
12321 }
12322 }
12323
12325 {
12326 super.WriteVarsToCTX(ctx);
12327
12328
12330 {
12332 }
12333
12335 {
12337 }
12338
12340 {
12342 }
12343
12345 {
12346 int r,g,b,a;
12352 }
12353
12355 {
12357 }
12358 }
12359
12361 {
12362 if (!super.ReadVarsFromCTX(ctx,version))
12363 return false;
12364
12365 int intValue;
12366 float value;
12367
12368 if (version < 140)
12369 {
12370 if (!ctx.
Read(intValue))
12371 return false;
12372
12373 m_VariablesMask = intValue;
12374 }
12375
12377 {
12378 if (!ctx.
Read(value))
12379 return false;
12380
12382 {
12384 }
12385 else
12386 {
12388 }
12389 }
12390
12391 if (version < 140)
12392 {
12394 {
12395 if (!ctx.
Read(value))
12396 return false;
12397 SetTemperatureDirect(value);
12398 }
12399 }
12400
12402 {
12403 if (!ctx.
Read(value))
12404 return false;
12406 }
12407
12409 {
12410 if (!ctx.
Read(intValue))
12411 return false;
12413 }
12414
12416 {
12417 int r,g,b,a;
12419 return false;
12421 return false;
12423 return false;
12425 return false;
12426
12428 }
12429
12431 {
12432 if (!ctx.
Read(intValue))
12433 return false;
12435 }
12436
12437 if (version >= 138 && version < 140)
12438 {
12440 {
12441 if (!ctx.
Read(intValue))
12442 return false;
12443 SetFrozen(intValue);
12444 }
12445 }
12446
12447 return true;
12448 }
12449
12450
12452 {
12455 {
12457 }
12458
12459 if (!super.OnStoreLoad(ctx, version))
12460 {
12462 return false;
12463 }
12464
12465 if (version >= 114)
12466 {
12467 bool hasQuickBarIndexSaved;
12468
12469 if (!ctx.
Read(hasQuickBarIndexSaved))
12470 {
12472 return false;
12473 }
12474
12475 if (hasQuickBarIndexSaved)
12476 {
12477 int itmQBIndex;
12478
12479
12480 if (!ctx.
Read(itmQBIndex))
12481 {
12483 return false;
12484 }
12485
12486 PlayerBase parentPlayer = PlayerBase.Cast(GetHierarchyRootPlayer());
12487 if (itmQBIndex != -1 && parentPlayer)
12488 parentPlayer.SetLoadedQuickBarItemBind(this, itmQBIndex);
12489 }
12490 }
12491 else
12492 {
12493
12494 PlayerBase player;
12495 int itemQBIndex;
12496 if (version ==
int.
MAX)
12497 {
12498 if (!ctx.
Read(itemQBIndex))
12499 {
12501 return false;
12502 }
12503 }
12504 else if (Class.CastTo(player, GetHierarchyRootPlayer()))
12505 {
12506
12507 if (!ctx.
Read(itemQBIndex))
12508 {
12510 return false;
12511 }
12512 if (itemQBIndex != -1 && player)
12513 player.SetLoadedQuickBarItemBind(this,itemQBIndex);
12514 }
12515 }
12516
12517 if (version < 140)
12518 {
12519
12520 if (!LoadVariables(ctx, version))
12521 {
12523 return false;
12524 }
12525 }
12526
12527
12529 {
12531 return false;
12532 }
12533 if (version >= 132)
12534 {
12536 if (raib)
12537 {
12539 {
12541 return false;
12542 }
12543 }
12544 }
12545
12547 return true;
12548 }
12549
12550
12551
12553 {
12554 super.OnStoreSave(ctx);
12555
12556 PlayerBase player;
12557 if (PlayerBase.CastTo(player,GetHierarchyRootPlayer()))
12558 {
12560
12561 int itemQBIndex = -1;
12562 itemQBIndex = player.FindQuickBarEntityIndex(this);
12563 ctx.
Write(itemQBIndex);
12564 }
12565 else
12566 {
12568 }
12569
12571
12573 if (raib)
12574 {
12576 }
12577 }
12578
12579
12581 {
12582 super.AfterStoreLoad();
12583
12585 {
12587 }
12588
12590 {
12593 }
12594 }
12595
12597 {
12598 super.EEOnAfterLoad();
12599
12601 {
12603 }
12604
12607 }
12608
12610 {
12611 return false;
12612 }
12613
12614
12615
12617 {
12619 {
12620 #ifdef PLATFORM_CONSOLE
12621
12623 {
12625 if (menu)
12626 {
12628 }
12629 }
12630 #endif
12631 }
12632
12634 {
12637 }
12638
12640 {
12641 SetWeightDirty();
12643 }
12645 {
12648 }
12649
12651 {
12654 }
12656 {
12659 }
12660
12661 super.OnVariablesSynchronized();
12662 }
12663
12664
12665
12667 override bool SetQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false,
bool allow_client =
false,
bool clamp_to_stack_max =
true)
12668 {
12669 if (!IsServerCheck(allow_client))
12670 return false;
12671
12673 return false;
12674
12677
12678 if (value <= (min + 0.001))
12679 value = min;
12680
12681 if (value == min)
12682 {
12683 if (destroy_config)
12684 {
12685 bool dstr = ConfigGetBool("varQuantityDestroyOnMin");
12686 if (dstr)
12687 {
12689 this.Delete();
12690 return true;
12691 }
12692 }
12693 else if (destroy_forced)
12694 {
12696 this.Delete();
12697 return true;
12698 }
12699
12701 }
12702
12705
12707 {
12709
12710 if (delta)
12712 }
12713
12715
12716 return false;
12717 }
12718
12719
12721 bool AddQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
12722 {
12724 }
12725
12727 {
12730 }
12731
12733 {
12736 }
12737
12739 override void SetQuantityNormalized(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
12740 {
12741 float value_clamped = Math.Clamp(value, 0, 1);
12743 SetQuantity(result, destroy_config, destroy_forced);
12744 }
12745
12746
12749 {
12751 }
12752
12754 {
12756 }
12757
12758
12759
12760
12761
12762
12763
12764
12765
12766
12768 {
12769 int slot = -1;
12770 if (GetInventory())
12771 {
12772 InventoryLocation il = new InventoryLocation;
12773 GetInventory().GetCurrentInventoryLocation(il);
12775 }
12776
12778 }
12779
12781 {
12782 float quantity_max = 0;
12783
12785 {
12786 if (attSlotID != -1)
12787 quantity_max = InventorySlots.GetStackMaxForSlotId(attSlotID);
12788
12789 if (quantity_max <= 0)
12791 }
12792
12793 if (quantity_max <= 0)
12795
12796 return quantity_max;
12797 }
12798
12800 {
12802 }
12803
12805 {
12807 }
12808
12809
12811 {
12813 }
12814
12816 {
12818 }
12819
12821 {
12823 }
12824
12825
12827 {
12828
12829 float weightEx = GetWeightEx();
12830 float special = GetInventoryAndCargoWeight();
12831 return weightEx - special;
12832 }
12833
12834
12836 {
12838 }
12839
12841 {
12843 {
12844 #ifdef DEVELOPER
12845 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
12846 {
12847 WeightDebugData data1 = WeightDebug.GetWeightDebug(this);
12849 }
12850 #endif
12851
12852 return GetQuantity() * GetConfigWeightModified();
12853 }
12854 else if (HasEnergyManager())
12855 {
12856 #ifdef DEVELOPER
12857 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
12858 {
12859 WeightDebugData data2 = WeightDebug.GetWeightDebug(this);
12860 data2.
SetCalcDetails(
"TIB2: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " + GetCompEM().
GetEnergy()+
"(energy) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit)");
12861 }
12862 #endif
12863 return super.GetWeightSpecialized(forceRecalc) + (GetCompEM().GetEnergy() * ConfigGetFloat("weightPerQuantityUnit")) + GetConfigWeightModified();
12864 }
12865 else
12866 {
12867 #ifdef DEVELOPER
12868 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
12869 {
12870 WeightDebugData data3 = WeightDebug.GetWeightDebug(this);
12871 data3.
SetCalcDetails(
"TIB3: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " +
GetQuantity()+
"(quantity) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit))");
12872 }
12873 #endif
12874 return super.GetWeightSpecialized(forceRecalc) + (
GetQuantity() * ConfigGetFloat(
"weightPerQuantityUnit")) + GetConfigWeightModified();
12875 }
12876 }
12877
12880 {
12881 int item_count = 0;
12883
12884 if (GetInventory().GetCargo() != NULL)
12885 {
12886 item_count = GetInventory().GetCargo().GetItemCount();
12887 }
12888
12889 for (int i = 0; i < GetInventory().AttachmentCount(); i++)
12890 {
12891 Class.CastTo(item,GetInventory().GetAttachmentFromIndex(i));
12892 if (item)
12893 item_count += item.GetNumberOfItems();
12894 }
12895 return item_count;
12896 }
12897
12900 {
12901 float weight = 0;
12902 float wetness = 1;
12903 if (include_wetness)
12906 {
12907 weight = wetness * m_ConfigWeight;
12908 }
12910 {
12911 weight = 1;
12912 }
12913 return weight;
12914 }
12915
12916
12917
12919 {
12920 if ((
GetGame().IsServer() || !
GetGame().IsMultiplayer()) && GetInventory())
12921 {
12922 GameInventory inv = GetInventory();
12923 array<EntityAI> items = new array<EntityAI>;
12925 for (int i = 0; i < items.Count(); i++)
12926 {
12928 if (item)
12929 {
12931 }
12932 }
12933 }
12934 }
12935
12936
12937
12938
12940 {
12941 float energy = 0;
12942 if (HasEnergyManager())
12943 {
12944 energy = GetCompEM().GetEnergy();
12945 }
12946 return energy;
12947 }
12948
12949
12951 {
12952 super.OnEnergyConsumed();
12953
12955 }
12956
12958 {
12959 super.OnEnergyAdded();
12960
12962 }
12963
12964
12966 {
12967 if (
GetGame().IsServer() && HasEnergyManager() && GetCompEM().HasConversionOfEnergyToQuantity())
12968 {
12970 {
12971 float energy_0to1 = GetCompEM().GetEnergy0To1();
12973 }
12974 }
12975 }
12976
12977
12979 {
12980 return ConfigGetFloat("heatIsolation");
12981 }
12982
12984 {
12986 }
12987
12989 {
12990 string paramPath =
string.Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Drying %2",
GetType(), pIncrementName);
12991 if (
GetGame().ConfigIsExisting(paramPath))
12993
12994 return 0.0;
12995 }
12996
12998 {
12999 string paramPath =
string.
Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Soaking %2",
GetType(), pIncrementName);
13000 if (
GetGame().ConfigIsExisting(paramPath))
13002
13003 return 0.0;
13004 }
13005
13006 override void SetWet(
float value,
bool allow_client =
false)
13007 {
13008 if (!IsServerCheck(allow_client))
13009 return;
13010
13013
13015
13016 m_VarWet = Math.Clamp(value, min, max);
13017
13019 {
13022 }
13023 }
13024
13025 override void AddWet(
float value)
13026 {
13028 }
13029
13031 {
13033 }
13034
13036 {
13038 }
13039
13041 {
13043 }
13044
13046 {
13048 }
13049
13051 {
13053 }
13054
13055 override void OnWetChanged(
float newVal,
float oldVal)
13056 {
13059 if (newLevel != oldLevel)
13060 {
13062 }
13063 }
13064
13066 {
13067 SetWeightDirty();
13068 }
13069
13071 {
13072 return GetWetLevelInternal(
m_VarWet);
13073 }
13074
13075
13076
13078 {
13080 }
13081
13083 {
13085 }
13086
13088 {
13090 }
13091
13093 {
13095 }
13096
13097
13098
13100 {
13101 if (ConfigIsExisting("itemModelLength"))
13102 {
13103 return ConfigGetFloat("itemModelLength");
13104 }
13105 return 0;
13106 }
13107
13109 {
13110 if (ConfigIsExisting("itemAttachOffset"))
13111 {
13112 return ConfigGetFloat("itemAttachOffset");
13113 }
13114 return 0;
13115 }
13116
13117 override void SetCleanness(
int value,
bool allow_client =
false)
13118 {
13119 if (!IsServerCheck(allow_client))
13120 return;
13121
13123
13125
13128 }
13129
13131 {
13133 }
13134
13136 {
13137 return true;
13138 }
13139
13140
13141
13142
13144 {
13146 }
13147
13149 {
13151 }
13152
13153
13154
13155
13156 override void SetColor(
int r,
int g,
int b,
int a)
13157 {
13163 }
13165 override void GetColor(out
int r,out
int g,out
int b,out
int a)
13166 {
13171 }
13172
13174 {
13176 }
13177
13180 {
13181 int r,g,b,a;
13183 r = r/255;
13184 g = g/255;
13185 b = b/255;
13186 a = a/255;
13187 return MiscGameplayFunctions.GetColorString(r, g, b, a);
13188 }
13189
13190
13191
13192 override void SetLiquidType(
int value,
bool allow_client =
false)
13193 {
13194 if (!IsServerCheck(allow_client))
13195 return;
13196
13201 }
13202
13204 {
13205 return ConfigGetInt("varLiquidTypeInit");
13206 }
13207
13209 {
13211 }
13212
13214 {
13216 SetFrozen(false);
13217 }
13218
13221 {
13222 player.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
13223 }
13224
13225
13228 {
13229 PlayerBase nplayer;
13230 if (PlayerBase.CastTo(nplayer, player))
13231 {
13233
13234 nplayer.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
13235 }
13236 }
13237
13238
13241 {
13242 PlayerBase nplayer;
13243 if (PlayerBase.CastTo(nplayer,player))
13244 {
13245
13246 nplayer.SetEnableQuickBarEntityShortcut(this,false);
13247
13248 }
13249
13250
13251 player.GetHumanInventory().ClearUserReservedLocationForContainer(this);
13252
13253
13254 if (HasEnergyManager())
13255 {
13256 GetCompEM().UpdatePlugState();
13257 }
13258 }
13259
13260
13262 {
13263 super.OnPlacementStarted(player);
13264
13266 }
13267
13268 override void OnPlacementComplete(Man player, vector position =
"0 0 0", vector orientation =
"0 0 0")
13269 {
13271 {
13272 m_AdminLog.OnPlacementComplete(player,
this);
13273 }
13274
13275 super.OnPlacementComplete(player, position, orientation);
13276 }
13277
13278
13279
13280
13281
13283 {
13285 {
13286 return true;
13287 }
13288 else
13289 {
13290 return false;
13291 }
13292 }
13293
13294
13296 {
13298 {
13300 }
13301 }
13302
13303
13305 {
13307 }
13308
13310 {
13312 }
13313
13314 override void InsertAgent(
int agent,
float count = 1)
13315 {
13316 if (count < 1)
13317 return;
13318
13320 }
13321
13324 {
13326 }
13327
13328
13330 {
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
13369
13370
13371
13372
13373
13374
13376 {
13378 return false;
13379 return true;
13380 }
13381
13383 {
13384
13386 }
13387
13388
13391 {
13392 super.CheckForRoofLimited(timeTresholdMS);
13393
13395 if ((time - m_PreviousRoofTestTime) >= timeTresholdMS)
13396 {
13397 m_PreviousRoofTestTime = time;
13398 SetRoofAbove(MiscGameplayFunctions.IsUnderRoof(this));
13399 }
13400 }
13401
13402
13404 {
13406 {
13407 return 0;
13408 }
13409
13410 if (GetInventory().GetAttachmentSlotsCount() != 0)
13411 {
13412 ItemBase filter =
ItemBase.Cast(FindAttachmentBySlotName(
"GasMaskFilter"));
13413 if (filter)
13414 return filter.GetProtectionLevel(type, false, system);
13415 else
13416 return 0;
13417 }
13418
13419 string subclassPath, entryName;
13420
13421 switch (type)
13422 {
13424 entryName = "biological";
13425 break;
13427 entryName = "chemical";
13428 break;
13429 default:
13430 entryName = "biological";
13431 break;
13432 }
13433
13434 subclassPath =
"CfgVehicles " + this.
GetType() +
" Protection ";
13435
13437 }
13438
13439
13440
13443 {
13444 if (!IsMagazine())
13446
13448 }
13449
13450
13451
13452
13453
13458 {
13459 return true;
13460 }
13461
13463 {
13465 }
13466
13467
13468
13469
13470
13472 {
13473 if (parent)
13474 {
13475 if (parent.IsInherited(DayZInfected))
13476 return true;
13477
13478 if (!parent.IsRuined())
13479 return true;
13480 }
13481
13482 return true;
13483 }
13484
13486 {
13487 if (!super.CanPutAsAttachment(parent))
13488 {
13489 return false;
13490 }
13491
13492 if (!IsRuined() && !parent.IsRuined())
13493 {
13494 return true;
13495 }
13496
13497 return false;
13498 }
13499
13501 {
13502
13503
13504
13505
13506 return super.CanReceiveItemIntoCargo(item);
13507 }
13508
13510 {
13511
13512
13513
13514
13515 GameInventory attachmentInv = attachment.GetInventory();
13517 {
13518 if (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase))
13519 return false;
13520 }
13521
13522 InventoryLocation loc = new InventoryLocation();
13523 attachment.GetInventory().GetCurrentInventoryLocation(loc);
13524 if (loc && loc.
IsValid() && !GetInventory().AreChildrenAccessible())
13525 return false;
13526
13527 return super.CanReceiveAttachment(attachment, slotId);
13528 }
13529
13531 {
13532 if (!super.CanReleaseAttachment(attachment))
13533 return false;
13534
13535 return GetInventory().AreChildrenAccessible();
13536 }
13537
13538
13539
13540
13541
13542
13543
13544
13545
13546
13547
13548
13549
13550
13551
13552
13553
13554
13555
13556
13557
13559 {
13560 int id = muzzle_owner.GetMuzzleID();
13561 array<ref WeaponParticlesOnFire> WPOF_array =
m_OnFireEffect.Get(
id);
13562
13563 if (WPOF_array)
13564 {
13565 for (int i = 0; i < WPOF_array.Count(); i++)
13566 {
13567 WeaponParticlesOnFire WPOF = WPOF_array.Get(i);
13568
13569 if (WPOF)
13570 {
13571 WPOF.OnActivate(weapon, muzzle_index, ammoType, muzzle_owner, suppressor, config_to_search);
13572 }
13573 }
13574 }
13575 }
13576
13577
13579 {
13580 int id = muzzle_owner.GetMuzzleID();
13582
13583 if (WPOBE_array)
13584 {
13585 for (int i = 0; i < WPOBE_array.Count(); i++)
13586 {
13587 WeaponParticlesOnBulletCasingEject WPOBE = WPOBE_array.Get(i);
13588
13589 if (WPOBE)
13590 {
13591 WPOBE.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
13592 }
13593 }
13594 }
13595 }
13596
13597
13599 {
13600 int id = muzzle_owner.GetMuzzleID();
13601 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
13602
13603 if (WPOOH_array)
13604 {
13605 for (int i = 0; i < WPOOH_array.Count(); i++)
13606 {
13607 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
13608
13609 if (WPOOH)
13610 {
13611 WPOOH.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
13612 }
13613 }
13614 }
13615 }
13616
13617
13619 {
13620 int id = muzzle_owner.GetMuzzleID();
13621 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
13622
13623 if (WPOOH_array)
13624 {
13625 for (int i = 0; i < WPOOH_array.Count(); i++)
13626 {
13627 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
13628
13629 if (WPOOH)
13630 {
13631 WPOOH.OnUpdate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
13632 }
13633 }
13634 }
13635 }
13636
13637
13639 {
13640 int id = muzzle_owner.GetMuzzleID();
13641 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
13642
13643 if (WPOOH_array)
13644 {
13645 for (int i = 0; i < WPOOH_array.Count(); i++)
13646 {
13647 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
13648
13649 if (WPOOH)
13650 {
13651 WPOOH.OnDeactivate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
13652 }
13653 }
13654 }
13655 }
13656
13657
13658
13660 {
13662 {
13663 return true;
13664 }
13665
13666 return false;
13667 }
13668
13670 {
13672 {
13673 return true;
13674 }
13675
13676 return false;
13677 }
13678
13680 {
13682 {
13683 return true;
13684 }
13685
13686 return false;
13687 }
13688
13690 {
13691 return false;
13692 }
13693
13696 {
13697 return UATimeSpent.DEFAULT_DEPLOY;
13698 }
13699
13700
13701
13702
13704 {
13706 SetSynchDirty();
13707 }
13708
13710 {
13712 }
13713
13714
13716 {
13717 return false;
13718 }
13719
13722 {
13723 string att_type = "None";
13724
13725 if (ConfigIsExisting("soundAttType"))
13726 {
13727 att_type = ConfigGetString("soundAttType");
13728 }
13729
13731 }
13732
13734 {
13736 }
13737
13738
13739
13740
13741
13747
13749 {
13752
13754 }
13755
13756
13758 {
13760 return;
13761
13763
13766
13769
13770 SoundParameters params = new SoundParameters();
13774 }
13775
13776
13778 {
13780 return;
13781
13783 SetSynchDirty();
13784
13787 }
13788
13789
13791 {
13793 return;
13794
13796 SetSynchDirty();
13797
13800 }
13801
13803 {
13805 }
13806
13808 {
13810 }
13811
13814 {
13815 if (!
GetGame().IsDedicatedServer())
13816 {
13817 if (ConfigIsExisting("attachSoundSet"))
13818 {
13819 string cfg_path = "";
13820 string soundset = "";
13821 string type_name =
GetType();
13822
13825 ConfigGetTextArray("attachSoundSet",cfg_soundset_array);
13826 ConfigGetTextArray("attachSoundSlot",cfg_slot_array);
13827
13828 if (cfg_soundset_array.Count() > 0 && cfg_soundset_array.Count() == cfg_slot_array.Count())
13829 {
13830 for (int i = 0; i < cfg_soundset_array.Count(); i++)
13831 {
13832 if (cfg_slot_array[i] == slot_type)
13833 {
13834 soundset = cfg_soundset_array[i];
13835 break;
13836 }
13837 }
13838 }
13839
13840 if (soundset != "")
13841 {
13842 EffectSound sound = SEffectManager.PlaySound(soundset,
GetPosition());
13844 }
13845 }
13846 }
13847 }
13848
13850 {
13851
13852 }
13853
13854 void OnApply(PlayerBase player);
13855
13857 {
13858 return 1.0;
13859 };
13860
13862 {
13864 }
13865
13867 {
13869 }
13870
13872
13874 {
13875 SetDynamicPhysicsLifeTime(0.01);
13877 }
13878
13880 {
13881 array<string> zone_names = new array<string>;
13882 GetDamageZones(zone_names);
13883 for (int i = 0; i < zone_names.Count(); i++)
13884 {
13885 SetHealthMax(zone_names.Get(i),"Health");
13886 }
13887 SetHealthMax("","Health");
13888 }
13889
13892 {
13893 float global_health = GetHealth01("","Health");
13894 array<string> zones = new array<string>;
13895 GetDamageZones(zones);
13896
13897 for (int i = 0; i < zones.Count(); i++)
13898 {
13899 SetHealth01(zones.Get(i),"Health",global_health);
13900 }
13901 }
13902
13905 {
13906 return IsExclusionFlagPresent(PlayerBase.GetFaceCoverageShaveValues());
13907 }
13908
13910 {
13911 if (!hasRootAsPlayer)
13912 {
13913 if (refParentIB)
13914 {
13915
13916 if ((refParentIB.GetWet() >= GameConstants.STATE_SOAKING_WET) && (
m_VarWet <
m_VarWetMax))
13917 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_INSIDE);
13918
13919 else if ((refParentIB.GetLiquidType() != 0) && (refParentIB.GetQuantity() > 0) && (
m_VarWet <
m_VarWetMax))
13920 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_LIQUID);
13921
13924 }
13925 else
13926 {
13927
13930 }
13931 }
13932 }
13933
13935 {
13937 {
13938 float target =
g_Game.GetMission().GetWorldData().GetBaseEnvTemperatureAtObject(
this);
13939 if (
GetTemperature() != target || !IsFreezeThawProgressFinished())
13940 {
13941 float heatPermCoef = 1.0;
13943 while (ent)
13944 {
13945 heatPermCoef *= ent.GetHeatPermeabilityCoef();
13946 ent = ent.GetHierarchyParent();
13947 }
13948
13949 SetTemperatureEx(
new TemperatureDataInterpolated(target,
ETemperatureAccessTypes.ACCESS_WORLD,delta,GameConstants.TEMP_COEF_WORLD,heatPermCoef));
13950 }
13951 }
13952 }
13953
13955 {
13956
13957 EntityAI parent = GetHierarchyParent();
13958 if (!parent)
13959 {
13960 hasParent = false;
13961 hasRootAsPlayer = false;
13962 }
13963 else
13964 {
13965 hasParent = true;
13966 hasRootAsPlayer = (GetHierarchyRootPlayer() != null);
13967 refParentIB =
ItemBase.Cast(parent);
13968 }
13969 }
13970
13971 protected void ProcessDecay(
float delta,
bool hasRootAsPlayer)
13972 {
13973
13974 }
13975
13977 {
13978
13979 return false;
13980 }
13981
13983 {
13984
13985
13986 return false;
13987 }
13988
13990 {
13991
13992 return false;
13993 }
13994
13997 {
13998 return !GetIsFrozen() &&
IsOpen();
13999 }
14000
14002 {
14003 bool hasParent = false, hasRootAsPlayer = false;
14005
14006 bool wwtu =
g_Game.IsWorldWetTempUpdateEnabled();
14007 bool foodDecay =
g_Game.IsFoodDecayEnabled();
14008
14009 if (wwtu || foodDecay)
14010 {
14014
14015 if (processWetness || processTemperature || processDecay)
14016 {
14018
14019 if (processWetness)
14020 ProcessItemWetness(m_ElapsedSinceLastUpdate, hasParent, hasRootAsPlayer, refParentIB);
14021
14022 if (processTemperature)
14024
14025 if (processDecay)
14026 ProcessDecay(m_ElapsedSinceLastUpdate, hasRootAsPlayer);
14027 }
14028 }
14029 }
14030
14033 {
14035 }
14036
14038 {
14041
14042 return super.GetTemperatureFreezeThreshold();
14043 }
14044
14046 {
14049
14050 return super.GetTemperatureThawThreshold();
14051 }
14052
14054 {
14057
14058 return super.GetItemOverheatThreshold();
14059 }
14060
14062 {
14064 return Math.Lerp(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureFreezeTime()),
GetQuantityNormalized());
14065
14066 return super.GetTemperatureFreezeTime();
14067 }
14068
14070 {
14072 return Math.Lerp(GameConstants.TEMPERATURE_TIME_THAW_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureThawTime()),
GetQuantityNormalized());
14073
14074 return super.GetTemperatureThawTime();
14075 }
14076
14081
14083 {
14084 return (item.IsKindOf("Cauldron") || item.IsKindOf("Pot") || item.IsKindOf("FryingPan") || item.IsKindOf("SmallProtectorCase") || (item.IsKindOf("PortableGasStove") && item.FindAttachmentBySlotName("CookingEquipment")));
14085 }
14086
14088 {
14089 MiscGameplayFunctions.TransferItemProperties(oldItem, this);
14090 }
14091
14094 {
14096 }
14097
14099 {
14101 }
14102
14104 {
14106 }
14107
14110 {
14111 return null;
14112 }
14113
14116 {
14117 return false;
14118 }
14119
14121 {
14123 {
14126 if (!trg)
14127 {
14129 explosive = this;
14130 }
14131
14132 explosive.PairRemote(trg);
14134
14135 int persistentID = RemotelyActivatedItemBehaviour.GeneratePersistentID();
14136 trg.SetPersistentPairID(persistentID);
14137 explosive.SetPersistentPairID(persistentID);
14138
14139 return true;
14140 }
14141 return false;
14142 }
14143
14146 {
14147 float ret = 1.0;
14150 ret *= GetHealth01();
14151
14152 return ret;
14153 }
14154
14155 #ifdef DEVELOPER
14156 override void SetDebugItem()
14157 {
14158 super.SetDebugItem();
14159 _itemBase = this;
14160 }
14161
14163 {
14164 string text = super.GetDebugText();
14165
14167 text +=
string.
Format(
"Heat isolation(modified): %1\n", MiscGameplayFunctions.GetCurrentItemHeatIsolation(
this));
14168
14169 return text;
14170 }
14171 #endif
14172
14174 {
14175 return true;
14176 }
14177
14179
14181
14183 {
14186 }
14187
14188
14196
14212}
14213
14215{
14217 if (entity)
14218 {
14219 bool is_item = entity.IsInherited(
ItemBase);
14220 if (is_item && full_quantity)
14221 {
14224 }
14225 }
14226 else
14227 {
14229 return NULL;
14230 }
14231 return entity;
14232}
14233
14235{
14236 if (item)
14237 {
14238 if (health > 0)
14239 item.SetHealth("", "", health);
14240
14241 if (item.CanHaveTemperature())
14242 {
14244 if (item.CanFreeze())
14245 item.SetFrozen(false);
14246 }
14247
14248 if (item.HasEnergyManager())
14249 {
14250 if (quantity >= 0)
14251 {
14252 item.GetCompEM().SetEnergy0To1(quantity);
14253 }
14254 else
14255 {
14257 }
14258 }
14259 else if (item.IsMagazine())
14260 {
14261 Magazine mag = Magazine.Cast(item);
14262 if (quantity >= 0)
14263 {
14264 mag.ServerSetAmmoCount(mag.GetAmmoMax() * quantity);
14265 }
14266 else
14267 {
14269 }
14270
14271 }
14272 else
14273 {
14274 if (quantity >= 0)
14275 {
14276 item.SetQuantityNormalized(quantity, false);
14277 }
14278 else
14279 {
14281 }
14282
14283 }
14284 }
14285}
14286
14287#ifdef DEVELOPER
14289#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.