Watchtower.c

Go to the documentation of this file.

class Watchtower extends BaseBuildingBase
{
  typename ATTACHMENT_BARBED_WIRE = BarbedWire;
  typename ATTACHMENT_CAMONET = CamoNet;
 
  const float MAX_FLOOR_VERTICAL_DISTANCE = 0.5;
 
  const float MIN_ACTION_DETECTION_ANGLE_RAD = 0.35; //0.35 RAD = 20 DEG
  const float MAX_ACTION_DETECTION_DISTANCE = 2.0; //meters
 
  static const string BASE_VIEW_NAME = "level_";
  static const string BASE_WALL_NAME = "_wall_";
  static const string BASE_ROOF_NAME = "_roof";
  static const int MAX_WATCHTOWER_FLOORS = 3;
  static const int MAX_WATCHTOWER_WALLS = 3;
 
  void Watchtower()
  {
  }
 
  override string GetConstructionKitType()
  {
    return "WatchtowerKit";
  }
 
  override int GetMeleeTargetType()
  {
    return EMeleeTargetType.NONALIGNABLE;
  }
 
  /*override void EEHitBy(TotalDamageResult damageResult, int damageType, EntityAI source, int component, string dmgZone, string ammo, vector modelPos, float speedCoef)
    {
    super.EEHitBy(damageResult, damageType, source, component, dmgZone, ammo, modelPos, speedCoef);
 
    if (component == -1)
    {
      Print("EEHitBy: " + this + "; damageType: "+ damageType +"; source: "+ source +"; component: "+ component +"; dmgZone: "+ dmgZone +"; ammo: "+ ammo +"; modelPos: "+ modelPos);
      Print("GetDamage " + damageResult.GetDamage("","Health"));
      Print("GetHighestDamage " + damageResult.GetHighestDamage("Health"));
    }
    }*/
 
  //overriden for the express purpose of handling view geometry (interaction) animations
  override void UpdateVisuals()
  {
    super.UpdateVisuals();
 
    SetAnimationPhase("level_1", 0); //always visible
    SetAnimationPhase("level_1_wall_1", 0); //always visible
    SetAnimationPhase("level_1_wall_2", 0); //always visible
    SetAnimationPhase("level_1_wall_3", 0); //always visible
 
    string part_name = "";
    bool built = false;
 
    for (int i = 1; i < MAX_WATCHTOWER_FLOORS; ++i)
    {
      //roof checks
      part_name = "" + BASE_VIEW_NAME + i + BASE_ROOF_NAME;
      built = GetConstruction().IsPartConstructed(part_name);
      //Print(part_name);
      //Print(built);
 
      //string tmp = "";
 
      if (built)
      {
        SetAnimationPhase(BASE_VIEW_NAME + (i + 1), 0); //show
        for (int j = 1; j < MAX_WATCHTOWER_WALLS + 1; ++j)
        {
          //tmp = BASE_VIEW_NAME + (i + 1) + BASE_WALL_NAME + j;
          //Print(tmp);
          SetAnimationPhase(BASE_VIEW_NAME + (i + 1) + BASE_WALL_NAME + j, 0); //show
        }
      }
      else
      {
        SetAnimationPhase(BASE_VIEW_NAME + (i + 1), 1); //hide
        for (j = 1; j < MAX_WATCHTOWER_WALLS + 1; ++j)
        {
          //tmp = BASE_VIEW_NAME + (i + 1) + BASE_WALL_NAME + j;
          //Print(tmp);
          SetAnimationPhase(BASE_VIEW_NAME + (i + 1) + BASE_WALL_NAME + j, 1); //hide
        }
      }
    }
  }
 
  //--- ATTACHMENT & CONDITIONS
  override bool CanReceiveAttachment(EntityAI attachment, int slotId)
  {
    if (!super.CanReceiveAttachment(attachment, slotId))
      return false;
 
    //because CanReceiveAttachment() method can be called on all clients in the vicinity, vertical distance check needs to be skipped on clients that don't
    //interact with the object through attach action (AT_ATTACH_TO_CONSTRUCTION)
    PlayerBase player;
    if (!GetGame().IsDedicatedServer())
    {
      //check action initiator (AT_ATTACH_TO_CONSTRUCTION)
      player = PlayerBase.Cast(GetGame().GetPlayer());
      if (player)
      {
        ConstructionActionData construction_action_data = player.GetConstructionActionData();
        PlayerBase action_initiator = construction_action_data.GetActionInitiator();
 
        if (action_initiator == player)
        {
          construction_action_data.SetActionInitiator(NULL); //reset action initiator
        }
        else
        {
          player = null; //do not do vertical check (next)
        }
      }
    }
    //
 
    return CheckSlotVerticalDistance(slotId, player);
  }
 
  //can put into hands
  override bool CanPutIntoHands(EntityAI parent)
  {
    return false;
  }
 
  override bool CanBeRepairedToPristine()
  {
    return true;
  }
 
  override bool PerformRoofCheckForBase(string partName, PlayerBase player, out bool result)
  {
    if (CfgGameplayHandler.GetDisablePerformRoofCheck())
      return false;
 
    if (partName != "level_1_base" && partName != "level_2_base" && partName != "level_3_base" && partName != "level_3_roof")
      return false;
 
    vector center;
    vector orientation = GetOrientation();
    vector edge_length;
    vector min_max[2];
    ref array<Object> excluded_objects = new array<Object>;
    ref array<Object> collided_objects = new array<Object>;
 
    excluded_objects.Insert(this);
    excluded_objects.Insert(player);
 
    if (partName == "level_2_base")
    {
      min_max[0] = GetMemoryPointPos("level_2_wall_1_down_min");
      min_max[1] = GetMemoryPointPos("level_2_roof_max");
    }
    else if (partName == "level_3_base")
    {
      min_max[0] = GetMemoryPointPos("level_3_wall_1_down_min");
      min_max[1] = GetMemoryPointPos("level_3_wall_2_up_max");
    }
    else if (partName == "level_3_roof")
    {
      min_max[0] = GetMemoryPointPos("level_3_roof_min");
      min_max[1] = GetMemoryPointPos("level_3_roof_max");
    }
    else
    {
      //min_max[0] = GetMemoryPointPos( "level_1_wall_1_up_min" );
      //min_max[0] = GetMemoryPointPos( "level_1_wall_1_down_min" );
      min_max[0] = GetMemoryPointPos("level_1_collisioncheck_min");
      min_max[1] = GetMemoryPointPos("level_1_roof_max");
    }
    center = GetPosition();
    center[1] = center[1] + (min_max[1][1] + min_max[0][1]) / 2;
 
    edge_length[0] = min_max[1][0] - min_max[0][0];
    edge_length[2] = min_max[1][2] - min_max[0][2];
    edge_length[1] = min_max[1][1] - min_max[0][1];
 
    result = false;
    /*result = */GetGame().IsBoxCollidingGeometry(center, orientation, edge_length, ObjIntersectView, ObjIntersectGeom, excluded_objects, collided_objects);
    if (collided_objects.Count() > 0)
    {
      foreach (Object o : collided_objects)
      {
        if (Building.Cast(o))
          result = true;
      }
    }
    return true;
  }
 
  // --- INVENTORY
  override bool CanDisplayAttachmentSlot(int slot_id)
  {
    //super
    if (!super.CanDisplayAttachmentSlot(slot_id))
      return false;
 
    string slot_name = InventorySlots.GetSlotName(slot_id);
    slot_name.ToLower();
    PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
    //base attachments
    if (slot_name.Contains("material_l1") || slot_name.Contains("level_1_"))
    {
      if (slot_name.Contains("woodenlogs"))
        return CheckMemoryPointVerticalDistance(MAX_FLOOR_VERTICAL_DISTANCE, "level_1", player);
      else
        return GetConstruction().IsPartConstructed("level_1_base") && CheckMemoryPointVerticalDistance(MAX_FLOOR_VERTICAL_DISTANCE, "level_1", player);
    }
    else if (slot_name.Contains("material_l2") || slot_name.Contains("level_2_"))
    {
      if (slot_name.Contains("woodenlogs"))
        return CheckMemoryPointVerticalDistance(MAX_FLOOR_VERTICAL_DISTANCE, "level_2", player);
      else
        return GetConstruction().IsPartConstructed("level_2_base") && CheckMemoryPointVerticalDistance(MAX_FLOOR_VERTICAL_DISTANCE, "level_2", player);
    }
    else if (slot_name.Contains("material_l3") || slot_name.Contains("level_3_"))
    {
      if (slot_name.Contains("woodenlogs"))
        return CheckMemoryPointVerticalDistance(MAX_FLOOR_VERTICAL_DISTANCE, "level_3", player);
      else
        return GetConstruction().IsPartConstructed("level_3_base") && CheckMemoryPointVerticalDistance(MAX_FLOOR_VERTICAL_DISTANCE, "level_3", player);
    }
 
    return true;
  }
 
  override bool CanDisplayAttachmentCategory(string category_name)
  {
    //super
    if (!super.CanDisplayAttachmentCategory(category_name))
      return false;
    //
 
    category_name.ToLower();
    PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
    //level 1
    if (category_name.Contains("level_1"))
    {
      if (category_name.Contains("level_1_"))
        return GetConstruction().IsPartConstructed("level_1_base") && CheckMemoryPointVerticalDistance(MAX_FLOOR_VERTICAL_DISTANCE, "level_1", player);
      else
        return CheckMemoryPointVerticalDistance(MAX_FLOOR_VERTICAL_DISTANCE, "level_1", player);
    }
    //level 2
    if (category_name.Contains("level_2"))
    {
      if (category_name.Contains("level_2_"))
        return GetConstruction().IsPartConstructed("level_2_base") && CheckMemoryPointVerticalDistance(MAX_FLOOR_VERTICAL_DISTANCE, "level_2", player);
      else
        return GetConstruction().IsPartConstructed("level_1_roof") && CheckMemoryPointVerticalDistance(MAX_FLOOR_VERTICAL_DISTANCE, "level_2", player);
    }
    //level 3
    if (category_name.Contains("level_3"))
    {
      if (category_name.Contains("level_3_"))
        return GetConstruction().IsPartConstructed("level_3_base") && CheckMemoryPointVerticalDistance(MAX_FLOOR_VERTICAL_DISTANCE, "level_3", player);
      else
        return GetConstruction().IsPartConstructed("level_2_roof") && CheckMemoryPointVerticalDistance(MAX_FLOOR_VERTICAL_DISTANCE, "level_3", player);
    }
 
    return true;
  }
 
  //returns true if attachment slot position is within given range
  override bool CheckSlotVerticalDistance(int slot_id, PlayerBase player)
  {
    string slot_name;
    InventorySlots.GetSelectionForSlotId(slot_id, slot_name);
    slot_name.ToLower();
 
    //wall attachments
    //level 1
    if (slot_name.Contains("material_l1") || slot_name.Contains("level_1_"))
    {
      if (slot_name.Contains("woodenlogs"))
        return CheckMemoryPointVerticalDistance(MAX_FLOOR_VERTICAL_DISTANCE, "level_1", player);
      else
        return GetConstruction().IsPartConstructed("level_1_base") && CheckMemoryPointVerticalDistance(MAX_FLOOR_VERTICAL_DISTANCE, "level_1", player);
    }
    //level 2
    if (slot_name.Contains("material_l2") || slot_name.Contains("level_2_"))
    {
      if (slot_name.Contains("material_l2w") || slot_name.Contains("level_2_wall"))
        return GetConstruction().IsPartConstructed("level_2_base") && CheckMemoryPointVerticalDistance(MAX_FLOOR_VERTICAL_DISTANCE, "level_2", player);
      else
      {
        if (slot_name.Contains("woodenlogs"))
          return CheckMemoryPointVerticalDistance(MAX_FLOOR_VERTICAL_DISTANCE, "level_2", player);
        else
          return GetConstruction().IsPartConstructed("level_1_roof") && CheckMemoryPointVerticalDistance(MAX_FLOOR_VERTICAL_DISTANCE, "level_2", player);
      }
    }
    //level 3
    if (slot_name.Contains("material_l3") || slot_name.Contains("level_3_"))
    {
      if (slot_name.Contains("material_l3w") || slot_name.Contains("level_3_wall"))
        return GetConstruction().IsPartConstructed("level_3_base") && CheckMemoryPointVerticalDistance(MAX_FLOOR_VERTICAL_DISTANCE, "level_3", player);
      else
      {
        if (slot_name.Contains("woodenlogs"))
          return CheckMemoryPointVerticalDistance(MAX_FLOOR_VERTICAL_DISTANCE, "level_3", player);
        else
          return GetConstruction().IsPartConstructed("level_2_roof") && CheckMemoryPointVerticalDistance(MAX_FLOOR_VERTICAL_DISTANCE, "level_3", player);
      }
    }
 
    return true;
  }
 
  //returns true if player->mem_point position is within given range
  override bool CheckMemoryPointVerticalDistance(float max_dist, string selection, PlayerBase player)
  {
    if (player)
    {
      //check vertical distance
      vector player_pos = player.GetPosition();
      vector pos;
 
      if (MemoryPointExists(selection))
        pos = ModelToWorld(GetMemoryPointPos(selection));
 
      if (Math.AbsFloat(player_pos[1] - pos[1]) <= max_dist)
        return true;
      else
        return false;
    }
 
    return true;
  }
 
  override bool CheckLevelVerticalDistance(float max_dist, string selection, PlayerBase player)
  {
    if (player)
    {
      if (selection.Contains("level_1_"))
        return CheckMemoryPointVerticalDistance(max_dist, "level_1", player);
 
      if (selection.Contains("level_2_"))
        return CheckMemoryPointVerticalDistance(max_dist, "level_2", player);
 
      if (selection.Contains("level_3_"))
        return CheckMemoryPointVerticalDistance(max_dist, "level_3", player);
    }
    return false;
  }
  // ---
  override void AfterStoreLoad()
  {
    super.AfterStoreLoad();
 
    UpdateVisuals();
  }
 
  override void OnPartBuiltServer(notnull Man player, string part_name, int action_id)
  {
    super.OnPartBuiltServer(player, part_name, action_id);
    //update visuals (server)
    UpdateVisuals();
  }
 
  override void OnPartDismantledServer(notnull Man player, string part_name, int action_id)
  {
    super.OnPartDismantledServer(player, part_name, action_id);
    //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);
    //update visuals (server)
    UpdateVisuals();
  }
 
  //--- ACTION CONDITIONS
  //returns dot product of player->construction direction based on existing/non-existing reference point
  override bool IsFacingPlayer(PlayerBase player, string selection)
  {
    vector ref_pos;
    vector ref_dir;
    vector player_dir;
    float dot;
    bool has_memory_point = MemoryPointExists(selection);
 
    if (has_memory_point)
    {
      ref_pos = ModelToWorld(GetMemoryPointPos(selection));
      ref_dir = ref_pos - GetPosition();
    }
    else
    {
      ref_pos = GetPosition();
      ref_dir = ref_pos - player.GetPosition();
    }
 
    ref_dir.Normalize();
    ref_dir[1] = 0; //ignore height
 
    player_dir = player.GetDirection();
    player_dir.Normalize();
    player_dir[1] = 0; //ignore height
 
    if (ref_dir.Length() != 0)
      dot = vector.Dot(player_dir, ref_dir);
 
    if (has_memory_point)
    {
      if (dot < 0 && Math.AbsFloat(dot) > MIN_ACTION_DETECTION_ANGLE_RAD)
        return true;
    }
    else
    {
      if (dot > 0 && Math.AbsFloat(dot) > MIN_ACTION_DETECTION_ANGLE_RAD)
        return true;
    }
 
    return false;
  }
 
  override bool IsFacingCamera(string selection)
  {
    vector ref_pos;
    vector ref_dir;
    vector cam_dir = GetGame().GetCurrentCameraDirection();
 
    if (MemoryPointExists(selection))
    {
      ref_pos = ModelToWorld(GetMemoryPointPos(selection));
      ref_dir = ref_pos - GetPosition();
 
      ref_dir.Normalize();
      ref_dir[1] = 0; //ignore height
 
      cam_dir[1] = 0; //ignore height
 
      if (ref_dir.Length() > 0.5) //if the distance (m) is too low, ignore this check
      {
        float dot = vector.Dot(cam_dir, ref_dir);
 
        if (dot < 0)
          return true;
      }
    }
 
    return false;
  }
 
  override bool IsPlayerInside(PlayerBase player, string selection)
  {
    if (selection != "")
      CheckLevelVerticalDistance(MAX_FLOOR_VERTICAL_DISTANCE, selection, player);
    vector player_pos = player.GetPosition();
    vector tower_pos = GetPosition();
    vector ref_dir = GetDirection();
    ref_dir[1] = 0;
    ref_dir.Normalize();
 
    vector min, max;
 
    min = -GetMemoryPointPos("interact_min");
    max = -GetMemoryPointPos("interact_max");
 
    vector dir_to_tower = tower_pos - player_pos;
    dir_to_tower[1] = 0;
    float len = dir_to_tower.Length();
 
 
    dir_to_tower.Normalize();
 
    vector ref_dir_angle = ref_dir.VectorToAngles();
    vector dir_to_tower_angle = dir_to_tower.VectorToAngles();
    vector test_angles = dir_to_tower_angle - ref_dir_angle;
 
    vector test_position = test_angles.AnglesToVector() * len;
 
    if (test_position[0] > max[0] || test_position[0] < min[0] || test_position[2] > max[2] || test_position[2] < min[2])
      return false;
 
    return true;
  }
 
  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 void SetActions()
  {
    super.SetActions();
 
    AddAction(ActionTogglePlaceObject);
    AddAction(ActionPlaceObject);
    AddAction(ActionFoldBaseBuildingObject);
  }
 
 
  //================================================================
  // DEBUG
  //================================================================
 
  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 = {"_metal_"};
    }
    else
    {
      excludes = {"_wood_"};
    }
 
    return excludes;
  }
 
  //Debug menu Spawn Ground Special
  override void OnDebugSpawn()
  {
    super.OnDebugSpawn();
 
    int i;
 
    for (i = 0; i < MAX_WATCHTOWER_FLOORS * MAX_WATCHTOWER_WALLS; ++i)
      GetInventory().CreateInInventory("CamoNet");
 
    for (i = 0; i < 2 * MAX_WATCHTOWER_WALLS; ++i)
    {
      BarbedWire wire = BarbedWire.Cast(GetInventory().CreateInInventory("BarbedWire"));
      wire.SetMountedState(true);
    }
  }
 
}