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

◆ RemoveAgent()

override void SpawnItemOnLocation::RemoveAgent ( int agent_id)
protected

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

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

Используется в InventoryItem::OnAction().