basebuildingbase.c

Go to the documentation of this file.

//BASE BUILDING BASE
class BaseBuildingBase extends ItemBase
{
 const string ANIMATION_DEPLOYED = "Deployed";
 
 float m_ConstructionKitHealth; //stored health value for used construction kit
 
 ref Construction m_Construction;
 
 bool m_HasBase;
 //variables for synchronization of base building parts (2x31 is the current limit)
 int m_SyncParts01; //synchronization for already built parts (31 parts)
 int m_SyncParts02; //synchronization for already built parts (+31 parts)
 int m_SyncParts03; //synchronization for already built parts (+31 parts)
 int m_InteractedPartId; //construction part id that an action was performed on
 int m_PerformedActionId; //action id that was performed on a construction part
 
 //Sounds
 //build
 const string SOUND_BUILD_WOOD_LOG = "putDown_WoodLog_SoundSet";
 const string SOUND_BUILD_WOOD_PLANK = "putDown_WoodPlank_SoundSet";
 const string SOUND_BUILD_WOOD_STAIRS = "putDown_WoodStairs_SoundSet";
 const string SOUND_BUILD_METAL = "putDown_MetalPlank_SoundSet";
 const string SOUND_BUILD_WIRE = "putDown_BarbedWire_SoundSet";
 //dismantle
 const string SOUND_DISMANTLE_WOOD_LOG = "Crash_WoodPlank_SoundSet";
 const string SOUND_DISMANTLE_WOOD_PLANK = "Crash_WoodPlank_SoundSet";
 const string SOUND_DISMANTLE_WOOD_STAIRS = "Crash_WoodPlank_SoundSet";
 const string SOUND_DISMANTLE_METAL = "Crash_MetalPlank_SoundSet";
 const string SOUND_DISMANTLE_WIRE = "putDown_BarbedWire_SoundSet";
 
 protected EffectSound m_Sound;
 
 ref map<string, ref AreaDamageManager> m_DamageTriggers;
 ref array<string> m_HybridAttachments;
 ref array<string> m_Mountables;
 
 // Constructor
 void BaseBuildingBase() 
 {
 m_DamageTriggers = new ref map<string, ref AreaDamageManager>;
 
 //synchronized variables
 RegisterNetSyncVariableInt( "m_SyncParts01" );
 RegisterNetSyncVariableInt( "m_SyncParts02" );
 RegisterNetSyncVariableInt( "m_SyncParts03" );
 RegisterNetSyncVariableInt( "m_InteractedPartId" );
 RegisterNetSyncVariableInt( "m_PerformedActionId" );
 RegisterNetSyncVariableBool( "m_HasBase" );
 
 //Construction init
 ConstructionInit();
 
 if (ConfigIsExisting("hybridAttachments"))
 {
 m_HybridAttachments = new array<string>;
 ConfigGetTextArray("hybridAttachments", m_HybridAttachments);
 }
 if (ConfigIsExisting("mountables"))
 {
 m_Mountables = new array<string>;
 ConfigGetTextArray("mountables", m_Mountables);
 }
 
 ProcessInvulnerabilityCheck(GetInvulnerabilityTypeString());
 }
 
 override void EEDelete(EntityAI parent)
 {
 super.EEDelete(parent);
 
 foreach (AreaDamageManager areaDamage : m_DamageTriggers)
 {
 areaDamage.Destroy();
 }
 
 }
 
 override string GetInvulnerabilityTypeString()
 {
 return "disableBaseDamage";
 }
 
 override bool CanObstruct()
 {
 return true;
 }
 
 override int GetHideIconMask()
 {
 return EInventoryIconVisibility.HIDE_VICINITY;
 }
 
 // --- SYNCHRONIZATION
 void SynchronizeBaseState()
 {
 if ( GetGame().IsServer() )
 {
 SetSynchDirty();
 }
 }
 
 override void OnVariablesSynchronized()
 {
 if (LogManager.IsBaseBuildingLogEnable()) bsbDebugPrint("[bsb] " + GetDebugName(this) + " OnVariablesSynchronized");
 super.OnVariablesSynchronized();
 
 GetGame().GetCallQueue( CALL_CATEGORY_GAMEPLAY ).CallLater( OnSynchronizedClient, 100, false );
 }
 
 protected void OnSynchronizedClient()
 {
 //update parts
 SetPartsFromSyncData();
 
 //update action on part
 SetActionFromSyncData();
 
 //update visuals (client)
 UpdateVisuals();
 }
 
 //parts synchronization
 void RegisterPartForSync( int part_id )
 {
 //part_id must starts from index = 1
 int offset;
 int mask;
 
 if ( part_id >= 1 && part_id <= 31 ) //<1,31> (31 parts)
 {
 offset = part_id - 1;
 mask = 1 << offset;
 
 m_SyncParts01 = m_SyncParts01 | mask; 
 }
 else if ( part_id >= 32 && part_id <= 62 ) //<32,62> (31 parts)
 {
 offset = ( part_id % 32 );
 mask = 1 << offset;
 
 m_SyncParts02 = m_SyncParts02 | mask; 
 }
 else if ( part_id >= 63 && part_id <= 93 ) //<63,93> (31 parts)
 {
 offset = ( part_id % 63 );
 mask = 1 << offset;
 
 m_SyncParts03 = m_SyncParts03 | mask; 
 }
 }
 
 void UnregisterPartForSync( int part_id )
 {
 //part_id must starts from index = 1
 int offset;
 int mask;
 
 if ( part_id >= 1 && part_id <= 31 ) //<1,31> (31 parts)
 {
 offset = part_id - 1;
 mask = 1 << offset;
 
 m_SyncParts01 = m_SyncParts01 & ~mask; 
 }
 else if ( part_id >= 32 && part_id <= 62 ) //<32,62> (31 parts)
 {
 offset = ( part_id % 32 );
 mask = 1 << offset;
 
 m_SyncParts02 = m_SyncParts02 & ~mask; 
 }
 else if ( part_id >= 63 && part_id <= 93 ) //<63,93> (31 parts)
 {
 offset = ( part_id % 63 );
 mask = 1 << offset;
 
 m_SyncParts03 = m_SyncParts03 & ~mask; 
 }
 } 
 
 bool IsPartBuildInSyncData( int part_id )
 {
 //part_id must starts from index = 1
 int offset;
 int mask;
 
 if ( part_id >= 1 && part_id <= 31 ) //<1,31> (31 parts)
 {
 offset = part_id - 1;
 mask = 1 << offset;
 
 if ( ( m_SyncParts01 & mask ) > 0 )
 {
 return true;
 }
 }
 else if ( part_id >= 32 && part_id <= 62 ) //<32,62> (31 parts)
 {
 offset = ( part_id % 32 );
 mask = 1 << offset;
 
 if ( ( m_SyncParts02 & mask ) > 0 )
 {
 return true;
 }
 }
 else if ( part_id >= 63 && part_id <= 93 ) //<63,93> (31 parts)
 {
 offset = ( part_id % 63 );
 mask = 1 << offset;
 
 if ( ( m_SyncParts03 & mask ) > 0 )
 {
 return true;
 }
 } 
 
 return false;
 }
 
 protected void RegisterActionForSync( int part_id, int action_id )
 {
 m_InteractedPartId = part_id;
 m_PerformedActionId = action_id;
 }
 
 protected void ResetActionSyncData()
 {
 //reset data
 m_InteractedPartId = -1;
 m_PerformedActionId = -1;
 }
 
 protected void SetActionFromSyncData()
 {
 if ( m_InteractedPartId > -1 && m_PerformedActionId > -1 )
 {
 ConstructionPart constrution_part = GetConstructionPartById( m_InteractedPartId );
 int build_action_id = m_PerformedActionId;
 
 switch( build_action_id )
 {
 case AT_BUILD_PART : OnPartBuiltClient( constrution_part.GetPartName(), build_action_id ); break;
 case AT_DISMANTLE_PART : OnPartDismantledClient( constrution_part.GetPartName(), build_action_id ); break;
 case AT_DESTROY_PART : OnPartDestroyedClient( constrution_part.GetPartName(), build_action_id ); break;
 }
 }
 }
 //------
 
 void SetPartFromSyncData( ConstructionPart part )
 {
 string key = part.m_PartName;
 bool is_base = part.IsBase();
 bool is_part_built_sync = IsPartBuildInSyncData( part.GetId() );
 bsbDebugSpam("[bsb] " + GetDebugName(this) + " SetPartFromSyncData try to sync: built=" + is_part_built_sync + " key=" + key + " part=" + part.GetPartName() + " part_built=" + part.IsBuilt());
 if ( is_part_built_sync )
 {
 if ( !part.IsBuilt() )
 {
 if (LogManager.IsBaseBuildingLogEnable()) bsbDebugPrint("[bsb] " + GetDebugName(this) + " SetPartsFromSyncData +++ " + key);
 GetConstruction().AddToConstructedParts( key );
 GetConstruction().ShowConstructionPartPhysics(part.GetPartName());
 
 if (is_base)
 {
 if (LogManager.IsBaseBuildingLogEnable()) bsbDebugPrint("[bsb] " + GetDebugName(this) + ANIMATION_DEPLOYED + " RM");
 RemoveProxyPhysics( ANIMATION_DEPLOYED );
 }
 }
 }
 else
 {
 if ( part.IsBuilt() )
 {
 if (LogManager.IsBaseBuildingLogEnable()) bsbDebugPrint("[bsb] " + GetDebugName(this) + " SetPartsFromSyncData --- " + key);
 GetConstruction().RemoveFromConstructedParts( key );
 GetConstruction().HideConstructionPartPhysics(part.GetPartName());
 
 if (is_base)
 {
 if (LogManager.IsBaseBuildingLogEnable()) bsbDebugPrint("[bsb] " + GetDebugName(this) + ANIMATION_DEPLOYED + " ADD");
 AddProxyPhysics( ANIMATION_DEPLOYED );
 }
 }
 }
 
 //check slot lock for material attachments 
 GetConstruction().SetLockOnAttachedMaterials( part.GetPartName(), part.IsBuilt() ); //failsafe for corrupted sync/storage data 
 }
 
 //set construction parts based on synchronized data
 void SetPartsFromSyncData()
 {
 Construction construction = GetConstruction();
 map<string, ref ConstructionPart> construction_parts = construction.GetConstructionParts();
 
 for ( int i = 0; i < construction_parts.Count(); ++i )
 {
 string key = construction_parts.GetKey( i );
 ConstructionPart value = construction_parts.Get( key );
 SetPartFromSyncData(value);
 }
 
 //regenerate navmesh
 UpdateNavmesh(); 
 }
 
 protected ConstructionPart GetConstructionPartById( int id )
 {
 Construction construction = GetConstruction();
 map<string, ref ConstructionPart> construction_parts = construction.GetConstructionParts();
 
 for ( int i = 0; i < construction_parts.Count(); ++i )
 {
 string key = construction_parts.GetKey( i );
 ConstructionPart value = construction_parts.Get( key );
 
 if ( value.GetId() == id )
 {
 return value;
 }
 }
 
 return NULL;
 }
 //
 
 //Base
 bool HasBase()
 {
 return m_HasBase;
 }
 
 void SetBaseState( bool has_base )
 {
 m_HasBase = has_base;
 }
 
 override bool IsDeployable()
 {
 return true;
 }
 
 bool IsOpened()
 {
 return false;
 }
 
 //--- CONSTRUCTION KIT
 ItemBase CreateConstructionKit()
 {
 ItemBase construction_kit = ItemBase.Cast( GetGame().CreateObjectEx( GetConstructionKitType(), GetKitSpawnPosition(), ECE_PLACE_ON_SURFACE ) );
 if ( m_ConstructionKitHealth > 0 )
 {
 construction_kit.SetHealth( m_ConstructionKitHealth );
 }
 
 return construction_kit;
 }
 
 void CreateConstructionKitInHands(notnull PlayerBase player)
 {
 ItemBase construction_kit = ItemBase.Cast(player.GetHumanInventory().CreateInHands(GetConstructionKitType()));
 if ( m_ConstructionKitHealth > 0 )
 {
 construction_kit.SetHealth( m_ConstructionKitHealth );
 }
 }
 
 protected vector GetKitSpawnPosition()
 {
 return GetPosition();
 }
 
 protected string GetConstructionKitType()
 {
 return "";
 }
 
 void DestroyConstructionKit( ItemBase construction_kit )
 {
 m_ConstructionKitHealth = construction_kit.GetHealth();
 GetGame().ObjectDelete( construction_kit );
 }
 
 //--- CONSTRUCTION
 void DestroyConstruction()
 {
 if (LogManager.IsBaseBuildingLogEnable()) bsbDebugPrint("[bsb] " + GetDebugName(this) + " DestroyConstruction");
 GetGame().ObjectDelete( this );
 } 
 
 // --- EVENTS
 override void OnStoreSave( ParamsWriteContext ctx )
 { 
 super.OnStoreSave( ctx );
 
 //sync parts 01
 ctx.Write( m_SyncParts01 );
 ctx.Write( m_SyncParts02 );
 ctx.Write( m_SyncParts03 );
 
 ctx.Write( m_HasBase );
 }
 
 override bool OnStoreLoad( ParamsReadContext ctx, int version )
 {
 if ( !super.OnStoreLoad( ctx, version ) )
 return false;
 
 //--- Base building data ---
 //Restore synced parts data
 if ( !ctx.Read( m_SyncParts01 ) )
 {
 m_SyncParts01 = 0; //set default
 return false;
 }
 if ( !ctx.Read( m_SyncParts02 ) )
 {
 m_SyncParts02 = 0; //set default
 return false;
 }
 if ( !ctx.Read( m_SyncParts03 ) )
 {
 m_SyncParts03 = 0; //set default
 return false;
 }
 
 //has base
 if ( !ctx.Read( m_HasBase ) )
 {
 m_HasBase = false;
 return false;
 }
 //---
 
 return true;
 }
 
 override void AfterStoreLoad()
 { 
 super.AfterStoreLoad(); 
 
 if (!m_FixDamageSystemInit)
 {
 SetPartsAfterStoreLoad();
 }
 }
 
 void SetPartsAfterStoreLoad()
 {
 //update server data
 SetPartsFromSyncData();
 
 //set base state
 ConstructionPart construction_part = GetConstruction().GetBaseConstructionPart();
 SetBaseState( construction_part.IsBuilt() ) ;
 
 //synchronize after load
 SynchronizeBaseState();
 }
 
 override void EEHealthLevelChanged(int oldLevel, int newLevel, string zone)
 {
 if (m_FixDamageSystemInit)
 return;
 
 super.EEHealthLevelChanged(oldLevel,newLevel,zone);
 
 if (GetGame().IsMultiplayer() && !GetGame().IsServer())
 return;
 
 Construction construction = GetConstruction();
 string part_name = zone;
 part_name.ToLower();
 
 if ( newLevel == GameConstants.STATE_RUINED )
 {
 ConstructionPart construction_part = construction.GetConstructionPart( part_name );
 
 if ( construction_part && construction.IsPartConstructed( part_name ) )
 {
 construction.DestroyPartServer( null, part_name, AT_DESTROY_PART );
 construction.DestroyConnectedParts(part_name);
 }
 
 //barbed wire handling (hack-ish)
 if ( part_name.Contains("barbed") )
 {
 BarbedWire barbed_wire = BarbedWire.Cast( FindAttachmentBySlotName( zone ) );
 if (barbed_wire)
 barbed_wire.SetMountedState( false );
 }
 }
 }
 
 override void EEOnAfterLoad()
 {
 if (m_FixDamageSystemInit)
 {
 GetGame().GetCallQueue( CALL_CATEGORY_GAMEPLAY ).CallLater( SetPartsAfterStoreLoad, 500, false, this );
 }
 
 super.EEOnAfterLoad();
 }
 
 override void EEInit()
 {
 super.EEInit();
 
 // init visuals and physics
 InitBaseState();
 
 //debug
 #ifdef DEVELOPER
 DebugCustomState();
 #endif
 }
 
 override void EEItemAttached( EntityAI item, string slot_name )
 {
 super.EEItemAttached( item, slot_name );
 
 CheckForHybridAttachments( item, slot_name );
 UpdateVisuals();
 UpdateAttachmentPhysics( slot_name, false );
 }
 
 override void EEItemDetached( EntityAI item, string slot_name )
 {
 super.EEItemDetached( item, slot_name );
 
 UpdateVisuals();
 UpdateAttachmentPhysics( slot_name, false );
 }
 
 protected void OnSetSlotLock( int slotId, bool locked, bool was_locked )
 {
 string slot_name = InventorySlots.GetSlotName( slotId );
 if (LogManager.IsBaseBuildingLogEnable()) bsbDebugPrint( "inv: OnSetSlotLock " + GetDebugName( this ) + " slot=" + slot_name + " locked=" + locked + " was_locked=" + was_locked );
 
 UpdateAttachmentVisuals( slot_name, locked );
 UpdateAttachmentPhysics( slot_name, locked );
 }
 
 //ignore out of reach condition
 override bool IgnoreOutOfReachCondition()
 {
 return true;
 }
 
 //CONSTRUCTION EVENTS
 //Build
 void OnPartBuiltServer(notnull Man player, string part_name, int action_id)
 {
 ConstructionPart construtionPart = GetConstruction().GetConstructionPart(part_name);
 
 //check base state
 if (construtionPart.IsBase())
 {
 SetBaseState(true);
 
 //spawn kit
 CreateConstructionKit();
 }
 
 //register constructed parts for synchronization
 RegisterPartForSync(construtionPart.GetId());
 
 //register action that was performed on part
 RegisterActionForSync(construtionPart.GetId(), action_id);
 
 //synchronize
 SynchronizeBaseState();
 
 SetPartFromSyncData(construtionPart); // server part of sync, client will be synced from SetPartsFromSyncData
 
 UpdateNavmesh();
 
 //update visuals
 UpdateVisuals();
 
 //reset action sync data
 GetGame().GetCallQueue(CALL_CATEGORY_GAMEPLAY).CallLater(ResetActionSyncData, 100, false, this);
 }
 
 void OnPartBuiltClient(string part_name, int action_id)
 {
 //play sound
 SoundBuildStart( part_name );
 } 
 
 //Dismantle
 void OnPartDismantledServer(notnull Man player, string part_name, int action_id)
 {
 if (LogManager.IsBaseBuildingLogEnable()) bsbDebugPrint("[bsb] " + GetDebugName(this) + " OnPartDismantledServer " + part_name);
 ConstructionPart construtionPart = GetConstruction().GetConstructionPart(part_name);
 
 //register constructed parts for synchronization
 UnregisterPartForSync(construtionPart.GetId());
 
 //register action that was performed on part
 RegisterActionForSync(construtionPart.GetId(), action_id);
 
 //synchronize
 SynchronizeBaseState();
 
 // server part of sync, client will be synced from SetPartsFromSyncData
 SetPartFromSyncData(construtionPart);
 
 UpdateNavmesh();
 
 //update visuals
 UpdateVisuals();
 
 //reset action sync data
 GetGame().GetCallQueue(CALL_CATEGORY_GAMEPLAY).CallLater(ResetActionSyncData, 100, false, this);
 
 //check base state
 if (construtionPart.IsBase())
 {
 //Destroy construction
 GetGame().GetCallQueue(CALL_CATEGORY_GAMEPLAY).CallLater(DestroyConstruction, 200, false, this);
 } 
 }
 
 void OnPartDismantledClient( string part_name, int action_id )
 {
 //play sound
 SoundDismantleStart( part_name );
 } 
 
 //Destroy
 void OnPartDestroyedServer(Man player, string part_name, int action_id, bool destroyed_by_connected_part = false)
 {
 if (LogManager.IsBaseBuildingLogEnable()) bsbDebugPrint("[bsb] " + GetDebugName(this) + " OnPartDestroyedServer " + part_name);
 ConstructionPart construtionPart = GetConstruction().GetConstructionPart(part_name);
 
 //register constructed parts for synchronization
 UnregisterPartForSync(construtionPart.GetId());
 
 //register action that was performed on part
 RegisterActionForSync(construtionPart.GetId(), action_id);
 
 //synchronize
 SynchronizeBaseState();
 
 // server part of sync, client will be synced from SetPartsFromSyncData
 SetPartFromSyncData(construtionPart);
 
 UpdateNavmesh();
 
 //update visuals
 UpdateVisuals();
 
 //reset action sync data
 GetGame().GetCallQueue(CALL_CATEGORY_GAMEPLAY).CallLater(ResetActionSyncData, 100, false, this);
 
 //check base state
 if (construtionPart.IsBase())
 {
 //Destroy construction
 GetGame().GetCallQueue(CALL_CATEGORY_GAMEPLAY).CallLater(DestroyConstruction, 200, false, this);
 } 
 }
 
 void OnPartDestroyedClient( string part_name, int action_id )
 {
 //play sound
 SoundDestroyStart( part_name );
 } 
 
 // --- UPDATE
 void InitBaseState()
 {
 if (LogManager.IsBaseBuildingLogEnable()) bsbDebugPrint("[bsb] " + GetDebugName(this) + " BaseBuildingBase::InitBaseState ");
 
 InitVisuals();
 UpdateNavmesh(); //regenerate navmesh
 GetConstruction().InitBaseState();
 } 
 
 void InitVisuals()
 {
 if (LogManager.IsBaseBuildingLogEnable()) bsbDebugPrint("[bsb] " + GetDebugName(this) + " InitVisuals");
 //check base
 if ( !HasBase() )
 {
 SetAnimationPhase( ANIMATION_DEPLOYED, 0 );
 }
 else
 {
 SetAnimationPhase( ANIMATION_DEPLOYED, 1 );
 }
 
 GetConstruction().UpdateVisuals();
 }
 
 void UpdateVisuals()
 {
 array<string> attachmentSlots = new array<string>;
 
 GetAttachmentSlots(this, attachmentSlots);
 foreach (string slotName : attachmentSlots)
 {
 UpdateAttachmentVisuals(slotName, IsAttachmentSlotLocked(slotName));
 }
 
 //check base
 if (!HasBase())
 SetAnimationPhase(ANIMATION_DEPLOYED, 0);
 else
 SetAnimationPhase(ANIMATION_DEPLOYED, 1);
 
 GetConstruction().UpdateVisuals();
 }
 
 void UpdateAttachmentVisuals(string slot_name, bool is_locked)
 {
 string slotNameMounted = slot_name + "_Mounted";
 EntityAI attachment = FindAttachmentBySlotName(slot_name);
 
 if (attachment)
 {
 BarbedWire barbedWire = BarbedWire.Cast(attachment);
 if (barbedWire && barbedWire.IsMounted())
 CreateAreaDamage(slotNameMounted);
 else
 DestroyAreaDamage(slotNameMounted);
 
 if (is_locked)
 {
 SetAnimationPhase(slotNameMounted, 0);
 SetAnimationPhase(slot_name, 1);
 }
 else
 {
 SetAnimationPhase(slotNameMounted, 1);
 SetAnimationPhase(slot_name, 0);
 }
 }
 else
 {
 SetAnimationPhase(slotNameMounted, 1);
 SetAnimationPhase(slot_name, 1);
 
 DestroyAreaDamage(slotNameMounted);
 }
 }
 
 // avoid calling this function on frequent occasions, it's a massive performance hit
 void UpdatePhysics()
 {
 if (LogManager.IsBaseBuildingLogEnable())
 bsbDebugPrint("[bsb] " + GetDebugName(this) + " BaseBuildingBase::UpdatePhysics");
 
 array<string> attachmentSlots = new array<string>;
 GetAttachmentSlots(this, attachmentSlots);
 
 if (LogManager.IsBaseBuildingLogEnable())
 bsbDebugPrint("[bsb] " + GetDebugName(this) + " att_cnt=" + attachmentSlots.Count());
 
 foreach (string slotName : attachmentSlots)
 {
 UpdateAttachmentPhysics(slotName, IsAttachmentSlotLocked(slotName));
 }
 
 //check base
 if (!HasBase())
 {
 if (LogManager.IsBaseBuildingLogEnable())
 bsbDebugPrint("[bsb] " + GetDebugName(this) + ANIMATION_DEPLOYED + " ADD");
 
 AddProxyPhysics(ANIMATION_DEPLOYED);
 }
 else
 {
 if (LogManager.IsBaseBuildingLogEnable())
 bsbDebugPrint("[bsb] " + GetDebugName(this) + ANIMATION_DEPLOYED + " RM");
 
 RemoveProxyPhysics(ANIMATION_DEPLOYED);
 }
 
 GetConstruction().UpdatePhysics();
 UpdateNavmesh();
 }
 
 void UpdateAttachmentPhysics( string slot_name, bool is_locked )
 {
 //checks for invalid appends; hotfix
 if ( !m_Mountables || m_Mountables.Find(slot_name) == -1 )
 return;
 //----------------------------------
 string slot_name_mounted = slot_name + "_Mounted";
 EntityAI attachment = FindAttachmentBySlotName( slot_name );
 
 //remove proxy physics
 if (LogManager.IsBaseBuildingLogEnable()) bsbDebugPrint("[bsb] " + GetDebugName(this) + " Removing ATT SLOT=" + slot_name + " RM / RM");
 RemoveProxyPhysics( slot_name_mounted );
 RemoveProxyPhysics( slot_name );
 
 if ( attachment )
 {
 if (LogManager.IsBaseBuildingLogEnable()) bsbDebugPrint("[bsb] " + GetDebugName(this) + " Adding ATT=" + Object.GetDebugName(attachment));
 if ( is_locked )
 {
 if (LogManager.IsBaseBuildingLogEnable()) bsbDebugPrint("[bsb] " + GetDebugName(this) + " RM / RM");
 AddProxyPhysics( slot_name_mounted );
 }
 else
 {
 if (LogManager.IsBaseBuildingLogEnable()) bsbDebugPrint("[bsb] " + GetDebugName(this) + " ADD");
 AddProxyPhysics( slot_name );
 }
 }
 }
 
 protected void UpdateNavmesh()
 {
 SetAffectPathgraph( true, false );
 GetGame().GetCallQueue( CALL_CATEGORY_SYSTEM ).CallLater( GetGame().UpdatePathgraphRegionByObject, 100, false, this );
 }
 
 override bool CanUseConstruction()
 {
 return true;
 }
 
 override bool CanUseConstructionBuild()
 {
 return true;
 }
 
 protected bool IsAttachmentSlotLocked( EntityAI attachment )
 {
 if ( attachment )
 {
 InventoryLocation inventory_location = new InventoryLocation;
 attachment.GetInventory().GetCurrentInventoryLocation( inventory_location );
 
 return GetInventory().GetSlotLock( inventory_location.GetSlot() );
 }
 
 return false;
 }
 
 protected bool IsAttachmentSlotLocked( string slot_name )
 {
 return GetInventory().GetSlotLock( InventorySlots.GetSlotIdFromString( slot_name ) );
 } 
 
 //--- ATTACHMENT SLOTS
 void GetAttachmentSlots( EntityAI entity, out array<string> attachment_slots )
 {
 string config_path = "CfgVehicles" + " " + entity.GetType() + " " + "attachments";
 if ( GetGame().ConfigIsExisting( config_path ) )
 {
 GetGame().ConfigGetTextArray( config_path, attachment_slots );
 }
 }
 
 bool CheckSlotVerticalDistance( int slot_id, PlayerBase player )
 {
 return true;
 }
 
 protected bool CheckMemoryPointVerticalDistance( float max_dist, string selection, PlayerBase player ) 
 {
 return true;
 }
 
 protected bool CheckLevelVerticalDistance( float max_dist, string selection, PlayerBase player ) 
 {
 return true;
 }
 
 // --- INIT
 void ConstructionInit()
 {
 if ( !m_Construction )
 {
 m_Construction = new Construction( this );
 }
 
 GetConstruction().Init();
 }
 
 Construction GetConstruction()
 {
 return m_Construction;
 }
 
 //--- INVENTORY/ATTACHMENTS CONDITIONS
 //attachments
 override bool CanReceiveAttachment( EntityAI attachment, int slotId )
 {
 return super.CanReceiveAttachment(attachment, slotId);
 }
 
 bool HasAttachmentsBesidesBase()
 {
 int attachment_count = GetInventory().AttachmentCount();
 if ( attachment_count > 0 )
 {
 if ( HasBase() && attachment_count == 1 )
 {
 return false;
 }
 
 return true;
 }
 
 return false;
 }
 
 override bool ShowZonesHealth()
 {
 return true;
 }
 
 //this into/outo parent.Cargo
 override bool CanPutInCargo( EntityAI parent )
 {
 return false;
 }
 
 override bool CanRemoveFromCargo( EntityAI parent )
 {
 return false;
 }
 
 //hands
 override bool CanPutIntoHands( EntityAI parent )
 {
 return false;
 }
 
 //--- ACTION CONDITIONS
 //direction
 override bool IsFacingPlayer( PlayerBase player, string selection )
 {
 return true;
 }
 
 override bool IsPlayerInside( PlayerBase player, string selection )
 {
 return true;
 }
 
 bool MustBeBuiltFromOutside()
 {
 return false;
 }
 
 //camera direction check
 bool IsFacingCamera( string selection )
 {
 return true;
 }
 
 //roof check
 bool PerformRoofCheckForBase( string partName, PlayerBase player, out bool result )
 {
 return false;
 }
 
 //selection->player distance check
 bool HasProperDistance( string selection, PlayerBase player )
 {
 return true;
 }
 
 //folding
 bool CanFoldBaseBuildingObject()
 {
 if ( HasBase() || GetInventory().AttachmentCount() > 0 )
 {
 return false;
 }
 
 return true;
 }
 
 ItemBase FoldBaseBuildingObject()
 {
 ItemBase item = CreateConstructionKit();
 DestroyConstruction();
 
 return item;
 }
 
 //Damage triggers (barbed wire)
 void CreateAreaDamage( string slot_name, float rotation_angle = 0 )
 {
 if ( GetGame() && GetGame().IsServer() )
 {
 //destroy area damage if some already exists
 DestroyAreaDamage( slot_name );
 
 //create new area damage
 AreaDamageLoopedDeferred_NoVehicle areaDamage = new AreaDamageLoopedDeferred_NoVehicle( this );
 areaDamage.SetDamageComponentType(AreaDamageComponentTypes.HITZONE);
 
 vector min_max[2];
 if ( MemoryPointExists( slot_name + "_min" ) )
 {
 min_max[0] = GetMemoryPointPos( slot_name + "_min" );
 }
 if ( MemoryPointExists( slot_name + "_max" ) )
 {
 min_max[1] = GetMemoryPointPos( slot_name + "_max" );
 }
 
 //get proper trigger extents (min<max)
 vector extents[2];
 GetConstruction().GetTriggerExtents( min_max, extents );
 
 //get box center
 vector center;
 center = GetConstruction().GetBoxCenter( min_max );
 center = ModelToWorld( center );
 
 //rotate center if needed
 vector orientation = GetOrientation();;
 CalcDamageAreaRotation( rotation_angle, center, orientation );
 
 areaDamage.SetExtents( extents[0], extents[1] );
 areaDamage.SetAreaPosition( center );
 areaDamage.SetAreaOrientation( orientation );
 areaDamage.SetLoopInterval( 1.0 );
 areaDamage.SetDeferDuration( 0.2 );
 areaDamage.SetHitZones( { "Torso","LeftHand","LeftLeg","LeftFoot","RightHand","RightLeg","RightFoot" } );
 areaDamage.SetAmmoName( "BarbedWireHit" );
 areaDamage.Spawn();
 
 m_DamageTriggers.Insert( slot_name, areaDamage );
 }
 }
 
 void CalcDamageAreaRotation( float angle_deg, out vector center, out vector orientation )
 {
 if ( angle_deg != 0 )
 {
 //orientation
 orientation[0] = orientation[0] - angle_deg;
 
 //center
 vector rotate_axis;
 if ( MemoryPointExists( "rotate_axis" ) )
 {
 rotate_axis = ModelToWorld( GetMemoryPointPos( "rotate_axis" ) );
 } 
 float r_center_x = ( Math.Cos( angle_deg * Math.DEG2RAD ) * ( center[0] - rotate_axis[0] ) ) - ( Math.Sin( angle_deg * Math.DEG2RAD ) * ( center[2] - rotate_axis[2] ) ) + rotate_axis[0];
 float r_center_z = ( Math.Sin( angle_deg * Math.DEG2RAD ) * ( center[0] - rotate_axis[0] ) ) + ( Math.Cos( angle_deg * Math.DEG2RAD ) * ( center[2] - rotate_axis[2] ) ) + rotate_axis[2];
 center[0] = r_center_x;
 center[2] = r_center_z;
 }
 }
 
 void DestroyAreaDamage( string slot_name )
 {
 if (GetGame() && GetGame().IsServer())
 {
 AreaDamageLoopedDeferred_NoVehicle areaDamage;
 if (m_DamageTriggers.Find(slot_name, areaDamage))
 {
 if (areaDamage)
 {
 areaDamage.Destroy();
 }
 
 m_DamageTriggers.Remove( slot_name );
 }
 }
 }
 
 override bool IsIgnoredByConstruction()
 {
 return true;
 }
 
 //================================================================
 // SOUNDS
 //================================================================
 protected void SoundBuildStart( string part_name )
 {
 PlaySoundSet( m_Sound, GetBuildSoundByMaterial( part_name ), 0.1, 0.1 );
 }
 
 protected void SoundDismantleStart( string part_name )
 {
 PlaySoundSet( m_Sound, GetDismantleSoundByMaterial( part_name ), 0.1, 0.1 );
 }
 
 protected void SoundDestroyStart( string part_name )
 {
 PlaySoundSet( m_Sound, GetDismantleSoundByMaterial( part_name ), 0.1, 0.1 );
 }
 
 protected string GetBuildSoundByMaterial( string part_name )
 {
 ConstructionMaterialType material_type = GetConstruction().GetMaterialType( part_name );
 
 switch ( material_type )
 {
 case ConstructionMaterialType.MATERIAL_LOG: return SOUND_BUILD_WOOD_LOG;
 case ConstructionMaterialType.MATERIAL_WOOD: return SOUND_BUILD_WOOD_PLANK;
 case ConstructionMaterialType.MATERIAL_STAIRS: return SOUND_BUILD_WOOD_STAIRS;
 case ConstructionMaterialType.MATERIAL_METAL: return SOUND_BUILD_METAL;
 case ConstructionMaterialType.MATERIAL_WIRE: return SOUND_BUILD_WIRE;
 }
 
 return "";
 }
 
 protected string GetDismantleSoundByMaterial( string part_name )
 {
 ConstructionMaterialType material_type = GetConstruction().GetMaterialType( part_name );
 
 switch ( material_type )
 {
 case ConstructionMaterialType.MATERIAL_LOG: return SOUND_DISMANTLE_WOOD_LOG;
 case ConstructionMaterialType.MATERIAL_WOOD: return SOUND_DISMANTLE_WOOD_PLANK;
 case ConstructionMaterialType.MATERIAL_STAIRS: return SOUND_DISMANTLE_WOOD_STAIRS;
 case ConstructionMaterialType.MATERIAL_METAL: return SOUND_DISMANTLE_METAL;
 case ConstructionMaterialType.MATERIAL_WIRE: return SOUND_DISMANTLE_WIRE;
 }
 
 return "";
 }
 
 //misc
 void CheckForHybridAttachments( EntityAI item, string slot_name )
 {
 if (!GetGame().IsMultiplayer() || GetGame().IsServer())
 {
 //if this is a hybrid attachment, set damage of appropriate damage zone. Zone name must match slot name...WIP
 if (m_HybridAttachments && m_HybridAttachments.Find(slot_name) != -1)
 {
 SetHealth(slot_name,"Health",item.GetHealth());
 }
 }
 }
 
 override int GetDamageSystemVersionChange()
 {
 return 111;
 }
 
 override void SetActions()
 {
 super.SetActions();
 
 AddAction(ActionDetachFromTarget);
 //AddAction(ActionTakeHybridAttachment);
 //AddAction(ActionTakeHybridAttachmentToHands);
 RemoveAction(ActionTakeItem);
 RemoveAction(ActionTakeItemToHands);
 }
 
 //================================================================
 // DEBUG
 //================================================================ 
 protected void DebugCustomState()
 {
 }
 
 array<string> OnDebugSpawnBuildExcludes()
 {
 return null;
 }
 
 override void OnDebugSpawn()
 {
 FullyBuild();
 }
 
 void FullyBuild()
 {
 array<string> excludes = OnDebugSpawnBuildExcludes();
 array<ConstructionPart> parts = GetConstruction().GetConstructionParts().GetValueArray();
 
 Man p;
 
 #ifdef SERVER
 array<Man> players = new array<Man>;
 GetGame().GetWorld().GetPlayerList(players);
 if (players.Count())
 p = players[0];
 #else
 p = GetGame().GetPlayer();
 #endif
 
 foreach (ConstructionPart part : parts)
 {
 bool excluded = false;
 string partName = part.GetPartName();
 if (excludes)
 {
 foreach (string exclude : excludes)
 {
 if (partName.Contains(exclude))
 {
 excluded = true;
 break;
 }
 }
 }
 
 if (!excluded)
 {
 OnPartBuiltServer(p, partName, AT_BUILD_PART);
 }
 }
 
 GetConstruction().UpdateVisuals();
 }
}
 
void bsbDebugPrint (string s)
{
#ifdef BSB_DEBUG
 PrintToRPT("" + s); // comment/uncomment to hide/see debug logs
#else
 //Print("" + s); // comment/uncomment to hide/see debug logs
#endif
}
void bsbDebugSpam (string s)
{
#ifdef BSB_DEBUG_SPAM
 PrintToRPT("" + s); // comment/uncomment to hide/see debug logs
#else
 //Print("" + s); // comment/uncomment to hide/see debug logs
#endif
}