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

◆ SetColor()

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

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

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