fence.c

Go to the documentation of this file.

class Fence extends BaseBuildingBase
{
 const int GATE_STATE_NONE = 0;
 const int GATE_STATE_PARTIAL = 1;
 const int GATE_STATE_FULL = 2;
 
 const string ATTACHMENT_SLOT_COMBINATION_LOCK = "Att_CombinationLock";
 const string SOUND_GATE_OPEN_START = "DoorWoodTowerOpen_SoundSet";
 const string SOUND_GATE_CLOSE_START = "DoorWoodTowerClose_start_SoundSet";
 const string SOUND_GATE_CLOSE_END = "DoorWoodTowerClose_end_SoundSet";
 
 //gate openining
 const float GATE_ROTATION_ANGLE_DEG = 100;
 const float GATE_ROTATION_TIME_APPROX = 2000; //ms
 
 const float MAX_ACTION_DETECTION_ANGLE_RAD = 1.3; //1.3 RAD = ~75 DEG
 const float MAX_ACTION_DETECTION_DISTANCE = 2.0; //meters
 
 typename ATTACHMENT_WOODEN_LOG = WoodenLog;
 typename ATTACHMENT_COMBINATION_LOCK = CombinationLock;
 
 string ATTSLOT_CAMONET = "Wall_Camonet";
 string ATTSLOT_BARBEDWIRE_DOWN = "Wall_Barbedwire_1";
 string ATTSLOT_BARBEDWIRE_UP = "Wall_Barbedwire_2";
 
 //protected bool m_HasHinges = false;
 //protected bool m_GateFullyConstructed = false;
 protected bool m_ToDiscard = false; //for legacy OnStoreLoad handling
 protected bool m_IsOpened = false;
 protected bool m_IsOpenedClient = false;
 protected int m_GateState = 0;
 
 protected EffectSound m_SoundGate_Start;
 protected EffectSound m_SoundGate_End;
 
 void Fence()
 {
 //synchronized variables
 //RegisterNetSyncVariableBool( "m_HasHinges" );
 //RegisterNetSyncVariableBool( "m_GateFullyConstructed" );
 RegisterNetSyncVariableBool( "m_IsOpened" );
 RegisterNetSyncVariableInt( "m_GateState" );
 }
 
 override string GetConstructionKitType()
 {
 return "FenceKit";
 }
 
 override int GetMeleeTargetType()
 {
 return EMeleeTargetType.NONALIGNABLE;
 }
 
 //Gate
 bool HasHinges()
 {
 return m_GateState > GATE_STATE_NONE;
 }
 
 bool HasFullyConstructedGate()
 {
 return m_GateState == GATE_STATE_FULL;
 }
 
 void SetGateState( int state )
 {
 m_GateState = state;
 SetSynchDirty();
 }
 
 int GetGateState()
 {
 return m_GateState;
 }
 
 int CheckGateState()
 {
 ConstructionPart gate_part = GetConstruction().GetGateConstructionPart();
 int state = GATE_STATE_NONE;
 if( gate_part.IsBuilt() )
 {
 ConstructionPart req_part;
 array<string> req_parts = gate_part.GetRequiredParts();
 for (int i = 0; i < req_parts.Count(); i++)
 {
 req_part = GetConstruction().GetConstructionPart(req_parts.Get(i));
 if(!req_part.IsBuilt())
 break;
 }
 
 if( i != req_parts.Count() )
 {
 state = GATE_STATE_PARTIAL;
 }
 else
 {
 state = GATE_STATE_FULL;
 }
 
 }
 return state;
 }
 
 void SetOpenedState( bool state )
 {
 m_IsOpened = state;
 }
 
 override bool IsOpened()
 {
 return m_IsOpened;
 }
 
 bool IsLocked()
 {
 CombinationLock combination_lock = GetCombinationLock();
 if ( combination_lock && combination_lock.IsLocked() )
 {
 return true;
 }
 
 return false;
 }
 
 override bool NameOverride(out string output)
 {
 if ( m_GateState != GATE_STATE_NONE )
 {
 output = "#str_cfgvehicles_construction_part_gate"; //changes object displayed name if in 'gate' state
 output.ToUpper();
 return true;
 }
 return false;
 }
//
 CombinationLock GetCombinationLock()
 {
 CombinationLock combination_lock = CombinationLock.Cast( FindAttachmentBySlotName( ATTACHMENT_SLOT_COMBINATION_LOCK ) );
 return combination_lock;
 }
 
 CamoNet GetCamoNet()
 {
 CamoNet camonet = CamoNet.Cast( FindAttachmentBySlotName( "Wall_Camonet" ) );
 return camonet;
 }
 
 BarbedWire GetBarbedWire1()
 {
 BarbedWire barbedwire = BarbedWire.Cast( FindAttachmentBySlotName( "Wall_Barbedwire_1" ) );
 return barbedwire;
 }
 
 BarbedWire GetBarbedWire2()
 {
 BarbedWire barbedwire = BarbedWire.Cast( FindAttachmentBySlotName( "Wall_Barbedwire_2" ) );
 return barbedwire;
 }
 
 //--- CONSTRUCTION KIT
 override vector GetKitSpawnPosition()
 {
 if ( MemoryPointExists( "kit_spawn_position" ) )
 {
 vector position;
 position = GetMemoryPointPos( "kit_spawn_position" );
 
 return ModelToWorld( position );
 }
 
 return GetPosition();
 } 
 
 // --- INVENTORY
 override bool CanDisplayAttachmentSlot( int slot_id )
 {
 if (!super.CanDisplayAttachmentSlot(slot_id))
 return false;
 
 string slot_name = InventorySlots.GetSlotName(slot_id);
 
 if ( slot_name == "Att_CombinationLock" )
 {
 if ( !HasFullyConstructedGate() )
 {
 return false;
 }
 }
 
 if ( !GateAttachmentConditions(InventorySlots.GetSlotIdFromString(slot_name)) )
 return false;
 
 return true;
 }
 
 override bool CanDisplayAttachmentCategory( string category_name )
 {
 if ( category_name == "Attachments" || category_name == "Material" )
 {
 if ( !HasBase() )
 {
 return false;
 }
 }
 
 return true;
 } 
 // ---
 
 // --- EVENTS
 override void OnStoreSave( ParamsWriteContext ctx )
 { 
 super.OnStoreSave( ctx );
 
 //write
 ctx.Write( m_GateState );
 ctx.Write( m_IsOpened );
 if (LogManager.IsBaseBuildingLogEnable()) bsbDebugPrint("[bsb] OnStoreSave - build=" + m_GateState + " opened=" + m_IsOpened);
 }
 
 override bool OnStoreLoad( ParamsReadContext ctx, int version )
 {
 if ( !super.OnStoreLoad( ctx, version ) )
 return false;
 
 //--- Fence data ---
 //has gate
 if (version < 110)
 {
 if ( !ctx.Read( m_ToDiscard ) )
 {
 m_ToDiscard = false;
 return false;
 }
 m_GateState = GATE_STATE_NONE;
 }
 else if ( !ctx.Read( m_GateState ) )
 {
 m_GateState = GATE_STATE_NONE;
 return false;
 }
 
 //is opened
 if ( !ctx.Read( m_IsOpened ) )
 {
 m_IsOpened = false;
 return false;
 }
 
 if (LogManager.IsBaseBuildingLogEnable()) bsbDebugPrint("[bsb] OnStoreLoad - build=" + m_GateState + " opened=" + m_IsOpened);
 //---
 
 return true;
 }
 
 override void AfterStoreLoad()
 { 
 super.AfterStoreLoad();
 
 //set gate state
 ConstructionPart gate_part = GetConstruction().GetGateConstructionPart();
 SetGateState( CheckGateState() );
 
 //update gate state visual
 if ( IsOpened() )
 {
 OpenFence();
 }
 
 UpdateVisuals();
 
 if (LogManager.IsBaseBuildingLogEnable()) bsbDebugPrint("[bsb] AfterStoreLoad - build=" + gate_part.IsBuilt() + " opened=" + IsOpened());
 } 
 
 override void OnVariablesSynchronized()
 {
 super.OnVariablesSynchronized();
 
 if ( m_IsOpenedClient != m_IsOpened )
 {
 m_IsOpenedClient = m_IsOpened;
 
 if ( m_IsOpenedClient )
 {
 OpenFence();
 }
 else
 {
 CloseFence();
 }
 }
 }
 
 //--- BUILD EVENTS
 //CONSTRUCTION EVENTS
 override void OnPartBuiltServer( notnull Man player, string part_name, int action_id )
 {
 ConstructionPart constrution_part = GetConstruction().GetConstructionPart( part_name );
 
 super.OnPartBuiltServer( player, part_name, action_id );
 
 SetGateState(CheckGateState());
 
 //update visuals (server)
 UpdateVisuals();
 }
 
 override void OnPartDismantledServer( notnull Man player, string part_name, int action_id )
 {
 ConstructionPart constrution_part = GetConstruction().GetConstructionPart( part_name );
 
 //check gate state
 if ( constrution_part.IsGate() )
 {
 if ( IsLocked() )
 {
 CombinationLock combination_lock = CombinationLock.Cast( FindAttachmentBySlotName( ATTACHMENT_SLOT_COMBINATION_LOCK ) );
 combination_lock.UnlockServer( player , this );
 }
 }
 
 super.OnPartDismantledServer( player, part_name, action_id );
 
 SetGateState( CheckGateState() );
 
 //update visuals (server)
 UpdateVisuals();
 }
 
 override void OnPartDestroyedServer( Man player, string part_name, int action_id, bool destroyed_by_connected_part = false )
 {
 super.OnPartDestroyedServer( player, part_name, action_id );
 
 //check gate state
 ConstructionPart constrution_part = GetConstruction().GetConstructionPart( part_name );
 if ( constrution_part.IsGate() && destroyed_by_connected_part ) //avoids attachment dropping on regular hinges destruction
 {
 //drop regular attachments
 HandleDropAttachment(GetBarbedWire1());
 HandleDropAttachment(GetBarbedWire2());
 HandleDropAttachment(GetCamoNet());
 HandleDropAttachment(GetCombinationLock());
 
 //rotate back to place
 if ( IsOpened() )
 CloseFence();
 }
 if ( part_name == "wall_base_down" )
 {
 HandleDropAttachment(GetBarbedWire1());
 HandleDropAttachment(GetCombinationLock());
 }
 if ( part_name == "wall_base_up" )
 {
 HandleDropAttachment(GetBarbedWire2());
 HandleDropAttachment(GetCamoNet());
 HandleDropAttachment(GetCombinationLock());
 }
 
 SetGateState( CheckGateState() );
 //update visuals (server)
 UpdateVisuals();
 }
 
 //--- ATTACHMENT & CONDITIONS
 override bool CanReceiveAttachment( EntityAI attachment, int slotId )
 {
 if ( !super.CanReceiveAttachment(attachment, slotId) )
 return false;
 
 //manage action initiator (AT_ATTACH_TO_CONSTRUCTION)
 if ( !GetGame().IsDedicatedServer() )
 {
 PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
 if ( player )
 {
 ConstructionActionData construction_action_data = player.GetConstructionActionData();
 
 //reset action initiator
 construction_action_data.SetActionInitiator( NULL ); 
 }
 }
 
 //conditions
 if ( attachment.Type() != ATTACHMENT_WOODEN_LOG )
 {
 if ( !HasBase() )
 {
 return false;
 }
 }
 
 if ( attachment.IsInherited( ATTACHMENT_COMBINATION_LOCK ) )
 {
 return ( HasFullyConstructedGate() && !IsOpened() );
 }
 
 if ( !GateAttachmentConditions(slotId) )
 return false;
 
 return true;
 }
 
 //hands
 override bool CanPutIntoHands( EntityAI parent )
 {
 if( !super.CanPutIntoHands( parent ) )
 {
 return false;
 }
 
 if ( HasBase() )
 {
 return false;
 }
 
 return true;
 }
 
 override bool CanBeRepairedToPristine()
 {
 return true;
 }
 
 //--- OPEN/CLOSE ACTIONS
 bool CanOpenFence()
 {
 if ( HasHinges() && !IsOpened() && !IsLocked() )
 {
 return true;
 }
 
 return false;
 }
 
 bool CanCloseFence()
 {
 if ( HasHinges() && IsOpened() )
 {
 return true;
 }
 
 return false;
 }
 
 void OpenFence()
 {
 //server or single player
 if ( GetGame().IsServer() )
 {
 float value = GATE_ROTATION_ANGLE_DEG;
 SetAnimationPhase( "Wall_Interact_Rotate", value );
 SetAnimationPhase( "Wall_Barbedwire_1_Mounted_Rotate", value );
 SetAnimationPhase( "Wall_Barbedwire_2_Mounted_Rotate", value );
 SetAnimationPhase( "Wall_Camonet_Rotate", value );
 SetAnimationPhase( "Wall_Gate_Rotate", value );
 SetAnimationPhase( "Wall_Base_Down_Rotate", value );
 SetAnimationPhase( "Wall_Base_Up_Rotate", value );
 SetAnimationPhase( "Wall_Wood_Down_Rotate", value );
 SetAnimationPhase( "Wall_Wood_Up_Rotate", value );
 SetAnimationPhase( "Wall_Metal_Down_Rotate", value );
 SetAnimationPhase( "Wall_Metal_Up_Rotate", value );
 
 SetOpenedState( true );
 
 //regenerate navmesh
 GetGame().GetCallQueue( CALL_CATEGORY_GAMEPLAY ).CallLater( UpdateNavmesh, GATE_ROTATION_TIME_APPROX, false );
 
 //synchronize
 SynchronizeBaseState();
 }
 
 //client or single player
 if ( !GetGame().IsDedicatedServer() )
 {
 //play sound
 SoundGateOpenStart();
 }
 
 //remove BarbedWire AreaDamageTrigger
 UpdateBarbedWireAreaDamagePos(0,true);
 
 //add check
 GetGame().GetCallQueue( CALL_CATEGORY_GAMEPLAY ).Remove(CheckFenceClosed);
 GetGame().GetCallQueue( CALL_CATEGORY_GAMEPLAY ).CallLater( CheckFenceOpened, 0, true );
 }
 
 void CloseFence()
 {
 //server or single player
 if ( GetGame().IsServer() )
 {
 float value = 0;
 SetAnimationPhase( "Wall_Interact_Rotate", value );
 SetAnimationPhase( "Wall_Barbedwire_1_Mounted_Rotate", value );
 SetAnimationPhase( "Wall_Barbedwire_2_Mounted_Rotate", value );
 SetAnimationPhase( "Wall_Camonet_Rotate", value );
 SetAnimationPhase( "Wall_Gate_Rotate", value );
 SetAnimationPhase( "Wall_Base_Down_Rotate", value );
 SetAnimationPhase( "Wall_Base_Up_Rotate", value );
 SetAnimationPhase( "Wall_Wood_Down_Rotate", value );
 SetAnimationPhase( "Wall_Wood_Up_Rotate", value );
 SetAnimationPhase( "Wall_Metal_Down_Rotate", value );
 SetAnimationPhase( "Wall_Metal_Up_Rotate", value );
 
 SetOpenedState( false );
 
 //regenerate navmesh
 GetGame().GetCallQueue( CALL_CATEGORY_GAMEPLAY ).CallLater( UpdateNavmesh, GATE_ROTATION_TIME_APPROX, false );
 
 //synchronize
 SynchronizeBaseState();
 }
 
 //client or single player
 if ( !GetGame().IsDedicatedServer() )
 {
 //play sound
 SoundGateCloseStart();
 }
 
 //remove BarbedWire AreaDamageTrigger
 UpdateBarbedWireAreaDamagePos(0,true);
 
 //add check
 GetGame().GetCallQueue( CALL_CATEGORY_GAMEPLAY ).Remove(CheckFenceOpened);
 GetGame().GetCallQueue( CALL_CATEGORY_GAMEPLAY ).CallLater( CheckFenceClosed, 0, true );
 }
 
 protected void CheckFenceOpened()
 {
 if ( GetAnimationPhase( "Wall_Gate_Rotate" ) == GATE_ROTATION_ANGLE_DEG ) //animation finished - open
 {
 UpdateBarbedWireAreaDamagePos(GetAnimationPhase( "Wall_Gate_Rotate" ));
 //remove check
 GetGame().GetCallQueue( CALL_CATEGORY_GAMEPLAY ).Remove( CheckFenceOpened );
 }
 }
 
 protected void CheckFenceClosed()
 {
 if ( GetAnimationPhase( "Wall_Gate_Rotate" ) == 0 ) //animation finished - closed
 {
 //client or single player
 if ( !GetGame().IsDedicatedServer() )
 {
 //play sound
 if ( this ) SoundGateCloseEnd();
 }
 UpdateBarbedWireAreaDamagePos(GetAnimationPhase( "Wall_Gate_Rotate" ));
 //remove check
 GetGame().GetCallQueue( CALL_CATEGORY_GAMEPLAY ).Remove( CheckFenceClosed );
 }
 }
 
 //Damage triggers
 override void CreateAreaDamage( string slot_name, float rotation_angle = 0 )
 {
 if ( IsOpened() )
 {
 rotation_angle = 100;
 }
 
 super.CreateAreaDamage( slot_name, rotation_angle );
 }
 
 //BarbedWire update
 void UpdateBarbedWireAreaDamagePos(float rotation_angle = 0, bool to_delete = false )
 {
 int slot_id;
 string slot_name;
 string slot_name_mounted;
 if ( GetBarbedWire1() && GetBarbedWire1().IsMounted() )
 {
 GetBarbedWire1().GetInventory().GetCurrentAttachmentSlotInfo(slot_id,slot_name);
 slot_name_mounted = slot_name + "_Mounted";
 if (to_delete)
 {
 DestroyAreaDamage( slot_name_mounted );
 }
 else
 {
 super.CreateAreaDamage( slot_name_mounted, rotation_angle );
 }
 }
 if ( GetBarbedWire2() && GetBarbedWire2().IsMounted() )
 {
 GetBarbedWire2().GetInventory().GetCurrentAttachmentSlotInfo(slot_id,slot_name);
 slot_name_mounted = slot_name + "_Mounted";
 if (to_delete)
 {
 DestroyAreaDamage( slot_name_mounted );
 }
 else
 {
 super.CreateAreaDamage( slot_name_mounted, rotation_angle );
 }
 }
 }
 
 //Here deal damage to BarbedWire when entity taking damage from it
 override void PostAreaDamageActions()
 {
 /*if (GetBarbedWire1())
 {
 //DecreaseHealth("Wall_BarbedWire_1", "", 1000); //why no dmg to wire???
 //BarbedWire wire = GetBarbedWire1();
 //wire.PostAreaDamageActions();
 //Print(GetHealth("BarbedWire1", ""));
 }*/
 }
 
 //--- ACTION CONDITIONS
 override bool IsPlayerInside( PlayerBase player, string selection )
 {
 vector player_pos = player.GetPosition();
 vector fence_pos = GetPosition();
 vector ref_dir = GetDirection();
 ref_dir[1] = 0;
 ref_dir.Normalize();
 
 vector x[2];
 vector b1,b2;
 GetCollisionBox(x);
 b1 = x[0];
 b2 = x[1];
 
 vector dir_to_fence = fence_pos - player_pos;
 dir_to_fence[1] = 0;
 float len = dir_to_fence.Length();
 
 dir_to_fence.Normalize();
 
 vector ref_dir_angle = ref_dir.VectorToAngles();
 vector dir_to_fence_angle = dir_to_fence.VectorToAngles();
 vector test_angles = dir_to_fence_angle - ref_dir_angle;
 
 vector test_position = test_angles.AnglesToVector() * len;
 
 if(test_position[0] < b1[0] || test_position[0] > b2[0] || test_position[2] < 0.2 || test_position[2] > 2.2 )
 {
 return false;
 }
 else
 {
 return true;
 }
 }
 
 override bool IsFacingPlayer( PlayerBase player, string selection )
 {
 vector fence_pos = GetPosition();
 vector player_pos = player.GetPosition();
 vector ref_dir = GetDirection();
 
 //vector fence_player_dir = player_pos - fence_pos;
 vector fence_player_dir = player.GetDirection();
 fence_player_dir.Normalize();
 fence_player_dir[1] = 0; //ignore height
 
 ref_dir.Normalize();
 ref_dir[1] = 0; //ignore height
 
 if ( ref_dir.Length() != 0 )
 {
 float angle = Math.Acos( fence_player_dir * ref_dir );
 
 if ( angle >= MAX_ACTION_DETECTION_ANGLE_RAD )
 {
 return true;
 }
 }
 
 return false;
 }
 
 override bool IsFacingCamera( string selection )
 {
 vector ref_dir = GetDirection();
 vector cam_dir = GetGame().GetCurrentCameraDirection();
 
 //ref_dir = GetGame().GetCurrentCameraPosition() - GetPosition();
 ref_dir.Normalize();
 ref_dir[1] = 0; //ignore height
 
 cam_dir.Normalize();
 cam_dir[1] = 0; //ignore height
 
 if ( ref_dir.Length() != 0 )
 {
 float angle = Math.Acos( cam_dir * ref_dir );
 
 if ( angle >= MAX_ACTION_DETECTION_ANGLE_RAD )
 {
 return true;
 }
 }
 
 return false;
 }
 
 override bool HasProperDistance( string selection, PlayerBase player )
 {
 if ( MemoryPointExists( selection ) )
 {
 vector selection_pos = ModelToWorld( GetMemoryPointPos( selection ) );
 float distance = vector.Distance( selection_pos, player.GetPosition() );
 if ( distance >= MAX_ACTION_DETECTION_DISTANCE )
 {
 return false;
 }
 }
 
 return true;
 }
 
 override bool CanUseConstructionBuild()
 {
 return !IsOpened();
 }
 
 //================================================================
 // SOUNDS
 //================================================================
 protected void SoundGateOpenStart()
 {
 //client or single player
 if ( !GetGame().IsDedicatedServer() )
 {
 PlaySoundSet( m_SoundGate_Start, SOUND_GATE_OPEN_START, 0.1, 0.1 );
 }
 }
 
 protected void SoundGateCloseStart()
 {
 //client or single player
 if ( !GetGame().IsDedicatedServer() )
 {
 PlaySoundSet( m_SoundGate_Start, SOUND_GATE_CLOSE_START, 0.1, 0.1 );
 }
 }
 
 protected void SoundGateCloseEnd()
 {
 //client or single player
 if ( !GetGame().IsDedicatedServer() )
 {
 PlaySoundSet( m_SoundGate_End, SOUND_GATE_CLOSE_END, 0.1, 0.1 );
 }
 }
 
 void GateAttachmentsSanityCheck()
 {
 ConstructionPart wall_base_down = GetConstruction().GetConstructionPart("wall_base_down");
 ConstructionPart wall_base_up = GetConstruction().GetConstructionPart("wall_base_up");
 if(GetBarbedWire1() && !wall_base_down.IsBuilt())
 {
 HandleDropAttachment(GetBarbedWire1());
 HandleDropAttachment(GetCombinationLock());
 }
 if( ( GetCamoNet() || GetBarbedWire2() ) && !wall_base_up.IsBuilt() )
 {
 HandleDropAttachment(GetBarbedWire2());
 HandleDropAttachment(GetCamoNet());
 HandleDropAttachment(GetCombinationLock());
 }
 }
 
 void HandleDropAttachment(ItemBase item)
 {
 BarbedWire wire;
 CombinationLock lock;
 if (Class.CastTo(wire,item)) //special barbed wire beh.
 {
 wire.SetMountedState( false );
 GetInventory().DropEntity(InventoryMode.SERVER, this, wire);
 }
 else if (Class.CastTo(lock,item))
 {
 lock.UnlockServer(null,this);
 }
 else if (item)//generic behaviour
 {
 GetInventory().DropEntity(InventoryMode.SERVER, this, item);
 }
 }
 
 bool GateAttachmentConditions(int slotId)
 {
 if ( GetGateState() == GATE_STATE_PARTIAL )
 {
 ConstructionPart wall_base_down = GetConstruction().GetConstructionPart("wall_base_down");
 ConstructionPart wall_base_up = GetConstruction().GetConstructionPart("wall_base_up");
 string slot_name = InventorySlots.GetSlotName(slotId);
 if ( !wall_base_up.IsBuilt() )
 {
 if ( slot_name == ATTSLOT_CAMONET || slot_name == ATTSLOT_BARBEDWIRE_UP )
 {
 return false;
 }
 }
 if ( !wall_base_down.IsBuilt() )
 {
 if ( slot_name == ATTSLOT_BARBEDWIRE_DOWN )
 {
 return false;
 }
 }
 }
 return true;
 }
 
 //specific selection for camonet attaching (other ones might be animated via rotation!)
 override bool TranslateSlotFromSelection(string selection_name, out int slot_id)
 {
 if ( selection_name == "wall_camonet_attach" )
 {
 slot_id = InventorySlots.GetSlotIdFromString("Wall_Camonet");
 return true;
 }
 return false;
 }
 
 override void SetActions()
 {
 super.SetActions();
 
 AddAction(ActionTogglePlaceObject);
 AddAction(ActionPlaceObject);
 AddAction(ActionFoldBaseBuildingObject);
 //AddAction(ActionDialCombinationLockOnTarget);
 //AddAction(ActionNextCombinationLockDialOnTarget);
 AddAction(ActionOpenFence);
 AddAction(ActionCloseFence);
 }
 
 //================================================================
 // DEBUG
 //================================================================ 
 /*
 override void DebugCustomState()
 {
 //debug
 m_SyncParts01 = 881; //full fence with gate
 m_HasHinges = true;
 m_HasBase = true;
 
 OnVariablesSynchronized();
 }
 */
 
 override array<string> OnDebugSpawnBuildExcludes()
 {
 array<string> excludes = {};
 
 #ifdef DIAG_DEVELOPER
 bool bWood = DiagMenu.GetBool(DiagMenuIDs.BASEBUILDING_WOOD);
 #else
 bool bWood = false;
 #endif
 
 if (bWood)
 {
 excludes.Insert("_metal_");
 }
 else
 {
 excludes.Insert("_wood_");
 }
 
 #ifdef DIAG_DEVELOPER
 bool bGate = DiagMenu.GetBool(DiagMenuIDs.BASEBUILDING_GATE);
 #else
 bool bGate = false;
 #endif
 
 if (bGate)
 {
 excludes.Insert("platform");
 }
 else
 {
 excludes.Insert("gate");
 }
 
 return excludes;
 }
 
 //Debug menu Spawn Ground Special
 override void OnDebugSpawn()
 {
 super.OnDebugSpawn();
 
 GetInventory().CreateInInventory("CamoNet");
 
 for (int i = 0; i < 2; ++i)
 {
 BarbedWire wire = BarbedWire.Cast(GetInventory().CreateInInventory("BarbedWire")); 
 wire.SetMountedState(true);
 }
 }
}