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

◆ OnPlacementStarted()

override void SpawnItemOnLocation::OnPlacementStarted ( Man player)
protected

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

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