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