7020{
7022 {
7023 return true;
7024 }
7025};
7026
7027
7028
7030{
7034
7036
7039
7040
7041
7042
7043
7052
7058
7063
7068
7089 protected bool m_IsResultOfSplit
7090
7092
7097
7098
7099
7101
7105
7106
7107
7109
7112
7113
7114
7120
7121
7129
7132
7133
7135
7136
7138
7139
7144
7145
7150
7151
7153
7154
7156 {
7161
7162 if (!
GetGame().IsDedicatedServer())
7163 {
7165 {
7167
7169 {
7171 }
7172 }
7173
7176 }
7177
7178 m_OldLocation = null;
7179
7181 {
7183 }
7184
7185 if (ConfigIsExisting("headSelectionsToHide"))
7186 {
7189 }
7190
7192 if (ConfigIsExisting("hideSelectionsByinventorySlot"))
7193 {
7195 }
7196
7198
7199 m_IsResultOfSplit = false;
7200
7202 }
7203
7205 {
7206 super.InitItemVariables();
7207
7213 m_Count = ConfigGetInt(
"count");
7214
7217
7222
7225
7230
7242
7246
7247
7250 if (ConfigIsExisting("canBeSplit"))
7251 {
7254 }
7255
7257 if (ConfigIsExisting("itemBehaviour"))
7259
7260
7263 RegisterNetSyncVariableInt("m_VarLiquidType");
7264 RegisterNetSyncVariableInt("m_Cleanness",0,1);
7265
7266 RegisterNetSyncVariableBoolSignal("m_WantPlayImpactSound");
7267 RegisterNetSyncVariableFloat("m_ImpactSpeed");
7268 RegisterNetSyncVariableInt("m_ImpactSoundSurfaceHash");
7269
7270 RegisterNetSyncVariableInt("m_ColorComponentR", 0, 255);
7271 RegisterNetSyncVariableInt("m_ColorComponentG", 0, 255);
7272 RegisterNetSyncVariableInt("m_ColorComponentB", 0, 255);
7273 RegisterNetSyncVariableInt("m_ColorComponentA", 0, 255);
7274
7275 RegisterNetSyncVariableBool("m_IsBeingPlaced");
7276 RegisterNetSyncVariableBool("m_IsTakeable");
7277 RegisterNetSyncVariableBool("m_IsHologram");
7278
7281 {
7284 }
7285
7287
7289 if (ConfigIsExisting("temperaturePerQuantityWeight"))
7291
7292 }
7293
7295 {
7297 }
7298
7300 {
7303 {
7308 }
7309 }
7310
7311 override void GetActions(
typename action_input_type, out array<ActionBase_Basic> actions)
7312 {
7314 {
7317 }
7318
7320 }
7321
7323 {
7329 }
7330
7332
7334 {
7336
7337 if (!action)
7338 {
7339 Debug.LogError(
"Action " + actionName +
" dosn't exist!");
7340 return;
7341 }
7342
7344 if (!ai)
7345 {
7347 return;
7348 }
7349
7351 if (!action_array)
7352 {
7353 action_array = new array<ActionBase_Basic>;
7355 }
7356 if (LogManager.IsActionLogEnable())
7357 {
7358 Debug.ActionLog(action.ToString() +
" -> " + ai,
this.ToString() ,
"n/a",
"Add action");
7359 }
7360
7361 if (action_array.Find(action) != -1)
7362 {
7363 Debug.Log(
"Action " + action.Type() +
" already added to " +
this +
", skipping!");
7364 }
7365 else
7366 {
7367 action_array.Insert(action);
7368 }
7369 }
7370
7372 {
7374 ActionBase action = player.GetActionManager().GetAction(actionName);
7377
7378 if (action_array)
7379 {
7380 action_array.RemoveItem(action);
7381 }
7382 }
7383
7384
7385
7387 {
7388 ActionOverrideData overrideData = new ActionOverrideData();
7392
7394 if (!actionMap)
7395 {
7398 }
7399
7400 actionMap.Insert(this.
Type(), overrideData);
7401
7402 }
7403
7405
7407
7408
7410 {
7413
7416
7417 string config_to_search = "CfgVehicles";
7418 string muzzle_owner_config;
7419
7421 {
7422 if (IsInherited(Weapon))
7423 config_to_search = "CfgWeapons";
7424
7425 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
7426
7427 string config_OnFire_class = muzzle_owner_config + "Particles " + "OnFire ";
7428
7430
7431 if (config_OnFire_subclass_count > 0)
7432 {
7433 array<ref WeaponParticlesOnFire> WPOF_array = new array<ref WeaponParticlesOnFire>;
7434
7435 for (int i = 0; i < config_OnFire_subclass_count; i++)
7436 {
7437 string particle_class = "";
7439 string config_OnFire_entry = config_OnFire_class + particle_class;
7440 WeaponParticlesOnFire WPOF = new WeaponParticlesOnFire(this, config_OnFire_entry);
7441 WPOF_array.Insert(WPOF);
7442 }
7443
7444
7446 }
7447 }
7448
7450 {
7451 config_to_search = "CfgWeapons";
7452 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
7453
7454 string config_OnBulletCasingEject_class = muzzle_owner_config + "Particles " + "OnBulletCasingEject ";
7455
7457
7458 if (config_OnBulletCasingEject_count > 0 && IsInherited(Weapon))
7459 {
7460 array<ref WeaponParticlesOnBulletCasingEject> WPOBE_array = new array<ref WeaponParticlesOnBulletCasingEject>;
7461
7462 for (i = 0; i < config_OnBulletCasingEject_count; i++)
7463 {
7464 string particle_class2 = "";
7466 string config_OnBulletCasingEject_entry = config_OnBulletCasingEject_class + particle_class2;
7467 WeaponParticlesOnBulletCasingEject WPOBE = new WeaponParticlesOnBulletCasingEject(this, config_OnBulletCasingEject_entry);
7468 WPOBE_array.Insert(WPOBE);
7469 }
7470
7471
7473 }
7474 }
7475 }
7476
7477
7479 {
7482
7484 {
7485 string config_to_search = "CfgVehicles";
7486
7487 if (IsInherited(Weapon))
7488 config_to_search = "CfgWeapons";
7489
7490 string muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
7491 string config_OnOverheating_class = muzzle_owner_config + "Particles " + "OnOverheating ";
7492
7493 if (
GetGame().ConfigIsExisting(config_OnOverheating_class))
7494 {
7495
7497
7499 {
7501 string error =
"Error reading config " +
GetType() +
">Particles>OnOverheating - Parameter shotsToStartOverheating is configured wrong or is missing! Its value must be 1 or higher!";
7503 return;
7504 }
7505
7508
7509
7510
7512 array<ref WeaponParticlesOnOverheating> WPOOH_array = new array<ref WeaponParticlesOnOverheating>;
7513
7514 for (int i = 0; i < config_OnOverheating_subclass_count; i++)
7515 {
7516 string particle_class = "";
7518 string config_OnOverheating_entry = config_OnOverheating_class + particle_class;
7520
7521 if (entry_type == CT_CLASS)
7522 {
7523 WeaponParticlesOnOverheating WPOF = new WeaponParticlesOnOverheating(this, config_OnOverheating_entry);
7524 WPOOH_array.Insert(WPOF);
7525 }
7526 }
7527
7528
7530 }
7531 }
7532 }
7533
7535 {
7537 }
7538
7540 {
7542 {
7544
7547
7550
7551 CheckOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
7552 }
7553 }
7554
7556 {
7558 UpdateOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
7559
7561 StartOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
7562
7564 StopOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
7565
7567 {
7569 }
7570 }
7571
7573 {
7575 }
7576
7578 {
7581 else
7583
7585 {
7588 }
7589 else
7590 {
7593
7596 }
7597
7599 }
7600
7602 {
7604 ItemBase.PlayOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
7605 }
7606
7608 {
7610 ItemBase.UpdateOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
7612 }
7613
7615 {
7617 ItemBase.StopOverheatingParticles(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
7618 }
7619
7621 {
7624
7625 OverheatingParticle OP = new OverheatingParticle();
7630
7632 }
7633
7635 {
7638
7639 return -1;
7640 }
7641
7643 {
7645 {
7648
7649 for (int i = count; i > 0; --i)
7650 {
7651 int id = i - 1;
7654
7657
7658 if (overheat_coef < overheat_min && overheat_coef >= overheat_max)
7659 {
7660 if (p)
7661 {
7664 }
7665 }
7666 }
7667 }
7668 }
7669
7671 {
7673 {
7675 {
7676 int id = i - 1;
7678
7679 if (OP)
7680 {
7682
7683 if (p)
7684 {
7686 }
7687
7688 delete OP;
7689 }
7690 }
7691
7694 }
7695 }
7696
7699 {
7700 return 0.0;
7701 }
7702
7703
7705 {
7706 return 250;
7707 }
7708
7710 {
7711 return 0;
7712 }
7713
7716 {
7718 return true;
7719
7720 return false;
7721 }
7722
7725 {
7728
7730 {
7732 }
7733 else
7734 {
7735
7737 }
7738
7740 }
7741
7748 {
7749 return -1;
7750 }
7751
7752
7753
7754
7756 {
7758 {
7760 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
7761
7762 if (r_index >= 0)
7763 {
7764 InventoryLocation r_il = new InventoryLocation;
7765 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
7766
7767 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
7770 {
7771 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
7772 }
7774 {
7775 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
7776 }
7777
7778 }
7779
7780 player.GetHumanInventory().ClearUserReservedLocation(this);
7781 }
7782
7785 }
7786
7787
7788
7789
7791 {
7792 return ItemBase.m_DebugActionsMask;
7793 }
7794
7796 {
7797 return ItemBase.m_DebugActionsMask & mask;
7798 }
7799
7801 {
7802 ItemBase.m_DebugActionsMask = mask;
7803 }
7804
7806 {
7807 ItemBase.m_DebugActionsMask |= mask;
7808 }
7809
7811 {
7812 ItemBase.m_DebugActionsMask &= ~mask;
7813 }
7814
7816 {
7818 {
7820 }
7821 else
7822 {
7824 }
7825 }
7826
7827
7829 {
7830 if (GetEconomyProfile())
7831 {
7832 float q_max = GetEconomyProfile().GetQuantityMax();
7833 if (q_max > 0)
7834 {
7835 float q_min = GetEconomyProfile().GetQuantityMin();
7836 float quantity_randomized = Math.RandomFloatInclusive(q_min, q_max);
7837
7839 {
7840 ComponentEnergyManager comp = GetCompEM();
7842 {
7844 }
7845 }
7847 {
7849
7850 }
7851
7852 }
7853 }
7854 }
7855
7858 {
7859 EntityAI parent = GetHierarchyParent();
7860
7861 if (parent)
7862 {
7863 InventoryLocation inventory_location_to_lock = new InventoryLocation;
7864 GetInventory().GetCurrentInventoryLocation(inventory_location_to_lock);
7865 parent.GetInventory().SetSlotLock(inventory_location_to_lock.
GetSlot(),
true);
7866 }
7867 }
7868
7871 {
7872 EntityAI parent = GetHierarchyParent();
7873
7874 if (parent)
7875 {
7876 InventoryLocation inventory_location_to_unlock = new InventoryLocation;
7877 GetInventory().GetCurrentInventoryLocation(inventory_location_to_unlock);
7878 parent.GetInventory().SetSlotLock(inventory_location_to_unlock.
GetSlot(),
false);
7879 }
7880 }
7881
7883 {
7884
7885
7886
7887
7889
7891 {
7892 if (ScriptInputUserData.CanStoreInputUserData())
7893 {
7894 ScriptInputUserData ctx = new ScriptInputUserData;
7900 ctx.
Write(use_stack_max);
7903
7905 {
7906 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(item2,null,GameInventory.c_InventoryReservationTimeoutShortMS);
7907 }
7908 }
7909 }
7910 else if (!
GetGame().IsMultiplayer())
7911 {
7913 }
7914 }
7915
7917 {
7919 }
7920
7922 {
7924 }
7925
7927 {
7929 }
7930
7932 {
7933
7934 return false;
7935 }
7936
7938 {
7939 return false;
7940 }
7941
7945 {
7946 return false;
7947 }
7948
7950 {
7951 return "";
7952 }
7953
7955
7957 {
7958 return false;
7959 }
7960
7962 {
7963 return true;
7964 }
7965
7966
7967
7969 {
7970 return true;
7971 }
7972
7974 {
7975 return true;
7976 }
7977
7979 {
7980 PlayerBase player = PlayerBase.Cast(
g_Game.GetPlayer());
7982 }
7983
7985 {
7987 }
7988
7990 {
7992 if (!is_being_placed)
7994 SetSynchDirty();
7995 }
7996
7997
7999
8001 {
8003 }
8004
8006 {
8008 }
8009
8011 {
8012 return 1;
8013 }
8014
8016 {
8017 return false;
8018 }
8019
8021 {
8023 SetSynchDirty();
8024 }
8025
8026
8027
8028
8029
8030
8031
8032
8033
8034
8035
8036
8037
8038
8039
8040
8041
8042
8043
8044
8045
8046
8047
8048
8049
8050
8051
8052
8053
8054
8055
8056
8057
8058
8059
8061 {
8062 super.OnMovedInsideCargo(container);
8063
8064 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
8065 }
8066
8067 override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
8068 {
8069 super.EEItemLocationChanged(oldLoc,newLoc);
8070
8071 PlayerBase new_player = null;
8072 PlayerBase old_player = null;
8073
8074 if (newLoc.GetParent())
8075 new_player = PlayerBase.Cast(newLoc.GetParent().GetHierarchyRootPlayer());
8076
8077 if (oldLoc.GetParent())
8078 old_player = PlayerBase.Cast(oldLoc.GetParent().GetHierarchyRootPlayer());
8079
8081 {
8082 int r_index = old_player.GetHumanInventory().FindUserReservedLocationIndex(this);
8083
8084 if (r_index >= 0)
8085 {
8086 InventoryLocation r_il = new InventoryLocation;
8087 old_player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
8088
8089 old_player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
8092 {
8093 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
8094 }
8096 {
8097 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
8098 }
8099
8100 }
8101 }
8102
8104 {
8105 if (new_player)
8106 new_player.ForceStandUpForHeavyItems(newLoc.GetItem());
8107
8108 if (new_player == old_player)
8109 {
8110
8111 if (oldLoc.GetParent() && new_player.GetHumanInventory().LocationGetEntity(oldLoc) == NULL)
8112 {
8114 {
8115 if (oldLoc.GetParent().GetInventory().TestAddEntityInCargoExLoc(oldLoc, false, false, false, true, false, false))
8116 {
8117 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
8118 }
8119 }
8120 else
8121 {
8122 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
8123 }
8124 }
8125
8126 if (new_player.GetHumanInventory().FindUserReservedLocationIndex(this) >= 0)
8127 {
8128 int type = oldLoc.GetType();
8130 {
8131 oldLoc.GetParent().GetOnSetLock().Invoke(this);
8132 }
8134 {
8135 oldLoc.GetParent().GetOnAttachmentSetLock().Invoke(this, oldLoc.GetSlot());
8136 }
8137 }
8138 if (!m_OldLocation)
8139 {
8140 m_OldLocation = new InventoryLocation;
8141 }
8142 m_OldLocation.Copy(oldLoc);
8143 }
8144 else
8145 {
8146 if (m_OldLocation)
8147 {
8148 m_OldLocation.Reset();
8149 }
8150 }
8151
8153 }
8154 else
8155 {
8156 if (new_player)
8157 {
8158 int res_index = new_player.GetHumanInventory().FindCollidingUserReservedLocationIndex(this, newLoc);
8159 if (res_index >= 0)
8160 {
8161 InventoryLocation il = new InventoryLocation;
8162 new_player.GetHumanInventory().GetUserReservedLocation(res_index,il);
8164 new_player.GetHumanInventory().ClearUserReservedLocationAtIndex(res_index);
8167 {
8168 il.
GetParent().GetOnReleaseLock().Invoke(it);
8169 }
8171 {
8173 }
8174
8175 }
8176 }
8178 {
8179
8181 }
8182
8183 if (m_OldLocation)
8184 {
8185 m_OldLocation.Reset();
8186 }
8187 }
8188 }
8189
8190 override void EOnContact(IEntity other, Contact extra)
8191 {
8193 {
8194 int liquidType = -1;
8196 if (impactSpeed > 0.0)
8197 {
8199 #ifndef SERVER
8201 #else
8203 SetSynchDirty();
8204 #endif
8206 }
8207 }
8208
8209 #ifdef SERVER
8210 if (GetCompEM() && GetCompEM().IsPlugged())
8211 {
8212 if (GetCompEM().GetCordLength() < vector.Distance(
GetPosition(), GetCompEM().GetEnergySource().
GetPosition()))
8213 GetCompEM().UnplugThis();
8214 }
8215 #endif
8216 }
8217
8219
8221 {
8223 }
8224
8226 {
8227
8228 }
8229
8231 {
8232 super.OnItemLocationChanged(old_owner, new_owner);
8233
8234 PlayerBase relatedPlayer = PlayerBase.Cast(old_owner);
8235 PlayerBase playerNew = PlayerBase.Cast(new_owner);
8236
8237 if (!relatedPlayer && playerNew)
8238 relatedPlayer = playerNew;
8239
8240 if (relatedPlayer && relatedPlayer.GetPerformedActionID() != -1)
8241 {
8243 if (actionMgr)
8244 {
8245 ActionBase currentAction = actionMgr.GetRunningAction();
8246 if (currentAction)
8248 }
8249 }
8250
8251 Man ownerPlayerOld = null;
8252 Man ownerPlayerNew = null;
8253
8254 if (old_owner)
8255 {
8256 if (old_owner.
IsMan())
8257 {
8258 ownerPlayerOld = Man.Cast(old_owner);
8259 }
8260 else
8261 {
8262 ownerPlayerOld = Man.Cast(old_owner.GetHierarchyRootPlayer());
8263 }
8264 }
8265 else
8266 {
8268 {
8270
8271 if (!action || !playerNew || playerNew.GetPerformedActionID() != action.
GetID())
8272 {
8273 GetCompEM().UnplugThis();
8274 }
8275 }
8276 }
8277
8278 if (new_owner)
8279 {
8280 if (new_owner.
IsMan())
8281 {
8282 ownerPlayerNew = Man.Cast(new_owner);
8283 }
8284 else
8285 {
8286 ownerPlayerNew = Man.Cast(new_owner.GetHierarchyRootPlayer());
8287 }
8288 }
8289
8290 if (ownerPlayerOld != ownerPlayerNew)
8291 {
8292 if (ownerPlayerOld)
8293 {
8294 array<EntityAI> subItemsExit = new array<EntityAI>;
8296 for (int i = 0; i < subItemsExit.Count(); i++)
8297 {
8300 }
8301 }
8302
8303 if (ownerPlayerNew)
8304 {
8305 array<EntityAI> subItemsEnter = new array<EntityAI>;
8307 for (int j = 0; j < subItemsEnter.Count(); j++)
8308 {
8311 }
8312 }
8313 }
8314 else if (ownerPlayerNew != null)
8315 {
8316 PlayerBase nplayer;
8317 if (PlayerBase.CastTo(nplayer, ownerPlayerNew))
8318 {
8319 array<EntityAI> subItemsUpdate = new array<EntityAI>;
8321 for (int k = 0; k < subItemsUpdate.Count(); k++)
8322 {
8324 itemUpdate.UpdateQuickbarShortcutVisibility(nplayer);
8325 }
8326 }
8327 }
8328
8329 if (old_owner)
8330 old_owner.OnChildItemRemoved(this);
8331 if (new_owner)
8332 new_owner.OnChildItemReceived(this);
8333 }
8334
8335
8337 {
8338 super.EEDelete(parent);
8339 PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
8340 if (player)
8341 {
8343
8344 if (player.IsAlive())
8345 {
8346 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
8347 if (r_index >= 0)
8348 {
8349 InventoryLocation r_il = new InventoryLocation;
8350 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
8351
8352 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
8355 {
8356 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
8357 }
8359 {
8360 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
8361 }
8362
8363 }
8364
8365 player.RemoveQuickBarEntityShortcut(this);
8366 }
8367 }
8368 }
8369
8371 {
8372 super.EEKilled(killer);
8373
8376 {
8377 if (
GetTemperature() >= GameConstants.ITEM_TEMPERATURE_TO_EXPLODE_MIN)
8378 {
8379 if (IsMagazine())
8380 {
8381 if (Magazine.Cast(this).GetAmmoCount() > 0)
8382 {
8384 }
8385 }
8386 else
8387 {
8389 }
8390 }
8391 }
8392 }
8393
8395 {
8396 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
8397
8398 super.OnWasAttached(parent, slot_id);
8399
8402
8404 }
8405
8407 {
8408 super.OnWasDetached(parent, slot_id);
8409
8412 }
8413
8415 {
8416 int idx;
8419
8420 ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
8421 if (inventory_slots.Count() < 1)
8422 {
8423 inventory_slots.Insert(ConfigGetString("ChangeInventorySlot"));
8424 attach_types.Insert(ConfigGetString("ChangeIntoOnAttach"));
8425 }
8426 else
8427 {
8428 ConfigGetTextArray("ChangeIntoOnAttach",attach_types);
8429 }
8430
8431 idx = inventory_slots.Find(slot);
8432 if (idx < 0)
8433 return "";
8434
8435 return attach_types.Get(idx);
8436 }
8437
8439 {
8440 int idx = -1;
8441 string slot;
8442
8445
8446 this.ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
8447 if (inventory_slots.Count() < 1)
8448 {
8449 inventory_slots.Insert(this.ConfigGetString("ChangeInventorySlot"));
8450 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
8451 }
8452 else
8453 {
8454 this.ConfigGetTextArray("ChangeIntoOnDetach",detach_types);
8455 if (detach_types.Count() < 1)
8456 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
8457 }
8458
8459 for (int i = 0; i < inventory_slots.Count(); i++)
8460 {
8461 slot = inventory_slots.Get(i);
8462 }
8463
8464 if (slot != "")
8465 {
8466 if (detach_types.Count() == 1)
8467 idx = 0;
8468 else
8469 idx = inventory_slots.Find(slot);
8470 }
8471 if (idx < 0)
8472 return "";
8473
8474 return detach_types.Get(idx);
8475 }
8476
8478 {
8479
8481
8482
8483 float min_time = 1;
8484 float max_time = 3;
8485 float delay = Math.RandomFloat(min_time, max_time);
8486
8487 explode_timer.Run(delay, this, "DoAmmoExplosion");
8488 }
8489
8491 {
8492 Magazine magazine = Magazine.Cast(this);
8493 int pop_sounds_count = 6;
8494 string pop_sounds[ 6 ] = { "ammopops_1","ammopops_2","ammopops_3","ammopops_4","ammopops_5","ammopops_6" };
8495
8496
8497 int sound_idx = Math.RandomInt(0, pop_sounds_count - 1);
8498 string sound_name = pop_sounds[ sound_idx ];
8500
8501
8502 magazine.ServerAddAmmoCount(-1);
8503
8504
8505 float min_temp_to_explode = 100;
8506
8507 if (magazine.GetAmmoCount() > 0 &&
GetTemperature() >= min_temp_to_explode)
8508 {
8510 }
8511 }
8512
8513
8514 override void EEHitBy(TotalDamageResult damageResult,
int damageType,
EntityAI source,
int component,
string dmgZone,
string ammo, vector modelPos,
float speedCoef)
8515 {
8516 super.EEHitBy(damageResult, damageType, source,
component, dmgZone, ammo, modelPos, speedCoef);
8517
8518 const int CHANCE_DAMAGE_CARGO = 4;
8519 const int CHANCE_DAMAGE_ATTACHMENT = 1;
8520 const int CHANCE_DAMAGE_NOTHING = 2;
8521
8523 {
8524 float dmg = damageResult.
GetDamage(
"",
"Health") * -0.5;
8525 int chances;
8526 int rnd;
8527
8528 if (GetInventory().GetCargo())
8529 {
8530 chances = CHANCE_DAMAGE_CARGO + CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
8531 rnd = Math.RandomInt(0,chances);
8532
8533 if (rnd < CHANCE_DAMAGE_CARGO)
8534 {
8536 }
8537 else if (rnd < (chances - CHANCE_DAMAGE_NOTHING))
8538 {
8540 }
8541 }
8542 else
8543 {
8544 chances = CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
8545 rnd = Math.RandomInt(0,chances);
8546
8547 if (rnd < CHANCE_DAMAGE_ATTACHMENT)
8548 {
8550 }
8551 }
8552 }
8553 }
8554
8556 {
8557 if (GetInventory().GetCargo())
8558 {
8559 int item_count = GetInventory().GetCargo().GetItemCount();
8560 if (item_count > 0)
8561 {
8562 int random_pick = Math.RandomInt(0, item_count);
8564 if (!item.IsExplosive())
8565 {
8566 item.AddHealth("","",damage);
8567 return true;
8568 }
8569 }
8570 }
8571 return false;
8572 }
8573
8575 {
8576 int attachment_count = GetInventory().AttachmentCount();
8577 if (attachment_count > 0)
8578 {
8579 int random_pick = Math.RandomInt(0, attachment_count);
8580 ItemBase attachment =
ItemBase.Cast(GetInventory().GetAttachmentFromIndex(random_pick));
8581 if (!attachment.IsExplosive())
8582 {
8583 attachment.AddHealth("","",damage);
8584 return true;
8585 }
8586 }
8587 return false;
8588 }
8589
8591 {
8593 }
8594
8596 {
8598 return GetInventory().CanRemoveEntity();
8599
8600 return false;
8601 }
8602
8604 {
8605
8607 return false;
8608
8609
8611 return false;
8612
8613
8614
8616 if (delta == 0)
8617 return false;
8618
8619
8620 return true;
8621 }
8622
8624 {
8626 {
8627 if (ScriptInputUserData.CanStoreInputUserData())
8628 {
8629 ScriptInputUserData ctx = new ScriptInputUserData;
8634 ctx.
Write(destination_entity);
8638 }
8639 }
8640 else if (!
GetGame().IsMultiplayer())
8641 {
8643 }
8644 }
8645
8647 {
8648 float split_quantity_new;
8652 InventoryLocation loc = new InventoryLocation;
8653
8654 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
8655 {
8657 split_quantity_new = stack_max;
8658 else
8660
8662 {
8663 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
8664 if (new_item)
8665 {
8666 new_item.SetResultOfSplit(true);
8667 MiscGameplayFunctions.TransferItemProperties(this, new_item);
8669 new_item.
SetQuantity(split_quantity_new,
false,
true);
8670 }
8671 }
8672 }
8673 else if (destination_entity && slot_id == -1)
8674 {
8675 if (quantity > stack_max)
8676 split_quantity_new = stack_max;
8677 else
8678 split_quantity_new = quantity;
8679
8681 {
8683 {
8686 }
8687
8688 if (new_item)
8689 {
8690 new_item.SetResultOfSplit(true);
8691 MiscGameplayFunctions.TransferItemProperties(this, new_item);
8693 new_item.
SetQuantity(split_quantity_new,
false,
true);
8694 }
8695 }
8696 }
8697 else
8698 {
8699 if (stack_max != 0)
8700 {
8702 {
8704 }
8705
8706 if (split_quantity_new == 0)
8707 {
8708 if (!
GetGame().IsMultiplayer())
8709 player.PhysicalPredictiveDropItem(this);
8710 else
8711 player.ServerDropEntity(this);
8712 return;
8713 }
8714
8716 {
8718
8719 if (new_item)
8720 {
8721 new_item.SetResultOfSplit(true);
8722 MiscGameplayFunctions.TransferItemProperties(this, new_item);
8725 new_item.PlaceOnSurface();
8726 }
8727 }
8728 }
8729 }
8730 }
8731
8733 {
8734 float split_quantity_new;
8738 InventoryLocation loc = new InventoryLocation;
8739
8740 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
8741 {
8743 split_quantity_new = stack_max;
8744 else
8746
8748 {
8749 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
8750 if (new_item)
8751 {
8752 new_item.SetResultOfSplit(true);
8753 MiscGameplayFunctions.TransferItemProperties(this, new_item);
8755 new_item.
SetQuantity(split_quantity_new,
false,
true);
8756 }
8757 }
8758 }
8759 else if (destination_entity && slot_id == -1)
8760 {
8761 if (quantity > stack_max)
8762 split_quantity_new = stack_max;
8763 else
8764 split_quantity_new = quantity;
8765
8767 {
8769 {
8772 }
8773
8774 if (new_item)
8775 {
8776 new_item.SetResultOfSplit(true);
8777 MiscGameplayFunctions.TransferItemProperties(this, new_item);
8779 new_item.
SetQuantity(split_quantity_new,
false,
true);
8780 }
8781 }
8782 }
8783 else
8784 {
8785 if (stack_max != 0)
8786 {
8788 {
8790 }
8791
8793 {
8795
8796 if (new_item)
8797 {
8798 new_item.SetResultOfSplit(true);
8799 MiscGameplayFunctions.TransferItemProperties(this, new_item);
8802 new_item.PlaceOnSurface();
8803 }
8804 }
8805 }
8806 }
8807 }
8808
8810 {
8812 {
8813 if (ScriptInputUserData.CanStoreInputUserData())
8814 {
8815 ScriptInputUserData ctx = new ScriptInputUserData;
8820 dst.WriteToContext(ctx);
8822 }
8823 }
8824 else if (!
GetGame().IsMultiplayer())
8825 {
8827 }
8828 }
8829
8831 {
8833 {
8834 if (ScriptInputUserData.CanStoreInputUserData())
8835 {
8836 ScriptInputUserData ctx = new ScriptInputUserData;
8841 ctx.
Write(destination_entity);
8847 }
8848 }
8849 else if (!
GetGame().IsMultiplayer())
8850 {
8852 }
8853 }
8854
8856 {
8858 }
8859
8861 {
8863 float split_quantity_new;
8865 if (dst.IsValid())
8866 {
8867 int slot_id = dst.GetSlot();
8869
8870 if (quantity > stack_max)
8871 split_quantity_new = stack_max;
8872 else
8873 split_quantity_new = quantity;
8874
8876 {
8878
8879 if (new_item)
8880 {
8881 new_item.SetResultOfSplit(true);
8882 MiscGameplayFunctions.TransferItemProperties(this,new_item);
8884 new_item.
SetQuantity(split_quantity_new,
false,
true);
8885 }
8886
8887 return new_item;
8888 }
8889 }
8890
8891 return null;
8892 }
8893
8895 {
8897 float split_quantity_new;
8899 if (destination_entity)
8900 {
8902 if (quantity > stackable)
8903 split_quantity_new = stackable;
8904 else
8905 split_quantity_new = quantity;
8906
8908 {
8909 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateEntityInCargoEx(
this.GetType(), idx, row, col,
false));
8910 if (new_item)
8911 {
8912 new_item.SetResultOfSplit(true);
8913 MiscGameplayFunctions.TransferItemProperties(this,new_item);
8915 new_item.
SetQuantity(split_quantity_new,
false,
true);
8916 }
8917 }
8918 }
8919 }
8920
8922 {
8924 {
8925 if (ScriptInputUserData.CanStoreInputUserData())
8926 {
8927 ScriptInputUserData ctx = new ScriptInputUserData;
8932 ItemBase destination_entity =
this;
8933 ctx.
Write(destination_entity);
8937 }
8938 }
8939 else if (!
GetGame().IsMultiplayer())
8940 {
8942 }
8943 }
8944
8946 {
8948 float split_quantity_new;
8950 if (player)
8951 {
8953 if (quantity > stackable)
8954 split_quantity_new = stackable;
8955 else
8956 split_quantity_new = quantity;
8957
8959 {
8960 EntityAI in_hands = player.GetHumanInventory().CreateInHands(this.
GetType());
8961 new_item =
ItemBase.Cast(in_hands);
8962 if (new_item)
8963 {
8964 new_item.SetResultOfSplit(true);
8965 MiscGameplayFunctions.TransferItemProperties(this,new_item);
8967 new_item.SetQuantity(split_quantity_new, false, true);
8968 }
8969 }
8970 }
8971 }
8972
8974 {
8976 float split_quantity_new = Math.Floor(quantity * 0.5);
8977
8979 return;
8980
8982
8983 if (new_item)
8984 {
8985 if (new_item.GetQuantityMax() < split_quantity_new)
8986 {
8987 split_quantity_new = new_item.GetQuantityMax();
8988 }
8989
8990 new_item.SetResultOfSplit(true);
8991 MiscGameplayFunctions.TransferItemProperties(this, new_item);
8992
8994 {
8997 }
8998 else
8999 {
9001 new_item.
SetQuantity(split_quantity_new,
false,
true);
9002 }
9003 }
9004 }
9005
9007 {
9009 float split_quantity_new = Math.Floor(quantity / 2);
9010
9012 return;
9013
9014 InventoryLocation invloc = new InventoryLocation;
9016
9018 new_item = player.CreateCopyOfItemInInventoryOrGroundEx(this, true);
9019
9020 if (new_item)
9021 {
9022 if (new_item.GetQuantityMax() < split_quantity_new)
9023 {
9024 split_quantity_new = new_item.GetQuantityMax();
9025 }
9027 {
9030 }
9031 else if (split_quantity_new > 1)
9032 {
9034 new_item.
SetQuantity(split_quantity_new,
false,
true);
9035 }
9036 }
9037 }
9038
9041 {
9042 SetWeightDirty();
9044
9045 if (parent)
9046 parent.OnAttachmentQuantityChangedEx(this, delta);
9047
9049 {
9051 {
9053 }
9055 {
9056 ErrorEx(
"Undefined liquid type quantity changed, please define liquid type first! Using init value.",
ErrorExSeverity.INFO);
9058 }
9059 }
9060
9061 }
9062
9065 {
9066
9067 }
9068
9071 {
9073 }
9074
9076 {
9077 super.EEHealthLevelChanged(oldLevel,newLevel,zone);
9078
9080 {
9081 if (newLevel == GameConstants.STATE_RUINED)
9082 {
9084 EntityAI parent = GetHierarchyParent();
9085 if (parent && parent.IsFireplace())
9086 {
9087 CargoBase cargo = GetInventory().GetCargo();
9088 if (cargo)
9089 {
9091 {
9093 }
9094 }
9095 }
9096 }
9097
9099 {
9100
9102 return;
9103 }
9104
9105 if (
m_Cleanness != 0 && oldLevel < newLevel && newLevel != 0)
9106 {
9108 }
9109 }
9110 }
9111
9112
9114 {
9115 super.OnRightClick();
9116
9118 {
9120 {
9121 if (ScriptInputUserData.CanStoreInputUserData())
9122 {
9123 EntityAI root = GetHierarchyRoot();
9124 Man playerOwner = GetHierarchyRootPlayer();
9125 InventoryLocation dst = new InventoryLocation;
9126
9127
9128 if (!playerOwner && root && root == this)
9129 {
9131 }
9132 else
9133 {
9134
9135 GetInventory().GetCurrentInventoryLocation(dst);
9137 {
9140 {
9142 }
9143 else
9144 {
9146
9147
9148 if (
GetGame().
GetPlayer().GetInventory().HasInventoryReservation(
this, dst))
9149 {
9151 }
9152 else
9153 {
9154 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(null, dst, GameInventory.c_InventoryReservationTimeoutShortMS);
9155 }
9156 }
9157 }
9158 }
9159
9160 ScriptInputUserData ctx = new ScriptInputUserData;
9168 }
9169 }
9170 else if (!
GetGame().IsMultiplayer())
9171 {
9173 }
9174 }
9175 }
9176
9178 {
9179 if (root)
9180 {
9181 vector m4[4];
9182 root.GetTransform(m4);
9183 dst.SetGround(this, m4);
9184 }
9185 else
9186 {
9187 GetInventory().GetCurrentInventoryLocation(dst);
9188 }
9189 }
9190
9191 override bool CanBeCombined(
EntityAI other_item,
bool reservation_check =
true,
bool stack_max_limit =
false)
9192 {
9193
9194 if (!other_item ||
GetType() != other_item.GetType() || (
IsFullQuantity() && other_item.GetQuantity() > 0) || other_item ==
this)
9195 return false;
9196
9197 if (GetHealthLevel() == GameConstants.STATE_RUINED || other_item.GetHealthLevel() == GameConstants.STATE_RUINED)
9198 return false;
9199
9200
9202 return false;
9203
9204
9205 Magazine mag = Magazine.Cast(this);
9206 if (mag)
9207 {
9208 if (mag.GetAmmoCount() >= mag.GetAmmoMax())
9209 return false;
9210
9211 if (stack_max_limit)
9212 {
9213 Magazine other_mag = Magazine.Cast(other_item);
9214 if (other_item)
9215 {
9216 if (mag.GetAmmoCount() + other_mag.GetAmmoCount() > mag.GetAmmoMax())
9217 return false;
9218 }
9219
9220 }
9221 }
9222 else
9223 {
9224
9226 return false;
9227
9229 return false;
9230 }
9231
9232 PlayerBase player = null;
9233 if (CastTo(player, GetHierarchyRootPlayer()))
9234 {
9235 if (player.GetInventory().HasAttachment(this))
9236 return false;
9237
9238 if (player.IsItemsToDelete())
9239 return false;
9240 }
9241
9242 if (reservation_check && (GetInventory().HasInventoryReservation(this, null) || other_item.GetInventory().HasInventoryReservation(other_item, null)))
9243 return false;
9244
9245 int slotID;
9247 if (GetInventory().GetCurrentAttachmentSlotInfo(slotID,
slotName) && GetHierarchyParent().GetInventory().GetSlotLock(slotID))
9248 return false;
9249
9250 return true;
9251 }
9252
9254 {
9256 }
9257
9259 {
9260 return m_IsResultOfSplit;
9261 }
9262
9264 {
9265 m_IsResultOfSplit = value;
9266 }
9267
9269 {
9271 }
9272
9274 {
9275 float other_item_quantity = other_item.GetQuantity();
9276 float this_free_space;
9277
9279
9281
9282 if (other_item_quantity > this_free_space)
9283 {
9284 return this_free_space;
9285 }
9286 else
9287 {
9288 return other_item_quantity;
9289 }
9290 }
9291
9293 {
9295 }
9296
9298 {
9300 return;
9301
9302 if (!IsMagazine() && other_item)
9303 {
9305 if (quantity_used != 0)
9306 {
9307 float hp1 = GetHealth01("","");
9308 float hp2 = other_item.GetHealth01("","");
9309 float hpResult = ((hp1*
GetQuantity()) + (hp2*quantity_used));
9310 hpResult = hpResult / (
GetQuantity() + quantity_used);
9311
9312 hpResult *= GetMaxHealth();
9313 Math.Round(hpResult);
9314 SetHealth("", "Health", hpResult);
9315
9317 other_item.AddQuantity(-quantity_used);
9318 }
9319 }
9321 }
9322
9324 {
9325 #ifdef SERVER
9326 if (!GetHierarchyRootPlayer() && GetHierarchyParent())
9327 GetHierarchyParent().IncreaseLifetimeUp();
9328 #endif
9329 };
9330
9332 {
9333 PlayerBase p = PlayerBase.Cast(player);
9334
9335 array<int> recipesIds = p.m_Recipes;
9336 PluginRecipesManager moduleRecipesManager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
9337 if (moduleRecipesManager)
9338 {
9339 EntityAI itemInHands = player.GetHumanInventory().GetEntityInHands();
9340 moduleRecipesManager.GetValidRecipes(
ItemBase.Cast(
this),
ItemBase.Cast(itemInHands), recipesIds, p);
9341 }
9342
9343 for (int i = 0;i < recipesIds.Count(); i++)
9344 {
9345 int key = recipesIds.Get(i);
9346 string recipeName = moduleRecipesManager.GetRecipeName(key);
9348 }
9349 }
9350
9351
9352 override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
9353 {
9354 super.GetDebugActions(outputList);
9355
9356
9362
9363
9368
9373
9374
9378
9379
9381 {
9385 }
9386
9389
9390
9394
9396
9397 InventoryLocation loc = new InventoryLocation();
9398 GetInventory().GetCurrentInventoryLocation(loc);
9400 {
9401 if (Gizmo_IsSupported())
9404 }
9405
9407 }
9408
9409
9410
9411
9413 {
9414 super.OnAction(action_id, player, ctx);
9415
9417 {
9418 switch (action_id)
9419 {
9422 return true;
9425 return true;
9426 }
9427 }
9428
9430 {
9431 switch (action_id)
9432 {
9434 Delete();
9435 return true;
9436 }
9437 }
9438
9439 if (action_id >=
EActions.RECIPES_RANGE_START && action_id <
EActions.RECIPES_RANGE_END)
9440 {
9441 PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
9442 int idWithoutOffset = action_id -
EActions.RECIPES_RANGE_START;
9443 PlayerBase p = PlayerBase.Cast(player);
9444 if (
EActions.RECIPES_RANGE_START < 1000)
9445 {
9446 float anim_length = plugin_recipes_manager.GetRecipeLengthInSecs(idWithoutOffset);
9447 float specialty_weight = plugin_recipes_manager.GetRecipeSpecialty(idWithoutOffset);
9448 }
9449 }
9450 #ifndef SERVER
9451 else if (action_id ==
EActions.WATCH_PLAYER)
9452 {
9453 PluginDeveloper.SetDeveloperItemClientEx(player);
9454 }
9455 #endif
9457 {
9458 if (action_id >=
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START && action_id <
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_END)
9459 {
9460 int id = action_id -
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START;
9461 OnDebugButtonPressServer(id + 1);
9462 }
9463
9464 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_INJECT_START && action_id <
EActions.DEBUG_AGENTS_RANGE_INJECT_END)
9465 {
9466 int agent_id = action_id -
EActions.DEBUG_AGENTS_RANGE_INJECT_START;
9468 }
9469
9470 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_REMOVE_START && action_id <
EActions.DEBUG_AGENTS_RANGE_REMOVE_END)
9471 {
9472 int agent_id2 = action_id -
EActions.DEBUG_AGENTS_RANGE_REMOVE_START;
9474 }
9475
9476 else if (action_id ==
EActions.ADD_QUANTITY)
9477 {
9478 if (IsMagazine())
9479 {
9480 Magazine mag = Magazine.Cast(this);
9481 mag.ServerSetAmmoCount(mag.GetAmmoCount() + mag.GetAmmoMax() * 0.2);
9482 }
9483 else
9484 {
9486 }
9487
9488 if (m_EM)
9489 {
9490 m_EM.AddEnergy(m_EM.GetEnergyMax() * 0.2);
9491 }
9492
9493 }
9494
9495 else if (action_id ==
EActions.REMOVE_QUANTITY)
9496 {
9497 if (IsMagazine())
9498 {
9499 Magazine mag2 = Magazine.Cast(this);
9500 mag2.ServerSetAmmoCount(mag2.GetAmmoCount() - mag2.GetAmmoMax() * 0.2);
9501 }
9502 else
9503 {
9505 }
9506 if (m_EM)
9507 {
9508 m_EM.AddEnergy(- m_EM.GetEnergyMax() * 0.2);
9509 }
9510
9511 }
9512
9513 else if (action_id ==
EActions.SET_QUANTITY_0)
9514 {
9516
9517 if (m_EM)
9518 {
9519 m_EM.SetEnergy(0);
9520 }
9521 }
9522
9523 else if (action_id ==
EActions.SET_MAX_QUANTITY)
9524 {
9526
9527 if (m_EM)
9528 {
9529 m_EM.SetEnergy(m_EM.GetEnergyMax());
9530 }
9531 }
9532
9533 else if (action_id ==
EActions.ADD_HEALTH)
9534 {
9535 AddHealth("","",GetMaxHealth("","Health")/5);
9536 }
9537 else if (action_id ==
EActions.REMOVE_HEALTH)
9538 {
9539 AddHealth("","",-GetMaxHealth("","Health")/5);
9540 }
9541 else if (action_id ==
EActions.DESTROY_HEALTH)
9542 {
9543 SetHealth01("","",0);
9544 }
9545 else if (action_id ==
EActions.WATCH_ITEM)
9546 {
9548 mid.RegisterDebugItem(
ItemBase.Cast(
this), PlayerBase.Cast(player));
9549 #ifdef DEVELOPER
9550 SetDebugDeveloper_item(this);
9551 #endif
9552 }
9553
9554 else if (action_id ==
EActions.ADD_TEMPERATURE)
9555 {
9556 AddTemperature(20);
9557
9558 }
9559
9560 else if (action_id ==
EActions.REMOVE_TEMPERATURE)
9561 {
9562 AddTemperature(-20);
9563
9564 }
9565
9566 else if (action_id ==
EActions.FLIP_FROZEN)
9567 {
9568 SetFrozen(!GetIsFrozen());
9569
9570 }
9571
9572 else if (action_id ==
EActions.ADD_WETNESS)
9573 {
9575
9576 }
9577
9578 else if (action_id ==
EActions.REMOVE_WETNESS)
9579 {
9581
9582 }
9583
9584 else if (action_id ==
EActions.LIQUIDTYPE_UP)
9585 {
9588
9589
9590 }
9591
9592 else if (action_id ==
EActions.LIQUIDTYPE_DOWN)
9593 {
9596 }
9597
9598 else if (action_id ==
EActions.MAKE_SPECIAL)
9599 {
9600 auto debugParams = DebugSpawnParams.WithPlayer(player);
9601 OnDebugSpawnEx(debugParams);
9602 }
9603
9604 }
9605
9606
9607 return false;
9608 }
9609
9610
9611
9612
9616
9619
9620
9621
9623 {
9624 return false;
9625 }
9626
9627
9629 {
9630 return true;
9631 }
9632
9633
9635 {
9636 return true;
9637 }
9638
9639
9640
9642 {
9643 string config_path =
string.Format(
"CfgVehicles %1 Food FoodStages",
GetType());
9645 }
9646
9649 {
9650 return null;
9651 }
9652
9654 {
9655 return false;
9656 }
9657
9659 {
9660 return false;
9661 }
9662
9666
9667
9669 {
9670 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
9671 return module_repairing.CanRepair(this, item_repair_kit);
9672 }
9673
9674
9675 bool Repair(PlayerBase player,
ItemBase item_repair_kit,
float specialty_weight)
9676 {
9677 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
9678 return module_repairing.Repair(player, this, item_repair_kit, specialty_weight);
9679 }
9680
9681
9683 {
9684
9685
9686
9687
9688
9689
9690
9691
9692 return 1;
9693 }
9694
9695
9696
9698 {
9700 }
9701
9702
9703
9705 {
9707 }
9708
9709
9718 {
9719 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
9720
9721 if (player)
9722 {
9723 player.MessageStatus(text);
9724 }
9725 }
9726
9727
9736 {
9737 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
9738
9739 if (player)
9740 {
9741 player.MessageAction(text);
9742 }
9743 }
9744
9745
9754 {
9755 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
9756
9757 if (player)
9758 {
9759 player.MessageFriendly(text);
9760 }
9761 }
9762
9763
9772 {
9773 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
9774
9775 if (player)
9776 {
9777 player.MessageImportant(text);
9778 }
9779 }
9780
9782 {
9783 return true;
9784 }
9785
9786
9787 override bool KindOf(
string tag)
9788 {
9789 bool found = false;
9790 string item_name = this.
GetType();
9793
9794 int array_size = item_tag_array.Count();
9795 for (int i = 0; i < array_size; i++)
9796 {
9797 if (item_tag_array.Get(i) == tag)
9798 {
9799 found = true;
9800 break;
9801 }
9802 }
9803 return found;
9804 }
9805
9806
9808 {
9809
9810 super.OnRPC(sender, rpc_type,ctx);
9811
9812
9813 switch (rpc_type)
9814 {
9815 #ifndef SERVER
9816 case ERPCs.RPC_SOUND_LOCK_ATTACH:
9817 Param2<bool, string> p = new Param2<bool, string>(false, "");
9818
9820 return;
9821
9822 bool play = p.param1;
9823 string soundSet = p.param2;
9824
9825 if (play)
9826 {
9828 {
9830 {
9832 }
9833 }
9834 else
9835 {
9837 }
9838 }
9839 else
9840 {
9842 }
9843
9844 break;
9845 #endif
9846
9847 }
9848
9850 {
9852 }
9853 }
9854
9855
9856
9857
9859 {
9860 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
9861 return plugin.GetID(
name);
9862 }
9863
9865 {
9866 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
9867 return plugin.GetName(id);
9868 }
9869
9872 {
9873
9874
9875 int varFlags;
9876 if (!ctx.
Read(varFlags))
9877 return;
9878
9879 if (varFlags & ItemVariableFlags.FLOAT)
9880 {
9882 }
9883 }
9884
9886 {
9887
9888 super.SerializeNumericalVars(floats_out);
9889
9890
9891
9893 {
9895 }
9896
9898 {
9900 }
9901
9903 {
9905 }
9906
9908 {
9913 }
9914
9916 {
9918 }
9919 }
9920
9922 {
9923
9924 super.DeSerializeNumericalVars(floats);
9925
9926
9927 int index = 0;
9928 int mask = Math.Round(floats.Get(index));
9929
9930 index++;
9931
9933 {
9935 {
9937 }
9938 else
9939 {
9940 float quantity = floats.Get(index);
9942 }
9943 index++;
9944 }
9945
9947 {
9948 float wet = floats.Get(index);
9950 index++;
9951 }
9952
9954 {
9955 int liquidtype = Math.Round(floats.Get(index));
9957 index++;
9958 }
9959
9961 {
9963 index++;
9965 index++;
9967 index++;
9969 index++;
9970 }
9971
9973 {
9974 int cleanness = Math.Round(floats.Get(index));
9976 index++;
9977 }
9978 }
9979
9981 {
9982 super.WriteVarsToCTX(ctx);
9983
9984
9986 {
9988 }
9989
9991 {
9993 }
9994
9996 {
9998 }
9999
10001 {
10002 int r,g,b,a;
10008 }
10009
10011 {
10013 }
10014 }
10015
10017 {
10018 if (!super.ReadVarsFromCTX(ctx,version))
10019 return false;
10020
10021 int intValue;
10022 float value;
10023
10024 if (version < 140)
10025 {
10026 if (!ctx.
Read(intValue))
10027 return false;
10028
10029 m_VariablesMask = intValue;
10030 }
10031
10033 {
10034 if (!ctx.
Read(value))
10035 return false;
10036
10038 {
10040 }
10041 else
10042 {
10044 }
10045 }
10046
10047 if (version < 140)
10048 {
10050 {
10051 if (!ctx.
Read(value))
10052 return false;
10053 SetTemperatureDirect(value);
10054 }
10055 }
10056
10058 {
10059 if (!ctx.
Read(value))
10060 return false;
10062 }
10063
10065 {
10066 if (!ctx.
Read(intValue))
10067 return false;
10069 }
10070
10072 {
10073 int r,g,b,a;
10075 return false;
10077 return false;
10079 return false;
10081 return false;
10082
10084 }
10085
10087 {
10088 if (!ctx.
Read(intValue))
10089 return false;
10091 }
10092
10093 if (version >= 138 && version < 140)
10094 {
10096 {
10097 if (!ctx.
Read(intValue))
10098 return false;
10099 SetFrozen(intValue);
10100 }
10101 }
10102
10103 return true;
10104 }
10105
10106
10108 {
10111 {
10113 }
10114
10115 if (!super.OnStoreLoad(ctx, version))
10116 {
10118 return false;
10119 }
10120
10121 if (version >= 114)
10122 {
10123 bool hasQuickBarIndexSaved;
10124
10125 if (!ctx.
Read(hasQuickBarIndexSaved))
10126 {
10128 return false;
10129 }
10130
10131 if (hasQuickBarIndexSaved)
10132 {
10133 int itmQBIndex;
10134
10135
10136 if (!ctx.
Read(itmQBIndex))
10137 {
10139 return false;
10140 }
10141
10142 PlayerBase parentPlayer = PlayerBase.Cast(GetHierarchyRootPlayer());
10143 if (itmQBIndex != -1 && parentPlayer)
10144 parentPlayer.SetLoadedQuickBarItemBind(this, itmQBIndex);
10145 }
10146 }
10147 else
10148 {
10149
10150 PlayerBase player;
10151 int itemQBIndex;
10152 if (version ==
int.
MAX)
10153 {
10154 if (!ctx.
Read(itemQBIndex))
10155 {
10157 return false;
10158 }
10159 }
10160 else if (Class.CastTo(player, GetHierarchyRootPlayer()))
10161 {
10162
10163 if (!ctx.
Read(itemQBIndex))
10164 {
10166 return false;
10167 }
10168 if (itemQBIndex != -1 && player)
10169 player.SetLoadedQuickBarItemBind(this,itemQBIndex);
10170 }
10171 }
10172
10173 if (version < 140)
10174 {
10175
10176 if (!LoadVariables(ctx, version))
10177 {
10179 return false;
10180 }
10181 }
10182
10183
10185 {
10187 return false;
10188 }
10189 if (version >= 132)
10190 {
10192 if (raib)
10193 {
10195 {
10197 return false;
10198 }
10199 }
10200 }
10201
10203 return true;
10204 }
10205
10206
10207
10209 {
10210 super.OnStoreSave(ctx);
10211
10212 PlayerBase player;
10213 if (PlayerBase.CastTo(player,GetHierarchyRootPlayer()))
10214 {
10216
10217 int itemQBIndex = -1;
10218 itemQBIndex = player.FindQuickBarEntityIndex(this);
10219 ctx.
Write(itemQBIndex);
10220 }
10221 else
10222 {
10224 }
10225
10227
10229 if (raib)
10230 {
10232 }
10233 }
10234
10235
10237 {
10238 super.AfterStoreLoad();
10239
10241 {
10243 }
10244
10246 {
10249 }
10250 }
10251
10253 {
10254 super.EEOnAfterLoad();
10255
10257 {
10259 }
10260
10263 }
10264
10266 {
10267 return false;
10268 }
10269
10270
10271
10273 {
10275 {
10276 #ifdef PLATFORM_CONSOLE
10277
10279 {
10281 if (menu)
10282 {
10284 }
10285 }
10286 #endif
10287 }
10288
10290 {
10293 }
10294
10296 {
10297 SetWeightDirty();
10299 }
10301 {
10304 }
10305
10307 {
10310 }
10312 {
10315 }
10316
10317 super.OnVariablesSynchronized();
10318 }
10319
10320
10321
10323 override bool SetQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false,
bool allow_client =
false,
bool clamp_to_stack_max =
true)
10324 {
10325 if (!IsServerCheck(allow_client))
10326 return false;
10327
10329 return false;
10330
10333
10334 if (value <= (min + 0.001))
10335 value = min;
10336
10337 if (value == min)
10338 {
10339 if (destroy_config)
10340 {
10341 bool dstr = ConfigGetBool("varQuantityDestroyOnMin");
10342 if (dstr)
10343 {
10345 this.Delete();
10346 return true;
10347 }
10348 }
10349 else if (destroy_forced)
10350 {
10352 this.Delete();
10353 return true;
10354 }
10355
10357 }
10358
10361
10363 {
10365
10366 if (delta)
10368 }
10369
10371
10372 return false;
10373 }
10374
10375
10377 bool AddQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
10378 {
10380 }
10381
10383 {
10386 }
10387
10389 {
10392 }
10393
10395 override void SetQuantityNormalized(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
10396 {
10397 float value_clamped = Math.Clamp(value, 0, 1);
10399 SetQuantity(result, destroy_config, destroy_forced);
10400 }
10401
10402
10405 {
10407 }
10408
10410 {
10412 }
10413
10414
10415
10416
10417
10418
10419
10420
10421
10422
10424 {
10425 int slot = -1;
10426 if (GetInventory())
10427 {
10428 InventoryLocation il = new InventoryLocation;
10429 GetInventory().GetCurrentInventoryLocation(il);
10431 }
10432
10434 }
10435
10437 {
10438 float quantity_max = 0;
10439
10441 {
10442 if (attSlotID != -1)
10443 quantity_max = InventorySlots.GetStackMaxForSlotId(attSlotID);
10444
10445 if (quantity_max <= 0)
10447 }
10448
10449 if (quantity_max <= 0)
10451
10452 return quantity_max;
10453 }
10454
10456 {
10458 }
10459
10461 {
10463 }
10464
10465
10467 {
10469 }
10470
10472 {
10474 }
10475
10477 {
10479 }
10480
10481
10483 {
10484
10485 float weightEx = GetWeightEx();
10486 float special = GetInventoryAndCargoWeight();
10487 return weightEx - special;
10488 }
10489
10490
10492 {
10494 }
10495
10497 {
10499 {
10500 #ifdef DEVELOPER
10501 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
10502 {
10503 WeightDebugData data1 = WeightDebug.GetWeightDebug(this);
10505 }
10506 #endif
10507
10508 return GetQuantity() * GetConfigWeightModified();
10509 }
10510 else if (HasEnergyManager())
10511 {
10512 #ifdef DEVELOPER
10513 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
10514 {
10515 WeightDebugData data2 = WeightDebug.GetWeightDebug(this);
10516 data2.
SetCalcDetails(
"TIB2: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " + GetCompEM().
GetEnergy()+
"(energy) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit)");
10517 }
10518 #endif
10519 return super.GetWeightSpecialized(forceRecalc) + (GetCompEM().GetEnergy() * ConfigGetFloat("weightPerQuantityUnit")) + GetConfigWeightModified();
10520 }
10521 else
10522 {
10523 #ifdef DEVELOPER
10524 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
10525 {
10526 WeightDebugData data3 = WeightDebug.GetWeightDebug(this);
10527 data3.
SetCalcDetails(
"TIB3: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " +
GetQuantity()+
"(quantity) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit))");
10528 }
10529 #endif
10530 return super.GetWeightSpecialized(forceRecalc) + (
GetQuantity() * ConfigGetFloat(
"weightPerQuantityUnit")) + GetConfigWeightModified();
10531 }
10532 }
10533
10536 {
10537 int item_count = 0;
10539
10540 if (GetInventory().GetCargo() != NULL)
10541 {
10542 item_count = GetInventory().GetCargo().GetItemCount();
10543 }
10544
10545 for (int i = 0; i < GetInventory().AttachmentCount(); i++)
10546 {
10547 Class.CastTo(item,GetInventory().GetAttachmentFromIndex(i));
10548 if (item)
10549 item_count += item.GetNumberOfItems();
10550 }
10551 return item_count;
10552 }
10553
10556 {
10557 float weight = 0;
10558 float wetness = 1;
10559 if (include_wetness)
10562 {
10563 weight = wetness * m_ConfigWeight;
10564 }
10566 {
10567 weight = 1;
10568 }
10569 return weight;
10570 }
10571
10572
10573
10575 {
10576 if ((
GetGame().IsServer() || !
GetGame().IsMultiplayer()) && GetInventory())
10577 {
10578 GameInventory inv = GetInventory();
10579 array<EntityAI> items = new array<EntityAI>;
10581 for (int i = 0; i < items.Count(); i++)
10582 {
10584 if (item)
10585 {
10587 }
10588 }
10589 }
10590 }
10591
10592
10593
10594
10596 {
10597 float energy = 0;
10598 if (HasEnergyManager())
10599 {
10600 energy = GetCompEM().GetEnergy();
10601 }
10602 return energy;
10603 }
10604
10605
10607 {
10608 super.OnEnergyConsumed();
10609
10611 }
10612
10614 {
10615 super.OnEnergyAdded();
10616
10618 }
10619
10620
10622 {
10623 if (
GetGame().IsServer() && HasEnergyManager() && GetCompEM().HasConversionOfEnergyToQuantity())
10624 {
10626 {
10627 float energy_0to1 = GetCompEM().GetEnergy0To1();
10629 }
10630 }
10631 }
10632
10633
10635 {
10636 return ConfigGetFloat("heatIsolation");
10637 }
10638
10640 {
10642 }
10643
10645 {
10646 string paramPath =
string.Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Drying %2",
GetType(), pIncrementName);
10647 if (
GetGame().ConfigIsExisting(paramPath))
10649
10650 return 0.0;
10651 }
10652
10654 {
10655 string paramPath =
string.
Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Soaking %2",
GetType(), pIncrementName);
10656 if (
GetGame().ConfigIsExisting(paramPath))
10658
10659 return 0.0;
10660 }
10661
10662 override void SetWet(
float value,
bool allow_client =
false)
10663 {
10664 if (!IsServerCheck(allow_client))
10665 return;
10666
10669
10671
10672 m_VarWet = Math.Clamp(value, min, max);
10673
10675 {
10678 }
10679 }
10680
10681 override void AddWet(
float value)
10682 {
10684 }
10685
10687 {
10689 }
10690
10692 {
10694 }
10695
10697 {
10699 }
10700
10702 {
10704 }
10705
10707 {
10709 }
10710
10711 override void OnWetChanged(
float newVal,
float oldVal)
10712 {
10715 if (newLevel != oldLevel)
10716 {
10718 }
10719 }
10720
10722 {
10723 SetWeightDirty();
10724 }
10725
10727 {
10728 return GetWetLevelInternal(
m_VarWet);
10729 }
10730
10731
10732
10734 {
10736 }
10737
10739 {
10741 }
10742
10744 {
10746 }
10747
10749 {
10751 }
10752
10753
10754
10756 {
10757 if (ConfigIsExisting("itemModelLength"))
10758 {
10759 return ConfigGetFloat("itemModelLength");
10760 }
10761 return 0;
10762 }
10763
10765 {
10766 if (ConfigIsExisting("itemAttachOffset"))
10767 {
10768 return ConfigGetFloat("itemAttachOffset");
10769 }
10770 return 0;
10771 }
10772
10773 override void SetCleanness(
int value,
bool allow_client =
false)
10774 {
10775 if (!IsServerCheck(allow_client))
10776 return;
10777
10779
10781
10784 }
10785
10787 {
10789 }
10790
10792 {
10793 return true;
10794 }
10795
10796
10797
10798
10800 {
10802 }
10803
10805 {
10807 }
10808
10809
10810
10811
10812 override void SetColor(
int r,
int g,
int b,
int a)
10813 {
10819 }
10821 override void GetColor(out
int r,out
int g,out
int b,out
int a)
10822 {
10827 }
10828
10830 {
10832 }
10833
10836 {
10837 int r,g,b,a;
10839 r = r/255;
10840 g = g/255;
10841 b = b/255;
10842 a = a/255;
10843 return MiscGameplayFunctions.GetColorString(r, g, b, a);
10844 }
10845
10846
10847
10848 override void SetLiquidType(
int value,
bool allow_client =
false)
10849 {
10850 if (!IsServerCheck(allow_client))
10851 return;
10852
10857 }
10858
10860 {
10861 return ConfigGetInt("varLiquidTypeInit");
10862 }
10863
10865 {
10867 }
10868
10870 {
10872 SetFrozen(false);
10873 }
10874
10877 {
10878 player.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
10879 }
10880
10881
10884 {
10885 PlayerBase nplayer;
10886 if (PlayerBase.CastTo(nplayer, player))
10887 {
10889
10890 nplayer.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
10891 }
10892 }
10893
10894
10897 {
10898 PlayerBase nplayer;
10899 if (PlayerBase.CastTo(nplayer,player))
10900 {
10901
10902 nplayer.SetEnableQuickBarEntityShortcut(this,false);
10903
10904 }
10905
10906
10907 player.GetHumanInventory().ClearUserReservedLocationForContainer(this);
10908
10909
10910 if (HasEnergyManager())
10911 {
10912 GetCompEM().UpdatePlugState();
10913 }
10914 }
10915
10916
10918 {
10919 super.OnPlacementStarted(player);
10920
10922 }
10923
10924 override void OnPlacementComplete(Man player, vector position =
"0 0 0", vector orientation =
"0 0 0")
10925 {
10927 {
10928 m_AdminLog.OnPlacementComplete(player,
this);
10929 }
10930
10931 super.OnPlacementComplete(player, position, orientation);
10932 }
10933
10934
10935
10936
10937
10939 {
10941 {
10942 return true;
10943 }
10944 else
10945 {
10946 return false;
10947 }
10948 }
10949
10950
10952 {
10954 {
10956 }
10957 }
10958
10959
10961 {
10963 }
10964
10966 {
10968 }
10969
10970 override void InsertAgent(
int agent,
float count = 1)
10971 {
10972 if (count < 1)
10973 return;
10974
10976 }
10977
10980 {
10982 }
10983
10984
10986 {
10988 }
10989
10990
10991
10992
10993
10994
10995
10996
10997
10998
10999
11000
11001
11002
11003
11004
11005
11006
11007
11008
11009
11010
11011
11012
11013
11014
11015
11016
11017
11018
11019
11020
11021
11022
11023
11024
11025
11026
11027
11028
11029
11030
11032 {
11034 return false;
11035 return true;
11036 }
11037
11039 {
11040
11042 }
11043
11044
11047 {
11048 super.CheckForRoofLimited(timeTresholdMS);
11049
11051 if ((time - m_PreviousRoofTestTime) >= timeTresholdMS)
11052 {
11053 m_PreviousRoofTestTime = time;
11054 SetRoofAbove(MiscGameplayFunctions.IsUnderRoof(this));
11055 }
11056 }
11057
11058
11060 {
11062 {
11063 return 0;
11064 }
11065
11066 if (GetInventory().GetAttachmentSlotsCount() != 0)
11067 {
11068 ItemBase filter =
ItemBase.Cast(FindAttachmentBySlotName(
"GasMaskFilter"));
11069 if (filter)
11070 return filter.GetProtectionLevel(type, false, system);
11071 else
11072 return 0;
11073 }
11074
11075 string subclassPath, entryName;
11076
11077 switch (type)
11078 {
11080 entryName = "biological";
11081 break;
11083 entryName = "chemical";
11084 break;
11085 default:
11086 entryName = "biological";
11087 break;
11088 }
11089
11090 subclassPath =
"CfgVehicles " + this.
GetType() +
" Protection ";
11091
11093 }
11094
11095
11096
11099 {
11100 if (!IsMagazine())
11102
11104 }
11105
11106
11107
11108
11109
11114 {
11115 return true;
11116 }
11117
11119 {
11121 }
11122
11123
11124
11125
11126
11128 {
11129 if (parent)
11130 {
11131 if (parent.IsInherited(DayZInfected))
11132 return true;
11133
11134 if (!parent.IsRuined())
11135 return true;
11136 }
11137
11138 return true;
11139 }
11140
11142 {
11143 if (!super.CanPutAsAttachment(parent))
11144 {
11145 return false;
11146 }
11147
11148 if (!IsRuined() && !parent.IsRuined())
11149 {
11150 return true;
11151 }
11152
11153 return false;
11154 }
11155
11157 {
11158
11159
11160
11161
11162 return super.CanReceiveItemIntoCargo(item);
11163 }
11164
11166 {
11167
11168
11169
11170
11171 GameInventory attachmentInv = attachment.GetInventory();
11173 {
11174 if (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase))
11175 return false;
11176 }
11177
11178 InventoryLocation loc = new InventoryLocation();
11179 attachment.GetInventory().GetCurrentInventoryLocation(loc);
11180 if (loc && loc.
IsValid() && !GetInventory().AreChildrenAccessible())
11181 return false;
11182
11183 return super.CanReceiveAttachment(attachment, slotId);
11184 }
11185
11187 {
11188 if (!super.CanReleaseAttachment(attachment))
11189 return false;
11190
11191 return GetInventory().AreChildrenAccessible();
11192 }
11193
11194
11195
11196
11197
11198
11199
11200
11201
11202
11203
11204
11205
11206
11207
11208
11209
11210
11211
11212
11213
11215 {
11216 int id = muzzle_owner.GetMuzzleID();
11217 array<ref WeaponParticlesOnFire> WPOF_array =
m_OnFireEffect.Get(
id);
11218
11219 if (WPOF_array)
11220 {
11221 for (int i = 0; i < WPOF_array.Count(); i++)
11222 {
11223 WeaponParticlesOnFire WPOF = WPOF_array.Get(i);
11224
11225 if (WPOF)
11226 {
11227 WPOF.OnActivate(weapon, muzzle_index, ammoType, muzzle_owner, suppressor, config_to_search);
11228 }
11229 }
11230 }
11231 }
11232
11233
11235 {
11236 int id = muzzle_owner.GetMuzzleID();
11238
11239 if (WPOBE_array)
11240 {
11241 for (int i = 0; i < WPOBE_array.Count(); i++)
11242 {
11243 WeaponParticlesOnBulletCasingEject WPOBE = WPOBE_array.Get(i);
11244
11245 if (WPOBE)
11246 {
11247 WPOBE.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
11248 }
11249 }
11250 }
11251 }
11252
11253
11255 {
11256 int id = muzzle_owner.GetMuzzleID();
11257 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
11258
11259 if (WPOOH_array)
11260 {
11261 for (int i = 0; i < WPOOH_array.Count(); i++)
11262 {
11263 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
11264
11265 if (WPOOH)
11266 {
11267 WPOOH.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
11268 }
11269 }
11270 }
11271 }
11272
11273
11275 {
11276 int id = muzzle_owner.GetMuzzleID();
11277 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
11278
11279 if (WPOOH_array)
11280 {
11281 for (int i = 0; i < WPOOH_array.Count(); i++)
11282 {
11283 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
11284
11285 if (WPOOH)
11286 {
11287 WPOOH.OnUpdate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
11288 }
11289 }
11290 }
11291 }
11292
11293
11295 {
11296 int id = muzzle_owner.GetMuzzleID();
11297 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
11298
11299 if (WPOOH_array)
11300 {
11301 for (int i = 0; i < WPOOH_array.Count(); i++)
11302 {
11303 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
11304
11305 if (WPOOH)
11306 {
11307 WPOOH.OnDeactivate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
11308 }
11309 }
11310 }
11311 }
11312
11313
11314
11316 {
11318 {
11319 return true;
11320 }
11321
11322 return false;
11323 }
11324
11326 {
11328 {
11329 return true;
11330 }
11331
11332 return false;
11333 }
11334
11336 {
11338 {
11339 return true;
11340 }
11341
11342 return false;
11343 }
11344
11346 {
11347 return false;
11348 }
11349
11352 {
11353 return UATimeSpent.DEFAULT_DEPLOY;
11354 }
11355
11356
11357
11358
11360 {
11362 SetSynchDirty();
11363 }
11364
11366 {
11368 }
11369
11370
11372 {
11373 return false;
11374 }
11375
11378 {
11379 string att_type = "None";
11380
11381 if (ConfigIsExisting("soundAttType"))
11382 {
11383 att_type = ConfigGetString("soundAttType");
11384 }
11385
11387 }
11388
11390 {
11392 }
11393
11394
11395
11396
11397
11403
11405 {
11408
11410 }
11411
11412
11414 {
11416 return;
11417
11419
11422
11425
11426 SoundParameters params = new SoundParameters();
11430 }
11431
11432
11434 {
11436 return;
11437
11439 SetSynchDirty();
11440
11443 }
11444
11445
11447 {
11449 return;
11450
11452 SetSynchDirty();
11453
11456 }
11457
11459 {
11461 }
11462
11464 {
11466 }
11467
11470 {
11471 if (!
GetGame().IsDedicatedServer())
11472 {
11473 if (ConfigIsExisting("attachSoundSet"))
11474 {
11475 string cfg_path = "";
11476 string soundset = "";
11477 string type_name =
GetType();
11478
11481 ConfigGetTextArray("attachSoundSet",cfg_soundset_array);
11482 ConfigGetTextArray("attachSoundSlot",cfg_slot_array);
11483
11484 if (cfg_soundset_array.Count() > 0 && cfg_soundset_array.Count() == cfg_slot_array.Count())
11485 {
11486 for (int i = 0; i < cfg_soundset_array.Count(); i++)
11487 {
11488 if (cfg_slot_array[i] == slot_type)
11489 {
11490 soundset = cfg_soundset_array[i];
11491 break;
11492 }
11493 }
11494 }
11495
11496 if (soundset != "")
11497 {
11498 EffectSound sound = SEffectManager.PlaySound(soundset,
GetPosition());
11500 }
11501 }
11502 }
11503 }
11504
11506 {
11507
11508 }
11509
11510 void OnApply(PlayerBase player);
11511
11513 {
11514 return 1.0;
11515 };
11516
11518 {
11520 }
11521
11523 {
11525 }
11526
11528
11530 {
11531 SetDynamicPhysicsLifeTime(0.01);
11533 }
11534
11536 {
11537 array<string> zone_names = new array<string>;
11538 GetDamageZones(zone_names);
11539 for (int i = 0; i < zone_names.Count(); i++)
11540 {
11541 SetHealthMax(zone_names.Get(i),"Health");
11542 }
11543 SetHealthMax("","Health");
11544 }
11545
11548 {
11549 float global_health = GetHealth01("","Health");
11550 array<string> zones = new array<string>;
11551 GetDamageZones(zones);
11552
11553 for (int i = 0; i < zones.Count(); i++)
11554 {
11555 SetHealth01(zones.Get(i),"Health",global_health);
11556 }
11557 }
11558
11561 {
11562 return IsExclusionFlagPresent(PlayerBase.GetFaceCoverageShaveValues());
11563 }
11564
11566 {
11567 if (!hasRootAsPlayer)
11568 {
11569 if (refParentIB)
11570 {
11571
11572 if ((refParentIB.GetWet() >= GameConstants.STATE_SOAKING_WET) && (
m_VarWet <
m_VarWetMax))
11573 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_INSIDE);
11574
11575 else if ((refParentIB.GetLiquidType() != 0) && (refParentIB.GetQuantity() > 0) && (
m_VarWet <
m_VarWetMax))
11576 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_LIQUID);
11577
11580 }
11581 else
11582 {
11583
11586 }
11587 }
11588 }
11589
11591 {
11593 {
11594 float target =
g_Game.GetMission().GetWorldData().GetBaseEnvTemperatureAtObject(
this);
11595 if (
GetTemperature() != target || !IsFreezeThawProgressFinished())
11596 {
11597 float heatPermCoef = 1.0;
11599 while (ent)
11600 {
11601 heatPermCoef *= ent.GetHeatPermeabilityCoef();
11602 ent = ent.GetHierarchyParent();
11603 }
11604
11605 SetTemperatureEx(
new TemperatureDataInterpolated(target,
ETemperatureAccessTypes.ACCESS_WORLD,delta,GameConstants.TEMP_COEF_WORLD,heatPermCoef));
11606 }
11607 }
11608 }
11609
11611 {
11612
11613 EntityAI parent = GetHierarchyParent();
11614 if (!parent)
11615 {
11616 hasParent = false;
11617 hasRootAsPlayer = false;
11618 }
11619 else
11620 {
11621 hasParent = true;
11622 hasRootAsPlayer = (GetHierarchyRootPlayer() != null);
11623 refParentIB =
ItemBase.Cast(parent);
11624 }
11625 }
11626
11627 protected void ProcessDecay(
float delta,
bool hasRootAsPlayer)
11628 {
11629
11630 }
11631
11633 {
11634
11635 return false;
11636 }
11637
11639 {
11640
11641
11642 return false;
11643 }
11644
11646 {
11647
11648 return false;
11649 }
11650
11653 {
11654 return !GetIsFrozen() &&
IsOpen();
11655 }
11656
11658 {
11659 bool hasParent = false, hasRootAsPlayer = false;
11661
11662 bool wwtu =
g_Game.IsWorldWetTempUpdateEnabled();
11663 bool foodDecay =
g_Game.IsFoodDecayEnabled();
11664
11665 if (wwtu || foodDecay)
11666 {
11670
11671 if (processWetness || processTemperature || processDecay)
11672 {
11674
11675 if (processWetness)
11676 ProcessItemWetness(m_ElapsedSinceLastUpdate, hasParent, hasRootAsPlayer, refParentIB);
11677
11678 if (processTemperature)
11680
11681 if (processDecay)
11682 ProcessDecay(m_ElapsedSinceLastUpdate, hasRootAsPlayer);
11683 }
11684 }
11685 }
11686
11689 {
11691 }
11692
11694 {
11697
11698 return super.GetTemperatureFreezeThreshold();
11699 }
11700
11702 {
11705
11706 return super.GetTemperatureThawThreshold();
11707 }
11708
11710 {
11713
11714 return super.GetItemOverheatThreshold();
11715 }
11716
11718 {
11720 return Math.Lerp(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureFreezeTime()),
GetQuantityNormalized());
11721
11722 return super.GetTemperatureFreezeTime();
11723 }
11724
11726 {
11728 return Math.Lerp(GameConstants.TEMPERATURE_TIME_THAW_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureThawTime()),
GetQuantityNormalized());
11729
11730 return super.GetTemperatureThawTime();
11731 }
11732
11737
11739 {
11740 return (item.IsKindOf("Cauldron") || item.IsKindOf("Pot") || item.IsKindOf("FryingPan") || item.IsKindOf("SmallProtectorCase") || (item.IsKindOf("PortableGasStove") && item.FindAttachmentBySlotName("CookingEquipment")));
11741 }
11742
11744 {
11745 MiscGameplayFunctions.TransferItemProperties(oldItem, this);
11746 }
11747
11750 {
11752 }
11753
11755 {
11757 }
11758
11760 {
11762 }
11763
11766 {
11767 return null;
11768 }
11769
11772 {
11773 return false;
11774 }
11775
11777 {
11779 {
11782 if (!trg)
11783 {
11785 explosive = this;
11786 }
11787
11788 explosive.PairRemote(trg);
11790
11791 int persistentID = RemotelyActivatedItemBehaviour.GeneratePersistentID();
11792 trg.SetPersistentPairID(persistentID);
11793 explosive.SetPersistentPairID(persistentID);
11794
11795 return true;
11796 }
11797 return false;
11798 }
11799
11802 {
11803 float ret = 1.0;
11806 ret *= GetHealth01();
11807
11808 return ret;
11809 }
11810
11811 #ifdef DEVELOPER
11812 override void SetDebugItem()
11813 {
11814 super.SetDebugItem();
11815 _itemBase = this;
11816 }
11817
11819 {
11820 string text = super.GetDebugText();
11821
11823 text +=
string.
Format(
"Heat isolation(modified): %1\n", MiscGameplayFunctions.GetCurrentItemHeatIsolation(
this));
11824
11825 return text;
11826 }
11827 #endif
11828
11830 {
11831 return true;
11832 }
11833
11835
11837
11839 {
11842 }
11843
11844
11852
11868}
11869
11871{
11873 if (entity)
11874 {
11875 bool is_item = entity.IsInherited(
ItemBase);
11876 if (is_item && full_quantity)
11877 {
11880 }
11881 }
11882 else
11883 {
11885 return NULL;
11886 }
11887 return entity;
11888}
11889
11891{
11892 if (item)
11893 {
11894 if (health > 0)
11895 item.SetHealth("", "", health);
11896
11897 if (item.CanHaveTemperature())
11898 {
11900 if (item.CanFreeze())
11901 item.SetFrozen(false);
11902 }
11903
11904 if (item.HasEnergyManager())
11905 {
11906 if (quantity >= 0)
11907 {
11908 item.GetCompEM().SetEnergy0To1(quantity);
11909 }
11910 else
11911 {
11913 }
11914 }
11915 else if (item.IsMagazine())
11916 {
11917 Magazine mag = Magazine.Cast(item);
11918 if (quantity >= 0)
11919 {
11920 mag.ServerSetAmmoCount(mag.GetAmmoMax() * quantity);
11921 }
11922 else
11923 {
11925 }
11926
11927 }
11928 else
11929 {
11930 if (quantity >= 0)
11931 {
11932 item.SetQuantityNormalized(quantity, false);
11933 }
11934 else
11935 {
11937 }
11938
11939 }
11940 }
11941}
11942
11943#ifdef DEVELOPER
11945#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.