DayZ 1.28
DayZ Explorer by KGB
 
Загрузка...
Поиск...
Не найдено

◆ GetColor()

override void SpawnItemOnLocation::GetColor ( out int r,
out int g,
out int b,
out int a )
protected

gets item's color variable as components

См. определение в файле ItemBase.c строка 8646

8650{
8651 override bool CanPutAsAttachment(EntityAI parent)
8652 {
8653 return true;
8654 }
8655};
8656
8657//const bool QUANTITY_DEBUG_REMOVE_ME = false;
8658
8659class ItemBase extends InventoryItem
8660{
8664
8666
8667 static int m_DebugActionsMask;
8669 // ============================================
8670 // Variable Manipulation System
8671 // ============================================
8672 // Quantity
8673
8674 float m_VarQuantity;
8675 float m_VarQuantityPrev;//for client to know quantity changed during synchronization
8677 int m_VarQuantityMin;
8678 int m_VarQuantityMax;
8679 int m_Count;
8680 float m_VarStackMax;
8681 float m_StoreLoadedQuantity = float.LOWEST;
8682 // Wet
8683 float m_VarWet;
8684 float m_VarWetPrev;//for client to know wetness changed during synchronization
8685 float m_VarWetInit;
8686 float m_VarWetMin;
8687 float m_VarWetMax;
8688 // Cleanness
8689 int m_Cleanness;
8690 int m_CleannessInit;
8691 int m_CleannessMin;
8692 int m_CleannessMax;
8693 // impact sounds
8695 bool m_CanPlayImpactSound = true;
8696 float m_ImpactSpeed;
8698 //
8699 float m_HeatIsolation;
8700 float m_ItemModelLength;
8701 float m_ItemAttachOffset; // Offset length for when the item is attached e.g. to weapon
8703 int m_VarLiquidType;
8704 int m_ItemBehaviour; // -1 = not specified; 0 = heavy item; 1= onehanded item; 2 = twohanded item
8705 int m_QuickBarBonus;
8706 bool m_IsBeingPlaced;
8707 bool m_IsHologram;
8708 bool m_IsTakeable;
8709 bool m_ThrowItemOnDrop;
8712 bool m_FixDamageSystemInit = false; //can be changed on storage version check
8713 bool can_this_be_combined; //Check if item can be combined
8714 bool m_CanThisBeSplit; //Check if item can be split
8715 bool m_IsStoreLoad = false;
8716 bool m_CanShowQuantity;
8717 bool m_HasQuantityBar;
8718 protected bool m_CanBeDigged;
8719 protected bool m_IsResultOfSplit
8720
8721 string m_SoundAttType;
8722 // items color variables
8727 //-------------------------------------------------------
8728
8729 // light source managing
8731
8735
8736 //==============================================
8737 // agent system
8738 private int m_AttachedAgents;
8739
8741 void TransferModifiers(PlayerBase reciever);
8742
8743
8744 // Weapons & suppressors particle effects
8749 static int m_LastRegisteredWeaponID = 0;
8750
8751 // Overheating effects
8753 float m_OverheatingShots;
8754 ref Timer m_CheckOverheating;
8755 int m_ShotsToStartOverheating = 0; // After these many shots, the overheating effect begins
8756 int m_MaxOverheatingValue = 0; // Limits the number of shots that will be tracked
8757 float m_OverheatingDecayInterval = 1; // Timer's interval for decrementing overheat effect's lifespan
8758 ref array <ref OverheatingParticle> m_OverheatingParticles;
8759
8761 protected bool m_HideSelectionsBySlot;
8762
8763 // Admin Log
8764 PluginAdminLog m_AdminLog;
8765
8766 // misc
8767 ref Timer m_PhysDropTimer;
8768
8769 // Attachment Locking variables
8770 ref array<int> m_CompatibleLocks;
8771 protected int m_LockType;
8772 protected ref EffectSound m_LockingSound;
8773 protected string m_LockSoundSet;
8774
8775 // ItemSoundHandler
8776 protected const int ITEM_SOUNDS_MAX = 63; // optimize network synch
8777 protected int m_SoundSyncPlay; // id for sound to play
8778 protected int m_SoundSyncStop; // id for sound to stop
8780
8781 //temperature
8782 private float m_TemperaturePerQuantityWeight;
8783
8784 // -------------------------------------------------------------------------
8785 void ItemBase()
8786 {
8787 SetEventMask(EntityEvent.INIT); // Enable EOnInit event
8791
8792 if (!GetGame().IsDedicatedServer())
8793 {
8794 if (HasMuzzle())
8795 {
8797
8799 {
8801 }
8802 }
8803
8805 m_ActionsInitialize = false;
8806 }
8807
8808 m_OldLocation = null;
8809
8810 if (GetGame().IsServer())
8811 {
8812 m_AdminLog = PluginAdminLog.Cast(GetPlugin(PluginAdminLog));
8813 }
8814
8815 if (ConfigIsExisting("headSelectionsToHide"))
8816 {
8818 ConfigGetTextArray("headSelectionsToHide",m_HeadHidingSelections);
8819 }
8820
8821 m_HideSelectionsBySlot = false;
8822 if (ConfigIsExisting("hideSelectionsByinventorySlot"))
8823 {
8824 m_HideSelectionsBySlot = ConfigGetBool("hideSelectionsByinventorySlot");
8825 }
8826
8827 m_QuickBarBonus = Math.Max(0, ConfigGetInt("quickBarBonus"));
8828
8829 m_IsResultOfSplit = false;
8830
8832 }
8833
8834 override void InitItemVariables()
8835 {
8836 super.InitItemVariables();
8837
8838 m_VarQuantityInit = ConfigGetInt("varQuantityInit");
8839 m_VarQuantity = m_VarQuantityInit;//should be by the CE, this is just a precaution
8840 m_VarQuantityMin = ConfigGetInt("varQuantityMin");
8841 m_VarQuantityMax = ConfigGetInt("varQuantityMax");
8842 m_VarStackMax = ConfigGetFloat("varStackMax");
8843 m_Count = ConfigGetInt("count");
8844
8845 m_CanShowQuantity = ConfigGetBool("quantityShow");
8846 m_HasQuantityBar = ConfigGetBool("quantityBar");
8847
8848 m_CleannessInit = ConfigGetInt("varCleannessInit");
8850 m_CleannessMin = ConfigGetInt("varCleannessMin");
8851 m_CleannessMax = ConfigGetInt("varCleannessMax");
8852
8853 m_WantPlayImpactSound = false;
8854 m_ImpactSpeed = 0.0;
8855
8856 m_VarWetInit = ConfigGetFloat("varWetInit");
8858 m_VarWetMin = ConfigGetFloat("varWetMin");
8859 m_VarWetMax = ConfigGetFloat("varWetMax");
8860
8861 m_LiquidContainerMask = ConfigGetInt("liquidContainerType");
8862 if (IsLiquidContainer() && GetQuantity() != 0)
8864 m_IsBeingPlaced = false;
8865 m_IsHologram = false;
8866 m_IsTakeable = true;
8867 m_CanBeMovedOverride = false;
8871 m_CanBeDigged = ConfigGetBool("canBeDigged");
8872
8873 m_CompatibleLocks = new array<int>();
8874 ConfigGetIntArray("compatibleLocks", m_CompatibleLocks);
8875 m_LockType = ConfigGetInt("lockType");
8876
8877 //Define if item can be split and set ability to be combined accordingly
8878 m_CanThisBeSplit = false;
8879 can_this_be_combined = false;
8880 if (ConfigIsExisting("canBeSplit"))
8881 {
8882 can_this_be_combined = ConfigGetBool("canBeSplit");
8884 }
8885
8886 m_ItemBehaviour = -1;
8887 if (ConfigIsExisting("itemBehaviour"))
8888 m_ItemBehaviour = ConfigGetInt("itemBehaviour");
8889
8890 //RegisterNetSyncVariableInt("m_VariablesMask");
8891 if (HasQuantity()) RegisterNetSyncVariableFloat("m_VarQuantity", GetQuantityMin(), m_VarQuantityMax);
8892 RegisterNetSyncVariableFloat("m_VarWet", GetWetMin(), GetWetMax(), 2);
8893 RegisterNetSyncVariableInt("m_VarLiquidType");
8894 RegisterNetSyncVariableInt("m_Cleanness",0,1);
8895
8896 RegisterNetSyncVariableBoolSignal("m_WantPlayImpactSound");
8897 RegisterNetSyncVariableFloat("m_ImpactSpeed");
8898 RegisterNetSyncVariableInt("m_ImpactSoundSurfaceHash");
8899
8900 RegisterNetSyncVariableInt("m_ColorComponentR", 0, 255);
8901 RegisterNetSyncVariableInt("m_ColorComponentG", 0, 255);
8902 RegisterNetSyncVariableInt("m_ColorComponentB", 0, 255);
8903 RegisterNetSyncVariableInt("m_ColorComponentA", 0, 255);
8904
8905 RegisterNetSyncVariableBool("m_IsBeingPlaced");
8906 RegisterNetSyncVariableBool("m_IsTakeable");
8907 RegisterNetSyncVariableBool("m_IsHologram");
8908
8909 InitItemSounds();
8911 {
8912 RegisterNetSyncVariableInt("m_SoundSyncPlay", 0, ITEM_SOUNDS_MAX);
8913 RegisterNetSyncVariableInt("m_SoundSyncStop", 0, ITEM_SOUNDS_MAX);
8914 }
8915
8916 m_LockSoundSet = ConfigGetString("lockSoundSet");
8917
8919 if (ConfigIsExisting("temperaturePerQuantityWeight"))
8920 m_TemperaturePerQuantityWeight = ConfigGetFloat("temperaturePerQuantityWeight");
8921
8922 }
8923
8924 override int GetQuickBarBonus()
8925 {
8926 return m_QuickBarBonus;
8927 }
8928
8929 void InitializeActions()
8930 {
8932 if (!m_InputActionMap)
8933 {
8935 m_InputActionMap = iam;
8936 SetActions();
8938 }
8939 }
8940
8941 override void GetActions(typename action_input_type, out array<ActionBase_Basic> actions)
8942 {
8944 {
8945 m_ActionsInitialize = true;
8947 }
8948
8949 actions = m_InputActionMap.Get(action_input_type);
8950 }
8951
8952 void SetActions()
8953 {
8954 AddAction(ActionTakeItem);
8955 AddAction(ActionTakeItemToHands);
8956 AddAction(ActionWorldCraft);
8958 AddAction(ActionAttachWithSwitch);
8959 }
8960
8961 void SetActionAnimOverrides(); // Override action animation for specific item
8962
8963 void AddAction(typename actionName)
8964 {
8965 ActionBase action = ActionManagerBase.GetAction(actionName);
8966
8967 if (!action)
8968 {
8969 Debug.LogError("Action " + actionName + " dosn't exist!");
8970 return;
8971 }
8972
8973 typename ai = action.GetInputType();
8974 if (!ai)
8975 {
8976 m_ActionsInitialize = false;
8977 return;
8978 }
8979
8980 array<ActionBase_Basic> action_array = m_InputActionMap.Get(ai);
8981 if (!action_array)
8982 {
8983 action_array = new array<ActionBase_Basic>;
8984 m_InputActionMap.Insert(ai, action_array);
8985 }
8986 if (LogManager.IsActionLogEnable())
8987 {
8988 Debug.ActionLog(action.ToString() + " -> " + ai, this.ToString() , "n/a", "Add action");
8989 }
8990
8991 if (action_array.Find(action) != -1)
8992 {
8993 Debug.Log("Action " + action.Type() + " already added to " + this + ", skipping!");
8994 }
8995 else
8996 {
8997 action_array.Insert(action);
8998 }
8999 }
9000
9001 void RemoveAction(typename actionName)
9002 {
9003 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
9004 ActionBase action = player.GetActionManager().GetAction(actionName);
9005 typename ai = action.GetInputType();
9006 array<ActionBase_Basic> action_array = m_InputActionMap.Get(ai);
9007
9008 if (action_array)
9009 {
9010 action_array.RemoveItem(action);
9011 }
9012 }
9013
9014 // Allows override of default action command per item, defined in the SetActionAnimOverrides() of the item's class
9015 // Set -1 for params which should stay in default state
9016 void OverrideActionAnimation(typename action, int commandUID, int stanceMask = -1, int commandUIDProne = -1)
9017 {
9018 ActionOverrideData overrideData = new ActionOverrideData();
9019 overrideData.m_CommandUID = commandUID;
9020 overrideData.m_CommandUIDProne = commandUIDProne;
9021 overrideData.m_StanceMask = stanceMask;
9022
9023 TActionAnimOverrideMap actionMap = m_ItemActionOverrides.Get(action);
9024 if (!actionMap) // create new map of action > overidables map
9025 {
9026 actionMap = new TActionAnimOverrideMap();
9027 m_ItemActionOverrides.Insert(action, actionMap);
9028 }
9029
9030 actionMap.Insert(this.Type(), overrideData); // insert item -> overrides
9031
9032 }
9033
9034 void OnItemInHandsPlayerSwimStart(PlayerBase player);
9035
9036 ScriptedLightBase GetLight();
9037
9038 // Loads muzzle flash particle configuration from config and saves it to a map for faster access
9039 void LoadParticleConfigOnFire(int id)
9040 {
9041 if (!m_OnFireEffect)
9043
9046
9047 string config_to_search = "CfgVehicles";
9048 string muzzle_owner_config;
9049
9050 if (!m_OnFireEffect.Contains(id))
9051 {
9052 if (IsInherited(Weapon))
9053 config_to_search = "CfgWeapons";
9054
9055 muzzle_owner_config = config_to_search + " " + GetType() + " ";
9056
9057 string config_OnFire_class = muzzle_owner_config + "Particles " + "OnFire ";
9058
9059 int config_OnFire_subclass_count = GetGame().ConfigGetChildrenCount(config_OnFire_class);
9060
9061 if (config_OnFire_subclass_count > 0)
9062 {
9063 array<ref WeaponParticlesOnFire> WPOF_array = new array<ref WeaponParticlesOnFire>;
9064
9065 for (int i = 0; i < config_OnFire_subclass_count; i++)
9066 {
9067 string particle_class = "";
9068 GetGame().ConfigGetChildName(config_OnFire_class, i, particle_class);
9069 string config_OnFire_entry = config_OnFire_class + particle_class;
9070 WeaponParticlesOnFire WPOF = new WeaponParticlesOnFire(this, config_OnFire_entry);
9071 WPOF_array.Insert(WPOF);
9072 }
9073
9074
9075 m_OnFireEffect.Insert(id, WPOF_array);
9076 }
9077 }
9078
9079 if (!m_OnBulletCasingEjectEffect.Contains(id))
9080 {
9081 config_to_search = "CfgWeapons"; // Bullet Eject efect is supported on weapons only.
9082 muzzle_owner_config = config_to_search + " " + GetType() + " ";
9083
9084 string config_OnBulletCasingEject_class = muzzle_owner_config + "Particles " + "OnBulletCasingEject ";
9085
9086 int config_OnBulletCasingEject_count = GetGame().ConfigGetChildrenCount(config_OnBulletCasingEject_class);
9087
9088 if (config_OnBulletCasingEject_count > 0 && IsInherited(Weapon))
9089 {
9090 array<ref WeaponParticlesOnBulletCasingEject> WPOBE_array = new array<ref WeaponParticlesOnBulletCasingEject>;
9091
9092 for (i = 0; i < config_OnBulletCasingEject_count; i++)
9093 {
9094 string particle_class2 = "";
9095 GetGame().ConfigGetChildName(config_OnBulletCasingEject_class, i, particle_class2);
9096 string config_OnBulletCasingEject_entry = config_OnBulletCasingEject_class + particle_class2;
9097 WeaponParticlesOnBulletCasingEject WPOBE = new WeaponParticlesOnBulletCasingEject(this, config_OnBulletCasingEject_entry);
9098 WPOBE_array.Insert(WPOBE);
9099 }
9100
9101
9102 m_OnBulletCasingEjectEffect.Insert(id, WPOBE_array);
9103 }
9104 }
9105 }
9106
9107 // Loads muzzle flash particle configuration from config and saves it to a map for faster access
9109 {
9112
9113 if (!m_OnOverheatingEffect.Contains(id))
9114 {
9115 string config_to_search = "CfgVehicles";
9116
9117 if (IsInherited(Weapon))
9118 config_to_search = "CfgWeapons";
9119
9120 string muzzle_owner_config = config_to_search + " " + GetType() + " ";
9121 string config_OnOverheating_class = muzzle_owner_config + "Particles " + "OnOverheating ";
9122
9123 if (GetGame().ConfigIsExisting(config_OnOverheating_class))
9124 {
9125
9126 m_ShotsToStartOverheating = GetGame().ConfigGetFloat(config_OnOverheating_class + "shotsToStartOverheating");
9127
9129 {
9130 m_ShotsToStartOverheating = -1; // This prevents futher readings from config for future creations of this item
9131 string error = "Error reading config " + GetType() + ">Particles>OnOverheating - Parameter shotsToStartOverheating is configured wrong or is missing! Its value must be 1 or higher!";
9132 Error(error);
9133 return;
9134 }
9135
9136 m_OverheatingDecayInterval = GetGame().ConfigGetFloat(config_OnOverheating_class + "overheatingDecayInterval");
9137 m_MaxOverheatingValue = GetGame().ConfigGetFloat(config_OnOverheating_class + "maxOverheatingValue");
9138
9139
9140
9141 int config_OnOverheating_subclass_count = GetGame().ConfigGetChildrenCount(config_OnOverheating_class);
9142 array<ref WeaponParticlesOnOverheating> WPOOH_array = new array<ref WeaponParticlesOnOverheating>;
9143
9144 for (int i = 0; i < config_OnOverheating_subclass_count; i++)
9145 {
9146 string particle_class = "";
9147 GetGame().ConfigGetChildName(config_OnOverheating_class, i, particle_class);
9148 string config_OnOverheating_entry = config_OnOverheating_class + particle_class;
9149 int entry_type = GetGame().ConfigGetType(config_OnOverheating_entry);
9150
9151 if (entry_type == CT_CLASS)
9152 {
9153 WeaponParticlesOnOverheating WPOF = new WeaponParticlesOnOverheating(this, config_OnOverheating_entry);
9154 WPOOH_array.Insert(WPOF);
9155 }
9156 }
9157
9158
9159 m_OnOverheatingEffect.Insert(id, WPOOH_array);
9160 }
9161 }
9162 }
9163
9164 float GetOverheatingValue()
9165 {
9166 return m_OverheatingShots;
9167 }
9168
9169 void IncreaseOverheating(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
9170 {
9171 if (m_MaxOverheatingValue > 0)
9172 {
9174
9175 if (!m_CheckOverheating)
9177
9179 m_CheckOverheating.Run(m_OverheatingDecayInterval, this, "OnOverheatingDecay");
9180
9181 CheckOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9182 }
9183 }
9184
9185 void CheckOverheating(ItemBase weapon = null, string ammoType = "", ItemBase muzzle_owner = null, ItemBase suppressor = null, string config_to_search = "")
9186 {
9188 UpdateOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9189
9191 StartOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9192
9194 StopOverheating(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9195
9197 {
9199 }
9200 }
9201
9203 {
9205 }
9206
9207 void OnOverheatingDecay()
9208 {
9209 if (m_MaxOverheatingValue > 0)
9210 m_OverheatingShots -= 1 + m_OverheatingShots / m_MaxOverheatingValue; // The hotter a barrel is, the faster it needs to cool down.
9211 else
9213
9214 if (m_OverheatingShots <= 0)
9215 {
9218 }
9219 else
9220 {
9221 if (!m_CheckOverheating)
9223
9225 m_CheckOverheating.Run(m_OverheatingDecayInterval, this, "OnOverheatingDecay");
9226 }
9227
9228 CheckOverheating(this, "", this);
9229 }
9230
9231 void StartOverheating(ItemBase weapon = null, string ammoType = "", ItemBase muzzle_owner = null, ItemBase suppressor = null, string config_to_search = "")
9232 {
9234 ItemBase.PlayOverheatingParticles(this, ammoType, this, suppressor, "CfgWeapons");
9235 }
9236
9237 void UpdateOverheating(ItemBase weapon = null, string ammoType = "", ItemBase muzzle_owner = null, ItemBase suppressor = null, string config_to_search = "")
9238 {
9240 ItemBase.UpdateOverheatingParticles(this, ammoType, this, suppressor, "CfgWeapons");
9242 }
9243
9244 void StopOverheating(ItemBase weapon = null, string ammoType = "", ItemBase muzzle_owner = null, ItemBase suppressor = null, string config_to_search = "")
9245 {
9247 ItemBase.StopOverheatingParticles(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
9248 }
9249
9250 void RegisterOverheatingParticle(Particle p, float min_heat_coef, float max_heat_coef, int particle_id, Object parent, vector local_pos, vector local_ori)
9251 {
9253 m_OverheatingParticles = new array<ref OverheatingParticle>;
9254
9255 OverheatingParticle OP = new OverheatingParticle();
9256 OP.RegisterParticle(p);
9257 OP.SetOverheatingLimitMin(min_heat_coef);
9258 OP.SetOverheatingLimitMax(max_heat_coef);
9259 OP.SetParticleParams(particle_id, parent, local_pos, local_ori);
9260
9261 m_OverheatingParticles.Insert(OP);
9262 }
9263
9264 float GetOverheatingCoef()
9265 {
9266 if (m_MaxOverheatingValue > 0)
9268
9269 return -1;
9270 }
9271
9273 {
9275 {
9276 float overheat_coef = GetOverheatingCoef();
9277 int count = m_OverheatingParticles.Count();
9278
9279 for (int i = count; i > 0; --i)
9280 {
9281 int id = i - 1;
9282 OverheatingParticle OP = m_OverheatingParticles.Get(id);
9283 Particle p = OP.GetParticle();
9284
9285 float overheat_min = OP.GetOverheatingLimitMin();
9286 float overheat_max = OP.GetOverheatingLimitMax();
9287
9288 if (overheat_coef < overheat_min && overheat_coef >= overheat_max)
9289 {
9290 if (p)
9291 {
9292 p.Stop();
9293 OP.RegisterParticle(null);
9294 }
9295 }
9296 }
9297 }
9298 }
9299
9301 {
9303 {
9304 for (int i = m_OverheatingParticles.Count(); i > 0; i--)
9305 {
9306 int id = i - 1;
9307 OverheatingParticle OP = m_OverheatingParticles.Get(id);
9308
9309 if (OP)
9310 {
9311 Particle p = OP.GetParticle();
9312
9313 if (p)
9314 {
9315 p.Stop();
9316 }
9317
9318 delete OP;
9319 }
9320 }
9321
9322 m_OverheatingParticles.Clear();
9324 }
9325 }
9326
9328 float GetInfectionChance(int system = 0, Param param = null)
9329 {
9330 return 0.0;
9331 }
9332
9333
9334 float GetDisinfectQuantity(int system = 0, Param param1 = null)
9335 {
9336 return 250;//default value
9337 }
9338
9339 float GetFilterDamageRatio()
9340 {
9341 return 0;
9342 }
9343
9345 bool HasMuzzle()
9346 {
9347 if (IsInherited(Weapon) || IsInherited(SuppressorBase))
9348 return true;
9349
9350 return false;
9351 }
9352
9354 int GetMuzzleID()
9355 {
9356 if (!m_WeaponTypeToID)
9358
9359 if (m_WeaponTypeToID.Contains(GetType()))
9360 {
9361 return m_WeaponTypeToID.Get(GetType());
9362 }
9363 else
9364 {
9365 // Register new weapon ID
9367 }
9368
9370 }
9371
9378 {
9379 return -1;
9380 }
9381
9382
9383
9384 // -------------------------------------------------------------------------
9385 void ~ItemBase()
9386 {
9387 if (GetGame() && GetGame().GetPlayer() && (!GetGame().IsDedicatedServer()))
9388 {
9389 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
9390 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
9391
9392 if (r_index >= 0)
9393 {
9394 InventoryLocation r_il = new InventoryLocation;
9395 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
9396
9397 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
9398 int r_type = r_il.GetType();
9399 if (r_type == InventoryLocationType.CARGO || r_type == InventoryLocationType.PROXYCARGO)
9400 {
9401 r_il.GetParent().GetOnReleaseLock().Invoke(this);
9402 }
9403 else if (r_type == InventoryLocationType.ATTACHMENT)
9404 {
9405 r_il.GetParent().GetOnAttachmentReleaseLock().Invoke(this, r_il.GetSlot());
9406 }
9407
9408 }
9409
9410 player.GetHumanInventory().ClearUserReservedLocation(this);
9411 }
9412
9413 if (m_LockingSound)
9414 SEffectManager.DestroyEffect(m_LockingSound);
9415 }
9416
9417
9418
9419 // -------------------------------------------------------------------------
9420 static int GetDebugActionsMask()
9421 {
9422 return ItemBase.m_DebugActionsMask;
9423 }
9424
9425 static bool HasDebugActionsMask(int mask)
9426 {
9427 return ItemBase.m_DebugActionsMask & mask;
9428 }
9429
9430 static void SetDebugActionsMask(int mask)
9431 {
9432 ItemBase.m_DebugActionsMask = mask;
9433 }
9434
9435 static void AddDebugActionsMask(int mask)
9436 {
9437 ItemBase.m_DebugActionsMask |= mask;
9438 }
9439
9440 static void RemoveDebugActionsMask(int mask)
9441 {
9442 ItemBase.m_DebugActionsMask &= ~mask;
9443 }
9444
9445 static void ToggleDebugActionsMask(int mask)
9446 {
9447 if (HasDebugActionsMask(mask))
9448 {
9450 }
9451 else
9452 {
9453 AddDebugActionsMask(mask);
9454 }
9455 }
9456
9457 // -------------------------------------------------------------------------
9458 void SetCEBasedQuantity()
9459 {
9460 if (GetEconomyProfile())
9461 {
9462 float q_max = GetEconomyProfile().GetQuantityMax();
9463 if (q_max > 0)
9464 {
9465 float q_min = GetEconomyProfile().GetQuantityMin();
9466 float quantity_randomized = Math.RandomFloatInclusive(q_min, q_max);
9467
9468 if (HasComponent(COMP_TYPE_ENERGY_MANAGER))//more direct access for speed
9469 {
9470 ComponentEnergyManager comp = GetCompEM();
9471 if (comp && (comp.GetEnergyMaxPristine() || comp.GetEnergyAtSpawn()))//checking for a potential for energy, we need to check both values, as both are optional, only when both are set to 0, we know the item can't have energy
9472 {
9473 comp.SetEnergy0To1(quantity_randomized);
9474 }
9475 }
9476 else if (HasQuantity())
9477 {
9478 SetQuantityNormalized(quantity_randomized, false);
9479 //PrintString("<==> Normalized quantity for item: "+ GetType()+", qmin:"+q_min.ToString()+"; qmax:"+q_max.ToString()+";quantity:" +quantity_randomized.ToString());
9480 }
9481
9482 }
9483 }
9484 }
9485
9487 void LockToParent()
9488 {
9489 EntityAI parent = GetHierarchyParent();
9490
9491 if (parent)
9492 {
9493 InventoryLocation inventory_location_to_lock = new InventoryLocation;
9494 GetInventory().GetCurrentInventoryLocation(inventory_location_to_lock);
9495 parent.GetInventory().SetSlotLock(inventory_location_to_lock.GetSlot(), true);
9496 }
9497 }
9498
9500 void UnlockFromParent()
9501 {
9502 EntityAI parent = GetHierarchyParent();
9503
9504 if (parent)
9505 {
9506 InventoryLocation inventory_location_to_unlock = new InventoryLocation;
9507 GetInventory().GetCurrentInventoryLocation(inventory_location_to_unlock);
9508 parent.GetInventory().SetSlotLock(inventory_location_to_unlock.GetSlot(), false);
9509 }
9510 }
9511
9512 override void CombineItemsClient(EntityAI entity2, bool use_stack_max = true)
9513 {
9514 /*
9515 ref Param1<EntityAI> item = new Param1<EntityAI>(entity2);
9516 RPCSingleParam(ERPCs.RPC_ITEM_COMBINE, item, GetGame().GetPlayer());
9517 */
9518 ItemBase item2 = ItemBase.Cast(entity2);
9519
9520 if (GetGame().IsClient())
9521 {
9522 if (ScriptInputUserData.CanStoreInputUserData())
9523 {
9524 ScriptInputUserData ctx = new ScriptInputUserData;
9526 ctx.Write(-1);
9527 ItemBase i1 = this; // @NOTE: workaround for correct serialization
9528 ctx.Write(i1);
9529 ctx.Write(item2);
9530 ctx.Write(use_stack_max);
9531 ctx.Write(-1);
9532 ctx.Send();
9533
9534 if (IsCombineAll(item2, use_stack_max))
9535 {
9536 GetGame().GetPlayer().GetInventory().AddInventoryReservationEx(item2,null,GameInventory.c_InventoryReservationTimeoutShortMS);
9537 }
9538 }
9539 }
9540 else if (!GetGame().IsMultiplayer())
9541 {
9542 CombineItems(item2, use_stack_max);
9543 }
9544 }
9545
9546 bool IsLiquidPresent()
9547 {
9548 return (GetLiquidType() != 0 && HasQuantity());
9549 }
9550
9551 bool IsLiquidContainer()
9552 {
9553 return m_LiquidContainerMask != 0;
9554 }
9555
9557 {
9558 return m_LiquidContainerMask;
9559 }
9560
9561 bool IsBloodContainer()
9562 {
9563 //m_LiquidContainerMask & GROUP_LIQUID_BLOOD ???
9564 return false;
9565 }
9566
9567 bool IsNVG()
9568 {
9569 return false;
9570 }
9571
9574 bool IsExplosive()
9575 {
9576 return false;
9577 }
9578
9580 {
9581 return "";
9582 }
9583
9585
9586 bool IsLightSource()
9587 {
9588 return false;
9589 }
9590
9592 {
9593 return true;
9594 }
9595
9596 //--- ACTION CONDITIONS
9597 //direction
9598 bool IsFacingPlayer(PlayerBase player, string selection)
9599 {
9600 return true;
9601 }
9602
9603 bool IsPlayerInside(PlayerBase player, string selection)
9604 {
9605 return true;
9606 }
9607
9608 override bool CanObstruct()
9609 {
9610 PlayerBase player = PlayerBase.Cast(g_Game.GetPlayer());
9611 return !player || !IsPlayerInside(player, "");
9612 }
9613
9614 override bool IsBeingPlaced()
9615 {
9616 return m_IsBeingPlaced;
9617 }
9618
9619 void SetIsBeingPlaced(bool is_being_placed)
9620 {
9621 m_IsBeingPlaced = is_being_placed;
9622 if (!is_being_placed)
9624 SetSynchDirty();
9625 }
9626
9627 //server-side
9628 void OnEndPlacement() {}
9629
9630 override bool IsHologram()
9631 {
9632 return m_IsHologram;
9633 }
9634
9635 bool CanBeDigged()
9636 {
9637 return m_CanBeDigged;
9638 }
9639
9641 {
9642 return 1;
9643 }
9644
9645 bool CanMakeGardenplot()
9646 {
9647 return false;
9648 }
9649
9650 void SetIsHologram(bool is_hologram)
9651 {
9652 m_IsHologram = is_hologram;
9653 SetSynchDirty();
9654 }
9655 /*
9656 protected float GetNutritionalEnergy()
9657 {
9658 Edible_Base edible = Edible_Base.Cast(this);
9659 return edible.GetFoodEnergy();
9660 }
9661
9662 protected float GetNutritionalWaterContent()
9663 {
9664 Edible_Base edible = Edible_Base.Cast(this);
9665 return edible.GetFoodWater();
9666 }
9667
9668 protected float GetNutritionalIndex()
9669 {
9670 Edible_Base edible = Edible_Base.Cast(this);
9671 return edible.GetFoodNutritionalIndex();
9672 }
9673
9674 protected float GetNutritionalFullnessIndex()
9675 {
9676 Edible_Base edible = Edible_Base.Cast(this);
9677 return edible.GetFoodTotalVolume();
9678 }
9679
9680 protected float GetNutritionalToxicity()
9681 {
9682 Edible_Base edible = Edible_Base.Cast(this);
9683 return edible.GetFoodToxicity();
9684
9685 }
9686 */
9687
9688
9689 // -------------------------------------------------------------------------
9690 override void OnMovedInsideCargo(EntityAI container)
9691 {
9692 super.OnMovedInsideCargo(container);
9693
9694 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
9695 }
9696
9697 override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
9698 {
9699 super.EEItemLocationChanged(oldLoc,newLoc);
9700
9701 PlayerBase new_player = null;
9702 PlayerBase old_player = null;
9703
9704 if (newLoc.GetParent())
9705 new_player = PlayerBase.Cast(newLoc.GetParent().GetHierarchyRootPlayer());
9706
9707 if (oldLoc.GetParent())
9708 old_player = PlayerBase.Cast(oldLoc.GetParent().GetHierarchyRootPlayer());
9709
9710 if (old_player && oldLoc.GetType() == InventoryLocationType.HANDS)
9711 {
9712 int r_index = old_player.GetHumanInventory().FindUserReservedLocationIndex(this);
9713
9714 if (r_index >= 0)
9715 {
9716 InventoryLocation r_il = new InventoryLocation;
9717 old_player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
9718
9719 old_player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
9720 int r_type = r_il.GetType();
9721 if (r_type == InventoryLocationType.CARGO || r_type == InventoryLocationType.PROXYCARGO)
9722 {
9723 r_il.GetParent().GetOnReleaseLock().Invoke(this);
9724 }
9725 else if (r_type == InventoryLocationType.ATTACHMENT)
9726 {
9727 r_il.GetParent().GetOnAttachmentReleaseLock().Invoke(this, r_il.GetSlot());
9728 }
9729
9730 }
9731 }
9732
9733 if (newLoc.GetType() == InventoryLocationType.HANDS)
9734 {
9735 if (new_player)
9736 new_player.ForceStandUpForHeavyItems(newLoc.GetItem());
9737
9738 if (new_player == old_player)
9739 {
9740
9741 if (oldLoc.GetParent() && new_player.GetHumanInventory().LocationGetEntity(oldLoc) == NULL)
9742 {
9743 if (oldLoc.GetType() == InventoryLocationType.CARGO)
9744 {
9745 if (oldLoc.GetParent().GetInventory().TestAddEntityInCargoExLoc(oldLoc, false, false, false, true, false, false))
9746 {
9747 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
9748 }
9749 }
9750 else
9751 {
9752 new_player.GetHumanInventory().SetUserReservedLocation(this,oldLoc);
9753 }
9754 }
9755
9756 if (new_player.GetHumanInventory().FindUserReservedLocationIndex(this) >= 0)
9757 {
9758 int type = oldLoc.GetType();
9759 if (type == InventoryLocationType.CARGO || type == InventoryLocationType.PROXYCARGO)
9760 {
9761 oldLoc.GetParent().GetOnSetLock().Invoke(this);
9762 }
9763 else if (type == InventoryLocationType.ATTACHMENT)
9764 {
9765 oldLoc.GetParent().GetOnAttachmentSetLock().Invoke(this, oldLoc.GetSlot());
9766 }
9767 }
9768 if (!m_OldLocation)
9769 {
9770 m_OldLocation = new InventoryLocation;
9771 }
9772 m_OldLocation.Copy(oldLoc);
9773 }
9774 else
9775 {
9776 if (m_OldLocation)
9777 {
9778 m_OldLocation.Reset();
9779 }
9780 }
9781
9783 }
9784 else
9785 {
9786 if (new_player)
9787 {
9788 int res_index = new_player.GetHumanInventory().FindCollidingUserReservedLocationIndex(this, newLoc);
9789 if (res_index >= 0)
9790 {
9791 InventoryLocation il = new InventoryLocation;
9792 new_player.GetHumanInventory().GetUserReservedLocation(res_index,il);
9793 ItemBase it = ItemBase.Cast(il.GetItem());
9794 new_player.GetHumanInventory().ClearUserReservedLocationAtIndex(res_index);
9795 int rel_type = il.GetType();
9796 if (rel_type == InventoryLocationType.CARGO || rel_type == InventoryLocationType.PROXYCARGO)
9797 {
9798 il.GetParent().GetOnReleaseLock().Invoke(it);
9799 }
9800 else if (rel_type == InventoryLocationType.ATTACHMENT)
9801 {
9802 il.GetParent().GetOnAttachmentReleaseLock().Invoke(it, il.GetSlot());
9803 }
9804 //it.GetOnReleaseLock().Invoke(it);
9805 }
9806 }
9807 else if (old_player && newLoc.GetType() == InventoryLocationType.GROUND && m_ThrowItemOnDrop)
9808 {
9809 //ThrowPhysically(old_player, vector.Zero);
9810 m_ThrowItemOnDrop = false;
9811 }
9812
9813 if (m_OldLocation)
9814 {
9815 m_OldLocation.Reset();
9816 }
9817 }
9818 }
9819
9820 override void EOnContact(IEntity other, Contact extra)
9821 {
9823 {
9824 int liquidType = -1;
9825 float impactSpeed = ProcessImpactSoundEx(other, extra, m_ConfigWeight, m_ImpactSoundSurfaceHash, liquidType);
9826 if (impactSpeed > 0.0)
9827 {
9828 m_ImpactSpeed = impactSpeed;
9829 #ifndef SERVER
9830 PlayImpactSound(m_ConfigWeight, m_ImpactSpeed, m_ImpactSoundSurfaceHash);
9831 #else
9832 m_WantPlayImpactSound = true;
9833 SetSynchDirty();
9834 #endif
9835 m_CanPlayImpactSound = (liquidType == -1);// prevents further playing of the sound when the surface is a liquid type
9836 }
9837 }
9838
9839 #ifdef SERVER
9840 if (GetCompEM() && GetCompEM().IsPlugged())
9841 {
9842 if (GetCompEM().GetCordLength() < vector.Distance(GetPosition(), GetCompEM().GetEnergySource().GetPosition()))
9843 GetCompEM().UnplugThis();
9844 }
9845 #endif
9846 }
9847
9848 void RefreshPhysics();
9849
9850 override void OnCreatePhysics()
9851 {
9853 }
9854
9855 override void OnItemAttachmentSlotChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
9856 {
9857
9858 }
9859 // -------------------------------------------------------------------------
9860 override void OnItemLocationChanged(EntityAI old_owner, EntityAI new_owner)
9861 {
9862 super.OnItemLocationChanged(old_owner, new_owner);
9863
9864 PlayerBase relatedPlayer = PlayerBase.Cast(old_owner);
9865 PlayerBase playerNew = PlayerBase.Cast(new_owner);
9866
9867 if (!relatedPlayer && playerNew)
9868 relatedPlayer = playerNew;
9869
9870 if (relatedPlayer && relatedPlayer.GetPerformedActionID() != -1)
9871 {
9872 ActionManagerBase actionMgr = relatedPlayer.GetActionManager();
9873 if (actionMgr)
9874 {
9875 ActionBase currentAction = actionMgr.GetRunningAction();
9876 if (currentAction)
9877 currentAction.OnItemLocationChanged(this);
9878 }
9879 }
9880
9881 Man ownerPlayerOld = null;
9882 Man ownerPlayerNew = null;
9883
9884 if (old_owner)
9885 {
9886 if (old_owner.IsMan())
9887 {
9888 ownerPlayerOld = Man.Cast(old_owner);
9889 }
9890 else
9891 {
9892 ownerPlayerOld = Man.Cast(old_owner.GetHierarchyRootPlayer());
9893 }
9894 }
9895 else
9896 {
9897 if (new_owner && IsElectricAppliance() && GetCompEM() && GetCompEM().IsPlugged())
9898 {
9899 ActionBase action = ActionManagerBase.GetAction(ActionRepositionPluggedItem);
9900
9901 if (!action || !playerNew || playerNew.GetPerformedActionID() != action.GetID())
9902 {
9903 GetCompEM().UnplugThis();
9904 }
9905 }
9906 }
9907
9908 if (new_owner)
9909 {
9910 if (new_owner.IsMan())
9911 {
9912 ownerPlayerNew = Man.Cast(new_owner);
9913 }
9914 else
9915 {
9916 ownerPlayerNew = Man.Cast(new_owner.GetHierarchyRootPlayer());
9917 }
9918 }
9919
9920 if (ownerPlayerOld != ownerPlayerNew)
9921 {
9922 if (ownerPlayerOld)
9923 {
9924 array<EntityAI> subItemsExit = new array<EntityAI>;
9925 GetInventory().EnumerateInventory(InventoryTraversalType.PREORDER,subItemsExit);
9926 for (int i = 0; i < subItemsExit.Count(); i++)
9927 {
9928 ItemBase itemExit = ItemBase.Cast(subItemsExit.Get(i));
9929 itemExit.OnInventoryExit(ownerPlayerOld);
9930 }
9931 }
9932
9933 if (ownerPlayerNew)
9934 {
9935 array<EntityAI> subItemsEnter = new array<EntityAI>;
9936 GetInventory().EnumerateInventory(InventoryTraversalType.PREORDER,subItemsEnter);
9937 for (int j = 0; j < subItemsEnter.Count(); j++)
9938 {
9939 ItemBase itemEnter = ItemBase.Cast(subItemsEnter.Get(j));
9940 itemEnter.OnInventoryEnter(ownerPlayerNew);
9941 }
9942 }
9943 }
9944 else if (ownerPlayerNew != null)
9945 {
9946 PlayerBase nplayer;
9947 if (PlayerBase.CastTo(nplayer, ownerPlayerNew))
9948 {
9949 array<EntityAI> subItemsUpdate = new array<EntityAI>;
9950 GetInventory().EnumerateInventory(InventoryTraversalType.PREORDER,subItemsUpdate);
9951 for (int k = 0; k < subItemsUpdate.Count(); k++)
9952 {
9953 ItemBase itemUpdate = ItemBase.Cast(subItemsUpdate.Get(k));
9954 itemUpdate.UpdateQuickbarShortcutVisibility(nplayer);
9955 }
9956 }
9957 }
9958
9959 if (old_owner)
9960 old_owner.OnChildItemRemoved(this);
9961 if (new_owner)
9962 new_owner.OnChildItemReceived(this);
9963 }
9964
9965 // -------------------------------------------------------------------------------
9966 override void EEDelete(EntityAI parent)
9967 {
9968 super.EEDelete(parent);
9969 PlayerBase player = PlayerBase.Cast(GetHierarchyRootPlayer());
9970 if (player)
9971 {
9972 OnInventoryExit(player);
9973
9974 if (player.IsAlive())
9975 {
9976 int r_index = player.GetHumanInventory().FindUserReservedLocationIndex(this);
9977 if (r_index >= 0)
9978 {
9979 InventoryLocation r_il = new InventoryLocation;
9980 player.GetHumanInventory().GetUserReservedLocation(r_index,r_il);
9981
9982 player.GetHumanInventory().ClearUserReservedLocationAtIndex(r_index);
9983 int r_type = r_il.GetType();
9984 if (r_type == InventoryLocationType.CARGO || r_type == InventoryLocationType.PROXYCARGO)
9985 {
9986 r_il.GetParent().GetOnReleaseLock().Invoke(this);
9987 }
9988 else if (r_type == InventoryLocationType.ATTACHMENT)
9989 {
9990 r_il.GetParent().GetOnAttachmentReleaseLock().Invoke(this, r_il.GetSlot());
9991 }
9992
9993 }
9994
9995 player.RemoveQuickBarEntityShortcut(this);
9996 }
9997 }
9998 }
9999 // -------------------------------------------------------------------------------
10000 override void EEKilled(Object killer)
10001 {
10002 super.EEKilled(killer);
10003
10005 if (killer && killer.IsFireplace() && CanExplodeInFire())
10006 {
10007 if (GetTemperature() >= GameConstants.ITEM_TEMPERATURE_TO_EXPLODE_MIN)
10008 {
10009 if (IsMagazine())
10010 {
10011 if (Magazine.Cast(this).GetAmmoCount() > 0)
10012 {
10013 ExplodeAmmo();
10014 }
10015 }
10016 else
10017 {
10018 Explode(DamageType.EXPLOSION);
10019 }
10020 }
10021 }
10022 }
10023
10024 override void OnWasAttached(EntityAI parent, int slot_id)
10025 {
10026 MiscGameplayFunctions.RemoveAllAttachedChildrenByTypename(this, {Bolt_Base});
10027
10028 super.OnWasAttached(parent, slot_id);
10029
10030 if (HasQuantity())
10031 UpdateNetSyncVariableFloat("m_VarQuantity", GetQuantityMin(), m_VarQuantityMax);
10032
10033 PlayAttachSound(InventorySlots.GetSlotName(slot_id));
10034 }
10035
10036 override void OnWasDetached(EntityAI parent, int slot_id)
10037 {
10038 super.OnWasDetached(parent, slot_id);
10039
10040 if (HasQuantity())
10041 UpdateNetSyncVariableFloat("m_VarQuantity", GetQuantityMin(), m_VarQuantityMax);
10042 }
10043
10044 override string ChangeIntoOnAttach(string slot)
10045 {
10046 int idx;
10047 TStringArray inventory_slots = new TStringArray;
10048 TStringArray attach_types = new TStringArray;
10049
10050 ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
10051 if (inventory_slots.Count() < 1) //is string
10052 {
10053 inventory_slots.Insert(ConfigGetString("ChangeInventorySlot"));
10054 attach_types.Insert(ConfigGetString("ChangeIntoOnAttach"));
10055 }
10056 else //is array
10057 {
10058 ConfigGetTextArray("ChangeIntoOnAttach",attach_types);
10059 }
10060
10061 idx = inventory_slots.Find(slot);
10062 if (idx < 0)
10063 return "";
10064
10065 return attach_types.Get(idx);
10066 }
10067
10068 override string ChangeIntoOnDetach()
10069 {
10070 int idx = -1;
10071 string slot;
10072
10073 TStringArray inventory_slots = new TStringArray;
10074 TStringArray detach_types = new TStringArray;
10075
10076 this.ConfigGetTextArray("ChangeInventorySlot",inventory_slots);
10077 if (inventory_slots.Count() < 1) //is string
10078 {
10079 inventory_slots.Insert(this.ConfigGetString("ChangeInventorySlot"));
10080 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
10081 }
10082 else //is array
10083 {
10084 this.ConfigGetTextArray("ChangeIntoOnDetach",detach_types);
10085 if (detach_types.Count() < 1)
10086 detach_types.Insert(this.ConfigGetString("ChangeIntoOnDetach"));
10087 }
10088
10089 for (int i = 0; i < inventory_slots.Count(); i++)
10090 {
10091 slot = inventory_slots.Get(i);
10092 }
10093
10094 if (slot != "")
10095 {
10096 if (detach_types.Count() == 1)
10097 idx = 0;
10098 else
10099 idx = inventory_slots.Find(slot);
10100 }
10101 if (idx < 0)
10102 return "";
10103
10104 return detach_types.Get(idx);
10105 }
10106
10107 void ExplodeAmmo()
10108 {
10109 //timer
10110 ref Timer explode_timer = new Timer(CALL_CATEGORY_SYSTEM);
10111
10112 //min/max time
10113 float min_time = 1;
10114 float max_time = 3;
10115 float delay = Math.RandomFloat(min_time, max_time);
10116
10117 explode_timer.Run(delay, this, "DoAmmoExplosion");
10118 }
10119
10120 void DoAmmoExplosion()
10121 {
10122 Magazine magazine = Magazine.Cast(this);
10123 int pop_sounds_count = 6;
10124 string pop_sounds[ 6 ] = { "ammopops_1","ammopops_2","ammopops_3","ammopops_4","ammopops_5","ammopops_6" };
10125
10126 //play sound
10127 int sound_idx = Math.RandomInt(0, pop_sounds_count - 1);
10128 string sound_name = pop_sounds[ sound_idx ];
10129 GetGame().CreateSoundOnObject(this, sound_name, 20, false);
10130
10131 //remove ammo count
10132 magazine.ServerAddAmmoCount(-1);
10133
10134 //if condition then repeat -> ExplodeAmmo
10135 float min_temp_to_explode = 100; //min temperature for item to explode
10136
10137 if (magazine.GetAmmoCount() > 0 && GetTemperature() >= min_temp_to_explode) //TODO ? add check for parent -> fireplace
10138 {
10139 ExplodeAmmo();
10140 }
10141 }
10142
10143 // -------------------------------------------------------------------------------
10144 override void EEHitBy(TotalDamageResult damageResult, int damageType, EntityAI source, int component, string dmgZone, string ammo, vector modelPos, float speedCoef)
10145 {
10146 super.EEHitBy(damageResult, damageType, source, component, dmgZone, ammo, modelPos, speedCoef);
10147
10148 const int CHANCE_DAMAGE_CARGO = 4;
10149 const int CHANCE_DAMAGE_ATTACHMENT = 1;
10150 const int CHANCE_DAMAGE_NOTHING = 2;
10151
10152 if (IsClothing() || IsContainer() || IsItemTent())
10153 {
10154 float dmg = damageResult.GetDamage("","Health") * -0.5;
10155 int chances;
10156 int rnd;
10157
10158 if (GetInventory().GetCargo())
10159 {
10160 chances = CHANCE_DAMAGE_CARGO + CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
10161 rnd = Math.RandomInt(0,chances);
10162
10163 if (rnd < CHANCE_DAMAGE_CARGO)
10164 {
10165 DamageItemInCargo(dmg);
10166 }
10167 else if (rnd < (chances - CHANCE_DAMAGE_NOTHING))
10168 {
10170 }
10171 }
10172 else
10173 {
10174 chances = CHANCE_DAMAGE_ATTACHMENT + CHANCE_DAMAGE_NOTHING;
10175 rnd = Math.RandomInt(0,chances);
10176
10177 if (rnd < CHANCE_DAMAGE_ATTACHMENT)
10178 {
10180 }
10181 }
10182 }
10183 }
10184
10185 bool DamageItemInCargo(float damage)
10186 {
10187 if (GetInventory().GetCargo())
10188 {
10189 int item_count = GetInventory().GetCargo().GetItemCount();
10190 if (item_count > 0)
10191 {
10192 int random_pick = Math.RandomInt(0, item_count);
10193 ItemBase item = ItemBase.Cast(GetInventory().GetCargo().GetItem(random_pick));
10194 if (!item.IsExplosive())
10195 {
10196 item.AddHealth("","",damage);
10197 return true;
10198 }
10199 }
10200 }
10201 return false;
10202 }
10203
10204 bool DamageItemAttachments(float damage)
10205 {
10206 int attachment_count = GetInventory().AttachmentCount();
10207 if (attachment_count > 0)
10208 {
10209 int random_pick = Math.RandomInt(0, attachment_count);
10210 ItemBase attachment = ItemBase.Cast(GetInventory().GetAttachmentFromIndex(random_pick));
10211 if (!attachment.IsExplosive())
10212 {
10213 attachment.AddHealth("","",damage);
10214 return true;
10215 }
10216 }
10217 return false;
10218 }
10219
10220 override bool IsSplitable()
10221 {
10222 return m_CanThisBeSplit;
10223 }
10224 //----------------
10225 override bool CanBeSplit()
10226 {
10227 if (IsSplitable() && (GetQuantity() > 1))
10228 return GetInventory().CanRemoveEntity();
10229
10230 return false;
10231 }
10232
10233 protected bool ShouldSplitQuantity(float quantity)
10234 {
10235 // don't call 'CanBeSplit' here, too strict and will introduce a freeze-crash when dismantling fence with a fireplace nearby
10236 if (!IsSplitable())
10237 return false;
10238
10239 // nothing to split?
10240 if (GetQuantity() <= 1)
10241 return false;
10242
10243 // check if we should re-use the item instead of creating a new copy?
10244 // implicit cast to int, if 'IsSplitable' returns true, these values are assumed ints
10245 int delta = GetQuantity() - quantity;
10246 if (delta == 0)
10247 return false;
10248
10249 // valid to split
10250 return true;
10251 }
10252
10253 override void SplitIntoStackMaxClient(EntityAI destination_entity, int slot_id )
10254 {
10255 if (GetGame().IsClient())
10256 {
10257 if (ScriptInputUserData.CanStoreInputUserData())
10258 {
10259 ScriptInputUserData ctx = new ScriptInputUserData;
10261 ctx.Write(1);
10262 ItemBase i1 = this; // @NOTE: workaround for correct serialization
10263 ctx.Write(i1);
10264 ctx.Write(destination_entity);
10265 ctx.Write(true);
10266 ctx.Write(slot_id);
10267 ctx.Send();
10268 }
10269 }
10270 else if (!GetGame().IsMultiplayer())
10271 {
10272 SplitIntoStackMax(destination_entity, slot_id, PlayerBase.Cast(GetGame().GetPlayer()));
10273 }
10274 }
10275
10276 void SplitIntoStackMax(EntityAI destination_entity, int slot_id, PlayerBase player)
10277 {
10278 float split_quantity_new;
10279 ItemBase new_item;
10280 float quantity = GetQuantity();
10281 float stack_max = GetTargetQuantityMax(slot_id);
10282 InventoryLocation loc = new InventoryLocation;
10283
10284 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
10285 {
10286 if (stack_max <= GetQuantity())
10287 split_quantity_new = stack_max;
10288 else
10289 split_quantity_new = GetQuantity();
10290
10291 if (ShouldSplitQuantity(split_quantity_new))
10292 {
10293 new_item = ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(this.GetType(), slot_id));
10294 if (new_item)
10295 {
10296 new_item.SetResultOfSplit(true);
10297 MiscGameplayFunctions.TransferItemProperties(this, new_item);
10298 AddQuantity(-split_quantity_new, false, true);
10299 new_item.SetQuantity(split_quantity_new, false, true);
10300 }
10301 }
10302 }
10303 else if (destination_entity && slot_id == -1)
10304 {
10305 if (quantity > stack_max)
10306 split_quantity_new = stack_max;
10307 else
10308 split_quantity_new = quantity;
10309
10310 if (ShouldSplitQuantity(split_quantity_new))
10311 {
10312 if (destination_entity.GetInventory().FindFreeLocationFor(this, FindInventoryLocationType.ANY, loc))
10313 {
10314 Object o = destination_entity.GetInventory().LocationCreateEntity(loc, GetType(), ECE_IN_INVENTORY, RF_DEFAULT);
10315 new_item = ItemBase.Cast(o);
10316 }
10317
10318 if (new_item)
10319 {
10320 new_item.SetResultOfSplit(true);
10321 MiscGameplayFunctions.TransferItemProperties(this, new_item);
10322 AddQuantity(-split_quantity_new, false, true);
10323 new_item.SetQuantity(split_quantity_new, false, true);
10324 }
10325 }
10326 }
10327 else
10328 {
10329 if (stack_max != 0)
10330 {
10331 if (stack_max < GetQuantity())
10332 {
10333 split_quantity_new = GetQuantity() - stack_max;
10334 }
10335
10336 if (split_quantity_new == 0)
10337 {
10338 if (!GetGame().IsMultiplayer())
10339 player.PhysicalPredictiveDropItem(this);
10340 else
10341 player.ServerDropEntity(this);
10342 return;
10343 }
10344
10345 if (ShouldSplitQuantity(split_quantity_new))
10346 {
10347 new_item = ItemBase.Cast(GetGame().CreateObjectEx(GetType(), player.GetWorldPosition(), ECE_PLACE_ON_SURFACE));
10348
10349 if (new_item)
10350 {
10351 new_item.SetResultOfSplit(true);
10352 MiscGameplayFunctions.TransferItemProperties(this, new_item);
10353 SetQuantity(split_quantity_new, false, true);
10354 new_item.SetQuantity(stack_max, false, true);
10355 new_item.PlaceOnSurface();
10356 }
10357 }
10358 }
10359 }
10360 }
10361
10362 override void SplitIntoStackMaxEx(EntityAI destination_entity, int slot_id)
10363 {
10364 float split_quantity_new;
10365 ItemBase new_item;
10366 float quantity = GetQuantity();
10367 float stack_max = GetTargetQuantityMax(slot_id);
10368 InventoryLocation loc = new InventoryLocation;
10369
10370 if (destination_entity && slot_id != -1 && InventorySlots.IsSlotIdValid(slot_id))
10371 {
10372 if (stack_max <= GetQuantity())
10373 split_quantity_new = stack_max;
10374 else
10375 split_quantity_new = GetQuantity();
10376
10377 if (ShouldSplitQuantity(split_quantity_new))
10378 {
10379 new_item = ItemBase.Cast(destination_entity.GetInventory().CreateAttachmentEx(this.GetType(), slot_id));
10380 if (new_item)
10381 {
10382 new_item.SetResultOfSplit(true);
10383 MiscGameplayFunctions.TransferItemProperties(this, new_item);
10384 AddQuantity(-split_quantity_new, false, true);
10385 new_item.SetQuantity(split_quantity_new, false, true);
10386 }
10387 }
10388 }
10389 else if (destination_entity && slot_id == -1)
10390 {
10391 if (quantity > stack_max)
10392 split_quantity_new = stack_max;
10393 else
10394 split_quantity_new = quantity;
10395
10396 if (ShouldSplitQuantity(split_quantity_new))
10397 {
10398 if (destination_entity.GetInventory().FindFreeLocationFor(this, FindInventoryLocationType.ANY, loc))
10399 {
10400 Object o = destination_entity.GetInventory().LocationCreateEntity(loc, GetType(), ECE_IN_INVENTORY, RF_DEFAULT);
10401 new_item = ItemBase.Cast(o);
10402 }
10403
10404 if (new_item)
10405 {
10406 new_item.SetResultOfSplit(true);
10407 MiscGameplayFunctions.TransferItemProperties(this, new_item);
10408 AddQuantity(-split_quantity_new, false, true);
10409 new_item.SetQuantity(split_quantity_new, false, true);
10410 }
10411 }
10412 }
10413 else
10414 {
10415 if (stack_max != 0)
10416 {
10417 if (stack_max < GetQuantity())
10418 {
10419 split_quantity_new = GetQuantity() - stack_max;
10420 }
10421
10422 if (ShouldSplitQuantity(split_quantity_new))
10423 {
10424 new_item = ItemBase.Cast(GetGame().CreateObjectEx(GetType(),GetWorldPosition(), ECE_PLACE_ON_SURFACE));
10425
10426 if (new_item)
10427 {
10428 new_item.SetResultOfSplit(true);
10429 MiscGameplayFunctions.TransferItemProperties(this, new_item);
10430 SetQuantity(split_quantity_new, false, true);
10431 new_item.SetQuantity(stack_max, false, true);
10432 new_item.PlaceOnSurface();
10433 }
10434 }
10435 }
10436 }
10437 }
10438
10439 void SplitIntoStackMaxToInventoryLocationClient(notnull InventoryLocation dst)
10440 {
10441 if (GetGame().IsClient())
10442 {
10443 if (ScriptInputUserData.CanStoreInputUserData())
10444 {
10445 ScriptInputUserData ctx = new ScriptInputUserData;
10447 ctx.Write(4);
10448 ItemBase thiz = this; // @NOTE: workaround for correct serialization
10449 ctx.Write(thiz);
10450 dst.WriteToContext(ctx);
10451 ctx.Send();
10452 }
10453 }
10454 else if (!GetGame().IsMultiplayer())
10455 {
10457 }
10458 }
10459
10460 void SplitIntoStackMaxCargoClient(EntityAI destination_entity, int idx, int row, int col)
10461 {
10462 if (GetGame().IsClient())
10463 {
10464 if (ScriptInputUserData.CanStoreInputUserData())
10465 {
10466 ScriptInputUserData ctx = new ScriptInputUserData;
10468 ctx.Write(2);
10469 ItemBase dummy = this; // @NOTE: workaround for correct serialization
10470 ctx.Write(dummy);
10471 ctx.Write(destination_entity);
10472 ctx.Write(true);
10473 ctx.Write(idx);
10474 ctx.Write(row);
10475 ctx.Write(col);
10476 ctx.Send();
10477 }
10478 }
10479 else if (!GetGame().IsMultiplayer())
10480 {
10481 SplitIntoStackMaxCargo(destination_entity, idx, row, col);
10482 }
10483 }
10484
10485 void SplitIntoStackMaxToInventoryLocation(notnull InventoryLocation dst)
10486 {
10488 }
10489
10490 ItemBase SplitIntoStackMaxToInventoryLocationEx(notnull InventoryLocation dst)
10491 {
10492 float quantity = GetQuantity();
10493 float split_quantity_new;
10494 ItemBase new_item;
10495 if (dst.IsValid())
10496 {
10497 int slot_id = dst.GetSlot();
10498 float stack_max = GetTargetQuantityMax(slot_id);
10499
10500 if (quantity > stack_max)
10501 split_quantity_new = stack_max;
10502 else
10503 split_quantity_new = quantity;
10504
10505 if (ShouldSplitQuantity(split_quantity_new))
10506 {
10507 new_item = ItemBase.Cast(GameInventory.LocationCreateEntity(dst, this.GetType(), ECE_IN_INVENTORY, RF_DEFAULT));
10508
10509 if (new_item)
10510 {
10511 new_item.SetResultOfSplit(true);
10512 MiscGameplayFunctions.TransferItemProperties(this,new_item);
10513 AddQuantity(-split_quantity_new, false, true);
10514 new_item.SetQuantity(split_quantity_new, false, true);
10515 }
10516
10517 return new_item;
10518 }
10519 }
10520
10521 return null;
10522 }
10523
10524 void SplitIntoStackMaxCargo(EntityAI destination_entity, int idx, int row, int col)
10525 {
10526 float quantity = GetQuantity();
10527 float split_quantity_new;
10528 ItemBase new_item;
10529 if (destination_entity)
10530 {
10531 float stackable = GetTargetQuantityMax();
10532 if (quantity > stackable)
10533 split_quantity_new = stackable;
10534 else
10535 split_quantity_new = quantity;
10536
10537 if (ShouldSplitQuantity(split_quantity_new))
10538 {
10539 new_item = ItemBase.Cast(destination_entity.GetInventory().CreateEntityInCargoEx(this.GetType(), idx, row, col, false));
10540 if (new_item)
10541 {
10542 new_item.SetResultOfSplit(true);
10543 MiscGameplayFunctions.TransferItemProperties(this,new_item);
10544 AddQuantity(-split_quantity_new, false, true);
10545 new_item.SetQuantity(split_quantity_new, false, true);
10546 }
10547 }
10548 }
10549 }
10550
10551 void SplitIntoStackMaxHandsClient(PlayerBase player)
10552 {
10553 if (GetGame().IsClient())
10554 {
10555 if (ScriptInputUserData.CanStoreInputUserData())
10556 {
10557 ScriptInputUserData ctx = new ScriptInputUserData;
10559 ctx.Write(3);
10560 ItemBase i1 = this; // @NOTE: workaround for correct serialization
10561 ctx.Write(i1);
10562 ItemBase destination_entity = this;
10563 ctx.Write(destination_entity);
10564 ctx.Write(true);
10565 ctx.Write(0);
10566 ctx.Send();
10567 }
10568 }
10569 else if (!GetGame().IsMultiplayer())
10570 {
10571 SplitIntoStackMaxHands(player);
10572 }
10573 }
10574
10575 void SplitIntoStackMaxHands(PlayerBase player)
10576 {
10577 float quantity = GetQuantity();
10578 float split_quantity_new;
10579 ref ItemBase new_item;
10580 if (player)
10581 {
10582 float stackable = GetTargetQuantityMax();
10583 if (quantity > stackable)
10584 split_quantity_new = stackable;
10585 else
10586 split_quantity_new = quantity;
10587
10588 if (ShouldSplitQuantity(split_quantity_new))
10589 {
10590 EntityAI in_hands = player.GetHumanInventory().CreateInHands(this.GetType());
10591 new_item = ItemBase.Cast(in_hands);
10592 if (new_item)
10593 {
10594 new_item.SetResultOfSplit(true);
10595 MiscGameplayFunctions.TransferItemProperties(this,new_item);
10596 AddQuantity(-split_quantity_new, false, true);
10597 new_item.SetQuantity(split_quantity_new, false, true);
10598 }
10599 }
10600 }
10601 }
10602
10603 void SplitItemToInventoryLocation(notnull InventoryLocation dst)
10604 {
10605 float quantity = GetQuantity();
10606 float split_quantity_new = Math.Floor(quantity * 0.5);
10607
10608 if (!ShouldSplitQuantity(split_quantity_new))
10609 return;
10610
10611 ItemBase new_item = ItemBase.Cast(GameInventory.LocationCreateEntity(dst, GetType(), ECE_IN_INVENTORY, RF_DEFAULT));
10612
10613 if (new_item)
10614 {
10615 if (new_item.GetQuantityMax() < split_quantity_new)
10616 {
10617 split_quantity_new = new_item.GetQuantityMax();
10618 }
10619
10620 new_item.SetResultOfSplit(true);
10621 MiscGameplayFunctions.TransferItemProperties(this, new_item);
10622
10623 if (dst.IsValid() && dst.GetType() == InventoryLocationType.ATTACHMENT && split_quantity_new > 1)
10624 {
10625 AddQuantity(-1, false, true);
10626 new_item.SetQuantity(1, false, true);
10627 }
10628 else
10629 {
10630 AddQuantity(-split_quantity_new, false, true);
10631 new_item.SetQuantity(split_quantity_new, false, true);
10632 }
10633 }
10634 }
10635
10636 void SplitItem(PlayerBase player)
10637 {
10638 float quantity = GetQuantity();
10639 float split_quantity_new = Math.Floor(quantity / 2);
10640
10641 if (!ShouldSplitQuantity(split_quantity_new))
10642 return;
10643
10644 InventoryLocation invloc = new InventoryLocation;
10645 bool found = player.GetInventory().FindFirstFreeLocationForNewEntity(GetType(), FindInventoryLocationType.ATTACHMENT, invloc);
10646
10647 ItemBase new_item;
10648 new_item = player.CreateCopyOfItemInInventoryOrGroundEx(this, true);
10649
10650 if (new_item)
10651 {
10652 if (new_item.GetQuantityMax() < split_quantity_new)
10653 {
10654 split_quantity_new = new_item.GetQuantityMax();
10655 }
10656 if (found && invloc.IsValid() && invloc.GetType() == InventoryLocationType.ATTACHMENT && split_quantity_new > 1)
10657 {
10658 AddQuantity(-1, false, true);
10659 new_item.SetQuantity(1, false, true);
10660 }
10661 else if (split_quantity_new > 1)
10662 {
10663 AddQuantity(-split_quantity_new, false, true);
10664 new_item.SetQuantity(split_quantity_new, false, true);
10665 }
10666 }
10667 }
10668
10670 void OnQuantityChanged(float delta)
10671 {
10672 SetWeightDirty();
10673 ItemBase parent = ItemBase.Cast(GetHierarchyParent());
10674
10675 if (parent)
10676 parent.OnAttachmentQuantityChangedEx(this, delta);
10677
10678 if (IsLiquidContainer())
10679 {
10680 if (GetQuantityNormalized() <= 0.0)
10681 {
10683 }
10684 else if (GetLiquidType() == LIQUID_NONE)
10685 {
10686 ErrorEx("Undefined liquid type quantity changed, please define liquid type first! Using init value.",ErrorExSeverity.INFO);
10688 }
10689 }
10690
10691 }
10692
10695 {
10696 // insert code here
10697 }
10698
10700 void OnAttachmentQuantityChangedEx(ItemBase item , float delta)
10701 {
10703 }
10704
10705 override void EEHealthLevelChanged(int oldLevel, int newLevel, string zone)
10706 {
10707 super.EEHealthLevelChanged(oldLevel,newLevel,zone);
10708
10709 if (GetGame().IsServer())
10710 {
10711 if (newLevel == GameConstants.STATE_RUINED)
10712 {
10714 EntityAI parent = GetHierarchyParent();
10715 if (parent && parent.IsFireplace())
10716 {
10717 CargoBase cargo = GetInventory().GetCargo();
10718 if (cargo)
10719 {
10720 for (int i = 0; i < cargo.GetItemCount(); ++i)
10721 {
10722 parent.GetInventory().TakeEntityToInventory(InventoryMode.SERVER, FindInventoryLocationType.CARGO, cargo.GetItem(i));
10723 }
10724 }
10725 }
10726 }
10727
10728 if (IsResultOfSplit())
10729 {
10730 // reset the splitting result flag, return to normal item behavior
10731 SetResultOfSplit(false);
10732 return;
10733 }
10734
10735 if (m_Cleanness != 0 && oldLevel < newLevel && newLevel != 0)
10736 {
10737 SetCleanness(0);//unclean the item upon damage dealt
10738 }
10739 }
10740 }
10741
10742 // just the split? TODO: verify
10743 override void OnRightClick()
10744 {
10745 super.OnRightClick();
10746
10747 if (CanBeSplit() && !GetDayZGame().IsLeftCtrlDown() && !GetGame().GetPlayer().GetInventory().HasInventoryReservation(this,null))
10748 {
10749 if (GetGame().IsClient())
10750 {
10751 if (ScriptInputUserData.CanStoreInputUserData())
10752 {
10753 EntityAI root = GetHierarchyRoot();
10754 Man playerOwner = GetHierarchyRootPlayer();
10755 InventoryLocation dst = new InventoryLocation;
10756
10757 // If we have no hierarchy root player and the root is the same as this item the source item is in the vicinity so we want to create the new split item there also
10758 if (!playerOwner && root && root == this)
10759 {
10761 }
10762 else
10763 {
10764 // Check if we can place the new split item in the same parent where the source item is placed in or otherwise drop it in vicinity
10765 GetInventory().GetCurrentInventoryLocation(dst);
10766 if (!dst.GetParent() || dst.GetParent() && !dst.GetParent().GetInventory().FindFreeLocationFor(this, FindInventoryLocationType.CARGO, dst))
10767 {
10768 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
10769 if (!player.GetInventory().FindFreeLocationFor(this, FindInventoryLocationType.CARGO, dst) || !playerOwner)
10770 {
10772 }
10773 else
10774 {
10775 dst.SetCargo(dst.GetParent(), this, dst.GetIdx(), dst.GetRow(), dst.GetCol(), dst.GetFlip());
10776 /* hacky solution to check reservation of "this" item instead of null since the gamecode is checking null against null and returning reservation=true incorrectly
10777 this shouldnt cause issues within this scope*/
10778 if (GetGame().GetPlayer().GetInventory().HasInventoryReservation(this, dst))
10779 {
10781 }
10782 else
10783 {
10784 GetGame().GetPlayer().GetInventory().AddInventoryReservationEx(null, dst, GameInventory.c_InventoryReservationTimeoutShortMS);
10785 }
10786 }
10787 }
10788 }
10789
10790 ScriptInputUserData ctx = new ScriptInputUserData;
10792 ctx.Write(4);
10793 ItemBase thiz = this; // @NOTE: workaround for correct serialization
10794 ctx.Write(thiz);
10795 dst.WriteToContext(ctx);
10796 ctx.Write(true); // dummy
10797 ctx.Send();
10798 }
10799 }
10800 else if (!GetGame().IsMultiplayer())
10801 {
10802 SplitItem(PlayerBase.Cast(GetGame().GetPlayer()));
10803 }
10804 }
10805 }
10806
10807 protected void SetInventoryLocationToVicinityOrCurrent(EntityAI root, inout InventoryLocation dst)
10808 {
10809 if (root)
10810 {
10811 vector m4[4];
10812 root.GetTransform(m4);
10813 dst.SetGround(this, m4);
10814 }
10815 else
10816 {
10817 GetInventory().GetCurrentInventoryLocation(dst);
10818 }
10819 }
10820
10821 override bool CanBeCombined(EntityAI other_item, bool reservation_check = true, bool stack_max_limit = false)
10822 {
10823 //TODO: delete check zero quantity check after fix double posts hands fsm events
10824 if (!other_item || GetType() != other_item.GetType() || (IsFullQuantity() && other_item.GetQuantity() > 0) || other_item == this)
10825 return false;
10826
10827 if (GetHealthLevel() == GameConstants.STATE_RUINED || other_item.GetHealthLevel() == GameConstants.STATE_RUINED)
10828 return false;
10829
10830 //can_this_be_combined = ConfigGetBool("canBeSplit");
10832 return false;
10833
10834
10835 Magazine mag = Magazine.Cast(this);
10836 if (mag)
10837 {
10838 if (mag.GetAmmoCount() >= mag.GetAmmoMax())
10839 return false;
10840
10841 if (stack_max_limit)
10842 {
10843 Magazine other_mag = Magazine.Cast(other_item);
10844 if (other_item)
10845 {
10846 if (mag.GetAmmoCount() + other_mag.GetAmmoCount() > mag.GetAmmoMax())
10847 return false;
10848 }
10849
10850 }
10851 }
10852 else
10853 {
10854 //TODO: delete check zero quantity check after fix double posts hands fsm events
10855 if (GetQuantity() >= GetQuantityMax() && other_item.GetQuantity() > 0 )
10856 return false;
10857
10858 if (stack_max_limit && (GetQuantity() + other_item.GetQuantity() > GetQuantityMax()))
10859 return false;
10860 }
10861
10862 PlayerBase player = null;
10863 if (CastTo(player, GetHierarchyRootPlayer())) //false when attached to player's attachment slot
10864 {
10865 if (player.GetInventory().HasAttachment(this))
10866 return false;
10867
10868 if (player.IsItemsToDelete())
10869 return false;
10870 }
10871
10872 if (reservation_check && (GetInventory().HasInventoryReservation(this, null) || other_item.GetInventory().HasInventoryReservation(other_item, null)))
10873 return false;
10874
10875 int slotID;
10876 string slotName;
10877 if (GetInventory().GetCurrentAttachmentSlotInfo(slotID,slotName) && GetHierarchyParent().GetInventory().GetSlotLock(slotID))
10878 return false;
10879
10880 return true;
10881 }
10882
10883 bool IsCombineAll(ItemBase other_item, bool use_stack_max = false)
10884 {
10885 return ComputeQuantityUsed(other_item, use_stack_max) == other_item.GetQuantity();
10886 }
10887
10888 bool IsResultOfSplit()
10889 {
10890 return m_IsResultOfSplit;
10891 }
10892
10893 void SetResultOfSplit(bool value)
10894 {
10895 m_IsResultOfSplit = value;
10896 }
10897
10898 int ComputeQuantityUsed(ItemBase other_item, bool use_stack_max = true)
10899 {
10900 return ComputeQuantityUsedEx(other_item, use_stack_max);
10901 }
10902
10903 float ComputeQuantityUsedEx(ItemBase other_item, bool use_stack_max = true)
10904 {
10905 float other_item_quantity = other_item.GetQuantity();
10906 float this_free_space;
10907
10908 float stack_max = GetQuantityMax();
10909
10910 this_free_space = stack_max - GetQuantity();
10911
10912 if (other_item_quantity > this_free_space)
10913 {
10914 return this_free_space;
10915 }
10916 else
10917 {
10918 return other_item_quantity;
10919 }
10920 }
10921
10922 override void CombineItemsEx(EntityAI entity2, bool use_stack_max = true)
10923 {
10924 CombineItems(ItemBase.Cast(entity2),use_stack_max);
10925 }
10926
10927 void CombineItems(ItemBase other_item, bool use_stack_max = true)
10928 {
10929 if (!CanBeCombined(other_item, false))
10930 return;
10931
10932 if (!IsMagazine() && other_item)
10933 {
10934 float quantity_used = ComputeQuantityUsedEx(other_item,use_stack_max);
10935 if (quantity_used != 0)
10936 {
10937 float hp1 = GetHealth01("","");
10938 float hp2 = other_item.GetHealth01("","");
10939 float hpResult = ((hp1*GetQuantity()) + (hp2*quantity_used));
10940 hpResult = hpResult / (GetQuantity() + quantity_used);
10941
10942 hpResult *= GetMaxHealth();
10943 Math.Round(hpResult);
10944 SetHealth("", "Health", hpResult);
10945
10946 AddQuantity(quantity_used);
10947 other_item.AddQuantity(-quantity_used);
10948 }
10949 }
10950 OnCombine(other_item);
10951 }
10952
10953 void OnCombine(ItemBase other_item)
10954 {
10955 #ifdef SERVER
10956 if (!GetHierarchyRootPlayer() && GetHierarchyParent())
10957 GetHierarchyParent().IncreaseLifetimeUp();
10958 #endif
10959 };
10960
10961 void GetRecipesActions(Man player, out TSelectableActionInfoArray outputList)
10962 {
10963 PlayerBase p = PlayerBase.Cast(player);
10964
10965 array<int> recipesIds = p.m_Recipes;
10966 PluginRecipesManager moduleRecipesManager = PluginRecipesManager.Cast(GetPlugin(PluginRecipesManager));
10967 if (moduleRecipesManager)
10968 {
10969 EntityAI itemInHands = player.GetHumanInventory().GetEntityInHands();
10970 moduleRecipesManager.GetValidRecipes(ItemBase.Cast(this), ItemBase.Cast(itemInHands), recipesIds, p);
10971 }
10972
10973 for (int i = 0;i < recipesIds.Count(); i++)
10974 {
10975 int key = recipesIds.Get(i);
10976 string recipeName = moduleRecipesManager.GetRecipeName(key);
10977 outputList.Insert(new TSelectableActionInfo(SAT_CRAFTING, key, recipeName));
10978 }
10979 }
10980
10981 // -------------------------------------------------------------------------
10982 override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
10983 {
10984 super.GetDebugActions(outputList);
10985
10986 //quantity
10987 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.ADD_QUANTITY, "Quantity +20%", FadeColors.LIGHT_GREY));
10988 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.REMOVE_QUANTITY, "Quantity -20%", FadeColors.LIGHT_GREY));
10989 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SET_QUANTITY_0, "Set Quantity 0", FadeColors.LIGHT_GREY));
10990 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SET_MAX_QUANTITY, "Set Quantity Max", FadeColors.LIGHT_GREY));
10991 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
10992
10993 //health
10994 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.ADD_HEALTH, "Health +20%", FadeColors.LIGHT_GREY));
10995 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.REMOVE_HEALTH, "Health -20%", FadeColors.LIGHT_GREY));
10996 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.DESTROY_HEALTH, "Health 0", FadeColors.LIGHT_GREY));
10997 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
10998 //temperature
10999 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.ADD_TEMPERATURE, "Temperature +20", FadeColors.LIGHT_GREY));
11000 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.REMOVE_TEMPERATURE, "Temperature -20", FadeColors.LIGHT_GREY));
11001 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.FLIP_FROZEN, "Toggle Frozen", FadeColors.LIGHT_GREY));
11002 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
11003
11004 //wet
11005 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.ADD_WETNESS, "Wetness +20", FadeColors.LIGHT_GREY));
11006 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.REMOVE_WETNESS, "Wetness -20", FadeColors.LIGHT_GREY));
11007 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
11008
11009 //liquidtype
11010 if (IsLiquidContainer())
11011 {
11012 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.LIQUIDTYPE_UP, "LiquidType Next", FadeColors.LIGHT_GREY));
11013 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.LIQUIDTYPE_DOWN, "LiquidType Previous", FadeColors.LIGHT_GREY));
11014 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
11015 }
11016
11017 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.MAKE_SPECIAL, "Make Special", FadeColors.LIGHT_GREY));
11018 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
11019
11020 // watch
11021 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.WATCH_ITEM, "Watch (CTRL-Z)", FadeColors.LIGHT_GREY));
11022 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.WATCH_PLAYER, "Watch Player", FadeColors.LIGHT_GREY));
11023 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
11024
11025 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.DELETE, "Delete", FadeColors.RED));
11026
11027 InventoryLocation loc = new InventoryLocation();
11028 GetInventory().GetCurrentInventoryLocation(loc);
11029 if (!loc || loc.GetType() == InventoryLocationType.GROUND)
11030 {
11031 if (Gizmo_IsSupported())
11032 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.GIZMO_OBJECT, "Gizmo Object", FadeColors.LIGHT_GREY));
11033 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.GIZMO_PHYSICS, "Gizmo Physics (SP Only)", FadeColors.LIGHT_GREY)); // intentionally allowed for testing physics desync
11034 }
11035
11036 outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.RED));
11037 }
11038
11039 // -------------------------------------------------------------------------
11040 // -------------------------------------------------------------------------
11041 // -------------------------------------------------------------------------
11042 override bool OnAction(int action_id, Man player, ParamsReadContext ctx)
11043 {
11044 super.OnAction(action_id, player, ctx);
11045
11046 if (GetGame().IsClient() || !GetGame().IsMultiplayer())
11047 {
11048 switch (action_id)
11049 {
11050 case EActions.GIZMO_OBJECT:
11051 GetGame().GizmoSelectObject(this);
11052 return true;
11053 case EActions.GIZMO_PHYSICS:
11054 GetGame().GizmoSelectPhysics(GetPhysics());
11055 return true;
11056 }
11057 }
11058
11059 if (GetGame().IsServer())
11060 {
11061 switch (action_id)
11062 {
11063 case EActions.DELETE:
11064 Delete();
11065 return true;
11066 }
11067 }
11068
11069 if (action_id >= EActions.RECIPES_RANGE_START && action_id < EActions.RECIPES_RANGE_END)
11070 {
11071 PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast(GetPlugin(PluginRecipesManager));
11072 int idWithoutOffset = action_id - EActions.RECIPES_RANGE_START;
11073 PlayerBase p = PlayerBase.Cast(player);
11074 if (EActions.RECIPES_RANGE_START < 1000)
11075 {
11076 float anim_length = plugin_recipes_manager.GetRecipeLengthInSecs(idWithoutOffset);
11077 float specialty_weight = plugin_recipes_manager.GetRecipeSpecialty(idWithoutOffset);
11078 }
11079 }
11080 #ifndef SERVER
11081 else if (action_id == EActions.WATCH_PLAYER)
11082 {
11083 PluginDeveloper.SetDeveloperItemClientEx(player);
11084 }
11085 #endif
11086 if (GetGame().IsServer())
11087 {
11088 if (action_id >= EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START && action_id < EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_END)
11089 {
11090 int id = action_id - EActions.DEBUG_ITEM_WATCH_BUTTON_RANGE_START;
11091 OnDebugButtonPressServer(id + 1);
11092 }
11093
11094 else if (action_id >= EActions.DEBUG_AGENTS_RANGE_INJECT_START && action_id < EActions.DEBUG_AGENTS_RANGE_INJECT_END)
11095 {
11096 int agent_id = action_id - EActions.DEBUG_AGENTS_RANGE_INJECT_START;
11097 InsertAgent(agent_id,100);
11098 }
11099
11100 else if (action_id >= EActions.DEBUG_AGENTS_RANGE_REMOVE_START && action_id < EActions.DEBUG_AGENTS_RANGE_REMOVE_END)
11101 {
11102 int agent_id2 = action_id - EActions.DEBUG_AGENTS_RANGE_REMOVE_START;
11103 RemoveAgent(agent_id2);
11104 }
11105
11106 else if (action_id == EActions.ADD_QUANTITY)
11107 {
11108 if (IsMagazine())
11109 {
11110 Magazine mag = Magazine.Cast(this);
11111 mag.ServerSetAmmoCount(mag.GetAmmoCount() + mag.GetAmmoMax() * 0.2);
11112 }
11113 else
11114 {
11115 AddQuantity(GetQuantityMax() * 0.2);
11116 }
11117
11118 if (m_EM)
11119 {
11120 m_EM.AddEnergy(m_EM.GetEnergyMax() * 0.2);
11121 }
11122 //PrintVariables();
11123 }
11124
11125 else if (action_id == EActions.REMOVE_QUANTITY) //Quantity -20%
11126 {
11127 if (IsMagazine())
11128 {
11129 Magazine mag2 = Magazine.Cast(this);
11130 mag2.ServerSetAmmoCount(mag2.GetAmmoCount() - mag2.GetAmmoMax() * 0.2);
11131 }
11132 else
11133 {
11134 AddQuantity(- GetQuantityMax() * 0.2);
11135 }
11136 if (m_EM)
11137 {
11138 m_EM.AddEnergy(- m_EM.GetEnergyMax() * 0.2);
11139 }
11140 //PrintVariables();
11141 }
11142
11143 else if (action_id == EActions.SET_QUANTITY_0) //SetMaxQuantity
11144 {
11145 SetQuantity(0);
11146
11147 if (m_EM)
11148 {
11149 m_EM.SetEnergy(0);
11150 }
11151 }
11152
11153 else if (action_id == EActions.SET_MAX_QUANTITY) //SetMaxQuantity
11154 {
11156
11157 if (m_EM)
11158 {
11159 m_EM.SetEnergy(m_EM.GetEnergyMax());
11160 }
11161 }
11162
11163 else if (action_id == EActions.ADD_HEALTH)
11164 {
11165 AddHealth("","",GetMaxHealth("","Health")/5);
11166 }
11167 else if (action_id == EActions.REMOVE_HEALTH)
11168 {
11169 AddHealth("","",-GetMaxHealth("","Health")/5);
11170 }
11171 else if (action_id == EActions.DESTROY_HEALTH)
11172 {
11173 SetHealth01("","",0);
11174 }
11175 else if (action_id == EActions.WATCH_ITEM)
11176 {
11178 mid.RegisterDebugItem(ItemBase.Cast(this), PlayerBase.Cast(player));
11179 #ifdef DEVELOPER
11180 SetDebugDeveloper_item(this);
11181 #endif
11182 }
11183
11184 else if (action_id == EActions.ADD_TEMPERATURE)
11185 {
11186 AddTemperature(20);
11187 //PrintVariables();
11188 }
11189
11190 else if (action_id == EActions.REMOVE_TEMPERATURE)
11191 {
11192 AddTemperature(-20);
11193 //PrintVariables();
11194 }
11195
11196 else if (action_id == EActions.FLIP_FROZEN)
11197 {
11198 SetFrozen(!GetIsFrozen());
11199 //PrintVariables();
11200 }
11201
11202 else if (action_id == EActions.ADD_WETNESS)
11203 {
11204 AddWet(GetWetMax()/5);
11205 //PrintVariables();
11206 }
11207
11208 else if (action_id == EActions.REMOVE_WETNESS)
11209 {
11210 AddWet(-GetWetMax()/5);
11211 //PrintVariables();
11212 }
11213
11214 else if (action_id == EActions.LIQUIDTYPE_UP)
11215 {
11216 int curr_type = GetLiquidType();
11217 SetLiquidType(curr_type * 2);
11218 //AddWet(1);
11219 //PrintVariables();
11220 }
11221
11222 else if (action_id == EActions.LIQUIDTYPE_DOWN)
11223 {
11224 int curr_type2 = GetLiquidType();
11225 SetLiquidType(curr_type2 / 2);
11226 }
11227
11228 else if (action_id == EActions.MAKE_SPECIAL)
11229 {
11230 auto debugParams = DebugSpawnParams.WithPlayer(player);
11231 OnDebugSpawnEx(debugParams);
11232 }
11233
11234 }
11235
11236
11237 return false;
11238 }
11239
11240 // -------------------------------------------------------------------------
11241
11242
11245 void OnActivatedByTripWire();
11246
11248 void OnActivatedByItem(notnull ItemBase item);
11249
11250 //----------------------------------------------------------------
11251 //returns true if item is able to explode when put in fire
11252 bool CanExplodeInFire()
11253 {
11254 return false;
11255 }
11256
11257 //----------------------------------------------------------------
11258 bool CanEat()
11259 {
11260 return true;
11261 }
11262
11263 //----------------------------------------------------------------
11264 override bool IsIgnoredByConstruction()
11265 {
11266 return true;
11267 }
11268
11269 //----------------------------------------------------------------
11270 //has FoodStages in config?
11271 bool HasFoodStage()
11272 {
11273 string config_path = string.Format("CfgVehicles %1 Food FoodStages", GetType());
11274 return GetGame().ConfigIsExisting(config_path);
11275 }
11276
11278 FoodStage GetFoodStage()
11279 {
11280 return null;
11281 }
11282
11283 bool CanBeCooked()
11284 {
11285 return false;
11286 }
11287
11288 bool CanBeCookedOnStick()
11289 {
11290 return false;
11291 }
11292
11294 void RefreshAudioVisualsOnClient( CookingMethodType cooking_method, bool is_done, bool is_empty, bool is_burned );
11296
11297 //----------------------------------------------------------------
11298 bool CanRepair(ItemBase item_repair_kit)
11299 {
11300 PluginRepairing module_repairing = PluginRepairing.Cast(GetPlugin(PluginRepairing));
11301 return module_repairing.CanRepair(this, item_repair_kit);
11302 }
11303
11304 //----------------------------------------------------------------
11305 bool Repair(PlayerBase player, ItemBase item_repair_kit, float specialty_weight)
11306 {
11307 PluginRepairing module_repairing = PluginRepairing.Cast(GetPlugin(PluginRepairing));
11308 return module_repairing.Repair(player, this, item_repair_kit, specialty_weight);
11309 }
11310
11311 //----------------------------------------------------------------
11312 int GetItemSize()
11313 {
11314 /*
11315 vector v_size = this.ConfigGetVector("itemSize");
11316 int v_size_x = v_size[0];
11317 int v_size_y = v_size[1];
11318 int size = v_size_x * v_size_y;
11319 return size;
11320 */
11321
11322 return 1;
11323 }
11324
11325 //----------------------------------------------------------------
11326 //Override for allowing seemingly unallowed moves when two clients send a conflicting message simultaneously
11327 bool CanBeMovedOverride()
11328 {
11329 return m_CanBeMovedOverride;
11330 }
11331
11332 //----------------------------------------------------------------
11333 //Override for allowing seemingly unallowed moves when two clients send a conflicting message simultaneously
11334 void SetCanBeMovedOverride(bool setting)
11335 {
11336 m_CanBeMovedOverride = setting;
11337 }
11338
11339 //----------------------------------------------------------------
11347 void MessageToOwnerStatus(string text)
11348 {
11349 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
11350
11351 if (player)
11352 {
11353 player.MessageStatus(text);
11354 }
11355 }
11356
11357 //----------------------------------------------------------------
11365 void MessageToOwnerAction(string text)
11366 {
11367 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
11368
11369 if (player)
11370 {
11371 player.MessageAction(text);
11372 }
11373 }
11374
11375 //----------------------------------------------------------------
11383 void MessageToOwnerFriendly(string text)
11384 {
11385 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
11386
11387 if (player)
11388 {
11389 player.MessageFriendly(text);
11390 }
11391 }
11392
11393 //----------------------------------------------------------------
11401 void MessageToOwnerImportant(string text)
11402 {
11403 PlayerBase player = PlayerBase.Cast(this.GetHierarchyRootPlayer());
11404
11405 if (player)
11406 {
11407 player.MessageImportant(text);
11408 }
11409 }
11410
11411 override bool IsItemBase()
11412 {
11413 return true;
11414 }
11415
11416 // Checks if item is of questioned kind
11417 override bool KindOf(string tag)
11418 {
11419 bool found = false;
11420 string item_name = this.GetType();
11421 ref TStringArray item_tag_array = new TStringArray;
11422 GetGame().ConfigGetTextArray("cfgVehicles " + item_name + " itemInfo", item_tag_array);
11423
11424 int array_size = item_tag_array.Count();
11425 for (int i = 0; i < array_size; i++)
11426 {
11427 if (item_tag_array.Get(i) == tag)
11428 {
11429 found = true;
11430 break;
11431 }
11432 }
11433 return found;
11434 }
11435
11436
11437 override void OnRPC(PlayerIdentity sender, int rpc_type,ParamsReadContext ctx)
11438 {
11439 //Debug.Log("OnRPC called");
11440 super.OnRPC(sender, rpc_type,ctx);
11441
11442 //Play soundset for attachment locking (ActionLockAttachment.c)
11443 switch (rpc_type)
11444 {
11445 #ifndef SERVER
11446 case ERPCs.RPC_SOUND_LOCK_ATTACH:
11447 Param2<bool, string> p = new Param2<bool, string>(false, "");
11448
11449 if (!ctx.Read(p))
11450 return;
11451
11452 bool play = p.param1;
11453 string soundSet = p.param2;
11454
11455 if (play)
11456 {
11457 if (m_LockingSound)
11458 {
11460 {
11461 m_LockingSound = SEffectManager.PlaySound(soundSet, GetPosition(), 0, 0, true);
11462 }
11463 }
11464 else
11465 {
11466 m_LockingSound = SEffectManager.PlaySound(soundSet, GetPosition(), 0, 0, true);
11467 }
11468 }
11469 else
11470 {
11471 SEffectManager.DestroyEffect(m_LockingSound);
11472 }
11473
11474 break;
11475 #endif
11476
11477 }
11478
11479 if (GetWrittenNoteData())
11480 {
11481 GetWrittenNoteData().OnRPC(sender, rpc_type,ctx);
11482 }
11483 }
11484
11485 //-----------------------------
11486 // VARIABLE MANIPULATION SYSTEM
11487 //-----------------------------
11488 int NameToID(string name)
11489 {
11490 PluginVariables plugin = PluginVariables.Cast(GetPlugin(PluginVariables));
11491 return plugin.GetID(name);
11492 }
11493
11494 string IDToName(int id)
11495 {
11496 PluginVariables plugin = PluginVariables.Cast(GetPlugin(PluginVariables));
11497 return plugin.GetName(id);
11498 }
11499
11501 void OnSyncVariables(ParamsReadContext ctx)//with ID optimization
11502 {
11503 //Debug.Log("OnSyncVariables called for item: "+ ToString(this.GetType()),"varSync");
11504 //read the flags
11505 int varFlags;
11506 if (!ctx.Read(varFlags))
11507 return;
11508
11509 if (varFlags & ItemVariableFlags.FLOAT)
11510 {
11511 ReadVarsFromCTX(ctx);
11512 }
11513 }
11514
11515 override void SerializeNumericalVars(array<float> floats_out)
11516 {
11517 //some variables handled on EntityAI level already!
11518 super.SerializeNumericalVars(floats_out);
11519
11520 // the order of serialization must be the same as the order of de-serialization
11521 //--------------------------------------------
11522 if (IsVariableSet(VARIABLE_QUANTITY))
11523 {
11524 floats_out.Insert(m_VarQuantity);
11525 }
11526 //--------------------------------------------
11527 if (IsVariableSet(VARIABLE_WET))
11528 {
11529 floats_out.Insert(m_VarWet);
11530 }
11531 //--------------------------------------------
11532 if (IsVariableSet(VARIABLE_LIQUIDTYPE))
11533 {
11534 floats_out.Insert(m_VarLiquidType);
11535 }
11536 //--------------------------------------------
11537 if (IsVariableSet(VARIABLE_COLOR))
11538 {
11539 floats_out.Insert(m_ColorComponentR);
11540 floats_out.Insert(m_ColorComponentG);
11541 floats_out.Insert(m_ColorComponentB);
11542 floats_out.Insert(m_ColorComponentA);
11543 }
11544 //--------------------------------------------
11545 if (IsVariableSet(VARIABLE_CLEANNESS))
11546 {
11547 floats_out.Insert(m_Cleanness);
11548 }
11549 }
11550
11551 override void DeSerializeNumericalVars(array<float> floats)
11552 {
11553 //some variables handled on EntityAI level already!
11554 super.DeSerializeNumericalVars(floats);
11555
11556 // the order of serialization must be the same as the order of de-serialization
11557 int index = 0;
11558 int mask = Math.Round(floats.Get(index));
11559
11560 index++;
11561 //--------------------------------------------
11562 if (mask & VARIABLE_QUANTITY)
11563 {
11564 if (m_IsStoreLoad)
11565 {
11566 SetStoreLoadedQuantity(floats.Get(index));
11567 }
11568 else
11569 {
11570 float quantity = floats.Get(index);
11571 SetQuantity(quantity, true, false, false, false);
11572 }
11573 index++;
11574 }
11575 //--------------------------------------------
11576 if (mask & VARIABLE_WET)
11577 {
11578 float wet = floats.Get(index);
11579 SetWet(wet);
11580 index++;
11581 }
11582 //--------------------------------------------
11583 if (mask & VARIABLE_LIQUIDTYPE)
11584 {
11585 int liquidtype = Math.Round(floats.Get(index));
11586 SetLiquidType(liquidtype);
11587 index++;
11588 }
11589 //--------------------------------------------
11590 if (mask & VARIABLE_COLOR)
11591 {
11592 m_ColorComponentR = Math.Round(floats.Get(index));
11593 index++;
11594 m_ColorComponentG = Math.Round(floats.Get(index));
11595 index++;
11596 m_ColorComponentB = Math.Round(floats.Get(index));
11597 index++;
11598 m_ColorComponentA = Math.Round(floats.Get(index));
11599 index++;
11600 }
11601 //--------------------------------------------
11602 if (mask & VARIABLE_CLEANNESS)
11603 {
11604 int cleanness = Math.Round(floats.Get(index));
11605 SetCleanness(cleanness);
11606 index++;
11607 }
11608 }
11609
11610 override void WriteVarsToCTX(ParamsWriteContext ctx)
11611 {
11612 super.WriteVarsToCTX(ctx);
11613
11614 //--------------------------------------------
11615 if (IsVariableSet(VARIABLE_QUANTITY))
11616 {
11617 ctx.Write(GetQuantity());
11618 }
11619 //--------------------------------------------
11620 if (IsVariableSet(VARIABLE_WET))
11621 {
11622 ctx.Write(GetWet());
11623 }
11624 //--------------------------------------------
11625 if (IsVariableSet(VARIABLE_LIQUIDTYPE))
11626 {
11627 ctx.Write(GetLiquidType());
11628 }
11629 //--------------------------------------------
11630 if (IsVariableSet(VARIABLE_COLOR))
11631 {
11632 int r,g,b,a;
11633 GetColor(r,g,b,a);
11634 ctx.Write(r);
11635 ctx.Write(g);
11636 ctx.Write(b);
11637 ctx.Write(a);
11638 }
11639 //--------------------------------------------
11640 if (IsVariableSet(VARIABLE_CLEANNESS))
11641 {
11642 ctx.Write(GetCleanness());
11643 }
11644 }
11645
11646 override bool ReadVarsFromCTX(ParamsReadContext ctx, int version = -1)//with ID optimization
11647 {
11648 if (!super.ReadVarsFromCTX(ctx,version))
11649 return false;
11650
11651 int intValue;
11652 float value;
11653
11654 if (version < 140)
11655 {
11656 if (!ctx.Read(intValue))
11657 return false;
11658
11659 m_VariablesMask = intValue;
11660 }
11661
11662 if (m_VariablesMask & VARIABLE_QUANTITY)
11663 {
11664 if (!ctx.Read(value))
11665 return false;
11666
11667 if (IsStoreLoad())
11668 {
11670 }
11671 else
11672 {
11673 SetQuantity(value, true, false, false, false);
11674 }
11675 }
11676 //--------------------------------------------
11677 if (version < 140)
11678 {
11679 if (m_VariablesMask & VARIABLE_TEMPERATURE)
11680 {
11681 if (!ctx.Read(value))
11682 return false;
11683 SetTemperatureDirect(value);
11684 }
11685 }
11686 //--------------------------------------------
11687 if (m_VariablesMask & VARIABLE_WET)
11688 {
11689 if (!ctx.Read(value))
11690 return false;
11691 SetWet(value);
11692 }
11693 //--------------------------------------------
11694 if (m_VariablesMask & VARIABLE_LIQUIDTYPE)
11695 {
11696 if (!ctx.Read(intValue))
11697 return false;
11698 SetLiquidType(intValue);
11699 }
11700 //--------------------------------------------
11701 if (m_VariablesMask & VARIABLE_COLOR)
11702 {
11703 int r,g,b,a;
11704 if (!ctx.Read(r))
11705 return false;
11706 if (!ctx.Read(g))
11707 return false;
11708 if (!ctx.Read(b))
11709 return false;
11710 if (!ctx.Read(a))
11711 return false;
11712
11713 SetColor(r,g,b,a);
11714 }
11715 //--------------------------------------------
11716 if (m_VariablesMask & VARIABLE_CLEANNESS)
11717 {
11718 if (!ctx.Read(intValue))
11719 return false;
11720 SetCleanness(intValue);
11721 }
11722 //--------------------------------------------
11723 if (version >= 138 && version < 140)
11724 {
11725 if (m_VariablesMask & VARIABLE_TEMPERATURE)
11726 {
11727 if (!ctx.Read(intValue))
11728 return false;
11729 SetFrozen(intValue);
11730 }
11731 }
11732
11733 return true;
11734 }
11735
11736 //----------------------------------------------------------------
11737 override bool OnStoreLoad(ParamsReadContext ctx, int version)
11738 {
11739 m_IsStoreLoad = true;
11741 {
11742 m_FixDamageSystemInit = true;
11743 }
11744
11745 if (!super.OnStoreLoad(ctx, version))
11746 {
11747 m_IsStoreLoad = false;
11748 return false;
11749 }
11750
11751 if (version >= 114)
11752 {
11753 bool hasQuickBarIndexSaved;
11754
11755 if (!ctx.Read(hasQuickBarIndexSaved))
11756 {
11757 m_IsStoreLoad = false;
11758 return false;
11759 }
11760
11761 if (hasQuickBarIndexSaved)
11762 {
11763 int itmQBIndex;
11764
11765 //Load quickbar item bind
11766 if (!ctx.Read(itmQBIndex))
11767 {
11768 m_IsStoreLoad = false;
11769 return false;
11770 }
11771
11772 PlayerBase parentPlayer = PlayerBase.Cast(GetHierarchyRootPlayer());
11773 if (itmQBIndex != -1 && parentPlayer)
11774 parentPlayer.SetLoadedQuickBarItemBind(this, itmQBIndex);
11775 }
11776 }
11777 else
11778 {
11779 // Backup of how it used to be
11780 PlayerBase player;
11781 int itemQBIndex;
11782 if (version == int.MAX)
11783 {
11784 if (!ctx.Read(itemQBIndex))
11785 {
11786 m_IsStoreLoad = false;
11787 return false;
11788 }
11789 }
11790 else if (Class.CastTo(player, GetHierarchyRootPlayer()))
11791 {
11792 //Load quickbar item bind
11793 if (!ctx.Read(itemQBIndex))
11794 {
11795 m_IsStoreLoad = false;
11796 return false;
11797 }
11798 if (itemQBIndex != -1 && player)
11799 player.SetLoadedQuickBarItemBind(this,itemQBIndex);
11800 }
11801 }
11802
11803 if (version < 140)
11804 {
11805 // variable management system
11806 if (!LoadVariables(ctx, version))
11807 {
11808 m_IsStoreLoad = false;
11809 return false;
11810 }
11811 }
11812
11813 //agent trasmission system
11814 if (!LoadAgents(ctx, version))
11815 {
11816 m_IsStoreLoad = false;
11817 return false;
11818 }
11819 if (version >= 132)
11820 {
11821 RemotelyActivatedItemBehaviour raib = GetRemotelyActivatedItemBehaviour();
11822 if (raib)
11823 {
11824 if (!raib.OnStoreLoad(ctx,version))
11825 {
11826 m_IsStoreLoad = false;
11827 return false;
11828 }
11829 }
11830 }
11831
11832 m_IsStoreLoad = false;
11833 return true;
11834 }
11835
11836 //----------------------------------------------------------------
11837
11838 override void OnStoreSave(ParamsWriteContext ctx)
11839 {
11840 super.OnStoreSave(ctx);
11841
11842 PlayerBase player;
11843 if (PlayerBase.CastTo(player,GetHierarchyRootPlayer()))
11844 {
11845 ctx.Write(true); // Keep track of if we should actually read this in or not
11846 //Save quickbar item bind
11847 int itemQBIndex = -1;
11848 itemQBIndex = player.FindQuickBarEntityIndex(this);
11849 ctx.Write(itemQBIndex);
11850 }
11851 else
11852 {
11853 ctx.Write(false); // Keep track of if we should actually read this in or not
11854 }
11855
11856 SaveAgents(ctx);//agent trasmission system
11857
11858 RemotelyActivatedItemBehaviour raib = GetRemotelyActivatedItemBehaviour();
11859 if (raib)
11860 {
11861 raib.OnStoreSave(ctx);
11862 }
11863 }
11864 //----------------------------------------------------------------
11865
11866 override void AfterStoreLoad()
11867 {
11868 super.AfterStoreLoad();
11869
11871 {
11873 }
11874
11875 if (GetStoreLoadedQuantity() != float.LOWEST)
11876 {
11878 SetStoreLoadedQuantity(float.LOWEST);//IMPORTANT to do this !! we use 'm_StoreLoadedQuantity' inside SetQuantity to distinguish between initial quantity setting and the consequent(normal gameplay) calls
11879 }
11880 }
11881
11882 override void EEOnAfterLoad()
11883 {
11884 super.EEOnAfterLoad();
11885
11887 {
11888 m_FixDamageSystemInit = false;
11889 }
11890
11893 }
11894
11895 bool CanBeDisinfected()
11896 {
11897 return false;
11898 }
11899
11900
11901 //----------------------------------------------------------------
11902 override void OnVariablesSynchronized()
11903 {
11904 if (m_Initialized)
11905 {
11906 #ifdef PLATFORM_CONSOLE
11907 //bruteforce it is
11908 if (IsSplitable())
11909 {
11910 UIScriptedMenu menu = GetGame().GetUIManager().FindMenu(MENU_INVENTORY);
11911 if (menu)
11912 {
11913 menu.Refresh();
11914 }
11915 }
11916 #endif
11917 }
11918
11920 {
11921 PlayImpactSound(m_ConfigWeight, m_ImpactSpeed, m_ImpactSoundSurfaceHash);
11922 m_WantPlayImpactSound = false;
11923 }
11924
11926 {
11927 SetWeightDirty();
11929 }
11930 if (m_VarWet != m_VarWetPrev)
11931 {
11934 }
11935
11936 if (m_SoundSyncPlay != 0)
11937 {
11938 m_ItemSoundHandler.PlayItemSoundClient(m_SoundSyncPlay);
11939 m_SoundSyncPlay = 0;
11940 }
11941 if (m_SoundSyncStop != 0)
11942 {
11943 m_ItemSoundHandler.StopItemSoundClient(m_SoundSyncStop);
11944 m_SoundSyncStop = 0;
11945 }
11946
11947 super.OnVariablesSynchronized();
11948 }
11949
11950 //------------------------- Quantity
11951 //----------------------------------------------------------------
11953 override bool SetQuantity(float value, bool destroy_config = true, bool destroy_forced = false, bool allow_client = false, bool clamp_to_stack_max = true)
11954 {
11955 if (!IsServerCheck(allow_client))
11956 return false;
11957
11958 if (!HasQuantity())
11959 return false;
11960
11961 float min = GetQuantityMin();
11962 float max = GetQuantityMax();
11963
11964 if (value <= (min + 0.001))
11965 value = min;
11966
11967 if (value == min)
11968 {
11969 if (destroy_config)
11970 {
11971 bool dstr = ConfigGetBool("varQuantityDestroyOnMin");
11972 if (dstr)
11973 {
11974 m_VarQuantity = Math.Clamp(value, min, max);
11975 this.Delete();
11976 return true;
11977 }
11978 }
11979 else if (destroy_forced)
11980 {
11981 m_VarQuantity = Math.Clamp(value, min, max);
11982 this.Delete();
11983 return true;
11984 }
11985 // we get here if destroy_config IS true AND dstr(config destroy param) IS false;
11986 RemoveAllAgents();//we remove all agents when we got to the min value, but the item is not getting deleted
11987 }
11988
11989 float delta = m_VarQuantity;
11990 m_VarQuantity = Math.Clamp(value, min, max);
11991
11992 if (GetStoreLoadedQuantity() == float.LOWEST)//any other value means we are setting quantity from storage
11993 {
11994 delta = m_VarQuantity - delta;
11995
11996 if (delta)
11997 OnQuantityChanged(delta);
11998 }
11999
12000 SetVariableMask(VARIABLE_QUANTITY);
12001
12002 return false;
12003 }
12004
12005 //----------------------------------------------------------------
12007 bool AddQuantity(float value, bool destroy_config = true, bool destroy_forced = false)
12008 {
12009 return SetQuantity(GetQuantity() + value, destroy_config, destroy_forced);
12010 }
12011 //----------------------------------------------------------------
12012 void SetQuantityMax()
12013 {
12014 float max = GetQuantityMax();
12015 SetQuantity(max);
12016 }
12017
12018 override void SetQuantityToMinimum()
12019 {
12020 float min = GetQuantityMin();
12021 SetQuantity(min);
12022 }
12023 //----------------------------------------------------------------
12025 override void SetQuantityNormalized(float value, bool destroy_config = true, bool destroy_forced = false)
12026 {
12027 float value_clamped = Math.Clamp(value, 0, 1);//just to make sure
12028 int result = Math.Round(Math.Lerp(GetQuantityMin(), GetQuantityMax(), value_clamped));
12029 SetQuantity(result, destroy_config, destroy_forced);
12030 }
12031
12032 //----------------------------------------------------------------
12034 override float GetQuantityNormalized()
12035 {
12036 return Math.InverseLerp(GetQuantityMin(), GetQuantityMax(),m_VarQuantity);
12037 }
12038
12040 {
12041 return GetQuantityNormalized();
12042 }
12043
12044 /*void SetAmmoNormalized(float value)
12045 {
12046 float value_clamped = Math.Clamp(value, 0, 1);
12047 Magazine this_mag = Magazine.Cast(this);
12048 int max_rounds = this_mag.GetAmmoMax();
12049 int result = value * max_rounds;//can the rounded if higher precision is required
12050 this_mag.SetAmmoCount(result);
12051 }*/
12052 //----------------------------------------------------------------
12053 override int GetQuantityMax()
12054 {
12055 int slot = -1;
12056 if (GetInventory())
12057 {
12058 InventoryLocation il = new InventoryLocation;
12059 GetInventory().GetCurrentInventoryLocation(il);
12060 slot = il.GetSlot();
12061 }
12062
12063 return GetTargetQuantityMax(slot);
12064 }
12065
12066 override int GetTargetQuantityMax(int attSlotID = -1)
12067 {
12068 float quantity_max = 0;
12069
12070 if (IsSplitable()) //only stackable/splitable items can check for stack size
12071 {
12072 if (attSlotID != -1)
12073 quantity_max = InventorySlots.GetStackMaxForSlotId(attSlotID);
12074
12075 if (quantity_max <= 0)
12076 quantity_max = m_VarStackMax;
12077 }
12078
12079 if (quantity_max <= 0)
12080 quantity_max = m_VarQuantityMax;
12081
12082 return quantity_max;
12083 }
12084 //----------------------------------------------------------------
12085 override int GetQuantityMin()
12086 {
12087 return m_VarQuantityMin;
12088 }
12089 //----------------------------------------------------------------
12090 int GetQuantityInit()
12091 {
12092 return m_VarQuantityInit;
12093 }
12094
12095 //----------------------------------------------------------------
12096 override bool HasQuantity()
12097 {
12098 return !(GetQuantityMax() - GetQuantityMin() == 0);
12099 }
12100
12101 override float GetQuantity()
12102 {
12103 return m_VarQuantity;
12104 }
12105
12106 bool IsFullQuantity()
12107 {
12108 return GetQuantity() >= GetQuantityMax();
12109 }
12110
12111 //Calculates weight of single item without attachments and cargo
12112 override float GetSingleInventoryItemWeightEx()
12113 {
12114 //this needs to be first stored inside local variables, when returned directly during inside return call, the result is completely different due to enforce script bug
12115 float weightEx = GetWeightEx();//overall weight of the item
12116 float special = GetInventoryAndCargoWeight();//cargo and attachment weight
12117 return weightEx - special;
12118 }
12119
12120 // Obsolete, use GetSingleInventoryItemWeightEx() instead
12122 {
12124 }
12125
12126 override protected float GetWeightSpecialized(bool forceRecalc = false)
12127 {
12128 if (IsSplitable()) //quantity determines size of the stack
12129 {
12130 #ifdef DEVELOPER
12131 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
12132 {
12133 WeightDebugData data1 = WeightDebug.GetWeightDebug(this);
12134 data1.SetCalcDetails("TIB1: " + GetConfigWeightModifiedDebugText() +" * " + GetQuantity()+"(quantity)");
12135 }
12136 #endif
12137
12138 return GetQuantity() * GetConfigWeightModified();
12139 }
12140 else if (HasEnergyManager())// items with energy manager
12141 {
12142 #ifdef DEVELOPER
12143 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
12144 {
12145 WeightDebugData data2 = WeightDebug.GetWeightDebug(this);
12146 data2.SetCalcDetails("TIB2: "+super.GetWeightSpecialized(forceRecalc)+"(contents weight) + " + GetConfigWeightModifiedDebugText() +" + " + GetCompEM().GetEnergy()+"(energy) * " + ConfigGetFloat("weightPerQuantityUnit") +"(weightPerQuantityUnit)");
12147 }
12148 #endif
12149 return super.GetWeightSpecialized(forceRecalc) + (GetCompEM().GetEnergy() * ConfigGetFloat("weightPerQuantityUnit")) + GetConfigWeightModified();
12150 }
12151 else//everything else
12152 {
12153 #ifdef DEVELOPER
12154 if (WeightDebug.m_VerbosityFlags & WeightDebugType.RECALC_FORCED)
12155 {
12156 WeightDebugData data3 = WeightDebug.GetWeightDebug(this);
12157 data3.SetCalcDetails("TIB3: "+super.GetWeightSpecialized(forceRecalc)+"(contents weight) + " + GetConfigWeightModifiedDebugText() +" + " + GetQuantity()+"(quantity) * " + ConfigGetFloat("weightPerQuantityUnit") +"(weightPerQuantityUnit))");
12158 }
12159 #endif
12160 return super.GetWeightSpecialized(forceRecalc) + (GetQuantity() * ConfigGetFloat("weightPerQuantityUnit")) + GetConfigWeightModified();
12161 }
12162 }
12163
12165 int GetNumberOfItems()
12166 {
12167 int item_count = 0;
12168 ItemBase item;
12169
12170 if (GetInventory().GetCargo() != NULL)
12171 {
12172 item_count = GetInventory().GetCargo().GetItemCount();
12173 }
12174
12175 for (int i = 0; i < GetInventory().AttachmentCount(); i++)
12176 {
12177 Class.CastTo(item,GetInventory().GetAttachmentFromIndex(i));
12178 if (item)
12179 item_count += item.GetNumberOfItems();
12180 }
12181 return item_count;
12182 }
12183
12185 float GetUnitWeight(bool include_wetness = true)
12186 {
12187 float weight = 0;
12188 float wetness = 1;
12189 if (include_wetness)
12190 wetness += GetWet();
12191 if (IsSplitable()) //quantity determines size of the stack
12192 {
12193 weight = wetness * m_ConfigWeight;
12194 }
12195 else if (IsLiquidContainer()) //is a liquid container, default liquid weight is set to 1. May revisit later?
12196 {
12197 weight = 1;
12198 }
12199 return weight;
12200 }
12201
12202 //-----------------------------------------------------------------
12203
12204 override void ClearInventory()
12205 {
12206 if ((GetGame().IsServer() || !GetGame().IsMultiplayer()) && GetInventory())
12207 {
12208 GameInventory inv = GetInventory();
12209 array<EntityAI> items = new array<EntityAI>;
12210 inv.EnumerateInventory(InventoryTraversalType.INORDER, items);
12211 for (int i = 0; i < items.Count(); i++)
12212 {
12213 ItemBase item = ItemBase.Cast(items.Get(i));
12214 if (item)
12215 {
12216 GetGame().ObjectDelete(item);
12217 }
12218 }
12219 }
12220 }
12221
12222 //------------------------- Energy
12223
12224 //----------------------------------------------------------------
12225 float GetEnergy()
12226 {
12227 float energy = 0;
12228 if (HasEnergyManager())
12229 {
12230 energy = GetCompEM().GetEnergy();
12231 }
12232 return energy;
12233 }
12234
12235
12236 override void OnEnergyConsumed()
12237 {
12238 super.OnEnergyConsumed();
12239
12241 }
12242
12243 override void OnEnergyAdded()
12244 {
12245 super.OnEnergyAdded();
12246
12248 }
12249
12250 // Converts energy (from Energy Manager) to quantity, if enabled.
12252 {
12253 if (GetGame().IsServer() && HasEnergyManager() && GetCompEM().HasConversionOfEnergyToQuantity())
12254 {
12255 if (HasQuantity())
12256 {
12257 float energy_0to1 = GetCompEM().GetEnergy0To1();
12258 SetQuantityNormalized(energy_0to1);
12259 }
12260 }
12261 }
12262
12263 //----------------------------------------------------------------
12264 float GetHeatIsolationInit()
12265 {
12266 return ConfigGetFloat("heatIsolation");
12267 }
12268
12269 float GetHeatIsolation()
12270 {
12271 return m_HeatIsolation;
12272 }
12273
12274 float GetDryingIncrement(string pIncrementName)
12275 {
12276 string paramPath = string.Format("CfgVehicles %1 EnvironmentWetnessIncrements Drying %2", GetType(), pIncrementName);
12277 if (GetGame().ConfigIsExisting(paramPath))
12278 return GetGame().ConfigGetFloat(paramPath);
12279
12280 return 0.0;
12281 }
12282
12283 float GetSoakingIncrement(string pIncrementName)
12284 {
12285 string paramPath = string.Format("CfgVehicles %1 EnvironmentWetnessIncrements Soaking %2", GetType(), pIncrementName);
12286 if (GetGame().ConfigIsExisting(paramPath))
12287 return GetGame().ConfigGetFloat(paramPath);
12288
12289 return 0.0;
12290 }
12291 //----------------------------------------------------------------
12292 override void SetWet(float value, bool allow_client = false)
12293 {
12294 if (!IsServerCheck(allow_client))
12295 return;
12296
12297 float min = GetWetMin();
12298 float max = GetWetMax();
12299
12300 float previousValue = m_VarWet;
12301
12302 m_VarWet = Math.Clamp(value, min, max);
12303
12304 if (previousValue != m_VarWet)
12305 {
12306 SetVariableMask(VARIABLE_WET);
12307 OnWetChanged(m_VarWet, previousValue);
12308 }
12309 }
12310 //----------------------------------------------------------------
12311 override void AddWet(float value)
12312 {
12313 SetWet(GetWet() + value);
12314 }
12315 //----------------------------------------------------------------
12316 override void SetWetMax()
12317 {
12319 }
12320 //----------------------------------------------------------------
12321 override float GetWet()
12322 {
12323 return m_VarWet;
12324 }
12325 //----------------------------------------------------------------
12326 override float GetWetMax()
12327 {
12328 return m_VarWetMax;
12329 }
12330 //----------------------------------------------------------------
12331 override float GetWetMin()
12332 {
12333 return m_VarWetMin;
12334 }
12335 //----------------------------------------------------------------
12336 override float GetWetInit()
12337 {
12338 return m_VarWetInit;
12339 }
12340 //----------------------------------------------------------------
12341 override void OnWetChanged(float newVal, float oldVal)
12342 {
12343 EWetnessLevel newLevel = GetWetLevelInternal(newVal);
12344 EWetnessLevel oldLevel = GetWetLevelInternal(oldVal);
12345 if (newLevel != oldLevel)
12346 {
12347 OnWetLevelChanged(newLevel,oldLevel);
12348 }
12349 }
12350
12351 override void OnWetLevelChanged(EWetnessLevel newLevel, EWetnessLevel oldLevel)
12352 {
12353 SetWeightDirty();
12354 }
12355
12356 override EWetnessLevel GetWetLevel()
12357 {
12358 return GetWetLevelInternal(m_VarWet);
12359 }
12360
12361 //----------------------------------------------------------------
12362
12363 override void SetStoreLoad(bool value)
12364 {
12365 m_IsStoreLoad = value;
12366 }
12367
12368 override bool IsStoreLoad()
12369 {
12370 return m_IsStoreLoad;
12371 }
12372
12373 override void SetStoreLoadedQuantity(float value)
12374 {
12375 m_StoreLoadedQuantity = value;
12376 }
12377
12378 override float GetStoreLoadedQuantity()
12379 {
12380 return m_StoreLoadedQuantity;
12381 }
12382
12383 //----------------------------------------------------------------
12384
12385 float GetItemModelLength()
12386 {
12387 if (ConfigIsExisting("itemModelLength"))
12388 {
12389 return ConfigGetFloat("itemModelLength");
12390 }
12391 return 0;
12392 }
12393
12394 float GetItemAttachOffset()
12395 {
12396 if (ConfigIsExisting("itemAttachOffset"))
12397 {
12398 return ConfigGetFloat("itemAttachOffset");
12399 }
12400 return 0;
12401 }
12402
12403 override void SetCleanness(int value, bool allow_client = false)
12404 {
12405 if (!IsServerCheck(allow_client))
12406 return;
12407
12408 int previousValue = m_Cleanness;
12409
12410 m_Cleanness = Math.Clamp(value, m_CleannessMin, m_CleannessMax);
12411
12412 if (previousValue != m_Cleanness)
12413 SetVariableMask(VARIABLE_CLEANNESS);
12414 }
12415
12416 override int GetCleanness()
12417 {
12418 return m_Cleanness;
12419 }
12420
12422 {
12423 return true;
12424 }
12425
12426 //----------------------------------------------------------------
12427 // ATTACHMENT LOCKING
12428 // Getters relevant to generic ActionLockAttachment
12429 int GetLockType()
12430 {
12431 return m_LockType;
12432 }
12433
12434 string GetLockSoundSet()
12435 {
12436 return m_LockSoundSet;
12437 }
12438
12439 //----------------------------------------------------------------
12440 //------------------------- Color
12441 // sets items color variable given color components
12442 override void SetColor(int r, int g, int b, int a)
12443 {
12448 SetVariableMask(VARIABLE_COLOR);
12449 }
12451 override void GetColor(out int r,out int g,out int b,out int a)
12452 {
12457 }
12458
12459 bool IsColorSet()
12460 {
12461 return IsVariableSet(VARIABLE_COLOR);
12462 }
12463
12465 string GetColorString()
12466 {
12467 int r,g,b,a;
12468 GetColor(r,g,b,a);
12469 r = r/255;
12470 g = g/255;
12471 b = b/255;
12472 a = a/255;
12473 return MiscGameplayFunctions.GetColorString(r, g, b, a);
12474 }
12475 //----------------------------------------------------------------
12476 //------------------------- LiquidType
12477
12478 override void SetLiquidType(int value, bool allow_client = false)
12479 {
12480 if (!IsServerCheck(allow_client))
12481 return;
12482
12483 int old = m_VarLiquidType;
12484 m_VarLiquidType = value;
12485 OnLiquidTypeChanged(old,value);
12486 SetVariableMask(VARIABLE_LIQUIDTYPE);
12487 }
12488
12489 int GetLiquidTypeInit()
12490 {
12491 return ConfigGetInt("varLiquidTypeInit");
12492 }
12493
12494 override int GetLiquidType()
12495 {
12496 return m_VarLiquidType;
12497 }
12498
12499 protected void OnLiquidTypeChanged(int oldType, int newType)
12500 {
12501 if (newType == LIQUID_NONE && GetIsFrozen())
12502 SetFrozen(false);
12503 }
12504
12506 void UpdateQuickbarShortcutVisibility(PlayerBase player)
12507 {
12508 player.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
12509 }
12510
12511 // -------------------------------------------------------------------------
12513 void OnInventoryEnter(Man player)
12514 {
12515 PlayerBase nplayer;
12516 if (PlayerBase.CastTo(nplayer, player))
12517 {
12518 m_CanPlayImpactSound = true;
12519 //nplayer.OnItemInventoryEnter(this);
12520 nplayer.SetEnableQuickBarEntityShortcut(this,!GetHierarchyParent() || GetHierarchyParent().GetInventory().AreChildrenAccessible());
12521 }
12522 }
12523
12524 // -------------------------------------------------------------------------
12526 void OnInventoryExit(Man player)
12527 {
12528 PlayerBase nplayer;
12529 if (PlayerBase.CastTo(nplayer,player))
12530 {
12531 //nplayer.OnItemInventoryExit(this);
12532 nplayer.SetEnableQuickBarEntityShortcut(this,false);
12533
12534 }
12535
12536 //if (!GetGame().IsDedicatedServer())
12537 player.GetHumanInventory().ClearUserReservedLocationForContainer(this);
12538
12539
12540 if (HasEnergyManager())
12541 {
12542 GetCompEM().UpdatePlugState(); // Unplug the el. device if it's necesarry.
12543 }
12544 }
12545
12546 // ADVANCED PLACEMENT EVENTS
12547 override void OnPlacementStarted(Man player)
12548 {
12549 super.OnPlacementStarted(player);
12550
12551 SetTakeable(false);
12552 }
12553
12554 override void OnPlacementComplete(Man player, vector position = "0 0 0", vector orientation = "0 0 0")
12555 {
12556 if (m_AdminLog)
12557 {
12558 m_AdminLog.OnPlacementComplete(player, this);
12559 }
12560
12561 super.OnPlacementComplete(player, position, orientation);
12562 }
12563
12564 //-----------------------------
12565 // AGENT SYSTEM
12566 //-----------------------------
12567 //--------------------------------------------------------------------------
12568 bool ContainsAgent(int agent_id)
12569 {
12570 if (agent_id & m_AttachedAgents)
12571 {
12572 return true;
12573 }
12574 else
12575 {
12576 return false;
12577 }
12578 }
12579
12580 //--------------------------------------------------------------------------
12581 override void RemoveAgent(int agent_id)
12582 {
12583 if (ContainsAgent(agent_id))
12584 {
12585 m_AttachedAgents = ~agent_id & m_AttachedAgents;
12586 }
12587 }
12588
12589 //--------------------------------------------------------------------------
12590 override void RemoveAllAgents()
12591 {
12592 m_AttachedAgents = 0;
12593 }
12594 //--------------------------------------------------------------------------
12595 override void RemoveAllAgentsExcept(int agent_to_keep)
12596 {
12597 m_AttachedAgents = m_AttachedAgents & agent_to_keep;
12598 }
12599 // -------------------------------------------------------------------------
12600 override void InsertAgent(int agent, float count = 1)
12601 {
12602 if (count < 1)
12603 return;
12604 //Debug.Log("Inserting Agent on item: " + agent.ToString() +" count: " + count.ToString());
12606 }
12607
12609 void TransferAgents(int agents)
12610 {
12612 }
12613
12614 // -------------------------------------------------------------------------
12615 override int GetAgents()
12616 {
12617 return m_AttachedAgents;
12618 }
12619 //----------------------------------------------------------------------
12620
12621 /*int GetContaminationType()
12622 {
12623 int contamination_type;
12624
12625 const int CONTAMINATED_MASK = eAgents.CHOLERA | eAgents.INFLUENZA | eAgents.SALMONELLA | eAgents.BRAIN;
12626 const int POISONED_MASK = eAgents.FOOD_POISON | eAgents.CHEMICAL_POISON;
12627 const int NERVE_GAS_MASK = eAgents.CHEMICAL_POISON;
12628 const int DIRTY_MASK = eAgents.WOUND_AGENT;
12629
12630 Edible_Base edible = Edible_Base.Cast(this);
12631 int agents = GetAgents();
12632 if (edible)
12633 {
12634 NutritionalProfile profile = Edible_Base.GetNutritionalProfile(edible);
12635 if (profile)
12636 {
12637 agents = agents | profile.GetAgents();//merge item's agents with nutritional agents
12638 }
12639 }
12640 if (agents & CONTAMINATED_MASK)
12641 {
12642 contamination_type = contamination_type | EContaminationTypes.ITEM_BADGE_CONTAMINATED;
12643 }
12644 if (agents & POISONED_MASK)
12645 {
12646 contamination_type = contamination_type | EContaminationTypes.ITEM_BADGE_POISONED;
12647 }
12648 if (agents & NERVE_GAS_MASK)
12649 {
12650 contamination_type = contamination_type | EContaminationTypes.ITEM_BADGE_NERVE_GAS;
12651 }
12652 if (agents & DIRTY_MASK)
12653 {
12654 contamination_type = contamination_type | EContaminationTypes.ITEM_BADGE_DIRTY;
12655 }
12656
12657 return agents;
12658 }*/
12659
12660 // -------------------------------------------------------------------------
12661 bool LoadAgents(ParamsReadContext ctx, int version)
12662 {
12663 if (!ctx.Read(m_AttachedAgents))
12664 return false;
12665 return true;
12666 }
12667 // -------------------------------------------------------------------------
12669 {
12670
12672 }
12673 // -------------------------------------------------------------------------
12674
12676 override void CheckForRoofLimited(float timeTresholdMS = 3000)
12677 {
12678 super.CheckForRoofLimited(timeTresholdMS);
12679
12680 float time = GetGame().GetTime();
12681 if ((time - m_PreviousRoofTestTime) >= timeTresholdMS)
12682 {
12683 m_PreviousRoofTestTime = time;
12684 SetRoofAbove(MiscGameplayFunctions.IsUnderRoof(this));
12685 }
12686 }
12687
12688 // returns item's protection level against enviromental hazard, for masks with filters, returns the filters protection for valid filter, otherwise 0
12689 float GetProtectionLevel(int type, bool consider_filter = false, int system = 0)
12690 {
12691 if (IsDamageDestroyed() || (HasQuantity() && GetQuantity() <= 0))
12692 {
12693 return 0;
12694 }
12695
12696 if (GetInventory().GetAttachmentSlotsCount() != 0)//is it an item with attachable filter ?
12697 {
12698 ItemBase filter = ItemBase.Cast(FindAttachmentBySlotName("GasMaskFilter"));
12699 if (filter)
12700 return filter.GetProtectionLevel(type, false, system);//it's a valid filter, return the protection
12701 else
12702 return 0;//otherwise return 0 when no filter attached
12703 }
12704
12705 string subclassPath, entryName;
12706
12707 switch (type)
12708 {
12709 case DEF_BIOLOGICAL:
12710 entryName = "biological";
12711 break;
12712 case DEF_CHEMICAL:
12713 entryName = "chemical";
12714 break;
12715 default:
12716 entryName = "biological";
12717 break;
12718 }
12719
12720 subclassPath = "CfgVehicles " + this.GetType() + " Protection ";
12721
12722 return GetGame().ConfigGetFloat(subclassPath + entryName);
12723 }
12724
12725
12726
12728 override void EEOnCECreate()
12729 {
12730 if (!IsMagazine())
12732
12734 }
12735
12736
12737 //-------------------------
12738 // OPEN/CLOSE USER ACTIONS
12739 //-------------------------
12741 void Open();
12742 void Close();
12743 bool IsOpen()
12744 {
12745 return true;
12746 }
12747
12748 override bool CanDisplayCargo()
12749 {
12750 return IsOpen();
12751 }
12752
12753
12754 // ------------------------------------------------------------
12755 // CONDITIONS
12756 // ------------------------------------------------------------
12757 override bool CanPutInCargo(EntityAI parent)
12758 {
12759 if (parent)
12760 {
12761 if (parent.IsInherited(DayZInfected))
12762 return true;
12763
12764 if (!parent.IsRuined())
12765 return true;
12766 }
12767
12768 return true;
12769 }
12770
12771 override bool CanPutAsAttachment(EntityAI parent)
12772 {
12773 if (!super.CanPutAsAttachment(parent))
12774 {
12775 return false;
12776 }
12777
12778 if (!IsRuined() && !parent.IsRuined())
12779 {
12780 return true;
12781 }
12782
12783 return false;
12784 }
12785
12786 override bool CanReceiveItemIntoCargo(EntityAI item)
12787 {
12788 //removed 15.06. coz of loading from storage -> after load items in cargo was lost -> waiting for proper solution
12789 //if (GetHealthLevel() == GameConstants.STATE_RUINED)
12790 // return false;
12791
12792 return super.CanReceiveItemIntoCargo(item);
12793 }
12794
12795 override bool CanReceiveAttachment(EntityAI attachment, int slotId)
12796 {
12797 //removed 15.06. coz of loading from storage -> after load items in cargo was lost -> waiting for proper solution
12798 //if (GetHealthLevel() == GameConstants.STATE_RUINED)
12799 // return false;
12800
12801 GameInventory attachmentInv = attachment.GetInventory();
12802 if (attachmentInv && attachmentInv.GetCargo() && attachmentInv.GetCargo().GetItemCount() > 0)
12803 {
12804 if (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase))
12805 return false;
12806 }
12807
12808 InventoryLocation loc = new InventoryLocation();
12809 attachment.GetInventory().GetCurrentInventoryLocation(loc);
12810 if (loc && loc.IsValid() && !GetInventory().AreChildrenAccessible())
12811 return false;
12812
12813 return super.CanReceiveAttachment(attachment, slotId);
12814 }
12815
12816 override bool CanReleaseAttachment(EntityAI attachment)
12817 {
12818 if (!super.CanReleaseAttachment(attachment))
12819 return false;
12820
12821 return GetInventory().AreChildrenAccessible();
12822 }
12823
12824 /*override bool CanLoadAttachment(EntityAI attachment)
12825 {
12826 //removed 15.06. coz of loading from storage -> after load items in cargo was lost -> waiting for proper solution
12827 //if (GetHealthLevel() == GameConstants.STATE_RUINED)
12828 // return false;
12829
12830 GameInventory attachmentInv = attachment.GetInventory();
12831 if (attachmentInv && attachmentInv.GetCargo() && attachmentInv.GetCargo().GetItemCount() > 0)
12832 {
12833 bool boo = (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase));
12834 ErrorEx("CanLoadAttachment | this: " + this + " | attachment: " + attachment + " | boo: " + boo,ErrorExSeverity.INFO);
12835
12836 if (GetHierarchyParent() && !GetHierarchyParent().IsInherited(PlayerBase))
12837 return false;
12838 }
12839
12840 return super.CanLoadAttachment(attachment);
12841 }*/
12842
12843 // Plays muzzle flash particle effects
12844 static void PlayFireParticles(ItemBase weapon, int muzzle_index, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
12845 {
12846 int id = muzzle_owner.GetMuzzleID();
12847 array<ref WeaponParticlesOnFire> WPOF_array = m_OnFireEffect.Get(id);
12848
12849 if (WPOF_array)
12850 {
12851 for (int i = 0; i < WPOF_array.Count(); i++)
12852 {
12853 WeaponParticlesOnFire WPOF = WPOF_array.Get(i);
12854
12855 if (WPOF)
12856 {
12857 WPOF.OnActivate(weapon, muzzle_index, ammoType, muzzle_owner, suppressor, config_to_search);
12858 }
12859 }
12860 }
12861 }
12862
12863 // Plays bullet eject particle effects (usually just smoke, the bullet itself is a 3D model and is not part of this function)
12864 static void PlayBulletCasingEjectParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
12865 {
12866 int id = muzzle_owner.GetMuzzleID();
12867 array<ref WeaponParticlesOnBulletCasingEject> WPOBE_array = m_OnBulletCasingEjectEffect.Get(id);
12868
12869 if (WPOBE_array)
12870 {
12871 for (int i = 0; i < WPOBE_array.Count(); i++)
12872 {
12873 WeaponParticlesOnBulletCasingEject WPOBE = WPOBE_array.Get(i);
12874
12875 if (WPOBE)
12876 {
12877 WPOBE.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
12878 }
12879 }
12880 }
12881 }
12882
12883 // Plays all weapon overheating particles
12884 static void PlayOverheatingParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
12885 {
12886 int id = muzzle_owner.GetMuzzleID();
12887 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
12888
12889 if (WPOOH_array)
12890 {
12891 for (int i = 0; i < WPOOH_array.Count(); i++)
12892 {
12893 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
12894
12895 if (WPOOH)
12896 {
12897 WPOOH.OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
12898 }
12899 }
12900 }
12901 }
12902
12903 // Updates all weapon overheating particles
12904 static void UpdateOverheatingParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
12905 {
12906 int id = muzzle_owner.GetMuzzleID();
12907 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
12908
12909 if (WPOOH_array)
12910 {
12911 for (int i = 0; i < WPOOH_array.Count(); i++)
12912 {
12913 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
12914
12915 if (WPOOH)
12916 {
12917 WPOOH.OnUpdate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
12918 }
12919 }
12920 }
12921 }
12922
12923 // Stops overheating particles
12924 static void StopOverheatingParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
12925 {
12926 int id = muzzle_owner.GetMuzzleID();
12927 array<ref WeaponParticlesOnOverheating> WPOOH_array = weapon.m_OnOverheatingEffect.Get(id);
12928
12929 if (WPOOH_array)
12930 {
12931 for (int i = 0; i < WPOOH_array.Count(); i++)
12932 {
12933 WeaponParticlesOnOverheating WPOOH = WPOOH_array.Get(i);
12934
12935 if (WPOOH)
12936 {
12937 WPOOH.OnDeactivate(weapon, ammoType, muzzle_owner, suppressor, config_to_search);
12938 }
12939 }
12940 }
12941 }
12942
12943 //----------------------------------------------------------------
12944 //Item Behaviour - unified approach
12945 override bool IsHeavyBehaviour()
12946 {
12947 if (m_ItemBehaviour == 0)
12948 {
12949 return true;
12950 }
12951
12952 return false;
12953 }
12954
12955 override bool IsOneHandedBehaviour()
12956 {
12957 if (m_ItemBehaviour == 1)
12958 {
12959 return true;
12960 }
12961
12962 return false;
12963 }
12964
12965 override bool IsTwoHandedBehaviour()
12966 {
12967 if (m_ItemBehaviour == 2)
12968 {
12969 return true;
12970 }
12971
12972 return false;
12973 }
12974
12975 bool IsDeployable()
12976 {
12977 return false;
12978 }
12979
12981 float GetDeployTime()
12982 {
12983 return UATimeSpent.DEFAULT_DEPLOY;
12984 }
12985
12986
12987 //----------------------------------------------------------------
12988 // Item Targeting (User Actions)
12989 override void SetTakeable(bool pState)
12990 {
12991 m_IsTakeable = pState;
12992 SetSynchDirty();
12993 }
12994
12995 override bool IsTakeable()
12996 {
12997 return m_IsTakeable;
12998 }
12999
13000 // For cases where we want to show object widget which cant be taken to hands
13002 {
13003 return false;
13004 }
13005
13007 protected void PreLoadSoundAttachmentType()
13008 {
13009 string att_type = "None";
13010
13011 if (ConfigIsExisting("soundAttType"))
13012 {
13013 att_type = ConfigGetString("soundAttType");
13014 }
13015
13016 m_SoundAttType = att_type;
13017 }
13018
13019 override string GetAttachmentSoundType()
13020 {
13021 return m_SoundAttType;
13022 }
13023
13024 //----------------------------------------------------------------
13025 //SOUNDS - ItemSoundHandler
13026 //----------------------------------------------------------------
13027
13028 string GetPlaceSoundset(); // played when deploy starts
13029 string GetLoopDeploySoundset(); // played when deploy starts and stopped when it finishes
13030 string GetDeploySoundset(); // played when deploy sucessfully finishes
13031 string GetLoopFoldSoundset(); // played when fold starts and stopped when it finishes
13032 string GetFoldSoundset(); // played when fold sucessfully finishes
13033
13035 {
13036 if (!m_ItemSoundHandler)
13038
13039 return m_ItemSoundHandler;
13040 }
13041
13042 // override to initialize sounds
13043 protected void InitItemSounds()
13044 {
13045 if (GetPlaceSoundset() == string.Empty && GetDeploySoundset() == string.Empty && GetLoopDeploySoundset() == string.Empty)
13046 return;
13047
13049
13050 if (GetPlaceSoundset() != string.Empty)
13051 handler.AddSound(SoundConstants.ITEM_PLACE, GetPlaceSoundset());
13052
13053 if (GetDeploySoundset() != string.Empty)
13054 handler.AddSound(SoundConstants.ITEM_DEPLOY, GetDeploySoundset());
13055
13056 SoundParameters params = new SoundParameters();
13057 params.m_Loop = true;
13058 if (GetLoopDeploySoundset() != string.Empty)
13059 handler.AddSound(SoundConstants.ITEM_DEPLOY_LOOP, GetLoopDeploySoundset(), params);
13060 }
13061
13062 // Start sound using ItemSoundHandler
13063 void StartItemSoundServer(int id)
13064 {
13065 if (!GetGame().IsServer())
13066 return;
13067
13068 m_SoundSyncPlay = id;
13069 SetSynchDirty();
13070
13071 GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).Remove(ClearStartItemSoundServer); // in case one is queued already
13073 }
13074
13075 // Stop sound using ItemSoundHandler
13076 void StopItemSoundServer(int id)
13077 {
13078 if (!GetGame().IsServer())
13079 return;
13080
13081 m_SoundSyncStop = id;
13082 SetSynchDirty();
13083
13084 GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).Remove(ClearStopItemSoundServer); // in case one is queued already
13086 }
13087
13088 protected void ClearStartItemSoundServer()
13089 {
13090 m_SoundSyncPlay = 0;
13091 }
13092
13093 protected void ClearStopItemSoundServer()
13094 {
13095 m_SoundSyncStop = 0;
13096 }
13097
13099 void PlayAttachSound(string slot_type)
13100 {
13101 if (!GetGame().IsDedicatedServer())
13102 {
13103 if (ConfigIsExisting("attachSoundSet"))
13104 {
13105 string cfg_path = "";
13106 string soundset = "";
13107 string type_name = GetType();
13108
13109 TStringArray cfg_soundset_array = new TStringArray;
13110 TStringArray cfg_slot_array = new TStringArray;
13111 ConfigGetTextArray("attachSoundSet",cfg_soundset_array);
13112 ConfigGetTextArray("attachSoundSlot",cfg_slot_array);
13113
13114 if (cfg_soundset_array.Count() > 0 && cfg_soundset_array.Count() == cfg_slot_array.Count())
13115 {
13116 for (int i = 0; i < cfg_soundset_array.Count(); i++)
13117 {
13118 if (cfg_slot_array[i] == slot_type)
13119 {
13120 soundset = cfg_soundset_array[i];
13121 break;
13122 }
13123 }
13124 }
13125
13126 if (soundset != "")
13127 {
13128 EffectSound sound = SEffectManager.PlaySound(soundset, GetPosition());
13129 sound.SetAutodestroy(true);
13130 }
13131 }
13132 }
13133 }
13134
13135 void PlayDetachSound(string slot_type)
13136 {
13137 //TODO - evaluate if needed and devise universal config structure if so
13138 }
13139
13140 void OnApply(PlayerBase player);
13141
13143 {
13144 return 1.0;
13145 };
13146 //returns applicable selection
13147 array<string> GetHeadHidingSelection()
13148 {
13150 }
13151
13153 {
13155 }
13156
13157 WrittenNoteData GetWrittenNoteData() {};
13158
13160 {
13161 SetDynamicPhysicsLifeTime(0.01);
13162 m_ItemBeingDroppedPhys = false;
13163 }
13164
13166 {
13167 array<string> zone_names = new array<string>;
13168 GetDamageZones(zone_names);
13169 for (int i = 0; i < zone_names.Count(); i++)
13170 {
13171 SetHealthMax(zone_names.Get(i),"Health");
13172 }
13173 SetHealthMax("","Health");
13174 }
13175
13177 void SetZoneDamageCEInit()
13178 {
13179 float global_health = GetHealth01("","Health");
13180 array<string> zones = new array<string>;
13181 GetDamageZones(zones);
13182 //set damage of all zones to match global health level
13183 for (int i = 0; i < zones.Count(); i++)
13184 {
13185 SetHealth01(zones.Get(i),"Health",global_health);
13186 }
13187 }
13188
13190 bool IsCoverFaceForShave(string slot_name)
13191 {
13192 return IsExclusionFlagPresent(PlayerBase.GetFaceCoverageShaveValues());
13193 }
13194
13195 void ProcessItemWetness(float delta, bool hasParent, bool hasRootAsPlayer, ItemBase refParentIB)
13196 {
13197 if (!hasRootAsPlayer)
13198 {
13199 if (refParentIB)
13200 {
13201 // parent is wet
13202 if ((refParentIB.GetWet() >= GameConstants.STATE_SOAKING_WET) && (m_VarWet < m_VarWetMax))
13203 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_INSIDE);
13204 // parent has liquid inside
13205 else if ((refParentIB.GetLiquidType() != 0) && (refParentIB.GetQuantity() > 0) && (m_VarWet < m_VarWetMax))
13206 AddWet(delta * GameConstants.WETNESS_RATE_WETTING_LIQUID);
13207 // drying
13208 else if (m_VarWet > m_VarWetMin)
13209 AddWet(-1 * delta * GetDryingIncrement("ground") * 2);
13210 }
13211 else
13212 {
13213 // drying on ground or inside non-itembase (car, ...)
13214 if (m_VarWet > m_VarWetMin)
13215 AddWet(-1 * delta * GetDryingIncrement("ground"));
13216 }
13217 }
13218 }
13219
13220 void ProcessItemTemperature(float delta, bool hasParent, bool hasRootAsPlayer, ItemBase refParentIB)
13221 {
13223 {
13224 float target = g_Game.GetMission().GetWorldData().GetBaseEnvTemperatureAtObject(this);
13225 if (GetTemperature() != target || !IsFreezeThawProgressFinished())
13226 {
13227 float heatPermCoef = 1.0;
13228 EntityAI ent = this;
13229 while (ent)
13230 {
13231 heatPermCoef *= ent.GetHeatPermeabilityCoef();
13232 ent = ent.GetHierarchyParent();
13233 }
13234
13235 SetTemperatureEx(new TemperatureDataInterpolated(target,ETemperatureAccessTypes.ACCESS_WORLD,delta,GameConstants.TEMP_COEF_WORLD,heatPermCoef));
13236 }
13237 }
13238 }
13239
13240 void HierarchyCheck(out bool hasParent, out bool hasRootAsPlayer, out ItemBase refParentIB)
13241 {
13242 // hierarchy check for an item to decide whether it has some parent and it is in some player inventory
13243 EntityAI parent = GetHierarchyParent();
13244 if (!parent)
13245 {
13246 hasParent = false;
13247 hasRootAsPlayer = false;
13248 }
13249 else
13250 {
13251 hasParent = true;
13252 hasRootAsPlayer = (GetHierarchyRootPlayer() != null);
13253 refParentIB = ItemBase.Cast(parent);
13254 }
13255 }
13256
13257 protected void ProcessDecay(float delta, bool hasRootAsPlayer)
13258 {
13259 // this is stub, implemented on Edible_Base
13260 }
13261
13262 bool CanDecay()
13263 {
13264 // return true used on selected food clases so they can decay
13265 return false;
13266 }
13267
13268 protected bool CanProcessDecay()
13269 {
13270 // this is stub, implemented on Edible_Base class
13271 // used to determine whether it is still necessary for the food to decay
13272 return false;
13273 }
13274
13275 protected bool CanHaveWetness()
13276 {
13277 // return true used on selected items that have a wetness effect
13278 return false;
13279 }
13280
13282 bool CanBeConsumed(ConsumeConditionData data = null)
13283 {
13284 return !GetIsFrozen() && IsOpen();
13285 }
13286
13287 override void ProcessVariables()
13288 {
13289 bool hasParent = false, hasRootAsPlayer = false;
13290 ItemBase refParentIB;
13291
13292 bool wwtu = g_Game.IsWorldWetTempUpdateEnabled();
13293 bool foodDecay = g_Game.IsFoodDecayEnabled();
13294
13295 if (wwtu || foodDecay)
13296 {
13297 bool processWetness = wwtu && CanHaveWetness();
13298 bool processTemperature = wwtu && CanHaveTemperature();
13299 bool processDecay = foodDecay && CanDecay() && CanProcessDecay();
13300
13301 if (processWetness || processTemperature || processDecay)
13302 {
13303 HierarchyCheck(hasParent, hasRootAsPlayer, refParentIB);
13304
13305 if (processWetness)
13306 ProcessItemWetness(m_ElapsedSinceLastUpdate, hasParent, hasRootAsPlayer, refParentIB);
13307
13308 if (processTemperature)
13309 ProcessItemTemperature(m_ElapsedSinceLastUpdate, hasParent, hasRootAsPlayer, refParentIB);
13310
13311 if (processDecay)
13312 ProcessDecay(m_ElapsedSinceLastUpdate, hasRootAsPlayer);
13313 }
13314 }
13315 }
13316
13319 {
13320 return m_TemperaturePerQuantityWeight * GameConstants.ITEM_TEMPERATURE_QUANTITY_WEIGHT_MULTIPLIER;
13321 }
13322
13323 override float GetTemperatureFreezeThreshold()
13324 {
13326 return Liquid.GetFreezeThreshold(GetLiquidType());
13327
13328 return super.GetTemperatureFreezeThreshold();
13329 }
13330
13331 override float GetTemperatureThawThreshold()
13332 {
13334 return Liquid.GetThawThreshold(GetLiquidType());
13335
13336 return super.GetTemperatureThawThreshold();
13337 }
13338
13339 override float GetItemOverheatThreshold()
13340 {
13342 return Liquid.GetBoilThreshold(GetLiquidType());
13343
13344 return super.GetItemOverheatThreshold();
13345 }
13346
13347 override float GetTemperatureFreezeTime()
13348 {
13349 if (HasQuantity())
13350 return Math.Lerp(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureFreezeTime()),GetQuantityNormalized());
13351
13352 return super.GetTemperatureFreezeTime();
13353 }
13354
13355 override float GetTemperatureThawTime()
13356 {
13357 if (HasQuantity())
13358 return Math.Lerp(GameConstants.TEMPERATURE_TIME_THAW_MIN,Math.Max(GameConstants.TEMPERATURE_TIME_FREEZE_MIN,super.GetTemperatureThawTime()),GetQuantityNormalized());
13359
13360 return super.GetTemperatureThawTime();
13361 }
13362
13364 void AffectLiquidContainerOnFill(int liquid_type, float amount);
13366 void AffectLiquidContainerOnTransfer(int liquidType, float amount, float sourceLiquidTemperature);
13367
13368 bool IsCargoException4x3(EntityAI item)
13369 {
13370 return (item.IsKindOf("Cauldron") || item.IsKindOf("Pot") || item.IsKindOf("FryingPan") || item.IsKindOf("SmallProtectorCase") || (item.IsKindOf("PortableGasStove") && item.FindAttachmentBySlotName("CookingEquipment")));
13371 }
13372
13374 {
13375 MiscGameplayFunctions.TransferItemProperties(oldItem, this);
13376 }
13377
13379 void AddLightSourceItem(ItemBase lightsource)
13380 {
13381 m_LightSourceItem = lightsource;
13382 }
13383
13385 {
13386 m_LightSourceItem = null;
13387 }
13388
13390 {
13391 return m_LightSourceItem;
13392 }
13393
13395 array<int> GetValidFinishers()
13396 {
13397 return null;
13398 }
13399
13401 bool GetActionWidgetOverride(out typename name)
13402 {
13403 return false;
13404 }
13405
13406 bool PairWithDevice(notnull ItemBase otherDevice)
13407 {
13408 if (GetGame().IsServer())
13409 {
13410 ItemBase explosive = otherDevice;
13412 if (!trg)
13413 {
13414 trg = RemoteDetonatorTrigger.Cast(otherDevice);
13415 explosive = this;
13416 }
13417
13418 explosive.PairRemote(trg);
13419 trg.SetControlledDevice(explosive);
13420
13421 int persistentID = RemotelyActivatedItemBehaviour.GeneratePersistentID();
13422 trg.SetPersistentPairID(persistentID);
13423 explosive.SetPersistentPairID(persistentID);
13424
13425 return true;
13426 }
13427 return false;
13428 }
13429
13431 float GetBaitEffectivity()
13432 {
13433 float ret = 1.0;
13434 if (HasQuantity())
13435 ret *= GetQuantityNormalized();
13436 ret *= GetHealth01();
13437
13438 return ret;
13439 }
13440
13441 #ifdef DEVELOPER
13442 override void SetDebugItem()
13443 {
13444 super.SetDebugItem();
13445 _itemBase = this;
13446 }
13447
13448 override string GetDebugText()
13449 {
13450 string text = super.GetDebugText();
13451
13452 text += string.Format("Heat isolation(raw): %1\n", GetHeatIsolation());
13453 text += string.Format("Heat isolation(modified): %1\n", MiscGameplayFunctions.GetCurrentItemHeatIsolation(this));
13454
13455 return text;
13456 }
13457 #endif
13458
13459 bool CanBeUsedForSuicide()
13460 {
13461 return true;
13462 }
13463
13465 //DEPRECATED BELOW
13467 // Backwards compatibility
13468 void ProcessItemWetnessAndTemperature(float delta, bool hasParent, bool hasRootAsPlayer, ItemBase refParentIB)
13469 {
13470 ProcessItemWetness(delta, hasParent, hasRootAsPlayer, refParentIB);
13471 ProcessItemTemperature(delta, hasParent, hasRootAsPlayer, refParentIB);
13472 }
13473
13474 // replaced by ItemSoundHandler
13475 protected EffectSound m_SoundDeployFinish;
13476 protected EffectSound m_SoundPlace;
13477 protected EffectSound m_DeployLoopSoundEx;
13478 protected EffectSound m_SoundDeploy;
13479 bool m_IsPlaceSound;
13480 bool m_IsDeploySound;
13482
13483 string GetDeployFinishSoundset();
13484 void PlayDeploySound();
13485 void PlayDeployFinishSound();
13486 void PlayPlaceSound();
13487 void PlayDeployLoopSoundEx();
13488 void StopDeployLoopSoundEx();
13489 void SoundSynchRemoteReset();
13490 void SoundSynchRemote();
13491 bool UsesGlobalDeploy(){return false;}
13492 bool CanPlayDeployLoopSound(){return false;}
13494 bool IsPlaceSound(){return m_IsPlaceSound;}
13495 bool IsDeploySound(){return m_IsDeploySound;}
13496 void SetIsPlaceSound(bool is_place_sound);
13497 void SetIsDeploySound(bool is_deploy_sound);
13498}
13499
13500EntityAI SpawnItemOnLocation(string object_name, notnull InventoryLocation loc, bool full_quantity)
13501{
13502 EntityAI entity = SpawnEntity(object_name, loc, ECE_IN_INVENTORY, RF_DEFAULT);
13503 if (entity)
13504 {
13505 bool is_item = entity.IsInherited(ItemBase);
13506 if (is_item && full_quantity)
13507 {
13508 ItemBase item = ItemBase.Cast(entity);
13509 item.SetQuantity(item.GetQuantityInit());
13510 }
13511 }
13512 else
13513 {
13514 ErrorEx("Cannot spawn entity: " + object_name,ErrorExSeverity.INFO);
13515 return NULL;
13516 }
13517 return entity;
13518}
13519
13520void SetupSpawnedItem(ItemBase item, float health, float quantity)
13521{
13522 if (item)
13523 {
13524 if (health > 0)
13525 item.SetHealth("", "", health);
13526
13527 if (item.CanHaveTemperature())
13528 {
13529 item.SetTemperatureDirect(GameConstants.ITEM_TEMPERATURE_NEUTRAL_ZONE_MIDDLE);
13530 if (item.CanFreeze())
13531 item.SetFrozen(false);
13532 }
13533
13534 if (item.HasEnergyManager())
13535 {
13536 if (quantity >= 0)
13537 {
13538 item.GetCompEM().SetEnergy0To1(quantity);
13539 }
13540 else
13541 {
13542 item.GetCompEM().SetEnergy(Math.AbsFloat(quantity));
13543 }
13544 }
13545 else if (item.IsMagazine())
13546 {
13547 Magazine mag = Magazine.Cast(item);
13548 if (quantity >= 0)
13549 {
13550 mag.ServerSetAmmoCount(mag.GetAmmoMax() * quantity);
13551 }
13552 else
13553 {
13554 mag.ServerSetAmmoCount(Math.AbsFloat(quantity));
13555 }
13556
13557 }
13558 else
13559 {
13560 if (quantity >= 0)
13561 {
13562 item.SetQuantityNormalized(quantity, false);
13563 }
13564 else
13565 {
13566 item.SetQuantity(Math.AbsFloat(quantity));
13567 }
13568
13569 }
13570 }
13571}
13572
13573#ifdef DEVELOPER
13574ItemBase _itemBase;//watched item goes here(LCTRL+RMB->Watch)
13575#endif
Param4< int, int, string, int > TSelectableActionInfoWithColor
Определения 3_Game/Entities/EntityAI.c:97
Param3 TSelectableActionInfo
EWetnessLevel
Определения 3_Game/Entities/EntityAI.c:2
InventoryMode
NOTE: PREDICTIVE is not to be used at all in multiplayer.
const int INPUT_UDT_ITEM_MANIPULATION
class LogManager EntityAI
eBleedingSourceType GetType()
ItemSuppressor SuppressorBase
void ActionDropItem()
Определения ActionDropItem.c:14
void ActionManagerBase(PlayerBase player)
Определения ActionManagerBase.c:63
map< typename, ref array< ActionBase_Basic > > TInputActionMap
Определения ActionManagerClient.c:1
void AddAction(typename actionName)
Определения AdvancedCommunication.c:220
void RemoveAction(typename actionName)
Определения AdvancedCommunication.c:252
TInputActionMap m_InputActionMap
Определения AdvancedCommunication.c:137
bool m_ActionsInitialize
Определения AdvancedCommunication.c:138
override void GetActions(typename action_input_type, out array< ActionBase_Basic > actions)
Определения AdvancedCommunication.c:202
void InitializeActions()
Определения AdvancedCommunication.c:190
int GetLiquidType()
Определения CCTWaterSurface.c:129
const int ECE_PLACE_ON_SURFACE
Определения CentralEconomy.c:37
proto native void SpawnEntity(string sClassName, vector vPos, float fRange, int iCount)
Spawn an entity through CE.
const int ECE_IN_INVENTORY
Определения CentralEconomy.c:36
const int RF_DEFAULT
Определения CentralEconomy.c:65
PlayerSpawnPresetDiscreteItemSetSlotData name
one set for cargo
PlayerSpawnPreset slotName
Open
Implementations only.
override void EEOnCECreate()
Определения ContaminatedArea_Dynamic.c:42
map
Определения ControlsXboxNew.c:4
CookingMethodType
Определения Cooking.c:2
DamageType
exposed from C++ (do not change)
Определения DamageSystem.c:11
DayZGame g_Game
Определения DayZGame.c:3868
DayZGame GetDayZGame()
Определения DayZGame.c:3870
EActions
Определения EActions.c:2
ERPCs
Определения ERPCs.c:2
PluginAdminLog m_AdminLog
Определения EmoteManager.c:142
const int MAX
Определения EnConvert.c:27
float GetTemperature()
Определения Environment.c:497
override bool IsExplosive()
Определения ExplosivesBase.c:59
override bool CanHaveTemperature()
Определения FireplaceBase.c:559
class GP5GasMask extends MaskBase ItemBase
Empty
Определения Hand_States.c:14
FindInventoryLocationType
flags for searching locations in inventory
Определения InventoryLocation.c:17
InventoryLocationType
types of Inventory Location
Определения InventoryLocation.c:4
class BoxCollidingParams component
ComponentInfo for BoxCollidingResult.
bool DamageItemInCargo(float damage)
Определения ItemBase.c:6380
static bool HasDebugActionsMask(int mask)
Определения ItemBase.c:5620
bool HidesSelectionBySlot()
Определения ItemBase.c:9347
float m_VarWetMin
Определения ItemBase.c:4881
void SplitItem(PlayerBase player)
Определения ItemBase.c:6831
void CopyScriptPropertiesFrom(EntityAI oldItem)
Определения ItemBase.c:9568
override void InsertAgent(int agent, float count=1)
Определения ItemBase.c:8795
override float GetQuantityNormalized()
Gets quantity in normalized 0..1 form between the item's Min a Max values as defined by item's config...
Определения ItemBase.c:8229
static void SetDebugActionsMask(int mask)
Определения ItemBase.c:5625
void SetIsDeploySound(bool is_deploy_sound)
bool IsOpen()
Определения ItemBase.c:8938
void SplitItemToInventoryLocation(notnull InventoryLocation dst)
Определения ItemBase.c:6798
override bool IsHeavyBehaviour()
Определения ItemBase.c:9140
override void SetWetMax()
Определения ItemBase.c:8511
bool IsCoverFaceForShave(string slot_name)
DEPRECATED in use, but returns correct values nontheless. Check performed elsewhere.
Определения ItemBase.c:9385
void ClearStartItemSoundServer()
Определения ItemBase.c:9283
float m_VarWet
Определения ItemBase.c:4878
void ProcessItemTemperature(float delta, bool hasParent, bool hasRootAsPlayer, ItemBase refParentIB)
Определения ItemBase.c:9415
map< typename, ref ActionOverrideData > TActionAnimOverrideMap
Определения ItemBase.c:2
override void RemoveAllAgentsExcept(int agent_to_keep)
Определения ItemBase.c:8790
static ref map< int, ref array< ref WeaponParticlesOnBulletCasingEject > > m_OnBulletCasingEjectEffect
Определения ItemBase.c:4941
bool CanBeMovedOverride()
Определения ItemBase.c:7522
override void SetWet(float value, bool allow_client=false)
Определения ItemBase.c:8487
ref TIntArray m_SingleUseActions
Определения ItemBase.c:4927
override void ProcessVariables()
Определения ItemBase.c:9482
ref TStringArray m_HeadHidingSelections
Определения ItemBase.c:4955
float GetWeightSpecialized(bool forceRecalc=false)
Определения ItemBase.c:8321
bool LoadAgents(ParamsReadContext ctx, int version)
Определения ItemBase.c:8856
void UpdateQuickbarShortcutVisibility(PlayerBase player)
To be called on moving item within character's inventory; 'player' should never be null.
Определения ItemBase.c:8701
void OverrideActionAnimation(typename action, int commandUID, int stanceMask=-1, int commandUIDProne=-1)
Определения ItemBase.c:5211
ref array< ref OverheatingParticle > m_OverheatingParticles
Определения ItemBase.c:4953
override float GetTemperatureFreezeThreshold()
Определения ItemBase.c:9518
bool m_IsSoundSynchRemote
Определения ItemBase.c:9676
float m_OverheatingShots
Определения ItemBase.c:4948
void StopItemSoundServer(int id)
Определения ItemBase.c:9271
static void ToggleDebugActionsMask(int mask)
Определения ItemBase.c:5640
void IncreaseOverheating(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
Определения ItemBase.c:5364
override float GetTemperatureFreezeTime()
Определения ItemBase.c:9542
ref array< int > m_CompatibleLocks
Определения ItemBase.c:4965
bool CanBeCooked()
Определения ItemBase.c:7478
override void CombineItemsClient(EntityAI entity2, bool use_stack_max=true)
Определения ItemBase.c:5707
float m_TemperaturePerQuantityWeight
Определения ItemBase.c:4977
bool m_RecipesInitialized
Определения ItemBase.c:4863
void SplitIntoStackMax(EntityAI destination_entity, int slot_id, PlayerBase player)
Определения ItemBase.c:6471
override float GetTemperatureThawThreshold()
Определения ItemBase.c:9526
override void OnEnergyConsumed()
Определения ItemBase.c:8431
void RefreshAudioVisualsOnClient(CookingMethodType cooking_method, bool is_done, bool is_empty, bool is_burned)
cooking-related effect methods
Определения Bottle_Base.c:158
int GetNumberOfItems()
Returns the number of items in cargo, otherwise returns 0(non-cargo objects). Recursive.
Определения ItemBase.c:8360
override EWetnessLevel GetWetLevel()
Определения ItemBase.c:8551
float GetSingleInventoryItemWeight()
Определения ItemBase.c:8316
ref TIntArray m_InteractActions
Определения ItemBase.c:4929
void MessageToOwnerStatus(string text)
Send message to owner player in grey color.
Определения ItemBase.c:7542
float m_VarQuantity
Определения ItemBase.c:4869
bool CanPlayDeployLoopSound()
Определения ItemBase.c:9687
override float GetWetMax()
Определения ItemBase.c:8521
bool CanBeUsedForSuicide()
Определения ItemBase.c:9654
override void CombineItemsEx(EntityAI entity2, bool use_stack_max=true)
Определения ItemBase.c:7117
void OnItemInHandsPlayerSwimStart(PlayerBase player)
void SetIsHologram(bool is_hologram)
Определения ItemBase.c:5845
void OnSyncVariables(ParamsReadContext ctx)
DEPRECATED (most likely)
Определения ItemBase.c:7696
void StartItemSoundServer(int id)
Определения ItemBase.c:9258
void DoAmmoExplosion()
Определения ItemBase.c:6315
static ref map< int, ref array< ref WeaponParticlesOnFire > > m_OnFireEffect
Определения ItemBase.c:4940
void SplitIntoStackMaxCargoClient(EntityAI destination_entity, int idx, int row, int col)
Определения ItemBase.c:6655
int GetItemSize()
Определения ItemBase.c:7507
bool m_CanBeMovedOverride
Определения ItemBase.c:4906
override string ChangeIntoOnAttach(string slot)
Определения ItemBase.c:6239
void UpdateOverheating(ItemBase weapon=null, string ammoType="", ItemBase muzzle_owner=null, ItemBase suppressor=null, string config_to_search="")
Определения ItemBase.c:5432
bool CanDecay()
Определения ItemBase.c:9457
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...
Определения ItemBase.c:8202
void SetQuantityMax()
Определения ItemBase.c:8207
override float GetQuantity()
Определения ItemBase.c:8296
int m_ColorComponentR
Определения ItemBase.c:4918
int m_ShotsToStartOverheating
Определения ItemBase.c:4950
override void OnWetChanged(float newVal, float oldVal)
Определения ItemBase.c:8536
void StopOverheating(ItemBase weapon=null, string ammoType="", ItemBase muzzle_owner=null, ItemBase suppressor=null, string config_to_search="")
Определения ItemBase.c:5439
static void PlayFireParticles(ItemBase weapon, int muzzle_index, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
Определения ItemBase.c:9039
void OnOverheatingDecay()
Определения ItemBase.c:5402
float GetDryingIncrement(string pIncrementName)
Определения ItemBase.c:8469
void SoundSynchRemoteReset()
int m_Cleanness
Определения ItemBase.c:4884
bool HasMuzzle()
Returns true if this item has a muzzle (weapons, suppressors)
Определения ItemBase.c:5540
bool UsesGlobalDeploy()
Определения ItemBase.c:9686
int m_ItemBehaviour
Определения ItemBase.c:4899
override bool CanReleaseAttachment(EntityAI attachment)
Определения ItemBase.c:9011
float m_HeatIsolation
Определения ItemBase.c:4894
float m_VarWetInit
Определения ItemBase.c:4880
override void OnMovedInsideCargo(EntityAI container)
Определения ItemBase.c:5885
void SetCEBasedQuantity()
Определения ItemBase.c:5653
bool m_CanPlayImpactSound
Определения ItemBase.c:4890
override string GetAttachmentSoundType()
Определения ItemBase.c:9214
float GetOverheatingCoef()
Определения ItemBase.c:5459
array< string > GetHeadHidingSelection()
Определения ItemBase.c:9342
void PlayAttachSound(string slot_type)
Plays sound on item attach. Be advised, the config structure may slightly change in 1....
Определения ItemBase.c:9294
override bool IsStoreLoad()
Определения ItemBase.c:8563
int ComputeQuantityUsed(ItemBase other_item, bool use_stack_max=true)
Определения ItemBase.c:7093
bool IsLightSource()
Определения ItemBase.c:5781
bool m_HasQuantityBar
Определения ItemBase.c:4912
void SetResultOfSplit(bool value)
Определения ItemBase.c:7088
void SplitIntoStackMaxCargo(EntityAI destination_entity, int idx, int row, int col)
Определения ItemBase.c:6719
void OnAttachmentQuantityChanged(ItemBase item)
Called on server side when some attachment's quantity is changed. Call super.OnAttachmentQuantityChan...
Определения ItemBase.c:6889
void UpdateAllOverheatingParticles()
Определения ItemBase.c:5467
float GetSoakingIncrement(string pIncrementName)
Определения ItemBase.c:8478
static void StopOverheatingParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
Определения ItemBase.c:9119
override float GetStoreLoadedQuantity()
Определения ItemBase.c:8573
int m_LockType
Определения ItemBase.c:4966
const int ITEM_SOUNDS_MAX
Определения ItemBase.c:4971
bool m_CanBeDigged
Определения ItemBase.c:4913
float m_ItemAttachOffset
Определения ItemBase.c:4896
float GetItemModelLength()
Определения ItemBase.c:8580
bool m_ThrowItemOnDrop
Определения ItemBase.c:4904
override bool ReadVarsFromCTX(ParamsReadContext ctx, int version=-1)
Определения ItemBase.c:7841
override void CheckForRoofLimited(float timeTresholdMS=3000)
Roof check for entity, limited by time (anti-spam solution)
Определения ItemBase.c:8871
void Close()
float GetHeatIsolation()
Определения ItemBase.c:8464
void CombineItems(ItemBase other_item, bool use_stack_max=true)
Определения ItemBase.c:7122
void TransferModifiers(PlayerBase reciever)
appears to be deprecated, legacy code
float GetTemperaturePerQuantityWeight()
Used in heat comfort calculations only!
Определения ItemBase.c:9513
bool CanHaveWetness()
Определения ItemBase.c:9470
int m_CleannessMin
Определения ItemBase.c:4886
void TransferAgents(int agents)
transfer agents from another item
Определения ItemBase.c:8804
string IDToName(int id)
Определения ItemBase.c:7689
bool CanBeConsumed(ConsumeConditionData data=null)
Items cannot be consumed if frozen by default. Override for exceptions.
Определения ItemBase.c:9477
float GetHeatIsolationInit()
Определения ItemBase.c:8459
void PlayPlaceSound()
void SetCanBeMovedOverride(bool setting)
Определения ItemBase.c:7529
override bool HasQuantity()
Определения ItemBase.c:8291
float m_VarWetPrev
Определения ItemBase.c:4879
int m_SoundSyncStop
Определения ItemBase.c:4973
bool IsCargoException4x3(EntityAI item)
Определения ItemBase.c:9563
ref TIntArray m_ContinuousActions
Определения ItemBase.c:4928
int GetMuzzleID()
Returns global muzzle ID. If not found, then it gets automatically registered.
Определения ItemBase.c:5549
void LoadParticleConfigOnFire(int id)
Определения ItemBase.c:5234
int m_VarLiquidType
Определения ItemBase.c:4898
int m_QuickBarBonus
Определения ItemBase.c:4900
void PreLoadSoundAttachmentType()
Attachment Sound Type getting from config file.
Определения ItemBase.c:9202
override float GetWetInit()
Определения ItemBase.c:8531
int m_ImpactSoundSurfaceHash
Определения ItemBase.c:4892
int m_SoundSyncPlay
Определения ItemBase.c:4972
int m_MaxOverheatingValue
Определения ItemBase.c:4951
void SetupSpawnedItem(ItemBase item, float health, float quantity)
Определения ItemBase.c:4875
bool m_IsTakeable
Определения ItemBase.c:4903
bool ShouldSplitQuantity(float quantity)
Определения ItemBase.c:6428
static ref map< string, int > m_WeaponTypeToID
Определения ItemBase.c:4943
string GetLockSoundSet()
Определения ItemBase.c:8629
string GetColorString()
Returns item's PROCEDURAL color as formated string, i.e. "#(argb,8,8,3)color(0.15,...
Определения ItemBase.c:8660
array< int > GetValidFinishers()
returns an array of possible finishers
Определения ItemBase.c:9590
void OnAttachmentQuantityChangedEx(ItemBase item, float delta)
Called on server side when some attachment's quantity is changed. Call super.OnAttachmentQuantityChan...
Определения ItemBase.c:6895
class ItemBase extends InventoryItem SpawnItemOnLocation(string object_name, notnull InventoryLocation loc, bool full_quantity)
Определения ItemBase.c:4855
ItemSoundHandler GetItemSoundHandler()
Определения ItemBase.c:9229
override int GetQuantityMin()
Определения ItemBase.c:8280
void SplitIntoStackMaxToInventoryLocationClient(notnull InventoryLocation dst)
Определения ItemBase.c:6634
override int GetQuickBarBonus()
Определения ItemBase.c:5119
override void SetTakeable(bool pState)
Определения ItemBase.c:9184
float m_OverheatingDecayInterval
Определения ItemBase.c:4952
void SetIsPlaceSound(bool is_place_sound)
override void SplitIntoStackMaxClient(EntityAI destination_entity, int slot_id)
Определения ItemBase.c:6448
void HierarchyCheck(out bool hasParent, out bool hasRootAsPlayer, out ItemBase refParentIB)
Определения ItemBase.c:9435
bool CanProcessDecay()
Определения ItemBase.c:9463
void RemoveAudioVisualsOnClient()
Определения Bottle_Base.c:151
void SoundSynchRemote()
static void AddDebugActionsMask(int mask)
Определения ItemBase.c:5630
void PlayDeployLoopSoundEx()
void RemoveLightSourceItem()
Определения ItemBase.c:9579
bool CanRepair(ItemBase item_repair_kit)
Определения ItemBase.c:7493
bool can_this_be_combined
Определения ItemBase.c:4908
EffectSound m_SoundDeploy
Определения ItemBase.c:9673
int m_Count
Определения ItemBase.c:4874
float GetBaitEffectivity()
generic effectivity as a bait for animal catching
Определения ItemBase.c:9626
float GetDeployTime()
how long it takes to deploy this item in seconds
Определения ItemBase.c:9176
override bool IsSplitable()
Определения ItemBase.c:6415
bool DamageItemAttachments(float damage)
Определения ItemBase.c:6399
override void WriteVarsToCTX(ParamsWriteContext ctx)
Определения ItemBase.c:7805
void ConvertEnergyToQuantity()
Определения ItemBase.c:8446
override void RemoveAllAgents()
Определения ItemBase.c:8785
override void SetQuantityToMinimum()
Определения ItemBase.c:8213
bool m_WantPlayImpactSound
Определения ItemBase.c:4889
override float GetTemperatureThawTime()
Определения ItemBase.c:9550
ref map< int, ref array< ref WeaponParticlesOnOverheating > > m_OnOverheatingEffect
Определения ItemBase.c:4942
int m_ColorComponentG
Определения ItemBase.c:4919
float m_StoreLoadedQuantity
Определения ItemBase.c:4876
void MessageToOwnerAction(string text)
Send message to owner player in yellow color.
Определения ItemBase.c:7560
int m_ColorComponentA
Определения ItemBase.c:4921
int m_VarQuantityInit
Определения ItemBase.c:4871
float GetFilterDamageRatio()
Определения ItemBase.c:5534
override void SetLiquidType(int value, bool allow_client=false)
Определения ItemBase.c:8673
void OnQuantityChanged(float delta)
Called on server side when this item's quantity is changed. Call super.OnQuantityChanged(); first whe...
Определения ItemBase.c:6865
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...
Определения ItemBase.c:8220
bool m_HideSelectionsBySlot
Определения ItemBase.c:4956
bool IsOverheatingEffectActive()
Определения ItemBase.c:5397
void SetIsBeingPlaced(bool is_being_placed)
Определения ItemBase.c:5814
int GetLiquidContainerMask()
Определения ItemBase.c:5751
void SetInventoryLocationToVicinityOrCurrent(EntityAI root, inout InventoryLocation dst)
Определения ItemBase.c:7002
ref Timer m_CheckOverheating
Определения ItemBase.c:4949
void RegisterOverheatingParticle(Particle p, float min_heat_coef, float max_heat_coef, int particle_id, Object parent, vector local_pos, vector local_ori)
Определения ItemBase.c:5445
float GetEnergy()
Определения ItemBase.c:8420
bool CanBeDigged()
Определения ItemBase.c:5830
bool GetActionWidgetOverride(out typename name)
If we need a different (handheld)item action widget displayed, the logic goes in here.
Определения ItemBase.c:9596
bool IsNVG()
Определения ItemBase.c:5762
float GetUnitWeight(bool include_wetness=true)
Obsolete, use GetWeightEx instead.
Определения ItemBase.c:8380
void SetZoneDamageCEInit()
Sets zone damages to match randomized global health set by CE (CE spawn only)
Определения ItemBase.c:9372
bool m_IsDeploySound
Определения ItemBase.c:9675
bool CanEat()
Определения ItemBase.c:7453
static void PlayOverheatingParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
Определения ItemBase.c:9079
override bool IsOneHandedBehaviour()
Определения ItemBase.c:9150
void AddLightSourceItem(ItemBase lightsource)
Adds a light source child.
Определения ItemBase.c:9574
bool IsLiquidContainer()
Определения ItemBase.c:5746
FoodStage GetFoodStage()
overridden on Edible_Base; so we don't have to parse configs all the time
Определения ItemBase.c:7473
override float GetSingleInventoryItemWeightEx()
Определения ItemBase.c:8307
void SaveAgents(ParamsWriteContext ctx)
Определения ItemBase.c:8863
override int GetTargetQuantityMax(int attSlotID=-1)
Определения ItemBase.c:8261
int m_CleannessInit
Определения ItemBase.c:4885
float GetDisinfectQuantity(int system=0, Param param1=null)
Определения ItemBase.c:5529
override int GetAgents()
Определения ItemBase.c:8810
int m_VarQuantityMax
Определения ItemBase.c:4873
override bool IsHologram()
Определения ItemBase.c:5825
float GetItemAttachOffset()
Определения ItemBase.c:8589
bool IsPlaceSound()
Определения ItemBase.c:9689
static int GetDebugActionsMask()
Определения ItemBase.c:5615
void ProcessDecay(float delta, bool hasRootAsPlayer)
Определения ItemBase.c:9452
override bool IsItemBase()
Определения ItemBase.c:7606
void PlayDeploySound()
override bool IsTwoHandedBehaviour()
Определения ItemBase.c:9160
void ExplodeAmmo()
Определения ItemBase.c:6302
bool IsCombineAll(ItemBase other_item, bool use_stack_max=false)
Определения ItemBase.c:7078
float GetProtectionLevel(int type, bool consider_filter=false, int system=0)
Определения ItemBase.c:8884
static void PlayBulletCasingEjectParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
Определения ItemBase.c:9059
override void OnEnergyAdded()
Определения ItemBase.c:8438
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()
Определения ItemBase.c:5774
EffectSound m_DeployLoopSoundEx
Определения ItemBase.c:9672
override void DeSerializeNumericalVars(array< float > floats)
Определения ItemBase.c:7746
void StopItemDynamicPhysics()
Определения ItemBase.c:9354
bool HasFoodStage()
Определения ItemBase.c:7466
override void SetStoreLoad(bool value)
Определения ItemBase.c:8558
float GetOverheatingValue()
Определения ItemBase.c:5359
bool ContainsAgent(int agent_id)
Определения ItemBase.c:8763
override void AddWet(float value)
Определения ItemBase.c:8506
bool IsLiquidPresent()
Определения ItemBase.c:5741
bool IsFullQuantity()
Определения ItemBase.c:8301
override void EOnContact(IEntity other, Contact extra)
Определения ItemBase.c:6015
void SplitIntoStackMaxHands(PlayerBase player)
Определения ItemBase.c:6770
void SplitIntoStackMaxHandsClient(PlayerBase player)
Определения ItemBase.c:6746
int m_CleannessMax
Определения ItemBase.c:4887
float m_VarStackMax
Определения ItemBase.c:4875
ref Timer m_PhysDropTimer
Определения ItemBase.c:4962
void MessageToOwnerFriendly(string text)
Send message to owner player in green color.
Определения ItemBase.c:7578
override void SetStoreLoadedQuantity(float value)
Определения ItemBase.c:8568
bool m_IsResultOfSplit string m_SoundAttType
distinguish if item has been created as new or it came from splitting (server only flag)
Определения ItemBase.c:4916
void CheckOverheating(ItemBase weapon=null, string ammoType="", ItemBase muzzle_owner=null, ItemBase suppressor=null, string config_to_search="")
Определения ItemBase.c:5380
void UnlockFromParent()
Unlocks this item from its attachment slot of its parent.
Определения ItemBase.c:5695
bool Repair(PlayerBase player, ItemBase item_repair_kit, float specialty_weight)
Определения ItemBase.c:7500
void OnLiquidTypeChanged(int oldType, int newType)
Определения ItemBase.c:8694
void StartOverheating(ItemBase weapon=null, string ammoType="", ItemBase muzzle_owner=null, ItemBase suppressor=null, string config_to_search="")
Определения ItemBase.c:5426
void PlayDeployFinishSound()
bool AllowFoodConsumption()
Определения ItemBase.c:8616
bool m_IsOverheatingEffectActive
Определения ItemBase.c:4947
int m_LiquidContainerMask
Определения ItemBase.c:4897
void ProcessItemWetness(float delta, bool hasParent, bool hasRootAsPlayer, ItemBase refParentIB)
Определения ItemBase.c:9390
override int GetCleanness()
Определения ItemBase.c:8611
bool PairWithDevice(notnull ItemBase otherDevice)
Определения ItemBase.c:9601
bool IsDeploySound()
Определения ItemBase.c:9690
static void RemoveDebugActionsMask(int mask)
Определения ItemBase.c:5635
static void UpdateOverheatingParticles(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
Определения ItemBase.c:9099
int m_VarQuantityMin
Определения ItemBase.c:4872
void PerformDamageSystemReinit()
Определения ItemBase.c:9360
override void ClearInventory()
Определения ItemBase.c:8399
static int m_LastRegisteredWeaponID
Определения ItemBase.c:4944
ItemBase GetLightSourceItem()
Определения ItemBase.c:9584
void MessageToOwnerImportant(string text)
Send message to owner player in red color.
Определения ItemBase.c:7596
override float GetItemOverheatThreshold()
Определения ItemBase.c:9534
void StopDeployLoopSoundEx()
bool m_CanThisBeSplit
Определения ItemBase.c:4909
override void SerializeNumericalVars(array< float > floats_out)
Определения ItemBase.c:7710
ItemBase SplitIntoStackMaxToInventoryLocationEx(notnull InventoryLocation dst)
Определения ItemBase.c:6685
float m_ItemModelLength
Определения ItemBase.c:4895
bool m_IsHologram
Определения ItemBase.c:4902
static int m_DebugActionsMask
Определения ItemBase.c:4862
void KillAllOverheatingParticles()
Определения ItemBase.c:5495
bool CanBeCookedOnStick()
Определения ItemBase.c:7483
override int GetQuantityMax()
Определения ItemBase.c:8248
void GetRecipesActions(Man player, out TSelectableActionInfoArray outputList)
Определения ItemBase.c:7156
void OnActivatedByTripWire()
bool IsColorSet()
Определения ItemBase.c:8654
override void RemoveAgent(int agent_id)
Определения ItemBase.c:8776
bool m_ItemBeingDroppedPhys
Определения ItemBase.c:4905
override bool CanPutAsAttachment(EntityAI parent)
Определения ItemBase.c:8966
void PlayDetachSound(string slot_type)
Определения ItemBase.c:9330
static ref map< typename, ref TInputActionMap > m_ItemTypeActionsMap
Определения ItemBase.c:4856
void ProcessItemWetnessAndTemperature(float delta, bool hasParent, bool hasRootAsPlayer, ItemBase refParentIB)
Определения ItemBase.c:9663
override bool IsBeingPlaced()
Определения ItemBase.c:5809
int GetQuantityInit()
Определения ItemBase.c:8285
float ComputeQuantityUsedEx(ItemBase other_item, bool use_stack_max=true)
Определения ItemBase.c:7098
bool IsResultOfSplit()
Определения ItemBase.c:7083
bool m_FixDamageSystemInit
Определения ItemBase.c:4907
float m_ImpactSpeed
Определения ItemBase.c:4891
bool m_IsStoreLoad
Определения ItemBase.c:4910
int GetLiquidTypeInit()
Определения ItemBase.c:8684
string GetDeployFinishSoundset()
ItemBase m_LightSourceItem
Определения ItemBase.c:4925
void LockToParent()
Locks this item in it's current attachment slot of its parent. This makes the "locked" icon visible i...
Определения ItemBase.c:5682
override void SplitIntoStackMaxEx(EntityAI destination_entity, int slot_id)
Определения ItemBase.c:6557
int m_AttachedAgents
Определения ItemBase.c:4933
string m_LockSoundSet
Определения ItemBase.c:4968
void LoadParticleConfigOnOverheating(int id)
Определения ItemBase.c:5303
float m_VarQuantityPrev
Определения ItemBase.c:4870
bool IsSoundSynchRemote()
Определения ItemBase.c:9688
bool m_CanShowQuantity
Определения ItemBase.c:4911
override void OnRightClick()
Определения ItemBase.c:6938
int m_ColorComponentB
Определения ItemBase.c:4920
static ref map< typename, ref TActionAnimOverrideMap > m_ItemActionOverrides
Определения ItemBase.c:4858
bool IsActionTargetVisible()
Определения ItemBase.c:9196
override void OnItemAttachmentSlotChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
Определения ItemBase.c:6050
override void EEHitBy(TotalDamageResult damageResult, int damageType, EntityAI source, int component, string dmgZone, string ammo, vector modelPos, float speedCoef)
Определения ItemBase.c:6339
bool m_IsBeingPlaced
Определения ItemBase.c:4901
int NameToID(string name)
Определения ItemBase.c:7683
void ~ItemBase()
Определения ItemBase.c:5580
override void OnWetLevelChanged(EWetnessLevel newLevel, EWetnessLevel oldLevel)
Определения ItemBase.c:8546
void ClearStopItemSoundServer()
Определения ItemBase.c:9288
override string ChangeIntoOnDetach()
Определения ItemBase.c:6263
float m_VarWetMax
Определения ItemBase.c:4882
void SplitIntoStackMaxToInventoryLocation(notnull InventoryLocation dst)
Определения ItemBase.c:6680
int GetLockType()
Определения ItemBase.c:8624
EffectSound m_SoundDeployFinish
Определения ItemBase.c:9670
override float GetWet()
Определения ItemBase.c:8516
EffectSound m_SoundPlace
Определения ItemBase.c:9671
float GetQuantityNormalizedScripted()
Определения ItemBase.c:8234
override void SetCleanness(int value, bool allow_client=false)
Определения ItemBase.c:8598
bool m_IsPlaceSound
Определения ItemBase.c:9674
override float GetWetMin()
Определения ItemBase.c:8526
ref ItemSoundHandler m_ItemSoundHandler
Определения ItemBase.c:4974
override bool KindOf(string tag)
Определения ItemBase.c:7612
void ItemSoundHandler(ItemBase parent)
Определения ItemSoundHandler.c:31
string Type
Определения JsonDataContaminatedArea.c:11
EffectSound m_LockingSound
Определения Land_Underground_Entrance.c:321
string GetDebugText()
Определения ModifierBase.c:71
PlayerBase GetPlayer()
Определения ModifierBase.c:51
@ LOWEST
Определения PPEConstants.c:54
void PluginItemDiagnostic()
Определения PluginItemDiagnostic.c:74
PluginBase GetPlugin(typename plugin_type)
Определения PluginManager.c:316
EntityAI GetItem()
Определения RadialQuickbarMenu.c:37
override RemotelyActivatedItemBehaviour GetRemotelyActivatedItemBehaviour()
Определения RemoteDetonator.c:272
void RemoteDetonatorTrigger()
Определения RemoteDetonator.c:233
override void OnActivatedByItem(notnull ItemBase item)
Called when this item is activated by other.
Определения RemoteDetonator.c:305
int particle_id
Определения SmokeSimulation.c:28
ETemperatureAccessTypes
Определения TemperatureAccessConstants.c:2
override void Explode(int damageType, string ammoType="")
Определения Trap_LandMine.c:220
bool m_Initialized
Определения UiHintPanel.c:317
void Debug()
Определения UniversalTemperatureSource.c:349
int GetID()
Определения ActionBase.c:1360
void OnItemLocationChanged(ItemBase item)
Определения ActionBase.c:998
GetInputType()
Определения ActionBase.c:215
int m_StanceMask
Определения ActionBase.c:25
int m_CommandUIDProne
Определения ActionBase.c:24
int m_CommandUID
Определения ActionBase.c:23
void OnItemAttachedAtPlayer(EntityAI item, string slot_name)
Определения AnalyticsManagerClient.c:77
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)
Определения DayZGame.c:1187
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()
Определения Global/game.c:1568
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)
float GetEnergyAtSpawn()
Определения ComponentEnergyManager.c:1280
void SetEnergy0To1(float energy01)
Energy manager: Sets stored energy for this device between 0 and MAX based on relative input value be...
Определения ComponentEnergyManager.c:541
float GetEnergyMaxPristine()
Energy manager: Returns the maximum amount of energy this device can store. It's damage is NOT taken ...
Определения ComponentEnergyManager.c:1275
override void SetAutodestroy(bool auto_destroy)
Sets whether Effect automatically cleans up when it stops.
Определения EffectSound.c:603
bool IsSoundPlaying()
Get whether EffectSound is currently playing.
Определения EffectSound.c:274
override bool IsMan()
Определения 3_Game/Entities/Man.c:44
proto native bool EnumerateInventory(InventoryTraversalType tt, out array< EntityAI > items)
enumerate inventory using traversal type and filling items array
proto native CargoBase GetCargo()
cargo
Определения ItemBase.c:15
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)
Определения InventoryLocation.c:469
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
InventoryLocation.
Определения InventoryLocation.c:29
override bool CanDisplayCargo()
Определения UndergroundStash.c:24
override void OnInventoryEnter(Man player)
Определения BarbedWire.c:203
override string GetFoldSoundset()
Определения BaseBuildingBase.c:108
override bool CanPutAsAttachment(EntityAI parent)
Определения ItemBase.c:6
override bool CanReceiveItemIntoCargo(EntityAI item)
Определения TentBase.c:913
override bool OnStoreLoad(ParamsReadContext ctx, int version)
Определения GardenBase.c:199
override void OnWasDetached(EntityAI parent, int slot_id)
override void EEOnAfterLoad()
Определения GardenBase.c:242
override void EEDelete(EntityAI parent)
Определения BaseBuildingBase.c:68
override bool CanBeRepairedByCrafting()
Определения TentBase.c:86
override void OnPlacementStarted(Man player)
Определения BatteryCharger.c:376
override void OnItemLocationChanged(EntityAI old_owner, EntityAI new_owner)
Определения BarbedWire.c:357
override bool IsElectricAppliance()
Определения BatteryCharger.c:43
override bool IsItemTent()
Определения TentBase.c:81
override void SetActions()
override string GetLoopFoldSoundset()
Определения BaseBuildingBase.c:113
override bool CanMakeGardenplot()
Определения FieldShovel.c:3
override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
Определения PowerGenerator.c:412
override void EEItemLocationChanged(notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
Определения HandcuffsLocked.c:12
override WrittenNoteData GetWrittenNoteData()
Определения Paper.c:30
override int GetDamageSystemVersionChange()
Определения BaseBuildingBase.c:1238
override bool SetQuantity(float value, bool destroy_config=true, bool destroy_forced=false, bool allow_client=false, bool clamp_to_stack_max=true)
Определения PileOfWoodenPlanks.c:88
override void InitItemVariables()
Определения Matchbox.c:3
override void SetActionAnimOverrides()
Определения PickAxe.c:28
override void OnCreatePhysics()
Определения BaseBuildingBase.c:489
override string GetDeploySoundset()
Определения BarbedWire.c:392
override float GetBandagingEffectivity()
Определения BandageDressing.c:49
override bool OnAction(int action_id, Man player, ParamsReadContext ctx)
Определения PowerGenerator.c:424
override void EEHealthLevelChanged(int oldLevel, int newLevel, string zone)
Определения BaseBuildingBase.c:496
override void OnStoreSave(ParamsWriteContext ctx)
Определения GardenBase.c:266
override void AfterStoreLoad()
Определения BarbedWire.c:155
override int GetOnDigWormsAmount()
Определения FieldShovel.c:27
override bool IsSelfAdjustingTemperature()
Определения PortableGasStove.c:287
override bool IsPlayerInside(PlayerBase player, string selection)
Определения BaseBuildingBase.c:1037
override void OnVariablesSynchronized()
Определения GardenBase.c:97
override void RefreshPhysics()
Определения BatteryCharger.c:359
override bool CanObstruct()
Определения BaseBuildingBase.c:84
override void OnWasAttached(EntityAI parent, int slot_id)
override bool CanReceiveAttachment(EntityAI attachment, int slotId)
Определения BaseBuildingBase.c:982
override bool CanPutInCargo(EntityAI parent)
Определения GardenBase.c:331
override string GetLoopDeploySoundset()
Определения BarbedWire.c:397
override void OnPlacementComplete(Man player, vector position="0 0 0", vector orientation="0 0 0")
Определения BarbedWire.c:372
override void OnInventoryExit(Man player)
Определения BatteryCharger.c:341
override bool IsTakeable()
Определения BaseBuildingBase.c:1008
override bool IsIgnoredByConstruction()
Определения BaseBuildingBase.c:1170
override void InitItemSounds()
Определения BaseBuildingBase.c:94
override void EEKilled(Object killer)
Определения HandcuffsLocked.c:70
override void OnCombine(ItemBase other_item)
Определения BandageDressing.c:71
override bool CanExplodeInFire()
Определения LargeGasCannister.c:3
override bool IsFacingPlayer(PlayerBase player, string selection)
Определения BaseBuildingBase.c:1032
override bool CanBeCombined(EntityAI other_item, bool reservation_check=true, bool stack_max_limit=false)
Определения Rag.c:61
override bool IsBloodContainer()
Определения BloodContainerBase.c:10
override bool IsClothing()
override bool CanBeSplit()
Определения Rag.c:34
override bool IsDeployable()
Определения BaseBuildingBase.c:365
override void OnRPC(PlayerIdentity sender, int rpc_type, ParamsReadContext ctx)
Определения ToolBase.c:24
override bool CanBeDisinfected()
Определения BandageDressing.c:54
override float GetInfectionChance(int system=0, Param param=null)
Определения BandageDressing.c:59
override void OnEndPlacement()
Определения KitBase.c:65
Определения EnMath.c:7
float GetOverheatingLimitMax()
Определения WeaponParticles.c:417
void SetOverheatingLimitMax(float max)
Определения WeaponParticles.c:407
void SetParticleParams(int particle_id, Object parent, vector local_pos, vector local_ori)
Определения WeaponParticles.c:422
float GetOverheatingLimitMin()
Определения WeaponParticles.c:412
Particle GetParticle()
Определения WeaponParticles.c:397
void SetOverheatingLimitMin(float min)
Определения WeaponParticles.c:402
void RegisterParticle(Particle p)
Определения WeaponParticles.c:392
void Stop()
Legacy function for backwards compatibility with 1.14 and below.
Определения Particle.c:266
void SetControlledDevice(EntityAI pDevice)
Определения RemoteDetonator.c:140
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 native void Send()
proto bool Write(void value_out)
proto bool Read(void value_in)
bool m_Loop
Определения ItemSoundHandler.c:5
override void Stop()
Определения DayZPlayerImplement.c:64
proto native float GetDamage(string zoneName, string healthType)
UIScriptedMenu FindMenu(int id)
Returns menu with specific ID if it is open (see MenuID)
Определения UIManager.c:160
override void Refresh()
Определения ChatInputMenu.c:70
void SetCalcDetails(string details)
Определения 3_Game/tools/Debug.c:816
void OnRPC(PlayerIdentity sender, int rpc_type, ParamsReadContext ctx)
Определения WrittenNoteData.c:13
const float LOWEST
Определения EnConvert.c:100
Serializer ParamsReadContext
Определения gameplay.c:15
class LOD Object
InventoryTraversalType
tree traversal type, for more see http://en.wikipedia.org/wiki/Tree_traversal
Определения gameplay.c:6
proto native CGame GetGame()
Serializer ParamsWriteContext
Определения gameplay.c:16
const int DEF_BIOLOGICAL
Определения 3_Game/constants.c:512
const int DEF_CHEMICAL
Определения 3_Game/constants.c:513
const int COMP_TYPE_ENERGY_MANAGER
Определения Component.c:9
ErrorExSeverity
Определения EnDebug.c:62
void Error(string err)
Messagebox with error message.
Определения EnDebug.c:90
enum ShapeType ErrorEx
proto native void SetColor(int color)
array< string > TStringArray
Определения EnScript.c:709
array< int > TIntArray
Определения EnScript.c:711
EntityEvent
Entity events for event-mask, or throwing event from code.
Определения EnEntity.c:45
static const float ITEM_TEMPERATURE_NEUTRAL_ZONE_MIDDLE
Определения 3_Game/constants.c:808
const int VARIABLE_LIQUIDTYPE
Определения 3_Game/constants.c:632
const int VARIABLE_CLEANNESS
Определения 3_Game/constants.c:635
const int VARIABLE_COLOR
Определения 3_Game/constants.c:634
const int VARIABLE_TEMPERATURE
Определения 3_Game/constants.c:630
const int VARIABLE_QUANTITY
Определения 3_Game/constants.c:628
const int VARIABLE_WET
Определения 3_Game/constants.c:631
const int LIQUID_NONE
Определения 3_Game/constants.c:529
static proto float AbsFloat(float f)
Returns absolute value.
const int MENU_INVENTORY
Определения 3_Game/constants.c:180
proto native bool dBodyIsDynamic(notnull IEntity ent)
const int SAT_CRAFTING
Определения 3_Game/constants.c:453
const int SAT_DEBUG_ACTION
Определения 3_Game/constants.c:454
class JsonUndergroundAreaTriggerData GetPosition
Определения UndergroundAreaLoader.c:9
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.
const int CALL_CATEGORY_GAMEPLAY
Определения 3_Game/tools/tools.c:10
const int CALL_CATEGORY_SYSTEM
Определения 3_Game/tools/tools.c:8
proto native int GetColor()