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
}