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

◆ GetAgents()

override int SpawnItemOnLocation::GetAgents ( )
protected

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

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

Используется в BakedBeansCan_Opened::CanProcessDecay(), PeachesCan_Opened::CanProcessDecay(), SardinesCan_Opened::CanProcessDecay(), SpaghettiCan_Opened::CanProcessDecay(), TunaCan_Opened::CanProcessDecay() и SetActions().