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

◆ GetColorString()

string SpawnItemOnLocation::GetColorString ( )
protected

Returns item's PROCEDURAL color as formated string, i.e. "#(argb,8,8,3)color(0.15,0.15,0.15,1.0,CO)".

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

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