totem.c

Go to the documentation of this file.

class TerritoryFlag extends BaseBuildingBase
{
 const float MAX_ACTION_DETECTION_ANGLE_RAD = 1.3; //1.3 RAD = ~75 DEG
 const float MAX_ACTION_DETECTION_DISTANCE = 2.0; //meters
 
 bool m_RefresherActive;
 bool m_RefresherActiveLocal;
 bool m_RefresherInitialized;
 int m_RefresherTimeRemaining;
 int m_RefreshTimeCounter;
 
 protected int m_FlagRefresherFrequency = GameConstants.REFRESHER_FREQUENCY_DEFAULT; //how often does the flag increase lifetimes
 protected int m_FlagRefresherMaxDuration = GameConstants.REFRESHER_MAX_DURATION_DEFAULT; //how long will the refresher run; multiple of m_FlagRefresherFrequency by default
 
 void TerritoryFlag()
 {
 m_RefresherActive = false;
 m_RefresherActiveLocal = false;
 m_RefresherInitialized = false;
 m_RefresherTimeRemaining = 0;
 
 if ( GetCEApi() )
 {
 InitRefresherData();
 }
 RegisterNetSyncVariableBool("m_RefresherActive");
 }
 
 void ~TerritoryFlag()
 {
 RemoveRefresherPosition();
 }
 
 void InitRefresherData()
 {
 int frequency = GetCEApi().GetCEGlobalInt("FlagRefreshFrequency");
 int max_duration = GetCEApi().GetCEGlobalInt("FlagRefreshMaxDuration");
 
 if ( frequency > 0)
 {
 m_FlagRefresherFrequency = frequency;
 }
 if ( max_duration > 0 )
 {
 m_FlagRefresherMaxDuration = max_duration;
 }
 m_RefresherInitialized = true;
 }
 
 override string GetConstructionKitType()
 {
 return "TerritoryFlagKit";
 }
 
 override int GetMeleeTargetType()
 {
 return EMeleeTargetType.NONALIGNABLE;
 }
 
 /*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;
 }*/
 
 //--- CONSTRUCTION KIT
 override vector GetKitSpawnPosition()
 {
 if ( MemoryPointExists( "kit_spawn_position" ) )
 {
 vector position;
 position = GetMemoryPointPos( "kit_spawn_position" );
 
 return ModelToWorld( position );
 }
 
 return GetPosition();
 }
 
 override bool CanDisplayAttachmentCategory( string category_name )
 {
 if ( category_name == "Base" && !HasBase() )
 return true;
 else if ( category_name == "Support" && HasBase() && !GetConstruction().IsPartConstructed("support") )
 return true;
 else if ( category_name == "Pole" && GetConstruction().IsPartConstructed("support") && !GetConstruction().IsPartConstructed("pole") )
 return true;
 else if ( category_name == "Flag" && GetConstruction().IsPartConstructed("pole") )
 return true;
 else
 return false;
 }
 // ---
 
 // --- EVENTS
 override void OnStoreSave( ParamsWriteContext ctx )
 { 
 super.OnStoreSave( ctx );
 
 ctx.Write( m_RefresherTimeRemaining );
 ctx.Write( m_RefreshTimeCounter );
 ctx.Write( m_FlagRefresherMaxDuration );
 ctx.Write( m_RefresherActive );
 }
 
 override bool OnStoreLoad( ParamsReadContext ctx, int version )
 {
 if ( !super.OnStoreLoad( ctx, version ) )
 return false;
 
 //int loaded_frequency;
 int loaded_max_duration;
 
 if ( !ctx.Read( m_RefresherTimeRemaining ) )
 {
 return false;
 }
 
 if ( !ctx.Read( m_RefreshTimeCounter ) )
 {
 return false;
 }
 
 if ( !ctx.Read( loaded_max_duration ) )
 {
 return false;
 }
 
 if ( version >= 118 && !ctx.Read( m_RefresherActive ) )
 {
 return false;
 }
 
 CheckLoadedVariables(loaded_max_duration);
 AnimateFlag(1 - GetRefresherTime01());
 
 return true;
 }
 
 override void AfterStoreLoad()
 {
 super.AfterStoreLoad();
 
 if (!m_RefresherInitialized && GetCEApi())
 {
 InitRefresherData();
 }
 SetSynchDirty();
 UpdateVisuals();
 }
 
 override void OnCEUpdate()
 {
 super.OnCEUpdate();
 
 int time_elapsed_rounded = Math.Round(m_ElapsedSinceLastUpdate);
 
 if ( m_RefresherTimeRemaining > 0 )
 {
 m_RefreshTimeCounter += time_elapsed_rounded;
 if ( m_RefreshTimeCounter >= m_FlagRefresherFrequency )
 {
 GetCEApi().RadiusLifetimeReset(GetPosition(),GameConstants.REFRESHER_RADIUS);
 m_RefresherTimeRemaining = Math.Clamp(m_RefresherTimeRemaining - m_RefreshTimeCounter,0,m_FlagRefresherMaxDuration);
 m_RefreshTimeCounter = 0; //possibly carry over the rest?
 AnimateFlag( 1 - GetRefresherTime01() );
 }
 }
 
 SetRefresherActive(m_RefresherTimeRemaining > 0);
 }
 
 void HandleRefreshers()
 {
 Mission mission = GetGame().GetMission();
 if (!mission.m_ActiveRefresherLocations)
 return;
 
 int idx = mission.m_ActiveRefresherLocations.Find(GetPosition());
 if ( m_RefresherActive && idx == -1 )
 {
 InsertRefresherPosition();
 }
 else if ( !m_RefresherActive && idx > -1 )
 {
 RemoveRefresherPosition(idx);
 }
 }
 
 void SetRefresherActive(bool state)
 {
 if ( m_RefresherActive != state )
 {
 m_RefresherActive = state;
 SetSynchDirty();
 
 //update on refresher activation / last update on refresher deactivation
 GetCEApi().RadiusLifetimeReset(GetPosition(),GameConstants.REFRESHER_RADIUS); //TODO spammable!!!
 }
 }
 
 void InsertRefresherPosition()
 {
 Mission mission = GetGame().GetMission();
 mission.m_ActiveRefresherLocations.Insert(GetPosition());
 }
 
 void RemoveRefresherPosition(int idx = -2)
 {
 if (!GetGame() || (GetGame().IsMultiplayer() && GetGame().IsServer()) )
 return;
 
 Mission mission = GetGame().GetMission();
 if (!mission || !mission.m_ActiveRefresherLocations)
 return;
 
 if (idx == -2)
 {
 idx = mission.m_ActiveRefresherLocations.Find(GetPosition());
 }
 
 if (idx > -1)
 {
 mission.m_ActiveRefresherLocations.Remove(idx);
 }
 }
 
 override void OnVariablesSynchronized()
 {
 super.OnVariablesSynchronized();
 
 if ( m_RefresherActive != m_RefresherActiveLocal )
 {
 HandleRefreshers();
 m_RefresherActiveLocal = m_RefresherActive;
 }
 }
 
 //--- 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 );
 
 //update visuals (server)
 UpdateVisuals();
 }
 
 override void OnPartDismantledServer( notnull Man player, string part_name, int action_id )
 {
 ConstructionPart constrution_part = GetConstruction().GetConstructionPart( part_name );
 
 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();
 }
 
 //--- ATTACHMENT & CONDITIONS
 override bool CanReceiveAttachment( EntityAI attachment, int slotId ) //TODO
 {
 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
 string slot_name = InventorySlots.GetSlotName(slotId);
 //flag item attachment
 if ( slot_name == "Material_FPole_Flag" )
 {
 if ( GetConstruction().IsPartConstructed("pole") )
 return true;
 else
 return false;
 }
 //materials
 ConstructionPart part;
 ConstructionPart part_lowest;
 int part_id = -1;
 for (int i = 0; i < GetConstruction().GetConstructionParts().Count(); i++)
 {
 part = GetConstruction().GetConstructionParts().GetElement(i);
 if (!part.IsBuilt())
 {
 if (part_id == -1 || part_id > part.GetId())
 {
 part_lowest = part;
 part_id = part.GetId();
 }
 }
 }
 
 if (part_lowest /*&& !part_lowest.IsBuilt()*/)
 {
 string cfg_path = "cfgVehicles " + GetType() + " Construction " + part_lowest.GetMainPartName() + " " + part_lowest.GetPartName() + " Materials";
 string material_path;
 if ( GetGame().ConfigIsExisting(cfg_path) )
 {
 string child_name;
 string child_slot_name;
 for ( i = 0; i < GetGame().ConfigGetChildrenCount( cfg_path ); i++ )
 {
 GetGame().ConfigGetChildName( cfg_path, i, child_name );
 material_path = "" + cfg_path + " " + child_name + " slot_name";
 if ( GetGame().ConfigGetText(material_path,child_slot_name) && child_slot_name == slot_name )
 {
 return true;
 }
 }
 }
 }
 
 return false;
 }
 
 //hands
 override bool CanPutIntoHands( EntityAI parent )
 {
 return false;
 }
 
 override bool CanBeRepairedToPristine()
 {
 return true;
 }
 
 //--- ACTION CONDITIONS
 override bool IsPlayerInside( PlayerBase player, string selection )
 {
 return true; //TODO
 
 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 )
 {
 return true; //TODO
 
 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 )
 {
 return false; //TODO
 
 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 )
 {
 //TODO
 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;
 }
 
 //================================================================
 // SOUNDS
 //================================================================
 //TODO
 
 override void SetActions()
 {
 super.SetActions();
 
 AddAction(ActionRaiseFlag);
 AddAction(ActionLowerFlag);
 AddAction(ActionFoldBaseBuildingObject);
 }
 
 /*override void UpdateVisuals()
 {
 super.UpdateVisuals();
 }*/
 
 //================================================================
 // FLAG MANIPULATION + REFRESHER
 //================================================================
 void AnimateFlagEx(float delta, PlayerBase player = null)
 {
 float temp = Math.Clamp( delta,0,1 );
 float phase_new;
 if (temp < 0.01 || temp > 0.99)
 {
 phase_new = Math.Round(temp);
 }
 else
 phase_new = temp;
 
 SetAnimationPhase("flag_mast",phase_new);
 
 if (player)
 LogAnimateFlag(phase_new, player);
 
 GetInventory().SetSlotLock(InventorySlots.GetSlotIdFromString("Material_FPole_Flag"),phase_new != 1);
 
 }
 
 void AnimateFlag(float delta)
 {
 AnimateFlagEx(delta);
 }
 
 protected void LogAnimateFlag(float newPhase, notnull PlayerBase player)
 {
 PluginAdminLog logs = PluginAdminLog.Cast(GetPlugin(PluginAdminLog));
 if (newPhase == 0)
 {
 // at the top(it's inverted)
 logs.TotemFlagChange(true, player, this);
 }
 else if (newPhase == 1)
 {
 // at the bottom(it's inverted)
 logs.TotemFlagChange(false, player, this);
 }
 
 }
 
 void SetRefreshTimer01(float fraction)
 {
 float temp = Math.Clamp(m_FlagRefresherMaxDuration * fraction, 0, m_FlagRefresherMaxDuration);
 m_RefresherTimeRemaining = Math.Round(temp);
 }
 
 /*void AddRefresherTimeFlat(float seconds) //seconds?
 {
 float temp = Math.Clamp(m_RefresherTimeRemaining + seconds, 0, m_FlagRefresherMaxDuration);
 m_RefresherTimeRemaining = Math.Round(temp);
 SetRefresherActive(m_RefresherTimeRemaining > 0);
 }*/
 
 void AddRefresherTime01(float fraction)
 {
 float temp = Math.Clamp(m_RefresherTimeRemaining + (fraction * m_FlagRefresherMaxDuration), 0, m_FlagRefresherMaxDuration);
 m_RefresherTimeRemaining = Math.Round(temp);
 SetRefresherActive(m_RefresherTimeRemaining > 0);
 //Print(m_RefresherTimeRemaining);
 }
 
 float GetRefresherTime01()
 {
 return m_RefresherTimeRemaining / m_FlagRefresherMaxDuration;
 }
 
 void CheckLoadedVariables(int max_duration)
 {
 if (max_duration != m_FlagRefresherMaxDuration)
 {
 m_RefresherTimeRemaining = m_FlagRefresherMaxDuration * m_RefresherTimeRemaining / max_duration;
 }
 }
 
 //================================================================
 // DEBUG
 //================================================================ 
 /*
 override void DebugCustomState()
 {
 //debug
 m_SyncParts01 = 881; //full fence with gate
 m_HasHinges = true;
 m_HasBase = true;
 
 OnVariablesSynchronized();
 }
 */
 
 //Debug menu Spawn Ground Special
 override void OnDebugSpawn()
 {
 super.OnDebugSpawn();
 
 GetInventory().CreateInInventory("Flag_DayZ");
 AnimateFlag(0);
 AddRefresherTime01(1);
 }
}