6835{
6837 {
6838 return true;
6839 }
6840};
6841
6842
6843
6845{
6849
6851
6854
6855
6856
6857
6858
6867
6873
6878
6883
6904 protected bool m_IsResultOfSplit
6905
6907
6912
6913
6914
6916
6920
6921
6922
6924
6927
6928
6929
6935
6936
6944
6947
6948
6950
6951
6953
6954
6959
6960
6965
6966
6968
6969
6971 {
6976
6977 if (!
GetGame().IsDedicatedServer())
6978 {
6980 {
6982
6984 {
6986 }
6987 }
6988
6991 }
6992
6993 m_OldLocation = null;
6994
6996 {
6998 }
6999
7000 if (ConfigIsExisting("headSelectionsToHide"))
7001 {
7004 }
7005
7007 if (ConfigIsExisting("hideSelectionsByinventorySlot"))
7008 {
7010 }
7011
7013
7014 m_IsResultOfSplit = false;
7015
7017 }
7018
7020 {
7021 super.InitItemVariables();
7022
7028 m_Count = ConfigGetInt(
"count");
7029
7032
7037
7040
7045
7057
7061
7062
7065 if (ConfigIsExisting("canBeSplit"))
7066 {
7069 }
7070
7072 if (ConfigIsExisting("itemBehaviour"))
7074
7075
7078 RegisterNetSyncVariableInt("m_VarLiquidType");
7079 RegisterNetSyncVariableInt("m_Cleanness",0,1);
7080
7081 RegisterNetSyncVariableBoolSignal("m_WantPlayImpactSound");
7082 RegisterNetSyncVariableFloat("m_ImpactSpeed");
7083 RegisterNetSyncVariableInt("m_ImpactSoundSurfaceHash");
7084
7085 RegisterNetSyncVariableInt("m_ColorComponentR", 0, 255);
7086 RegisterNetSyncVariableInt("m_ColorComponentG", 0, 255);
7087 RegisterNetSyncVariableInt("m_ColorComponentB", 0, 255);
7088 RegisterNetSyncVariableInt("m_ColorComponentA", 0, 255);
7089
7090 RegisterNetSyncVariableBool("m_IsBeingPlaced");
7091 RegisterNetSyncVariableBool("m_IsTakeable");
7092 RegisterNetSyncVariableBool("m_IsHologram");
7093
7096 {
7099 }
7100
7102
7104 if (ConfigIsExisting("temperaturePerQuantityWeight"))
7106
7107 }
7108
7110 {
7112 }
7113
7115 {
7118 {
7123 }
7124 }
7125
7126 override void GetActions(
typename action_input_type, out array<ActionBase_Basic> actions)
7127 {
7129 {
7132 }
7133
7135 }
7136
7138 {
7144 }
7145
7147
7149 {
7151
7152 if (!action)
7153 {
7154 Debug.LogError(
"Action " + actionName +
" dosn't exist!");
7155 return;
7156 }
7157
7159 if (!ai)
7160 {
7162 return;
7163 }
7164
7166 if (!action_array)
7167 {
7168 action_array = new array<ActionBase_Basic>;
7170 }
7171 if (LogManager.IsActionLogEnable())
7172 {
7173 Debug.ActionLog(action.ToString() +
" -> " + ai,
this.ToString() ,
"n/a",
"Add action");
7174 }
7175
7176 if (action_array.Find(action) != -1)
7177 {
7178 Debug.Log(
"Action " + action.Type() +
" already added to " +
this +
", skipping!");
7179 }
7180 else
7181 {
7182 action_array.Insert(action);
7183 }
7184 }
7185
7187 {
7189 ActionBase action = player.GetActionManager().GetAction(actionName);
7192
7193 if (action_array)
7194 {
7195 action_array.RemoveItem(action);
7196 }
7197 }
7198
7199
7200
7202 {
7203 ActionOverrideData overrideData = new ActionOverrideData();
7207
7209 if (!actionMap)
7210 {
7213 }
7214
7215 actionMap.Insert(this.
Type(), overrideData);
7216
7217 }
7218
7220
7222
7223
7225 {
7228
7231
7232 string config_to_search = "CfgVehicles";
7233 string muzzle_owner_config;
7234
7236 {
7237 if (IsInherited(Weapon))
7238 config_to_search = "CfgWeapons";
7239
7240 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
7241
7242 string config_OnFire_class = muzzle_owner_config + "Particles " + "OnFire ";
7243
7245
7246 if (config_OnFire_subclass_count > 0)
7247 {
7248 array<ref WeaponParticlesOnFire> WPOF_array = new array<ref WeaponParticlesOnFire>;
7249
7250 for (int i = 0; i < config_OnFire_subclass_count; i++)
7251 {
7252 string particle_class = "";
7254 string config_OnFire_entry = config_OnFire_class + particle_class;
7255 WeaponParticlesOnFire WPOF = new WeaponParticlesOnFire(this, config_OnFire_entry);
7256 WPOF_array.Insert(WPOF);
7257 }
7258
7259
7261 }
7262 }
7263
7265 {
7266 config_to_search = "CfgWeapons";
7267 muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
7268
7269 string config_OnBulletCasingEject_class = muzzle_owner_config + "Particles " + "OnBulletCasingEject ";
7270
7272
7273 if (config_OnBulletCasingEject_count > 0 && IsInherited(Weapon))
7274 {
7275 array<ref WeaponParticlesOnBulletCasingEject> WPOBE_array = new array<ref WeaponParticlesOnBulletCasingEject>;
7276
7277 for (i = 0; i < config_OnBulletCasingEject_count; i++)
7278 {
7279 string particle_class2 = "";
7281 string config_OnBulletCasingEject_entry = config_OnBulletCasingEject_class + particle_class2;
7282 WeaponParticlesOnBulletCasingEject WPOBE = new WeaponParticlesOnBulletCasingEject(this, config_OnBulletCasingEject_entry);
7283 WPOBE_array.Insert(WPOBE);
7284 }
7285
7286
7288 }
7289 }
7290 }
7291
7292
7294 {
7297
7299 {
7300 string config_to_search = "CfgVehicles";
7301
7302 if (IsInherited(Weapon))
7303 config_to_search = "CfgWeapons";
7304
7305 string muzzle_owner_config = config_to_search +
" " +
GetType() +
" ";
7306 string config_OnOverheating_class = muzzle_owner_config + "Particles " + "OnOverheating ";
7307
7308 if (
GetGame().ConfigIsExisting(config_OnOverheating_class))
7309 {
7310
7312
7314 {
7316 string error =
"Error reading config " +
GetType() +
">Particles>OnOverheating - Parameter shotsToStartOverheating is configured wrong or is missing! Its value must be 1 or higher!";
7318 return;
7319 }
7320
7323
7324
7325
7327 array<ref WeaponParticlesOnOverheating> WPOOH_array = new array<ref WeaponParticlesOnOverheating>;
7328
7329 for (int i = 0; i < config_OnOverheating_subclass_count; i++)
7330 {
7331 string particle_class = "";
7333 string config_OnOverheating_entry = config_OnOverheating_class + particle_class;
7335
7336 if (entry_type == CT_CLASS)
7337 {
7338 WeaponParticlesOnOverheating WPOF = new WeaponParticlesOnOverheating(this, config_OnOverheating_entry);
7339 WPOOH_array.Insert(WPOF);
7340 }
7341 }
7342
7343
7345 }
7346 }
7347 }
7348
7350 {
7352 }
7353
7355 {
7357 {
7359
7362
7365
7366 CheckOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
7367 }
7368 }
7369
7371 {
7373 UpdateOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
7374
7376 StartOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
7377
7379 StopOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
7380
7382 {
7384 }
7385 }
7386
7388 {
7390 }
7391
7393 {
7396 else
7398
7400 {
7403 }
7404 else
7405 {
7408
7411 }
7412
7414 }
7415
7417 {
7419 ItemBase.PlayOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
7420 }
7421
7423 {
7425 ItemBase.UpdateOverheatingParticles(
this, ammoType,
this, suppressor,
"CfgWeapons");
7427 }
7428
7430 {
7432 ItemBase.StopOverheatingParticles(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
7433 }
7434
7436 {
7439
7440 OverheatingParticle OP = new OverheatingParticle();
7445
7447 }
7448
7450 {
7453
7454 return -1;
7455 }
7456
7458 {
7460 {
7463
7464 for (int i = count; i > 0; --i)
7465 {
7466 int id = i - 1;
7469
7472
7473 if (overheat_coef < overheat_min && overheat_coef >= overheat_max)
7474 {
7475 if (p)
7476 {
7479 }
7480 }
7481 }
7482 }
7483 }
7484
7486 {
7488 {
7490 {
7491 int id = i - 1;
7493
7494 if (OP)
7495 {
7497
7498 if (p)
7499 {
7501 }
7502
7503 delete OP;
7504 }
7505 }
7506
7509 }
7510 }
7511
7514 {
7515 return 0.0;
7516 }
7517
7518
7520 {
7521 return 250;
7522 }
7523
7525 {
7526 return 0;
7527 }
7528
7531 {
7533 return true;
7534
7535 return false;
7536 }
7537
7540 {
7543
7545 {
7547 }
7548 else
7549 {
7550
7552 }
7553
7555 }
7556
7563 {
7564 return -1;
7565 }
7566
7567
7568
7569
7571 {
7573 {
7575 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
7576
7577 if (r_index >= 0)
7578 {
7579 InventoryLocation r_il = new InventoryLocation;
7580 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
7581
7582 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
7585 {
7586 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
7587 }
7589 {
7590 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
7591 }
7592
7593 }
7594
7595 player.GetHumanInventory().ClearUserReservedLocation(this);
7596 }
7597
7600 }
7601
7602
7603
7604
7606 {
7607 return ItemBase.m_DebugActionsMask;
7608 }
7609
7611 {
7612 return ItemBase.m_DebugActionsMask & mask;
7613 }
7614
7616 {
7617 ItemBase.m_DebugActionsMask = mask;
7618 }
7619
7621 {
7622 ItemBase.m_DebugActionsMask |= mask;
7623 }
7624
7626 {
7627 ItemBase.m_DebugActionsMask &= ~mask;
7628 }
7629
7631 {
7633 {
7635 }
7636 else
7637 {
7639 }
7640 }
7641
7642
7644 {
7645 if (GetEconomyProfile())
7646 {
7647 float q_max = GetEconomyProfile().GetQuantityMax();
7648 if (q_max > 0)
7649 {
7650 float q_min = GetEconomyProfile().GetQuantityMin();
7651 float quantity_randomized = Math.RandomFloatInclusive(q_min, q_max);
7652
7654 {
7655 ComponentEnergyManager comp = GetCompEM();
7657 {
7659 }
7660 }
7662 {
7664
7665 }
7666
7667 }
7668 }
7669 }
7670
7673 {
7674 EntityAI parent = GetHierarchyParent();
7675
7676 if (parent)
7677 {
7678 InventoryLocation inventory_location_to_lock = new InventoryLocation;
7679 GetInventory().GetCurrentInventoryLocation(inventory_location_to_lock);
7680 parent.GetInventory().SetSlotLock(inventory_location_to_lock.
GetSlot(),
true);
7681 }
7682 }
7683
7686 {
7687 EntityAI parent = GetHierarchyParent();
7688
7689 if (parent)
7690 {
7691 InventoryLocation inventory_location_to_unlock = new InventoryLocation;
7692 GetInventory().GetCurrentInventoryLocation(inventory_location_to_unlock);
7693 parent.GetInventory().SetSlotLock(inventory_location_to_unlock.
GetSlot(),
false);
7694 }
7695 }
7696
7698 {
7699
7700
7701
7702
7704
7706 {
7707 if (ScriptInputUserData.CanStoreInputUserData())
7708 {
7709 ScriptInputUserData ctx = new ScriptInputUserData;
7715 ctx.
Write(use_stack_max);
7718
7720 {
7721 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(item2,null,GameInventory.c_InventoryReservationTimeoutShortMS);
7722 }
7723 }
7724 }
7725 else if (!
GetGame().IsMultiplayer())
7726 {
7728 }
7729 }
7730
7732 {
7734 }
7735
7737 {
7739 }
7740
7742 {
7744 }
7745
7747 {
7748
7749 return false;
7750 }
7751
7753 {
7754 return false;
7755 }
7756
7760 {
7761 return false;
7762 }
7763
7765 {
7766 return "";
7767 }
7768
7770
7772 {
7773 return false;
7774 }
7775
7777 {
7778 return true;
7779 }
7780
7781
7782
7784 {
7785 return true;
7786 }
7787
7789 {
7790 return true;
7791 }
7792
7794 {
7795 PlayerBase player = PlayerBase.Cast(
g_Game.GetPlayer());
7797 }
7798
7800 {
7802 }
7803
7805 {
7807 if (!is_being_placed)
7809 SetSynchDirty();
7810 }
7811
7812
7814
7816 {
7818 }
7819
7821 {
7823 }
7824
7826 {
7827 return 1;
7828 }
7829
7831 {
7832 return false;
7833 }
7834
7836 {
7838 SetSynchDirty();
7839 }
7840
7841
7842
7843
7844
7845
7846
7847
7848
7849
7850
7851
7852
7853
7854
7855
7856
7857
7858
7859
7860
7861
7862
7863
7864
7865
7866
7867
7868
7869
7870
7871
7872
7873
7874
7876 {
7877 super.OnMovedInsideCargo(container);
7878
7879 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
7880 }
7881
7882 override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
7883 {
7884 super.EEItemLocationChanged(oldLoc,newLoc);
7885
7886 PlayerBase new_player = null;
7887 PlayerBase old_player = null;
7888
7889 if (newLoc.GetParent())
7890 new_player = PlayerBase.Cast(newLoc.GetParent().GetHierarchyRootPlayer());
7891
7892 if (oldLoc.GetParent())
7893 old_player = PlayerBase.Cast(oldLoc.GetParent().GetHierarchyRootPlayer());
7894
7896 {
7897 int r_index = old_player.GetHumanInventory().FindUserReservedLocationIndex(this);
7898
7899 if (r_index >= 0)
7900 {
7901 InventoryLocation r_il = new InventoryLocation;
7902 old_player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
7903
7904 old_player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
7907 {
7908 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
7909 }
7911 {
7912 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
7913 }
7914
7915 }
7916 }
7917
7919 {
7920 if (new_player)
7921 new_player.ForceStandUpForHeavyItems(newLoc.GetItem());
7922
7923 if (new_player == old_player)
7924 {
7925
7926 if (oldLoc.GetParent() && new_player.GetHumanInventory().LocationGetEntity(oldLoc) == NULL)
7927 {
7929 {
7930 if (oldLoc.GetParent().GetInventory().TestAddEntityInCargoExLoc(oldLoc, false, false, false, true, false, false))
7931 {
7932 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
7933 }
7934 }
7935 else
7936 {
7937 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
7938 }
7939 }
7940
7941 if (new_player.GetHumanInventory().FindUserReservedLocationIndex(this) >= 0)
7942 {
7943 int type = oldLoc.GetType();
7945 {
7946 oldLoc.GetParent().GetOnSetLock().Invoke(this);
7947 }
7949 {
7950 oldLoc.GetParent().GetOnAttachmentSetLock().Invoke(this, oldLoc.GetSlot());
7951 }
7952 }
7953 if (!m_OldLocation)
7954 {
7955 m_OldLocation = new InventoryLocation;
7956 }
7957 m_OldLocation.Copy(oldLoc);
7958 }
7959 else
7960 {
7961 if (m_OldLocation)
7962 {
7963 m_OldLocation.Reset();
7964 }
7965 }
7966
7968 }
7969 else
7970 {
7971 if (new_player)
7972 {
7973 int res_index = new_player.GetHumanInventory().FindCollidingUserReservedLocationIndex(this, newLoc);
7974 if (res_index >= 0)
7975 {
7976 InventoryLocation il = new InventoryLocation;
7977 new_player.GetHumanInventory().GetUserReservedLocation(res_index,il);
7979 new_player.GetHumanInventory().ClearUserReservedLocationAtIndex(res_index);
7982 {
7983 il.
GetParent().GetOnReleaseLock().Invoke(it);
7984 }
7986 {
7988 }
7989
7990 }
7991 }
7993 {
7994
7996 }
7997
7998 if (m_OldLocation)
7999 {
8000 m_OldLocation.Reset();
8001 }
8002 }
8003 }
8004
8005 override void EOnContact(IEntity other, Contact extra)
8006 {
8008 {
8009 int liquidType = -1;
8011 if (impactSpeed > 0.0)
8012 {
8014 #ifndef SERVER
8016 #else
8018 SetSynchDirty();
8019 #endif
8021 }
8022 }
8023
8024 #ifdef SERVER
8025 if (GetCompEM() && GetCompEM().IsPlugged())
8026 {
8027 if (GetCompEM().GetCordLength() < vector.Distance(
GetPosition(), GetCompEM().GetEnergySource().
GetPosition()))
8028 GetCompEM().UnplugThis();
8029 }
8030 #endif
8031 }
8032
8034
8036 {
8038 }
8039
8041 {
8042
8043 }
8044
8046 {
8047 super.OnItemLocationChanged(old_owner, new_owner);
8048
8049 PlayerBase relatedPlayer = PlayerBase.Cast(old_owner);
8050 PlayerBase playerNew = PlayerBase.Cast(new_owner);
8051
8052 if (!relatedPlayer && playerNew)
8053 relatedPlayer = playerNew;
8054
8055 if (relatedPlayer && relatedPlayer.GetPerformedActionID() != -1)
8056 {
8058 if (actionMgr)
8059 {
8060 ActionBase currentAction = actionMgr.GetRunningAction();
8061 if (currentAction)
8063 }
8064 }
8065
8066 Man ownerPlayerOld = null;
8067 Man ownerPlayerNew = null;
8068
8069 if (old_owner)
8070 {
8071 if (old_owner.
IsMan())
8072 {
8073 ownerPlayerOld = Man.Cast(old_owner);
8074 }
8075 else
8076 {
8077 ownerPlayerOld = Man.Cast(old_owner.GetHierarchyRootPlayer());
8078 }
8079 }
8080 else
8081 {
8083 {
8085
8086 if (!action || !playerNew || playerNew.GetPerformedActionID() != action.
GetID())
8087 {
8088 GetCompEM().UnplugThis();
8089 }
8090 }
8091 }
8092
8093 if (new_owner)
8094 {
8095 if (new_owner.
IsMan())
8096 {
8097 ownerPlayerNew = Man.Cast(new_owner);
8098 }
8099 else
8100 {
8101 ownerPlayerNew = Man.Cast(new_owner.GetHierarchyRootPlayer());
8102 }
8103 }
8104
8105 if (ownerPlayerOld != ownerPlayerNew)
8106 {
8107 if (ownerPlayerOld)
8108 {
8109 array<EntityAI> subItemsExit = new array<EntityAI>;
8111 for (int i = 0; i < subItemsExit.Count(); i++)
8112 {
8115 }
8116 }
8117
8118 if (ownerPlayerNew)
8119 {
8120 array<EntityAI> subItemsEnter = new array<EntityAI>;
8122 for (int j = 0; j < subItemsEnter.Count(); j++)
8123 {
8126 }
8127 }
8128 }
8129 else if (ownerPlayerNew != null)
8130 {
8131 PlayerBase nplayer;
8132 if (PlayerBase.CastTo(nplayer, ownerPlayerNew))
8133 {
8134 array<EntityAI> subItemsUpdate = new array<EntityAI>;
8136 for (int k = 0; k < subItemsUpdate.Count(); k++)
8137 {
8139 itemUpdate.UpdateQuickbarShortcutVisibility(nplayer);
8140 }
8141 }
8142 }
8143
8144 if (old_owner)
8145 old_owner.OnChildItemRemoved(this);
8146 if (new_owner)
8147 new_owner.OnChildItemReceived(this);
8148 }
8149
8150
8152 {
8153 super.EEDelete(parent);
8154 PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
8155 if (player)
8156 {
8158
8159 if (player.IsAlive())
8160 {
8161 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
8162 if (r_index >= 0)
8163 {
8164 InventoryLocation r_il = new InventoryLocation;
8165 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
8166
8167 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
8170 {
8171 r_il.
GetParent().GetOnReleaseLock().Invoke(
this);
8172 }
8174 {
8175 r_il.
GetParent().GetOnAttachmentReleaseLock().Invoke(
this, r_il.
GetSlot());
8176 }
8177
8178 }
8179
8180 player.RemoveQuickBarEntityShortcut(this);
8181 }
8182 }
8183 }
8184
8186 {
8187 super.EEKilled(killer);
8188
8191 {
8192 if (
GetTemperature() >= GameConstants.ITEM_TEMPERATURE_TO_EXPLODE_MIN)
8193 {
8194 if (IsMagazine())
8195 {
8196 if (Magazine.Cast(this).GetAmmoCount() > 0)
8197 {
8199 }
8200 }
8201 else
8202 {
8204 }
8205 }
8206 }
8207 }
8208
8210 {
8211 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
8212
8213 super.OnWasAttached(parent, slot_id);
8214
8217
8219 }
8220
8222 {
8223 super.OnWasDetached(parent, slot_id);
8224
8227 }
8228
8230 {
8231 int idx;
8234
8235 ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
8236 if (inventory_slots.Count() < 1)
8237 {
8238 inventory_slots.Insert(ConfigGetString("ChangeInventorySlot"));
8239 attach_types.Insert(ConfigGetString("ChangeIntoOnAttach"));
8240 }
8241 else
8242 {
8243 ConfigGetTextArray("ChangeIntoOnAttach",attach_types);
8244 }
8245
8246 idx = inventory_slots.Find(slot);
8247 if (idx < 0)
8248 return "";
8249
8250 return attach_types.Get(idx);
8251 }
8252
8254 {
8255 int idx = -1;
8256 string slot;
8257
8260
8261 this.ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
8262 if (inventory_slots.Count() < 1)
8263 {
8264 inventory_slots.Insert(this.ConfigGetString("ChangeInventorySlot"));
8265 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
8266 }
8267 else
8268 {
8269 this.ConfigGetTextArray("ChangeIntoOnDetach",detach_types);
8270 if (detach_types.Count() < 1)
8271 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
8272 }
8273
8274 for (int i = 0; i < inventory_slots.Count(); i++)
8275 {
8276 slot = inventory_slots.Get(i);
8277 }
8278
8279 if (slot != "")
8280 {
8281 if (detach_types.Count() == 1)
8282 idx = 0;
8283 else
8284 idx = inventory_slots.Find(slot);
8285 }
8286 if (idx < 0)
8287 return "";
8288
8289 return detach_types.Get(idx);
8290 }
8291
8293 {
8294
8296
8297
8298 float min_time = 1;
8299 float max_time = 3;
8300 float delay = Math.RandomFloat(min_time, max_time);
8301
8302 explode_timer.Run(delay, this, "DoAmmoExplosion");
8303 }
8304
8306 {
8307 Magazine magazine = Magazine.Cast(this);
8308 int pop_sounds_count = 6;
8309 string pop_sounds[ 6 ] = { "ammopops_1","ammopops_2","ammopops_3","ammopops_4","ammopops_5","ammopops_6" };
8310
8311
8312 int sound_idx = Math.RandomInt(0, pop_sounds_count - 1);
8313 string sound_name = pop_sounds[ sound_idx ];
8315
8316
8317 magazine.ServerAddAmmoCount(-1);
8318
8319
8320 float min_temp_to_explode = 100;
8321
8322 if (magazine.GetAmmoCount() > 0 &&
GetTemperature() >= min_temp_to_explode)
8323 {
8325 }
8326 }
8327
8328
8329 override void EEHitBy(TotalDamageResult damageResult,
int damageType,
EntityAI source,
int component,
string dmgZone,
string ammo, vector modelPos,
float speedCoef)
8330 {
8331 super.EEHitBy(damageResult, damageType, source,
component, dmgZone, ammo, modelPos, speedCoef);
8332
8333 const int CHANCE_DAMAGE_CARGO = 4;
8334 const int CHANCE_DAMAGE_ATTACHMENT = 1;
8335 const int CHANCE_DAMAGE_NOTHING = 2;
8336
8338 {
8339 float dmg = damageResult.
GetDamage(
"",
"Health") * -0.5;
8340 int chances;
8341 int rnd;
8342
8343 if (GetInventory().GetCargo())
8344 {
8345 chances = CHANCE_DAMAGE_CARGO + CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
8346 rnd = Math.RandomInt(0,chances);
8347
8348 if (rnd < CHANCE_DAMAGE_CARGO)
8349 {
8351 }
8352 else if (rnd < (chances - CHANCE_DAMAGE_NOTHING))
8353 {
8355 }
8356 }
8357 else
8358 {
8359 chances = CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
8360 rnd = Math.RandomInt(0,chances);
8361
8362 if (rnd < CHANCE_DAMAGE_ATTACHMENT)
8363 {
8365 }
8366 }
8367 }
8368 }
8369
8371 {
8372 if (GetInventory().GetCargo())
8373 {
8374 int item_count = GetInventory().GetCargo().GetItemCount();
8375 if (item_count > 0)
8376 {
8377 int random_pick = Math.RandomInt(0, item_count);
8379 if (!item.IsExplosive())
8380 {
8381 item.AddHealth("","",damage);
8382 return true;
8383 }
8384 }
8385 }
8386 return false;
8387 }
8388
8390 {
8391 int attachment_count = GetInventory().AttachmentCount();
8392 if (attachment_count > 0)
8393 {
8394 int random_pick = Math.RandomInt(0, attachment_count);
8395 ItemBase attachment =
ItemBase.Cast(GetInventory().GetAttachmentFromIndex(random_pick));
8396 if (!attachment.IsExplosive())
8397 {
8398 attachment.AddHealth("","",damage);
8399 return true;
8400 }
8401 }
8402 return false;
8403 }
8404
8406 {
8408 }
8409
8411 {
8413 return GetInventory().CanRemoveEntity();
8414
8415 return false;
8416 }
8417
8419 {
8420
8422 return false;
8423
8424
8426 return false;
8427
8428
8429
8431 if (delta == 0)
8432 return false;
8433
8434
8435 return true;
8436 }
8437
8439 {
8441 {
8442 if (ScriptInputUserData.CanStoreInputUserData())
8443 {
8444 ScriptInputUserData ctx = new ScriptInputUserData;
8449 ctx.
Write(destination_entity);
8453 }
8454 }
8455 else if (!
GetGame().IsMultiplayer())
8456 {
8458 }
8459 }
8460
8462 {
8463 float split_quantity_new;
8467 InventoryLocation loc = new InventoryLocation;
8468
8469 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
8470 {
8472 split_quantity_new = stack_max;
8473 else
8475
8477 {
8478 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
8479 if (new_item)
8480 {
8481 new_item.SetResultOfSplit(true);
8482 MiscGameplayFunctions.TransferItemProperties(this, new_item);
8484 new_item.
SetQuantity(split_quantity_new,
false,
true);
8485 }
8486 }
8487 }
8488 else if (destination_entity && slot_id == -1)
8489 {
8490 if (quantity > stack_max)
8491 split_quantity_new = stack_max;
8492 else
8493 split_quantity_new = quantity;
8494
8496 {
8498 {
8501 }
8502
8503 if (new_item)
8504 {
8505 new_item.SetResultOfSplit(true);
8506 MiscGameplayFunctions.TransferItemProperties(this, new_item);
8508 new_item.
SetQuantity(split_quantity_new,
false,
true);
8509 }
8510 }
8511 }
8512 else
8513 {
8514 if (stack_max != 0)
8515 {
8517 {
8519 }
8520
8521 if (split_quantity_new == 0)
8522 {
8523 if (!
GetGame().IsMultiplayer())
8524 player.PhysicalPredictiveDropItem(this);
8525 else
8526 player.ServerDropEntity(this);
8527 return;
8528 }
8529
8531 {
8533
8534 if (new_item)
8535 {
8536 new_item.SetResultOfSplit(true);
8537 MiscGameplayFunctions.TransferItemProperties(this, new_item);
8540 new_item.PlaceOnSurface();
8541 }
8542 }
8543 }
8544 }
8545 }
8546
8548 {
8549 float split_quantity_new;
8553 InventoryLocation loc = new InventoryLocation;
8554
8555 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
8556 {
8558 split_quantity_new = stack_max;
8559 else
8561
8563 {
8564 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(
this.GetType(), slot_id));
8565 if (new_item)
8566 {
8567 new_item.SetResultOfSplit(true);
8568 MiscGameplayFunctions.TransferItemProperties(this, new_item);
8570 new_item.
SetQuantity(split_quantity_new,
false,
true);
8571 }
8572 }
8573 }
8574 else if (destination_entity && slot_id == -1)
8575 {
8576 if (quantity > stack_max)
8577 split_quantity_new = stack_max;
8578 else
8579 split_quantity_new = quantity;
8580
8582 {
8584 {
8587 }
8588
8589 if (new_item)
8590 {
8591 new_item.SetResultOfSplit(true);
8592 MiscGameplayFunctions.TransferItemProperties(this, new_item);
8594 new_item.
SetQuantity(split_quantity_new,
false,
true);
8595 }
8596 }
8597 }
8598 else
8599 {
8600 if (stack_max != 0)
8601 {
8603 {
8605 }
8606
8608 {
8610
8611 if (new_item)
8612 {
8613 new_item.SetResultOfSplit(true);
8614 MiscGameplayFunctions.TransferItemProperties(this, new_item);
8617 new_item.PlaceOnSurface();
8618 }
8619 }
8620 }
8621 }
8622 }
8623
8625 {
8627 {
8628 if (ScriptInputUserData.CanStoreInputUserData())
8629 {
8630 ScriptInputUserData ctx = new ScriptInputUserData;
8635 dst.WriteToContext(ctx);
8637 }
8638 }
8639 else if (!
GetGame().IsMultiplayer())
8640 {
8642 }
8643 }
8644
8646 {
8648 {
8649 if (ScriptInputUserData.CanStoreInputUserData())
8650 {
8651 ScriptInputUserData ctx = new ScriptInputUserData;
8656 ctx.
Write(destination_entity);
8662 }
8663 }
8664 else if (!
GetGame().IsMultiplayer())
8665 {
8667 }
8668 }
8669
8671 {
8673 }
8674
8676 {
8678 float split_quantity_new;
8680 if (dst.IsValid())
8681 {
8682 int slot_id = dst.GetSlot();
8684
8685 if (quantity > stack_max)
8686 split_quantity_new = stack_max;
8687 else
8688 split_quantity_new = quantity;
8689
8691 {
8693
8694 if (new_item)
8695 {
8696 new_item.SetResultOfSplit(true);
8697 MiscGameplayFunctions.TransferItemProperties(this,new_item);
8699 new_item.
SetQuantity(split_quantity_new,
false,
true);
8700 }
8701
8702 return new_item;
8703 }
8704 }
8705
8706 return null;
8707 }
8708
8710 {
8712 float split_quantity_new;
8714 if (destination_entity)
8715 {
8717 if (quantity > stackable)
8718 split_quantity_new = stackable;
8719 else
8720 split_quantity_new = quantity;
8721
8723 {
8724 new_item =
ItemBase.Cast(destination_entity.GetInventory().CreateEntityInCargoEx(
this.GetType(), idx, row, col,
false));
8725 if (new_item)
8726 {
8727 new_item.SetResultOfSplit(true);
8728 MiscGameplayFunctions.TransferItemProperties(this,new_item);
8730 new_item.
SetQuantity(split_quantity_new,
false,
true);
8731 }
8732 }
8733 }
8734 }
8735
8737 {
8739 {
8740 if (ScriptInputUserData.CanStoreInputUserData())
8741 {
8742 ScriptInputUserData ctx = new ScriptInputUserData;
8747 ItemBase destination_entity =
this;
8748 ctx.
Write(destination_entity);
8752 }
8753 }
8754 else if (!
GetGame().IsMultiplayer())
8755 {
8757 }
8758 }
8759
8761 {
8763 float split_quantity_new;
8765 if (player)
8766 {
8768 if (quantity > stackable)
8769 split_quantity_new = stackable;
8770 else
8771 split_quantity_new = quantity;
8772
8774 {
8775 EntityAI in_hands = player.GetHumanInventory().CreateInHands(this.
GetType());
8776 new_item =
ItemBase.Cast(in_hands);
8777 if (new_item)
8778 {
8779 new_item.SetResultOfSplit(true);
8780 MiscGameplayFunctions.TransferItemProperties(this,new_item);
8782 new_item.SetQuantity(split_quantity_new, false, true);
8783 }
8784 }
8785 }
8786 }
8787
8789 {
8791 float split_quantity_new = Math.Floor(quantity * 0.5);
8792
8794 return;
8795
8797
8798 if (new_item)
8799 {
8800 if (new_item.GetQuantityMax() < split_quantity_new)
8801 {
8802 split_quantity_new = new_item.GetQuantityMax();
8803 }
8804
8805 new_item.SetResultOfSplit(true);
8806 MiscGameplayFunctions.TransferItemProperties(this, new_item);
8807
8809 {
8812 }
8813 else
8814 {
8816 new_item.
SetQuantity(split_quantity_new,
false,
true);
8817 }
8818 }
8819 }
8820
8822 {
8824 float split_quantity_new = Math.Floor(quantity / 2);
8825
8827 return;
8828
8829 InventoryLocation invloc = new InventoryLocation;
8831
8833 new_item = player.CreateCopyOfItemInInventoryOrGroundEx(this, true);
8834
8835 if (new_item)
8836 {
8837 if (new_item.GetQuantityMax() < split_quantity_new)
8838 {
8839 split_quantity_new = new_item.GetQuantityMax();
8840 }
8842 {
8845 }
8846 else if (split_quantity_new > 1)
8847 {
8849 new_item.
SetQuantity(split_quantity_new,
false,
true);
8850 }
8851 }
8852 }
8853
8856 {
8857 SetWeightDirty();
8859
8860 if (parent)
8861 parent.OnAttachmentQuantityChangedEx(this, delta);
8862
8864 {
8866 {
8868 }
8870 {
8871 ErrorEx(
"Undefined liquid type quantity changed, please define liquid type first! Using init value.",
ErrorExSeverity.INFO);
8873 }
8874 }
8875
8876 }
8877
8880 {
8881
8882 }
8883
8886 {
8888 }
8889
8891 {
8892 super.EEHealthLevelChanged(oldLevel,newLevel,zone);
8893
8895 {
8896 if (newLevel == GameConstants.STATE_RUINED)
8897 {
8899 EntityAI parent = GetHierarchyParent();
8900 if (parent && parent.IsFireplace())
8901 {
8902 CargoBase cargo = GetInventory().GetCargo();
8903 if (cargo)
8904 {
8906 {
8908 }
8909 }
8910 }
8911 }
8912
8914 {
8915
8917 return;
8918 }
8919
8920 if (
m_Cleanness != 0 && oldLevel < newLevel && newLevel != 0)
8921 {
8923 }
8924 }
8925 }
8926
8927
8929 {
8930 super.OnRightClick();
8931
8933 {
8935 {
8936 if (ScriptInputUserData.CanStoreInputUserData())
8937 {
8938 EntityAI root = GetHierarchyRoot();
8939 Man playerOwner = GetHierarchyRootPlayer();
8940 InventoryLocation dst = new InventoryLocation;
8941
8942
8943 if (!playerOwner && root && root == this)
8944 {
8946 }
8947 else
8948 {
8949
8950 GetInventory().GetCurrentInventoryLocation(dst);
8952 {
8955 {
8957 }
8958 else
8959 {
8961
8962
8963 if (
GetGame().
GetPlayer().GetInventory().HasInventoryReservation(
this, dst))
8964 {
8966 }
8967 else
8968 {
8969 GetGame().
GetPlayer().GetInventory().AddInventoryReservationEx(null, dst, GameInventory.c_InventoryReservationTimeoutShortMS);
8970 }
8971 }
8972 }
8973 }
8974
8975 ScriptInputUserData ctx = new ScriptInputUserData;
8983 }
8984 }
8985 else if (!
GetGame().IsMultiplayer())
8986 {
8988 }
8989 }
8990 }
8991
8993 {
8994 if (root)
8995 {
8996 vector m4[4];
8997 root.GetTransform(m4);
8998 dst.SetGround(this, m4);
8999 }
9000 else
9001 {
9002 GetInventory().GetCurrentInventoryLocation(dst);
9003 }
9004 }
9005
9006 override bool CanBeCombined(
EntityAI other_item,
bool reservation_check =
true,
bool stack_max_limit =
false)
9007 {
9008
9009 if (!other_item ||
GetType() != other_item.GetType() || (
IsFullQuantity() && other_item.GetQuantity() > 0) || other_item ==
this)
9010 return false;
9011
9012 if (GetHealthLevel() == GameConstants.STATE_RUINED || other_item.GetHealthLevel() == GameConstants.STATE_RUINED)
9013 return false;
9014
9015
9017 return false;
9018
9019
9020 Magazine mag = Magazine.Cast(this);
9021 if (mag)
9022 {
9023 if (mag.GetAmmoCount() >= mag.GetAmmoMax())
9024 return false;
9025
9026 if (stack_max_limit)
9027 {
9028 Magazine other_mag = Magazine.Cast(other_item);
9029 if (other_item)
9030 {
9031 if (mag.GetAmmoCount() + other_mag.GetAmmoCount() > mag.GetAmmoMax())
9032 return false;
9033 }
9034
9035 }
9036 }
9037 else
9038 {
9039
9041 return false;
9042
9044 return false;
9045 }
9046
9047 PlayerBase player = null;
9048 if (CastTo(player, GetHierarchyRootPlayer()))
9049 {
9050 if (player.GetInventory().HasAttachment(this))
9051 return false;
9052
9053 if (player.IsItemsToDelete())
9054 return false;
9055 }
9056
9057 if (reservation_check && (GetInventory().HasInventoryReservation(this, null) || other_item.GetInventory().HasInventoryReservation(other_item, null)))
9058 return false;
9059
9060 int slotID;
9062 if (GetInventory().GetCurrentAttachmentSlotInfo(slotID,
slotName) && GetHierarchyParent().GetInventory().GetSlotLock(slotID))
9063 return false;
9064
9065 return true;
9066 }
9067
9069 {
9071 }
9072
9074 {
9075 return m_IsResultOfSplit;
9076 }
9077
9079 {
9080 m_IsResultOfSplit = value;
9081 }
9082
9084 {
9086 }
9087
9089 {
9090 float other_item_quantity = other_item.GetQuantity();
9091 float this_free_space;
9092
9094
9096
9097 if (other_item_quantity > this_free_space)
9098 {
9099 return this_free_space;
9100 }
9101 else
9102 {
9103 return other_item_quantity;
9104 }
9105 }
9106
9108 {
9110 }
9111
9113 {
9115 return;
9116
9117 if (!IsMagazine() && other_item)
9118 {
9120 if (quantity_used != 0)
9121 {
9122 float hp1 = GetHealth01("","");
9123 float hp2 = other_item.GetHealth01("","");
9124 float hpResult = ((hp1*
GetQuantity()) + (hp2*quantity_used));
9125 hpResult = hpResult / (
GetQuantity() + quantity_used);
9126
9127 hpResult *= GetMaxHealth();
9128 Math.Round(hpResult);
9129 SetHealth("", "Health", hpResult);
9130
9132 other_item.AddQuantity(-quantity_used);
9133 }
9134 }
9136 }
9137
9139 {
9140 #ifdef SERVER
9141 if (!GetHierarchyRootPlayer() && GetHierarchyParent())
9142 GetHierarchyParent().IncreaseLifetimeUp();
9143 #endif
9144 };
9145
9147 {
9148 PlayerBase p = PlayerBase.Cast(player);
9149
9150 array<int> recipesIds = p.m_Recipes;
9151 PluginRecipesManager moduleRecipesManager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
9152 if (moduleRecipesManager)
9153 {
9154 EntityAI itemInHands = player.GetHumanInventory().GetEntityInHands();
9155 moduleRecipesManager.GetValidRecipes(
ItemBase.Cast(
this),
ItemBase.Cast(itemInHands), recipesIds, p);
9156 }
9157
9158 for (int i = 0;i < recipesIds.Count(); i++)
9159 {
9160 int key = recipesIds.Get(i);
9161 string recipeName = moduleRecipesManager.GetRecipeName(key);
9163 }
9164 }
9165
9166
9167 override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
9168 {
9169 super.GetDebugActions(outputList);
9170
9171
9177
9178
9183
9188
9189
9193
9194
9196 {
9200 }
9201
9204
9205
9209
9211
9212 InventoryLocation loc = new InventoryLocation();
9213 GetInventory().GetCurrentInventoryLocation(loc);
9215 {
9216 if (Gizmo_IsSupported())
9219 }
9220
9222 }
9223
9224
9225
9226
9228 {
9229 super.OnAction(action_id, player, ctx);
9230
9232 {
9233 switch (action_id)
9234 {
9237 return true;
9240 return true;
9241 }
9242 }
9243
9245 {
9246 switch (action_id)
9247 {
9249 Delete();
9250 return true;
9251 }
9252 }
9253
9254 if (action_id >=
EActions.RECIPES_RANGE_START && action_id <
EActions.RECIPES_RANGE_END)
9255 {
9256 PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast(
GetPlugin(PluginRecipesManager));
9257 int idWithoutOffset = action_id -
EActions.RECIPES_RANGE_START;
9258 PlayerBase p = PlayerBase.Cast(player);
9259 if (
EActions.RECIPES_RANGE_START < 1000)
9260 {
9261 float anim_length = plugin_recipes_manager.GetRecipeLengthInSecs(idWithoutOffset);
9262 float specialty_weight = plugin_recipes_manager.GetRecipeSpecialty(idWithoutOffset);
9263 }
9264 }
9265 #ifndef SERVER
9266 else if (action_id ==
EActions.WATCH_PLAYER)
9267 {
9268 PluginDeveloper.SetDeveloperItemClientEx(player);
9269 }
9270 #endif
9272 {
9273 if (action_id >=
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START && action_id <
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_END)
9274 {
9275 int id = action_id -
EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START;
9276 OnDebugButtonPressServer(id + 1);
9277 }
9278
9279 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_INJECT_START && action_id <
EActions.DEBUG_AGENTS_RANGE_INJECT_END)
9280 {
9281 int agent_id = action_id -
EActions.DEBUG_AGENTS_RANGE_INJECT_START;
9283 }
9284
9285 else if (action_id >=
EActions.DEBUG_AGENTS_RANGE_REMOVE_START && action_id <
EActions.DEBUG_AGENTS_RANGE_REMOVE_END)
9286 {
9287 int agent_id2 = action_id -
EActions.DEBUG_AGENTS_RANGE_REMOVE_START;
9289 }
9290
9291 else if (action_id ==
EActions.ADD_QUANTITY)
9292 {
9293 if (IsMagazine())
9294 {
9295 Magazine mag = Magazine.Cast(this);
9296 mag.ServerSetAmmoCount(mag.GetAmmoCount() + mag.GetAmmoMax() * 0.2);
9297 }
9298 else
9299 {
9301 }
9302
9303 if (m_EM)
9304 {
9305 m_EM.AddEnergy(m_EM.GetEnergyMax() * 0.2);
9306 }
9307
9308 }
9309
9310 else if (action_id ==
EActions.REMOVE_QUANTITY)
9311 {
9312 if (IsMagazine())
9313 {
9314 Magazine mag2 = Magazine.Cast(this);
9315 mag2.ServerSetAmmoCount(mag2.GetAmmoCount() - mag2.GetAmmoMax() * 0.2);
9316 }
9317 else
9318 {
9320 }
9321 if (m_EM)
9322 {
9323 m_EM.AddEnergy(- m_EM.GetEnergyMax() * 0.2);
9324 }
9325
9326 }
9327
9328 else if (action_id ==
EActions.SET_QUANTITY_0)
9329 {
9331
9332 if (m_EM)
9333 {
9334 m_EM.SetEnergy(0);
9335 }
9336 }
9337
9338 else if (action_id ==
EActions.SET_MAX_QUANTITY)
9339 {
9341
9342 if (m_EM)
9343 {
9344 m_EM.SetEnergy(m_EM.GetEnergyMax());
9345 }
9346 }
9347
9348 else if (action_id ==
EActions.ADD_HEALTH)
9349 {
9350 AddHealth("","",GetMaxHealth("","Health")/5);
9351 }
9352 else if (action_id ==
EActions.REMOVE_HEALTH)
9353 {
9354 AddHealth("","",-GetMaxHealth("","Health")/5);
9355 }
9356 else if (action_id ==
EActions.DESTROY_HEALTH)
9357 {
9358 SetHealth01("","",0);
9359 }
9360 else if (action_id ==
EActions.WATCH_ITEM)
9361 {
9363 mid.RegisterDebugItem(
ItemBase.Cast(
this), PlayerBase.Cast(player));
9364 #ifdef DEVELOPER
9365 SetDebugDeveloper_item(this);
9366 #endif
9367 }
9368
9369 else if (action_id ==
EActions.ADD_TEMPERATURE)
9370 {
9371 AddTemperature(20);
9372
9373 }
9374
9375 else if (action_id ==
EActions.REMOVE_TEMPERATURE)
9376 {
9377 AddTemperature(-20);
9378
9379 }
9380
9381 else if (action_id ==
EActions.FLIP_FROZEN)
9382 {
9383 SetFrozen(!GetIsFrozen());
9384
9385 }
9386
9387 else if (action_id ==
EActions.ADD_WETNESS)
9388 {
9390
9391 }
9392
9393 else if (action_id ==
EActions.REMOVE_WETNESS)
9394 {
9396
9397 }
9398
9399 else if (action_id ==
EActions.LIQUIDTYPE_UP)
9400 {
9403
9404
9405 }
9406
9407 else if (action_id ==
EActions.LIQUIDTYPE_DOWN)
9408 {
9411 }
9412
9413 else if (action_id ==
EActions.MAKE_SPECIAL)
9414 {
9415 auto debugParams = DebugSpawnParams.WithPlayer(player);
9416 OnDebugSpawnEx(debugParams);
9417 }
9418
9419 }
9420
9421
9422 return false;
9423 }
9424
9425
9426
9427
9431
9434
9435
9436
9438 {
9439 return false;
9440 }
9441
9442
9444 {
9445 return true;
9446 }
9447
9448
9450 {
9451 return true;
9452 }
9453
9454
9455
9457 {
9458 string config_path =
string.Format(
"CfgVehicles %1 Food FoodStages",
GetType());
9460 }
9461
9464 {
9465 return null;
9466 }
9467
9469 {
9470 return false;
9471 }
9472
9474 {
9475 return false;
9476 }
9477
9481
9482
9484 {
9485 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
9486 return module_repairing.CanRepair(this, item_repair_kit);
9487 }
9488
9489
9490 bool Repair(PlayerBase player,
ItemBase item_repair_kit,
float specialty_weight)
9491 {
9492 PluginRepairing module_repairing = PluginRepairing.Cast(
GetPlugin(PluginRepairing));
9493 return module_repairing.Repair(player, this, item_repair_kit, specialty_weight);
9494 }
9495
9496
9498 {
9499
9500
9501
9502
9503
9504
9505
9506
9507 return 1;
9508 }
9509
9510
9511
9513 {
9515 }
9516
9517
9518
9520 {
9522 }
9523
9524
9533 {
9534 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
9535
9536 if (player)
9537 {
9538 player.MessageStatus(text);
9539 }
9540 }
9541
9542
9551 {
9552 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
9553
9554 if (player)
9555 {
9556 player.MessageAction(text);
9557 }
9558 }
9559
9560
9569 {
9570 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
9571
9572 if (player)
9573 {
9574 player.MessageFriendly(text);
9575 }
9576 }
9577
9578
9587 {
9588 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
9589
9590 if (player)
9591 {
9592 player.MessageImportant(text);
9593 }
9594 }
9595
9597 {
9598 return true;
9599 }
9600
9601
9602 override bool KindOf(
string tag)
9603 {
9604 bool found = false;
9605 string item_name = this.
GetType();
9608
9609 int array_size = item_tag_array.Count();
9610 for (int i = 0; i < array_size; i++)
9611 {
9612 if (item_tag_array.Get(i) == tag)
9613 {
9614 found = true;
9615 break;
9616 }
9617 }
9618 return found;
9619 }
9620
9621
9623 {
9624
9625 super.OnRPC(sender, rpc_type,ctx);
9626
9627
9628 switch (rpc_type)
9629 {
9630 #ifndef SERVER
9631 case ERPCs.RPC_SOUND_LOCK_ATTACH:
9632 Param2<bool, string> p = new Param2<bool, string>(false, "");
9633
9635 return;
9636
9637 bool play = p.param1;
9638 string soundSet = p.param2;
9639
9640 if (play)
9641 {
9643 {
9645 {
9647 }
9648 }
9649 else
9650 {
9652 }
9653 }
9654 else
9655 {
9657 }
9658
9659 break;
9660 #endif
9661
9662 }
9663
9665 {
9667 }
9668 }
9669
9670
9671
9672
9674 {
9675 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
9676 return plugin.GetID(
name);
9677 }
9678
9680 {
9681 PluginVariables plugin = PluginVariables.Cast(
GetPlugin(PluginVariables));
9682 return plugin.GetName(id);
9683 }
9684
9687 {
9688
9689
9690 int varFlags;
9691 if (!ctx.
Read(varFlags))
9692 return;
9693
9694 if (varFlags & ItemVariableFlags.FLOAT)
9695 {
9697 }
9698 }
9699
9701 {
9702
9703 super.SerializeNumericalVars(floats_out);
9704
9705
9706
9708 {
9710 }
9711
9713 {
9715 }
9716
9718 {
9720 }
9721
9723 {
9728 }
9729
9731 {
9733 }
9734 }
9735
9737 {
9738
9739 super.DeSerializeNumericalVars(floats);
9740
9741
9742 int index = 0;
9743 int mask = Math.Round(floats.Get(index));
9744
9745 index++;
9746
9748 {
9750 {
9752 }
9753 else
9754 {
9755 float quantity = floats.Get(index);
9757 }
9758 index++;
9759 }
9760
9762 {
9763 float wet = floats.Get(index);
9765 index++;
9766 }
9767
9769 {
9770 int liquidtype = Math.Round(floats.Get(index));
9772 index++;
9773 }
9774
9776 {
9778 index++;
9780 index++;
9782 index++;
9784 index++;
9785 }
9786
9788 {
9789 int cleanness = Math.Round(floats.Get(index));
9791 index++;
9792 }
9793 }
9794
9796 {
9797 super.WriteVarsToCTX(ctx);
9798
9799
9801 {
9803 }
9804
9806 {
9808 }
9809
9811 {
9813 }
9814
9816 {
9817 int r,g,b,a;
9823 }
9824
9826 {
9828 }
9829 }
9830
9832 {
9833 if (!super.ReadVarsFromCTX(ctx,version))
9834 return false;
9835
9836 int intValue;
9837 float value;
9838
9839 if (version < 140)
9840 {
9841 if (!ctx.
Read(intValue))
9842 return false;
9843
9844 m_VariablesMask = intValue;
9845 }
9846
9848 {
9849 if (!ctx.
Read(value))
9850 return false;
9851
9853 {
9855 }
9856 else
9857 {
9859 }
9860 }
9861
9862 if (version < 140)
9863 {
9865 {
9866 if (!ctx.
Read(value))
9867 return false;
9868 SetTemperatureDirect(value);
9869 }
9870 }
9871
9873 {
9874 if (!ctx.
Read(value))
9875 return false;
9877 }
9878
9880 {
9881 if (!ctx.
Read(intValue))
9882 return false;
9884 }
9885
9887 {
9888 int r,g,b,a;
9890 return false;
9892 return false;
9894 return false;
9896 return false;
9897
9899 }
9900
9902 {
9903 if (!ctx.
Read(intValue))
9904 return false;
9906 }
9907
9908 if (version >= 138 && version < 140)
9909 {
9911 {
9912 if (!ctx.
Read(intValue))
9913 return false;
9914 SetFrozen(intValue);
9915 }
9916 }
9917
9918 return true;
9919 }
9920
9921
9923 {
9926 {
9928 }
9929
9930 if (!super.OnStoreLoad(ctx, version))
9931 {
9933 return false;
9934 }
9935
9936 if (version >= 114)
9937 {
9938 bool hasQuickBarIndexSaved;
9939
9940 if (!ctx.
Read(hasQuickBarIndexSaved))
9941 {
9943 return false;
9944 }
9945
9946 if (hasQuickBarIndexSaved)
9947 {
9948 int itmQBIndex;
9949
9950
9951 if (!ctx.
Read(itmQBIndex))
9952 {
9954 return false;
9955 }
9956
9957 PlayerBase parentPlayer = PlayerBase.Cast(GetHierarchyRootPlayer());
9958 if (itmQBIndex != -1 && parentPlayer)
9959 parentPlayer.SetLoadedQuickBarItemBind(this, itmQBIndex);
9960 }
9961 }
9962 else
9963 {
9964
9965 PlayerBase player;
9966 int itemQBIndex;
9967 if (version ==
int.
MAX)
9968 {
9969 if (!ctx.
Read(itemQBIndex))
9970 {
9972 return false;
9973 }
9974 }
9975 else if (Class.CastTo(player, GetHierarchyRootPlayer()))
9976 {
9977
9978 if (!ctx.
Read(itemQBIndex))
9979 {
9981 return false;
9982 }
9983 if (itemQBIndex != -1 && player)
9984 player.SetLoadedQuickBarItemBind(this,itemQBIndex);
9985 }
9986 }
9987
9988 if (version < 140)
9989 {
9990
9991 if (!LoadVariables(ctx, version))
9992 {
9994 return false;
9995 }
9996 }
9997
9998
10000 {
10002 return false;
10003 }
10004 if (version >= 132)
10005 {
10007 if (raib)
10008 {
10010 {
10012 return false;
10013 }
10014 }
10015 }
10016
10018 return true;
10019 }
10020
10021
10022
10024 {
10025 super.OnStoreSave(ctx);
10026
10027 PlayerBase player;
10028 if (PlayerBase.CastTo(player,GetHierarchyRootPlayer()))
10029 {
10031
10032 int itemQBIndex = -1;
10033 itemQBIndex = player.FindQuickBarEntityIndex(this);
10034 ctx.
Write(itemQBIndex);
10035 }
10036 else
10037 {
10039 }
10040
10042
10044 if (raib)
10045 {
10047 }
10048 }
10049
10050
10052 {
10053 super.AfterStoreLoad();
10054
10056 {
10058 }
10059
10061 {
10064 }
10065 }
10066
10068 {
10069 super.EEOnAfterLoad();
10070
10072 {
10074 }
10075
10078 }
10079
10081 {
10082 return false;
10083 }
10084
10085
10086
10088 {
10090 {
10091 #ifdef PLATFORM_CONSOLE
10092
10094 {
10096 if (menu)
10097 {
10099 }
10100 }
10101 #endif
10102 }
10103
10105 {
10108 }
10109
10111 {
10112 SetWeightDirty();
10114 }
10116 {
10119 }
10120
10122 {
10125 }
10127 {
10130 }
10131
10132 super.OnVariablesSynchronized();
10133 }
10134
10135
10136
10138 override bool SetQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false,
bool allow_client =
false,
bool clamp_to_stack_max =
true)
10139 {
10140 if (!IsServerCheck(allow_client))
10141 return false;
10142
10144 return false;
10145
10148
10149 if (value <= (min + 0.001))
10150 value = min;
10151
10152 if (value == min)
10153 {
10154 if (destroy_config)
10155 {
10156 bool dstr = ConfigGetBool("varQuantityDestroyOnMin");
10157 if (dstr)
10158 {
10160 this.Delete();
10161 return true;
10162 }
10163 }
10164 else if (destroy_forced)
10165 {
10167 this.Delete();
10168 return true;
10169 }
10170
10172 }
10173
10176
10178 {
10180
10181 if (delta)
10183 }
10184
10186
10187 return false;
10188 }
10189
10190
10192 bool AddQuantity(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
10193 {
10195 }
10196
10198 {
10201 }
10202
10204 {
10207 }
10208
10210 override void SetQuantityNormalized(
float value,
bool destroy_config =
true,
bool destroy_forced =
false)
10211 {
10212 float value_clamped = Math.Clamp(value, 0, 1);
10214 SetQuantity(result, destroy_config, destroy_forced);
10215 }
10216
10217
10220 {
10222 }
10223
10225 {
10227 }
10228
10229
10230
10231
10232
10233
10234
10235
10236
10237
10239 {
10240 int slot = -1;
10241 if (GetInventory())
10242 {
10243 InventoryLocation il = new InventoryLocation;
10244 GetInventory().GetCurrentInventoryLocation(il);
10246 }
10247
10249 }
10250
10252 {
10253 float quantity_max = 0;
10254
10256 {
10257 if (attSlotID != -1)
10258 quantity_max = InventorySlots.GetStackMaxForSlotId(attSlotID);
10259
10260 if (quantity_max <= 0)
10262 }
10263
10264 if (quantity_max <= 0)
10266
10267 return quantity_max;
10268 }
10269
10271 {
10273 }
10274
10276 {
10278 }
10279
10280
10282 {
10284 }
10285
10287 {
10289 }
10290
10292 {
10294 }
10295
10296
10298 {
10299
10300 float weightEx = GetWeightEx();
10301 float special = GetInventoryAndCargoWeight();
10302 return weightEx - special;
10303 }
10304
10305
10307 {
10309 }
10310
10312 {
10314 {
10315 #ifdef DEVELOPER
10316 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
10317 {
10318 WeightDebugData data1 = WeightDebug.GetWeightDebug(this);
10320 }
10321 #endif
10322
10323 return GetQuantity() * GetConfigWeightModified();
10324 }
10325 else if (HasEnergyManager())
10326 {
10327 #ifdef DEVELOPER
10328 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
10329 {
10330 WeightDebugData data2 = WeightDebug.GetWeightDebug(this);
10331 data2.
SetCalcDetails(
"TIB2: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " + GetCompEM().
GetEnergy()+
"(energy) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit)");
10332 }
10333 #endif
10334 return super.GetWeightSpecialized(forceRecalc) + (GetCompEM().GetEnergy() * ConfigGetFloat("weightPerQuantityUnit")) + GetConfigWeightModified();
10335 }
10336 else
10337 {
10338 #ifdef DEVELOPER
10339 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
10340 {
10341 WeightDebugData data3 = WeightDebug.GetWeightDebug(this);
10342 data3.
SetCalcDetails(
"TIB3: "+super.GetWeightSpecialized(forceRecalc)+
"(contents weight) + " + GetConfigWeightModifiedDebugText() +
" + " +
GetQuantity()+
"(quantity) * " + ConfigGetFloat(
"weightPerQuantityUnit") +
"(weightPerQuantityUnit))");
10343 }
10344 #endif
10345 return super.GetWeightSpecialized(forceRecalc) + (
GetQuantity() * ConfigGetFloat(
"weightPerQuantityUnit")) + GetConfigWeightModified();
10346 }
10347 }
10348
10351 {
10352 int item_count = 0;
10354
10355 if (GetInventory().GetCargo() != NULL)
10356 {
10357 item_count = GetInventory().GetCargo().GetItemCount();
10358 }
10359
10360 for (int i = 0; i < GetInventory().AttachmentCount(); i++)
10361 {
10362 Class.CastTo(item,GetInventory().GetAttachmentFromIndex(i));
10363 if (item)
10364 item_count += item.GetNumberOfItems();
10365 }
10366 return item_count;
10367 }
10368
10371 {
10372 float weight = 0;
10373 float wetness = 1;
10374 if (include_wetness)
10377 {
10378 weight = wetness * m_ConfigWeight;
10379 }
10381 {
10382 weight = 1;
10383 }
10384 return weight;
10385 }
10386
10387
10388
10390 {
10391 if ((
GetGame().IsServer() || !
GetGame().IsMultiplayer()) && GetInventory())
10392 {
10393 GameInventory inv = GetInventory();
10394 array<EntityAI> items = new array<EntityAI>;
10396 for (int i = 0; i < items.Count(); i++)
10397 {
10399 if (item)
10400 {
10402 }
10403 }
10404 }
10405 }
10406
10407
10408
10409
10411 {
10412 float energy = 0;
10413 if (HasEnergyManager())
10414 {
10415 energy = GetCompEM().GetEnergy();
10416 }
10417 return energy;
10418 }
10419
10420
10422 {
10423 super.OnEnergyConsumed();
10424
10426 }
10427
10429 {
10430 super.OnEnergyAdded();
10431
10433 }
10434
10435
10437 {
10438 if (
GetGame().IsServer() && HasEnergyManager() && GetCompEM().HasConversionOfEnergyToQuantity())
10439 {
10441 {
10442 float energy_0to1 = GetCompEM().GetEnergy0To1();
10444 }
10445 }
10446 }
10447
10448
10450 {
10451 return ConfigGetFloat("heatIsolation");
10452 }
10453
10455 {
10457 }
10458
10460 {
10461 string paramPath =
string.Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Drying %2",
GetType(), pIncrementName);
10462 if (
GetGame().ConfigIsExisting(paramPath))
10464
10465 return 0.0;
10466 }
10467
10469 {
10470 string paramPath =
string.
Format(
"CfgVehicles %1 EnvironmentWetnessIncrements Soaking %2",
GetType(), pIncrementName);
10471 if (
GetGame().ConfigIsExisting(paramPath))
10473
10474 return 0.0;
10475 }
10476
10477 override void SetWet(
float value,
bool allow_client =
false)
10478 {
10479 if (!IsServerCheck(allow_client))
10480 return;
10481
10484
10486
10487 m_VarWet = Math.Clamp(value, min, max);
10488
10490 {
10493 }
10494 }
10495
10496 override void AddWet(
float value)
10497 {
10499 }
10500
10502 {
10504 }
10505
10507 {
10509 }
10510
10512 {
10514 }
10515
10517 {
10519 }
10520
10522 {
10524 }
10525
10526 override void OnWetChanged(
float newVal,
float oldVal)
10527 {
10530 if (newLevel != oldLevel)
10531 {
10533 }
10534 }
10535
10537 {
10538 SetWeightDirty();
10539 }
10540
10542 {
10543 return GetWetLevelInternal(
m_VarWet);
10544 }
10545
10546
10547
10549 {
10551 }
10552
10554 {
10556 }
10557
10559 {
10561 }
10562
10564 {
10566 }
10567
10568
10569
10571 {
10572 if (ConfigIsExisting("itemModelLength"))
10573 {
10574 return ConfigGetFloat("itemModelLength");
10575 }
10576 return 0;
10577 }
10578
10580 {
10581 if (ConfigIsExisting("itemAttachOffset"))
10582 {
10583 return ConfigGetFloat("itemAttachOffset");
10584 }
10585 return 0;
10586 }
10587
10588 override void SetCleanness(
int value,
bool allow_client =
false)
10589 {
10590 if (!IsServerCheck(allow_client))
10591 return;
10592
10594
10596
10599 }
10600
10602 {
10604 }
10605
10607 {
10608 return true;
10609 }
10610
10611
10612
10613
10615 {
10617 }
10618
10620 {
10622 }
10623
10624
10625
10626
10627 override void SetColor(
int r,
int g,
int b,
int a)
10628 {
10634 }
10636 override void GetColor(out
int r,out
int g,out
int b,out
int a)
10637 {
10642 }
10643
10645 {
10647 }
10648
10651 {
10652 int r,g,b,a;
10654 r = r/255;
10655 g = g/255;
10656 b = b/255;
10657 a = a/255;
10658 return MiscGameplayFunctions.GetColorString(r, g, b, a);
10659 }
10660
10661
10662
10663 override void SetLiquidType(
int value,
bool allow_client =
false)
10664 {
10665 if (!IsServerCheck(allow_client))
10666 return;
10667
10672 }
10673
10675 {
10676 return ConfigGetInt("varLiquidTypeInit");
10677 }
10678
10680 {
10682 }
10683
10685 {
10687 SetFrozen(false);
10688 }
10689
10692 {
10693 player.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
10694 }
10695
10696
10699 {
10700 PlayerBase nplayer;
10701 if (PlayerBase.CastTo(nplayer, player))
10702 {
10704
10705 nplayer.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
10706 }
10707 }
10708
10709
10712 {
10713 PlayerBase nplayer;
10714 if (PlayerBase.CastTo(nplayer,player))
10715 {
10716
10717 nplayer.SetEnableQuickBarEntityShortcut(this,false);
10718
10719 }
10720
10721
10722 player.GetHumanInventory().ClearUserReservedLocationForContainer(this);
10723
10724
10725 if (HasEnergyManager())
10726 {
10727 GetCompEM().UpdatePlugState();
10728 }
10729 }
10730
10731
10733 {
10734 super.OnPlacementStarted(player);
10735
10737 }
10738
10739 override void OnPlacementComplete(Man player, vector position =
"0 0 0", vector orientation =
"0 0 0")
10740 {
10742 {
10743 m_AdminLog.OnPlacementComplete(player,
this);
10744 }
10745
10746 super.OnPlacementComplete(player, position, orientation);
10747 }
10748
10749
10750
10751
10752
10754 {
10756 {
10757 return true;
10758 }
10759 else
10760 {
10761 return false;
10762 }
10763 }
10764
10765
10767 {
10769 {
10771 }
10772 }
10773
10774
10776 {
10778 }
10779
10781 {
10783 }
10784
10785 override void InsertAgent(
int agent,
float count = 1)
10786 {
10787 if (count < 1)
10788 return;
10789
10791 }
10792
10795 {
10797 }
10798
10799
10801 {
10803 }
10804
10805
10806
10807
10808
10809
10810
10811
10812
10813
10814
10815
10816
10817
10818
10819
10820
10821
10822
10823
10824
10825
10826
10827
10828
10829
10830
10831
10832
10833
10834
10835
10836
10837
10838
10839
10840
10841
10842
10843
10844
10845
10847 {
10849 return false;
10850 return true;
10851 }
10852
10854 {
10855
10857 }
10858
10859
10862 {
10863 super.CheckForRoofLimited(timeTresholdMS);
10864
10866 if ((time - m_PreviousRoofTestTime) >= timeTresholdMS)
10867 {
10868 m_PreviousRoofTestTime = time;
10869 SetRoofAbove(MiscGameplayFunctions.IsUnderRoof(this));
10870 }
10871 }
10872
10873
10875 {
10877 {
10878 return 0;
10879 }
10880
10881 if (GetInventory().GetAttachmentSlotsCount() != 0)
10882 {
10883 ItemBase filter =
ItemBase.Cast(FindAttachmentBySlotName(
"GasMaskFilter"));
10884 if (filter)
10885 return filter.GetProtectionLevel(type, false, system);
10886 else
10887 return 0;
10888 }
10889
10890 string subclassPath, entryName;
10891
10892 switch (type)
10893 {
10895 entryName = "biological";
10896 break;
10898 entryName = "chemical";
10899 break;
10900 default:
10901 entryName = "biological";
10902 break;
10903 }
10904
10905 subclassPath =
"CfgVehicles " + this.
GetType() +
" Protection ";
10906
10908 }
10909
10910
10911
10914 {
10915 if (!IsMagazine())
10917
10919 }
10920
10921
10922
10923
10924
10929 {
10930 return true;
10931 }
10932
10934 {
10936 }
10937
10938
10939
10940
10941
10943 {
10944 if (parent)
10945 {
10946 if (parent.IsInherited(DayZInfected))
10947 return true;
10948
10949 if (!parent.IsRuined())
10950 return true;
10951 }
10952
10953 return true;
10954 }
10955
10957 {
10958 if (!super.CanPutAsAttachment(parent))
10959 {
10960 return false;
10961 }
10962
10963 if (!IsRuined() && !parent.IsRuined())
10964 {
10965 return true;
10966 }
10967
10968 return false;
10969 }
10970
10972 {
10973
10974
10975
10976
10977 return super.CanReceiveItemIntoCargo(item);
10978 }
10979
10981 {
10982
10983
10984
10985
10986 GameInventory attachmentInv = attachment.GetInventory();
10988 {
10989 if (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase))
10990 return false;
10991 }
10992
10993 InventoryLocation loc = new InventoryLocation();
10994 attachment.GetInventory().GetCurrentInventoryLocation(loc);
10995 if (loc && loc.
IsValid() && !GetInventory().AreChildrenAccessible())
10996 return false;
10997
10998 return super.CanReceiveAttachment(attachment, slotId);
10999 }
11000
11002 {
11003 if (!super.CanReleaseAttachment(attachment))
11004 return false;
11005
11006 return GetInventory().AreChildrenAccessible();
11007 }
11008
11009
11010
11011
11012
11013
11014
11015
11016
11017
11018
11019
11020
11021
11022
11023
11024
11025
11026
11027
11028
11030 {
11031 int id = muzzle_owner.GetMuzzleID();
11032 array<ref WeaponParticlesOnFire> WPOF_array =
m_OnFireEffect.Get(
id);
11033
11034 if (WPOF_array)
11035 {
11036 for (int i = 0; i < WPOF_array.Count(); i++)
11037 {
11038 WeaponParticlesOnFire WPOF = WPOF_array.Get(i);
11039
11040 if (WPOF)
11041 {
11042 WPOF.OnActivate(weapon, muzzle_index, ammoType, muzzle_owner, suppressor, config_to_search);
11043 }
11044 }
11045 }
11046 }
11047
11048
11050 {
11051 int id = muzzle_owner.GetMuzzleID();
11053
11054 if (WPOBE_array)
11055 {
11056 for (int i = 0; i < WPOBE_array.Count(); i++)
11057 {
11058 WeaponParticlesOnBulletCasingEject WPOBE = WPOBE_array.Get(i);
11059
11060 if (WPOBE)
11061 {
11062 WPOBE.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
11063 }
11064 }
11065 }
11066 }
11067
11068
11070 {
11071 int id = muzzle_owner.GetMuzzleID();
11072 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
11073
11074 if (WPOOH_array)
11075 {
11076 for (int i = 0; i < WPOOH_array.Count(); i++)
11077 {
11078 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
11079
11080 if (WPOOH)
11081 {
11082 WPOOH.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
11083 }
11084 }
11085 }
11086 }
11087
11088
11090 {
11091 int id = muzzle_owner.GetMuzzleID();
11092 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
11093
11094 if (WPOOH_array)
11095 {
11096 for (int i = 0; i < WPOOH_array.Count(); i++)
11097 {
11098 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
11099
11100 if (WPOOH)
11101 {
11102 WPOOH.OnUpdate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
11103 }
11104 }
11105 }
11106 }
11107
11108
11110 {
11111 int id = muzzle_owner.GetMuzzleID();
11112 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
11113
11114 if (WPOOH_array)
11115 {
11116 for (int i = 0; i < WPOOH_array.Count(); i++)
11117 {
11118 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
11119
11120 if (WPOOH)
11121 {
11122 WPOOH.OnDeactivate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
11123 }
11124 }
11125 }
11126 }
11127
11128
11129
11131 {
11133 {
11134 return true;
11135 }
11136
11137 return false;
11138 }
11139
11141 {
11143 {
11144 return true;
11145 }
11146
11147 return false;
11148 }
11149
11151 {
11153 {
11154 return true;
11155 }
11156
11157 return false;
11158 }
11159
11161 {
11162 return false;
11163 }
11164
11167 {
11168 return UATimeSpent.DEFAULT_DEPLOY;
11169 }
11170
11171
11172
11173
11175 {
11177 SetSynchDirty();
11178 }
11179
11181 {
11183 }
11184
11185
11187 {
11188 return false;
11189 }
11190
11193 {
11194 string att_type = "None";
11195
11196 if (ConfigIsExisting("soundAttType"))
11197 {
11198 att_type = ConfigGetString("soundAttType");
11199 }
11200
11202 }
11203
11205 {
11207 }
11208
11209
11210
11211
11212
11218
11220 {
11223
11225 }
11226
11227
11229 {
11231 return;
11232
11234
11237
11240
11241 SoundParameters params = new SoundParameters();
11245 }
11246
11247
11249 {
11251 return;
11252
11254 SetSynchDirty();
11255
11258 }
11259
11260
11262 {
11264 return;
11265
11267 SetSynchDirty();
11268
11271 }
11272
11274 {
11276 }
11277
11279 {
11281 }
11282
11285 {
11286 if (!
GetGame().IsDedicatedServer())
11287 {
11288 if (ConfigIsExisting("attachSoundSet"))
11289 {
11290 string cfg_path = "";
11291 string soundset = "";
11292 string type_name =
GetType();
11293
11296 ConfigGetTextArray("attachSoundSet",cfg_soundset_array);
11297 ConfigGetTextArray("attachSoundSlot",cfg_slot_array);
11298
11299 if (cfg_soundset_array.Count() > 0 && cfg_soundset_array.Count() == cfg_slot_array.Count())
11300 {
11301 for (int i = 0; i < cfg_soundset_array.Count(); i++)
11302 {
11303 if (cfg_slot_array[i] == slot_type)
11304 {
11305 soundset = cfg_soundset_array[i];
11306 break;
11307 }
11308 }
11309 }
11310
11311 if (soundset != "")
11312 {
11313 EffectSound sound = SEffectManager.PlaySound(soundset,
GetPosition());
11315 }
11316 }
11317 }
11318 }
11319
11321 {
11322
11323 }
11324
11325 void OnApply(PlayerBase player);
11326
11328 {
11329 return 1.0;
11330 };
11331
11333 {
11335 }
11336
11338 {
11340 }
11341
11343
11345 {
11346 SetDynamicPhysicsLifeTime(0.01);
11348 }
11349
11351 {
11352 array<string> zone_names = new array<string>;
11353 GetDamageZones(zone_names);
11354 for (int i = 0; i < zone_names.Count(); i++)
11355 {
11356 SetHealthMax(zone_names.Get(i),"Health");
11357 }
11358 SetHealthMax("","Health");
11359 }
11360
11363 {
11364 float global_health = GetHealth01("","Health");
11365 array<string> zones = new array<string>;
11366 GetDamageZones(zones);
11367
11368 for (int i = 0; i < zones.Count(); i++)
11369 {
11370 SetHealth01(zones.Get(i),"Health",global_health);
11371 }
11372 }
11373
11376 {
11377 return IsExclusionFlagPresent(PlayerBase.GetFaceCoverageShaveValues());
11378 }
11379
11381 {
11382 if (!hasRootAsPlayer)
11383 {
11384 if (refParentIB)
11385 {
11386
11387 if ((refParentIB.GetWet() >= GameConstants.STATE_SOAKING_WET) && (
m_VarWet <
m_VarWetMax))
11388 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_INSIDE);
11389
11390 else if ((refParentIB.GetLiquidType() != 0) && (refParentIB.GetQuantity() > 0) && (
m_VarWet <
m_VarWetMax))
11391 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_LIQUID);
11392
11395 }
11396 else
11397 {
11398
11401 }
11402 }
11403 }
11404
11406 {
11408 {
11409 float target =
g_Game.GetMission().GetWorldData().GetBaseEnvTemperatureAtObject(
this);
11410 if (
GetTemperature() != target || !IsFreezeThawProgressFinished())
11411 {
11412 float heatPermCoef = 1.0;
11414 while (ent)
11415 {
11416 heatPermCoef *= ent.GetHeatPermeabilityCoef();
11417 ent = ent.GetHierarchyParent();
11418 }
11419
11420 SetTemperatureEx(
new TemperatureDataInterpolated(target,
ETemperatureAccessTypes.ACCESS_WORLD,delta,GameConstants.TEMP_COEF_WORLD,heatPermCoef));
11421 }
11422 }
11423 }
11424
11426 {
11427
11428 EntityAI parent = GetHierarchyParent();
11429 if (!parent)
11430 {
11431 hasParent = false;
11432 hasRootAsPlayer = false;
11433 }
11434 else
11435 {
11436 hasParent = true;
11437 hasRootAsPlayer = (GetHierarchyRootPlayer() != null);
11438 refParentIB =
ItemBase.Cast(parent);
11439 }
11440 }
11441
11442 protected void ProcessDecay(
float delta,
bool hasRootAsPlayer)
11443 {
11444
11445 }
11446
11448 {
11449
11450 return false;
11451 }
11452
11454 {
11455
11456
11457 return false;
11458 }
11459
11461 {
11462
11463 return false;
11464 }
11465
11468 {
11469 return !GetIsFrozen() &&
IsOpen();
11470 }
11471
11473 {
11474 bool hasParent = false, hasRootAsPlayer = false;
11476
11477 bool wwtu =
g_Game.IsWorldWetTempUpdateEnabled();
11478 bool foodDecay =
g_Game.IsFoodDecayEnabled();
11479
11480 if (wwtu || foodDecay)
11481 {
11485
11486 if (processWetness || processTemperature || processDecay)
11487 {
11489
11490 if (processWetness)
11491 ProcessItemWetness(m_ElapsedSinceLastUpdate, hasParent, hasRootAsPlayer, refParentIB);
11492
11493 if (processTemperature)
11495
11496 if (processDecay)
11497 ProcessDecay(m_ElapsedSinceLastUpdate, hasRootAsPlayer);
11498 }
11499 }
11500 }
11501
11504 {
11506 }
11507
11509 {
11512
11513 return super.GetTemperatureFreezeThreshold();
11514 }
11515
11517 {
11520
11521 return super.GetTemperatureThawThreshold();
11522 }
11523
11525 {
11528
11529 return super.GetItemOverheatThreshold();
11530 }
11531
11533 {
11535 return Math.Lerp(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureFreezeTime()),
GetQuantityNormalized());
11536
11537 return super.GetTemperatureFreezeTime();
11538 }
11539
11541 {
11543 return Math.Lerp(GameConstants.TEMPERATURE_TIME_THAW_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureThawTime()),
GetQuantityNormalized());
11544
11545 return super.GetTemperatureThawTime();
11546 }
11547
11552
11554 {
11555 return (item.IsKindOf("Cauldron") || item.IsKindOf("Pot") || item.IsKindOf("FryingPan") || item.IsKindOf("SmallProtectorCase") || (item.IsKindOf("PortableGasStove") && item.FindAttachmentBySlotName("CookingEquipment")));
11556 }
11557
11559 {
11560 MiscGameplayFunctions.TransferItemProperties(oldItem, this);
11561 }
11562
11565 {
11567 }
11568
11570 {
11572 }
11573
11575 {
11577 }
11578
11581 {
11582 return null;
11583 }
11584
11587 {
11588 return false;
11589 }
11590
11592 {
11594 {
11597 if (!trg)
11598 {
11600 explosive = this;
11601 }
11602
11603 explosive.PairRemote(trg);
11605
11606 int persistentID = RemotelyActivatedItemBehaviour.GeneratePersistentID();
11607 trg.SetPersistentPairID(persistentID);
11608 explosive.SetPersistentPairID(persistentID);
11609
11610 return true;
11611 }
11612 return false;
11613 }
11614
11617 {
11618 float ret = 1.0;
11621 ret *= GetHealth01();
11622
11623 return ret;
11624 }
11625
11626 #ifdef DEVELOPER
11627 override void SetDebugItem()
11628 {
11629 super.SetDebugItem();
11630 _itemBase = this;
11631 }
11632
11634 {
11635 string text = super.GetDebugText();
11636
11638 text +=
string.
Format(
"Heat isolation(modified): %1\n", MiscGameplayFunctions.GetCurrentItemHeatIsolation(
this));
11639
11640 return text;
11641 }
11642 #endif
11643
11645 {
11646 return true;
11647 }
11648
11650
11652
11654 {
11657 }
11658
11659
11667
11683}
11684
11686{
11688 if (entity)
11689 {
11690 bool is_item = entity.IsInherited(
ItemBase);
11691 if (is_item && full_quantity)
11692 {
11695 }
11696 }
11697 else
11698 {
11700 return NULL;
11701 }
11702 return entity;
11703}
11704
11706{
11707 if (item)
11708 {
11709 if (health > 0)
11710 item.SetHealth("", "", health);
11711
11712 if (item.CanHaveTemperature())
11713 {
11715 if (item.CanFreeze())
11716 item.SetFrozen(false);
11717 }
11718
11719 if (item.HasEnergyManager())
11720 {
11721 if (quantity >= 0)
11722 {
11723 item.GetCompEM().SetEnergy0To1(quantity);
11724 }
11725 else
11726 {
11728 }
11729 }
11730 else if (item.IsMagazine())
11731 {
11732 Magazine mag = Magazine.Cast(item);
11733 if (quantity >= 0)
11734 {
11735 mag.ServerSetAmmoCount(mag.GetAmmoMax() * quantity);
11736 }
11737 else
11738 {
11740 }
11741
11742 }
11743 else
11744 {
11745 if (quantity >= 0)
11746 {
11747 item.SetQuantityNormalized(quantity, false);
11748 }
11749 else
11750 {
11752 }
11753
11754 }
11755 }
11756}
11757
11758#ifdef DEVELOPER
11760#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.