object.c

Go to the documentation of this file.

enum ProcessDirectDamageFlags
{
 ALL_TRANSFER,
 NO_ATTACHMENT_TRANSFER, 
 NO_GLOBAL_TRANSFER, 
 NO_TRANSFER, 
}
 
class ObjectSnapCallback
{
 Object m_Owner; 
 vector m_OwnerPosition; 
 vector m_OwnerDirection; 
 
 vector m_Offset; 
 vector m_Extents; 
 
 vector m_DirectionFunc; 
 
 bool m_DebugEnabled; 
 vector m_Transform[4]; 
 
 void OnSetup()
 {
 }
 
 void OnDebug(vector p0, vector p1, bool hasHit, bool found)
 {
 }
 
 bool OnFirstContact(Object other)
 {
 return false;
 }
 
 bool OnQuery(Object other)
 {
 return true;
 }
 
 bool OnCollide(Object other)
 {
 return true;
 }
};
 
class Object extends IEntity
{
 private void ~Object();
 private void Object();
 
 bool CanBeSkinned()
 {
 return false;
 }
 
 void Delete()
 {
 GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).Call(GetGame().ObjectDelete, this);
 }
 
 proto native void AddProxyPhysics(string proxySelectionName); 
 
 proto native void RemoveProxyPhysics(string proxySelectionName); 
 
 void OnEnterTrigger(ScriptedEntity trigger) {}
 
 void OnLeaveTrigger(ScriptedEntity trigger) {}
 
 proto native bool GetLODS(notnull out array<LOD> lods);
 
 proto native owned string GetLODName(LOD lod);
 
 proto native vector GetBoundingCenter();
 
 LOD GetLODByName( string name )
 {
 array<LOD> lods = new array<LOD>;
 GetLODS( lods );
 
 for ( int i = 0; i < lods.Count(); ++i )
 {
 string lod_name = GetLODName( lods.Get( i ) );
 lod_name.ToLower();
 name.ToLower();
 if ( lod_name == name ) 
 {
 return lods.Get( i );
 }
 }
 
 return NULL;
 }
 
 TStringArray GetHiddenSelections()
 {
 return HiddenSelectionsData.GetHiddenSelectionsConfig(GetType());
 }
 
 TStringArray GetHiddenSelectionsTextures()
 {
 return HiddenSelectionsData.GetHiddenSelectionsTexturesConfig(GetType());
 }
 
 TStringArray GetHiddenSelectionsMaterials()
 {
 return HiddenSelectionsData.GetHiddenSelectionsMaterialsConfig(GetType());
 }
 
 void Explode(int damageType, string ammoType = "")
 {
 if (ammoType == "")
 ammoType = ConfigGetString("ammoType");
 
 if (ammoType == "")
 ammoType = "Dummy_Heavy";
 
 if ( GetGame().IsServer() )
 {
 SynchExplosion();
 DamageSystem.ExplosionDamage(EntityAI.Cast(this), null, ammoType, GetPosition(), damageType);
 }
 }
 
 void SynchExplosion()
 {
 if ( GetGame().IsDedicatedServer() ) // Multiplayer server
 {
 Param1<EntityAI> p = new Param1<EntityAI>(null); 
 GetGame().RPCSingleParam( this, ERPCs.RPC_EXPLODE_EVENT, p, true);
 }
 else if ( !GetGame().IsMultiplayer() ) // Singleplayer
 {
 OnExplodeClient();
 }
 }
 
 void OnExplodeClient()
 {
 string ammoType = ConfigGetString("ammoType");
 
 if (ammoType == "")
 ammoType = "Dummy_Heavy";
 
 vector pos = GetPosition();
 
 // Handle spawn of particle if one is configured in config
 AmmoEffects.PlayAmmoParticle(ammoType, pos); 
 
 // Handle spawn of Effect if one is configured in config
 AmmoEffects.PlayAmmoEffect(ammoType, pos);
 }
 
 void OnExplosionEffects(Object source, Object directHit, int componentIndex, string surface, vector pos, vector surfNormal, float energyFactor, float explosionFactor, bool isWater, string ammoType) { }
 
 proto native owned string GetActionComponentName(int componentIndex, string geometry = "");
 
 proto native owned vector GetActionComponentPosition(int componentIndex, string geometry = "");
 
 proto native owned int GetActionComponentNameList(int componentIndex, TStringArray nameList, string geometry = "");
 
 proto native bool IsActionComponentPartOfSelection(int componentIndex, string selectionName, string geometry = "");
 
 proto void GetActionComponentsForSelectionName(int level, string selectionName, TIntArray componentIndices);
 
 proto vector GetActionComponentCenter(int level, int componentIndex);
 
 proto vector GetActionComponentCenterOOB(int level, int componentIndex);
 
 proto void GetActionComponentMinMax(int level, int componentIndex, out vector min, out vector max);
 
 proto native bool ToDelete();
 
 proto native bool IsPendingDeletion();
 
 proto native int GetGeometryLevel();
 proto native int GetFireGeometryLevel();
 proto native int GetViewGeometryLevel();
 proto native int GetMemoryLevel();
 
#ifdef DEVELOPER
 proto bool ToBonePivot(out int pivot, int level, int bone);
 proto bool FromBonePivot(int pivot, out int level, out int bone);
#endif
 
 proto int GetBonePivot(int level, int component);
 
 proto native void GetBonePivotsForAnimationSource(int level, string animationSource, out TIntArray pivots);
 
 proto native vector GetBonePositionLS(int pivot);
 proto native vector GetBonePositionMS(int pivot);
 proto native vector GetBonePositionWS(int pivot);
 
 proto native void GetBoneRotationLS(int pivot, out float quaternion[4]);
 proto native void GetBoneRotationMS(int pivot, out float quaternion[4]);
 proto native void GetBoneRotationWS(int pivot, out float quaternion[4]);
 
 proto native void GetBoneTransformLS(int pivot, out vector transform[4]);
 proto native void GetBoneTransformMS(int pivot, out vector transform[4]);
 proto native void GetBoneTransformWS(int pivot, out vector transform[4]);
 
 proto native void GetTightlyPackedCorners(ETransformationAxis axis, out vector corners[4]);
 
#ifdef DIAG_DEVELOPER
 void DebugDrawTightlyPackedCorners(ETransformationAxis axis, int color)
 {
#ifndef SERVER
 vector points[2];
 vector corners[4];
 
 GetTightlyPackedCorners(axis, corners);
 
 points[0] = corners[0];
 points[1] = corners[1];
 Shape.CreateLines(color, ShapeFlags.TRANSP | ShapeFlags.ONCE | ShapeFlags.NOOUTLINE | ShapeFlags.NOZBUFFER, points, 2);
 
 points[0] = corners[1];
 points[1] = corners[3];
 Shape.CreateLines(color, ShapeFlags.TRANSP | ShapeFlags.ONCE | ShapeFlags.NOOUTLINE | ShapeFlags.NOZBUFFER, points, 2);
 
 points[0] = corners[3];
 points[1] = corners[2];
 Shape.CreateLines(color, ShapeFlags.TRANSP | ShapeFlags.ONCE | ShapeFlags.NOOUTLINE | ShapeFlags.NOZBUFFER, points, 2);
 
 points[0] = corners[2];
 points[1] = corners[0];
 Shape.CreateLines(color, ShapeFlags.TRANSP | ShapeFlags.ONCE | ShapeFlags.NOOUTLINE | ShapeFlags.NOZBUFFER, points, 2);
#endif
 }
#endif
 
 proto native vector GetPosition();
 
 proto native vector GetWorldPosition();
 
 proto native void SetPosition(vector vPos);
 
 proto native void PlaceOnSurface();
 
 proto native vector GetOrientation();
 
 proto native void SetOrientation(vector vOrientation);
 
 proto native vector GetDirection();
 
 proto native void SetDirection(vector vPos);
 
 proto native vector GetDirectionUp();
 
 proto native vector GetDirectionAside();
 
 proto native vector GetLocalPos(vector vPos);
 proto native vector GetGlobalPos(vector vPos);
 
 proto native vector GetSpeed();
 
 proto native vector GetModelSpeed();
 
 proto native bool CanAffectPathgraph();
 
 proto native void SetAffectPathgraph(bool fromConfig, bool affect);
 
 
 proto float ClippingInfo(out vector minMax[2]);
 
 proto native bool GetCollisionBox(out vector minMax[2]);
 
 proto native float GetCollisionRadius();
 
 proto native float GetDamage();
 
 
 proto native void GetSelectionList(out TStringArray selectionList);
 
 float GetSurfaceNoise()
 {
 vector position = GetPosition();
 return GetGame().SurfaceGetNoiseMultiplier(NULL, position, -1);
 }
 
 string GetSurfaceType()
 {
 string surface_type;
 int liquid_type;
 
 GetGame().SurfaceUnderObject(this, surface_type,liquid_type);
// Print(surface_type);
// Print(liquid_type);
 
 return surface_type;
 }
 
 bool HasSelection( string selection )
 {
 TStringArray selections = new TStringArray;
 GetSelectionList( selections );
 
 for ( int i = 0; i < selections.Count(); ++i )
 {
 if ( selections.Get( i ) == selection )
 {
 return true;
 }
 }
 
 return false;
 }
 
 bool HasAnimation( string anim_name )
 {
 string cfg_path_vehicles = "CfgVehicles " + GetType() + " ";
 if ( GetGame().ConfigIsExisting (cfg_path_vehicles) && GetGame().ConfigIsExisting (cfg_path_vehicles + "AnimationSources " + anim_name) )
 {
 return true;
 }
 
 string cfg_path_weapons = "CfgWeapons " + GetType() + " ";
 if ( GetGame().ConfigIsExisting (cfg_path_weapons) && GetGame().ConfigIsExisting (cfg_path_weapons + "AnimationSources " + anim_name) )
 {
 return true;
 }
 
 string cfg_path_magazines = "CfgMagazines " + GetType() + " ";
 if ( GetGame().ConfigIsExisting (cfg_path_magazines) && GetGame().ConfigIsExisting (cfg_path_magazines + "AnimationSources " + anim_name) )
 {
 return true;
 }
 
 return false;
 }
 
 /*bool HasEnergyManager()
 {
 return false;
 }*/
 
 proto native int GetMemoryPointIndex(string memoryPointName);
 proto native vector GetMemoryPointPos(string memoryPointName);
 proto native vector GetMemoryPointPosByIndex(int pointIndex);
 proto native bool MemoryPointExists(string memoryPoint);
 
 proto native void CreateDynamicPhysics(int interactionLayers);
 proto native void EnableDynamicCCD(bool state);
 proto native void SetDynamicPhysicsLifeTime(float lifeTime);
 
 void OnTreeCutDown(EntityAI cutting_entity);
 
 string GetType()
 {
 string ret;
 GetGame().ObjectGetType(this, ret);
 
 return ret;
 }
 
 string GetDisplayName()
 {
 string tmp;
 if (NameOverride(tmp))
 {
 tmp = Widget.TranslateString(tmp);
 }
 else
 {
 GetGame().ObjectGetDisplayName(this, tmp);
 }
 return tmp;
 }
 
 //Used to specify this object will always display it's own name when attached to another object
 bool DisplayNameRuinAttach()
 {
 return false;
 }
 
 string GetModelName()
 {
 return GetGame().GetModelName(GetType());
 }
 
 proto native owned string GetShapeName();
 
 int Release()
 {
 return GetGame().ObjectRelease(this);
 }
 
 bool IsKindOf(string type)
 {
 return GetGame().ObjectIsKindOf(this, type);
 }
 
 // Check alive state
 bool IsAlive()
 {
 return !IsDamageDestroyed();
 }
 
 bool IsMan()
 {
 return false;
 }
 
 bool IsDayZCreature()
 {
 return false;
 }
 
 bool IsEntityAI()
 {
 return false;
 }
 
 bool IsStaticTransmitter()
 {
 return false;
 }
 
 bool IsTransmitter()
 {
 return false;
 }
 
 bool IsItemBase()
 {
 return false;
 }
 
 //Returns true for protector cases and similar items. Usually can be nested in other cargo while full, unlike clothing..
 bool IsContainer()
 {
 return false;
 }
 
 bool IsMagazine()
 {
 return false;
 }
 
 bool IsAmmoPile()
 {
 return false;
 }
 
 bool IsInventoryItem()
 {
 return false;
 }
 
 bool IsClothing()
 {
 return false;
 }
 
 bool IsFireplace()
 { 
 return false;
 }
 
 bool IsTree()
 { 
 return false;
 }
 
 bool IsRock()
 { 
 return false;
 }
 
 bool IsWoodBase()
 {
 return false;
 }
 
 bool IsBush()
 {
 return false;
 }
 
 bool IsCuttable()
 {
 return false;
 }
 
 bool IsPeltBase()
 {
 return false;
 }
 
 bool IsWeapon()
 {
 return false;
 }
 
 bool IsMeleeWeapon()
 {
 return false;
 }
 
 bool IsBuilding()
 {
 return false;
 }
 
 EWaterSourceObjectType GetWaterSourceObjectType()
 {
 return EWaterSourceObjectType.NONE;
 }
 
 bool IsWell()
 {
 return false;
 }
 bool ShootsExplosiveAmmo()//placed on Object so that we can optimize early checks in DayZGame without casting
 {
 return false;
 }
 
 bool IsFuelStation()
 {
 return false;
 }
 
 bool IsTransport()
 {
 return false;
 }
 
 bool IsElectricAppliance()
 {
 return false;
 }
 
 bool CanUseConstruction()
 {
 return false;
 }
 
 bool CanUseConstructionBuild()
 {
 return false;
 }
 
 bool CanUseHandConstruction()
 {
 return false;
 }
 
 bool IsBeingBackstabbed()
 {
 return false;
 }
 
 void SetBeingBackstabbed(int backstabType){}
 
 bool IsFood()
 {
 return ( IsFruit() || IsMeat() || IsCorpse() || IsMushroom() );
 }
 
 bool IsFruit()
 {
 return false;
 }
 
 bool IsMeat()
 {
 return false;
 }
 
 bool IsCorpse()
 {
 return false;
 }
 
 bool IsMushroom()
 {
 return false;
 } 
 
 bool IsHealthVisible()
 {
 return true;
 }
 
 bool ShowZonesHealth()
 {
 return false;
 }
 
 bool IsParticle()
 {
 return false;
 }
 
 bool IsItemTent()
 {
 return false;
 }
 
 bool IsScriptedLight()
 {
 return false;
 }
 
 bool IsHologram()
 {
 return false;
 }
 
 bool HasProxyParts()
 {
 return false;
 }
 
 bool CanObstruct()
 {
 return IsPlainObject() && !IsScenery();
 }
 
 bool CanProxyObstruct()
 {
 return HasProxyParts() || CanUseConstruction();
 }
 
 bool CanProxyObstructSelf()
 {
 return false;
 }
 
 bool CanBeIgnoredByDroppedItem()
 {
 return IsBush() || IsTree() || IsMan() || IsDayZCreature() || IsItemBase();
 }
 
 bool CanBeAutoDeleted()
 {
 return true;
 }
 
 bool DisableVicinityIcon()
 {
 return false;
 }
 
 proto void GetNetworkID( out int lowBits, out int highBits );
 
 string GetNetworkIDString()
 {
 int low, high;
 GetNetworkID( low, high );
 return high.ToString() + low.ToString();
 }
 
 override string GetDebugName()
 {
 return GetDebugNameNative();
 }
 
 static string GetDebugName(Object o)
 {
 if (o)
 return o.GetDebugName();
 return "null";
 }
 
 proto string GetDebugNameNative();
 
 void RPC(int rpc_type, array<ref Param> params, bool guaranteed, PlayerIdentity recipient = NULL)
 {
 GetGame().RPC(this, rpc_type, params, guaranteed, recipient);
 }
 
 void RPCSingleParam(int rpc_type, Param param, bool guaranteed, PlayerIdentity recipient = NULL)
 {
 GetGame().RPCSingleParam(this, rpc_type, param, guaranteed, recipient);
 }
 
 void OnRPC(PlayerIdentity sender, int rpc_type, ParamsReadContext ctx);
 
 vector GetSelectionPositionOld(string name)
 {
 return GetGame().ObjectGetSelectionPosition(this, name);
 }
 
 vector GetSelectionPositionLS(string name)
 {
 return GetGame().ObjectGetSelectionPositionLS(this, name);
 }
 
 vector GetSelectionPositionMS(string name)
 {
 return GetGame().ObjectGetSelectionPositionMS(this, name);
 }
 
 vector GetSelectionPositionWS(string name)
 {
 return GetGame().ObjectGetSelectionPositionWS(this, name);
 }
 
 
 vector ModelToWorld(vector modelPos)
 {
 return GetGame().ObjectModelToWorld(this, modelPos);
 }
 
 vector WorldToModel(vector worldPos)
 {
 return GetGame().ObjectWorldToModel(this, worldPos);
 }
 
 // config class API 
 
 proto string ConfigGetString(string entryName);
 proto string ConfigGetStringRaw(string entryName);
 proto int ConfigGetInt(string entryName);
 bool ConfigGetBool(string entryName)
 {
 return (ConfigGetInt(entryName) == 1);
 }
 
 proto float ConfigGetFloat(string entryName);
 proto vector ConfigGetVector(string entryName);
 //proto ParamEntry ConfigGetEntry(string entryName);
 
 proto native void ConfigGetTextArray(string entryName, out TStringArray values);
 
 proto native void ConfigGetTextArrayRaw(string entryName, out TStringArray values);
 
 proto native void ConfigGetFloatArray(string entryName, out TFloatArray values);
 
 proto native void ConfigGetIntArray(string entryName, out TIntArray values);
 
 proto native bool ConfigIsExisting(string entryName);
 
 bool KindOf( string tag )
 {
 bool found = false;
 string item_name = this.GetType(); 
 TStringArray item_tag_array = new TStringArray;
 ConfigGetTextArray("cfgVehicles " + item_name + " itemInfo", item_tag_array); 
 
 int array_size = item_tag_array.Count();
 for (int i = 0; i < array_size; i++)
 {
 if ( item_tag_array.Get(i) == tag )
 {
 found = true;
 break;
 }
 }
 return found;
 }
 
 bool IsAnyInherited( array<typename> typenames )
 {
 bool ret;
 for( int i = 0; i < typenames.Count(); i++ )
 {
 ret = ret || this.IsInherited( typenames.Get(i) );
 }
 return ret;
 }
 
 proto native bool IsPlainObject();
 
 proto native bool IsScenery();
 
 // Damage system
 proto native bool HasDamageSystem();
 
 proto native bool IsDamageDestroyed();
 
 proto native void SetDestructTime(float time);
 
 proto native float GetHealth(string zoneName, string healthType);
 
 proto native float GetHealth01(string zoneName, string healthType);
 
 proto native float GetMaxHealth(string zoneName, string healthType);
 
 proto native void SetHealth(string zoneName, string healthType, float value);
 
 proto native void SetFullHealth();
 
 proto native void AddHealth(string zoneName, string healthType, float value);
 
 proto native void DecreaseHealth(string zoneName, string healthType, float value);
 
 void DecreaseHealth(string zoneName, string healthType, float value, bool auto_delete)
 {
 DecreaseHealth( zoneName, healthType, value);
 
 float result_health = GetHealth(zoneName, healthType);
 
 if ( auto_delete && result_health <= 0 )
 {
 GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).Call(GetGame().ObjectDelete, this); 
 }
 }
 
 float GetHealth()
 {
 return GetHealth("", "");
 }
 float GetHealth01()
 {
 return GetHealth01("", "");
 }
 float GetMaxHealth()
 {
 return GetMaxHealth("", "");
 }
 void SetHealth(float health)
 {
 SetHealth("", "", health);
 }
 void SetGlobalHealth(float health)
 {
 SetHealth("", "", health);
 }
 void SetHealthLevel(int healthLevel, string zone = "")
 {
 SetHealth01(zone,"", GetHealthLevelValue(healthLevel, zone));
 }
 void AddHealthLevel(int healthLevelDelta, string zone = "")
 {
 int maxHealthLevel = GetNumberOfHealthLevels(zone) - 1;
 int newHealthLevel = Math.Clamp(GetHealthLevel(zone) + healthLevelDelta,0,maxHealthLevel);
 SetHealthLevel(newHealthLevel,zone);
 }
 
 void SetHealth01(string zoneName, string healthType, float coef)
 {
 SetHealth(zoneName,healthType,(GetMaxHealth(zoneName,healthType)*coef));
 }
 void SetHealthMax(string zoneName = "", string healthType = "")
 {
 SetHealth(zoneName,healthType,GetMaxHealth(zoneName,healthType));
 }
 void AddHealth( float add_health)
 {
 AddHealth("", "", add_health);
 }
 void DecreaseHealth(float dec_health, bool auto_delete = true)
 {
 DecreaseHealth("", "", dec_health, auto_delete);
 }
 void DecreaseHealthCoef(float dec_health_coef, bool auto_delete = true)
 {
 float current_health = GetHealth();
 float final_health_coef = GetHealth01() - dec_health_coef;
 float final_health = GetMaxHealth() * final_health_coef; 
 DecreaseHealth("", "", current_health - final_health);
 }
 
 proto native void ProcessDirectDamage(int damageType, EntityAI source, string componentName, string ammoName, vector modelPos, float damageCoef = 1.0, int flags = 0);
 
 bool EEOnDamageCalculated(TotalDamageResult damageResult, int damageType, EntityAI source, int component, string dmgZone, string ammo, vector modelPos, float speedCoef)
 {
 return true;
 }
 
 proto native void GetDamageZones(out TStringArray dmgZones);
 
 proto native vector GetDamageZonePos(string zoneName);
 proto native owned string GetDamageZoneNameByComponentIndex(int componentIndex);
 
 proto native int GetHealthLevel(string zone = "");
 
 proto native int GetNumberOfHealthLevels(string zone = "");
 
 proto native float GetHealthLevelValue(int healthLevel, string zone = "");
 
 
 proto native bool GetAllowDamage();
 proto native void SetAllowDamage(bool val);
 
 proto native bool GetCanBeDestroyed();
 
 proto native void SetCanBeDestroyed(bool val);
 
 bool IsRuined()
 {
 return IsDamageDestroyed();
 }
 
 void OnSimulationEnabled() {}
 
 void OnSimulationDisabled() {}
 
 void GetActions(typename action_input_type, out array<ActionBase_Basic> actions)
 {
 }
 
 SoundOnVehicle PlaySound(string sound_name, float range, bool create_local = true)
 {
 return GetGame().CreateSoundOnObject(this, sound_name, range, false, create_local);
 }
 
 SoundOnVehicle PlaySoundLoop(string sound_name, float range, bool create_local = true)
 {
 return GetGame().CreateSoundOnObject(this, sound_name, range, true, create_local);
 }
 
 bool PlaySoundSet( out EffectSound sound, string sound_set, float fade_in, float fade_out, bool loop = false )
 {
 if ( GetGame() && !GetGame().IsDedicatedServer() )
 {
 if ( sound )
 {
 if ( loop )
 {
 return true;
 }
 else
 {
 StopSoundSet( sound ); //auto stop for non-looped sounds
 }
 }
 
 sound = SEffectManager.PlaySoundOnObject( sound_set, this, fade_in, fade_out, loop );
 sound.SetAutodestroy( true );
 
 return true;
 }
 
 return false;
 } 
 
 bool PlaySoundSetLoop( out EffectSound sound, string sound_set, float fade_in, float fade_out )
 {
 return PlaySoundSet( sound, sound_set, fade_in, fade_out, true );
 }
 
 bool PlaySoundSetAtMemoryPointLoopedSafe(out EffectSound sound, string soundSet, string memoryPoint,float play_fade_in = 0, float stop_fade_out = 0)
 {
 if (sound && sound.IsPlaying())
 {
 sound.SoundStop();
 }
 return PlaySoundSetAtMemoryPointLooped(sound, soundSet, memoryPoint, play_fade_in, stop_fade_out);
 }
 
 bool PlaySoundSetAtMemoryPointLooped(out EffectSound sound, string soundSet, string memoryPoint, float play_fade_in = 0, float stop_fade_out = 0)
 {
 return PlaySoundSetAtMemoryPoint(sound, soundSet, memoryPoint, true, play_fade_in, stop_fade_out);
 }
 
 
 bool PlaySoundSetAtMemoryPoint(out EffectSound sound, string soundSet, string memoryPoint, bool looped = false, float play_fade_in = 0, float stop_fade_out = 0)
 {
 vector pos;
 
 if (MemoryPointExists(memoryPoint))
 {
 pos = GetMemoryPointPos(memoryPoint);
 pos = ModelToWorld(pos);
 }
 else
 {
 ErrorEx(string.Format("Memory point %1 not found when playing soundset %2 at memory point location", memoryPoint, soundSet));
 return false;
 }
 
 sound = SEffectManager.PlaySoundEnviroment(soundSet, pos, play_fade_in, stop_fade_out, looped);
 return true;
 }
 
 bool StopSoundSet( out EffectSound sound )
 {
 if ( sound && GetGame() && ( !GetGame().IsDedicatedServer() ) )
 {
 sound.SoundStop();
 sound = null;
 
 return true;
 }
 
 return false;
 }
 
 void PostAreaDamageActions();
 void PreAreaDamageActions();
 
 void SpawnDamageDealtEffect();
 void OnReceivedHit(ImpactEffectsData hitData);
 
 void OnPlayerRecievedHit();
 
 bool HasNetworkID()
 {
 int lo = 0;
 int hi = 0;
 GetNetworkID(lo, hi);
 return lo | hi;
 }
 
 bool NameOverride(out string output)
 {
 return false;
 }
 
 bool DescriptionOverride(out string output)
 {
 return false;
 }
 
 EntityAI ProcessMeleeItemDamage(int mode = 0) {}
 
 bool CanBeRepairedToPristine()
 {
 return false;
 }
 
 vector GetCenter()
 {
 if ( MemoryPointExists("ce_center") )
 {
 //Print("CE_CENTER found");
 return ModelToWorld( GetMemoryPointPos("ce_center") );
 }
 else
 {
 //Print("CE_CENTER DOING A BAMBOOZLE => not found");
 return GetPosition() + Vector(0, 0.2, 0);
 }
 }
 
 #ifdef DEVELOPER
 void SetDebugItem();
 #endif
 
 void AddArrow(Object arrow, int componentIndex, vector closeBonePosWS, vector closeBoneRotWS)
 {
 int pivot = GetBonePivot(GetFireGeometryLevel(), componentIndex);
 vector parentTransMat[4];
 vector arrowTransMat[4];
 
 if (pivot == -1)
 {
 GetTransform(parentTransMat);
 }
 else
 {
 GetBoneTransformWS(pivot, parentTransMat);
 }
 
 float scale = GetScale();
 scale = 1 / (scale * scale);
 
 arrow.GetTransform(arrowTransMat);
 Math3D.MatrixInvMultiply4(parentTransMat, arrowTransMat, arrowTransMat);
 
 // orthogonalize matrix - parent might be skewed
 Math3D.MatrixOrthogonalize4(arrowTransMat);
 
 arrowTransMat[3] = arrowTransMat[3] * scale;
 
 arrow.SetTransform(arrowTransMat);
 
 AddChild(arrow, pivot);
 }
 
 bool CanBeActionTarget()
 {
 return !IsHologram();
 }
 
 bool HasFixedActionTargetCursorPosition()
 {
 return false;
 }
 
 //Debug
 //----------------------------------------------
 /*void DbgAddPxyPhy(string slot)
 {
 Print("AddProxyPhysics slot: " + slot);
 AddProxyPhysics(slot);
 }*/
};