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);
 }
 }
 
}