SoftSkillsManager.c

См. документацию.

class SoftSkillsManager
{   
    protected PlayerBase          m_Player;
    protected float                 m_SpecialtyLevel;
    protected float                 m_RoughLevel;
    protected float                 m_PreciseLevel;
     
    protected bool                  m_IsLinear;
    protected bool                  m_IsActive;
    protected bool                  m_IsCoolDown;
 
    protected int                   m_UserActionsCounter;   
 
    static protected const int      DEFAULT_EFFICIENCY = 0;
    static protected const float    PRECISE_WEIGHT_LIMIT = -1; 
    static protected const float    ROUGH_WEIGHT_LIMIT = 1;
    static protected const float    COOLDOWN_TIMER = 5; //default 5, 
 
    protected ref Timer            m_CoolDownTimer = new Timer();
 
    protected bool              m_IsDebugMode;
    protected float                 m_CoolDownValue;
    protected float                 m_LastUAValue;
    protected float                 m_ComponentBonusBefore;
    protected float                 m_ComponentBonusAfter;
    protected float                 m_GeneralBonusBefore;
    protected float                 m_GeneralBonusAfter;
 
    protected ref SoftSkillManagerDebug m_DebugWindow;
 
    protected ref Timer            m_SynchTimer;
 
    void SoftSkillsManager( PlayerBase player )
    {
        m_Player = player;
        m_IsCoolDown = false;
        m_IsLinear = false;
        m_IsActive = true;
        m_IsDebugMode = false;
    }
 
    void InitSpecialty( float specialty_level )
    {
        SetSpecialtyLevel( specialty_level );
        SynchSpecialtyLevel();
    }
 
    void ~SoftSkillsManager()
    {       
        delete m_CoolDownTimer;
    }
 
    // ----------------------------------------------------------------------------------------
    float AddLinearPrecise( float specialty_weight )
    {
        m_SpecialtyLevel += specialty_weight; 
        SetLastUAValue( specialty_weight );
        m_SpecialtyLevel = Math.Clamp( m_SpecialtyLevel, PRECISE_WEIGHT_LIMIT, ROUGH_WEIGHT_LIMIT );
 
        return m_SpecialtyLevel;
    }
 
    // ----------------------------------------------------------------------------------------
    float AddLinearRough( float specialty_weight )
    {
        m_SpecialtyLevel += specialty_weight;
        SetLastUAValue( specialty_weight );
        m_SpecialtyLevel = Math.Clamp( m_SpecialtyLevel, PRECISE_WEIGHT_LIMIT, ROUGH_WEIGHT_LIMIT );
 
        return m_SpecialtyLevel;
    }
 
    // ----------------------------------------------------------------------------------------
    float AddExponentialPrecise( float specialty_weight )
    {
        m_UserActionsCounter -= 1;
 
        if( m_UserActionsCounter == 0)
        {
            m_UserActionsCounter = -1;
            m_SpecialtyLevel = 0;
        }
        
        float adjusted_weight = specialty_weight / Math.Sqrt( Math.AbsInt( m_UserActionsCounter ) );
    
        SetLastUAValue( adjusted_weight );
 
        m_SpecialtyLevel += adjusted_weight;
        m_SpecialtyLevel = Math.Clamp( m_SpecialtyLevel, PRECISE_WEIGHT_LIMIT, ROUGH_WEIGHT_LIMIT );
 
        return m_SpecialtyLevel;
    }
        
    // ----------------------------------------------------------------------------------------
    float AddExponentialRough( float specialty_weight )
    {
        m_UserActionsCounter += 1;
            
        if( m_UserActionsCounter == 0)
        {
            m_UserActionsCounter = 1;
            m_SpecialtyLevel = 0;
        }
        
        float adjusted_weight = specialty_weight / Math.Sqrt( Math.AbsInt( m_UserActionsCounter ) );
 
        SetLastUAValue( adjusted_weight );
 
        m_SpecialtyLevel += adjusted_weight;
        m_SpecialtyLevel = Math.Clamp( m_SpecialtyLevel, PRECISE_WEIGHT_LIMIT, ROUGH_WEIGHT_LIMIT );
 
        return m_SpecialtyLevel;
    }
 
    // ----------------------------------------------------------------------------------------
    void AddSpecialty( float specialty_weight )
    {
        if( GetSoftSkillsState() )
        {
            if( !IsCoolDown() )
            {   
                    if( specialty_weight < 0 )
                    {   
                        if( IsLinear() )
                        {
                            SetSpecialtyLevel( AddLinearPrecise( specialty_weight ) ); 
                        }
                        else
                        {
                             SetSpecialtyLevel( AddExponentialPrecise( specialty_weight ) );
                        }
 
                        m_Player.GetStatSpecialty().Set( m_SpecialtyLevel );
                        StartCoolDownTimer( Math.AbsFloat( ( specialty_weight * 100 ) ) * COOLDOWN_TIMER );
                        SynchSpecialtyLevel();
                    }
                    else if( specialty_weight > 0 )
                    {
                        if( IsLinear() )
                        {                           
                            SetSpecialtyLevel( AddLinearRough( specialty_weight ) );
                        }
                        else
                        {                       
                            SetSpecialtyLevel( AddExponentialRough( specialty_weight ) );       
                        }
 
                        m_Player.GetStatSpecialty().Set( m_SpecialtyLevel );
                        StartCoolDownTimer( Math.AbsFloat( ( specialty_weight * 100 ) ) * COOLDOWN_TIMER );
                        SynchSpecialtyLevel();
                    }
                    else
                    {
                        //if the specialty weight for a recipe or UA is set to 0, it will increase neither specialty, nor UA counter
                        return;
                    }
                }
            else
            {
                StartCoolDownTimer( Math.AbsFloat( ( specialty_weight * 100 ) ) * COOLDOWN_TIMER );     
            }
        }
    }
 
    // ---------------------------------------------------------------------------------------- 
    // Use AddSpecialtyBonus if you want to increase a value, based on the specialty level of the player. e.g. more harvested material
    // limit_efficiency sets the max amount of bonus, the soft skill can provide: limit_efficiency = 2 is 50% bonus, limit_efficiency = 3 is 33% bonus etc
    float AddSpecialtyBonus( float base_value, float specialty_weight, bool is_cacomponent = false, float limit_efficiency = 2 )
    {   
        if ( specialty_weight == 0 )
        {
            return base_value;  
        }
        
        SetBonusBefore( is_cacomponent, base_value);
 
        float adjusted_value;
        
        GetPreciseRoughLevels();
 
        if ( limit_efficiency != 0 )
        {
            if ( specialty_weight < 0 )
            {           
                adjusted_value = base_value + ( ( base_value * m_PreciseLevel ) / limit_efficiency );
            }
            else
            {
                adjusted_value = base_value + ( ( base_value * m_RoughLevel ) / limit_efficiency );
            }
        }
        else
        {
            if ( specialty_weight < 0 )
            {           
                adjusted_value = base_value + ( ( base_value * m_PreciseLevel ) );
            }
            else
            {
                adjusted_value = base_value + ( ( base_value * m_RoughLevel ) );
            }
        }
 
        SetBonusAfter( is_cacomponent, adjusted_value );
 
        return adjusted_value;
    }
    
    // ----------------------------------------------------------------------------------------
    // Use SubtractSpecialtyBonus if you want to decrease a value, based on the specialty level of the player. e.g. faster harvesting time
    // limit_efficiency sets the max amount of bonus, the soft skill can provide: limit_efficiency = 2 is 50% bonus, limit_efficiency = 3 is 33% bonus etc
    float SubtractSpecialtyBonus( float base_value, float specialty_weight, bool is_cacomponent = false, float limit_efficiency = 2 )
    {
        if ( specialty_weight == 0 )
        {
            return base_value;  
        }
        
        SetBonusBefore( is_cacomponent, base_value);
 
        float adjusted_value;
        
        GetPreciseRoughLevels();
 
        if ( limit_efficiency != 0 )
        {
            if ( specialty_weight < 0 )
            {
                adjusted_value = base_value - ( ( base_value * m_PreciseLevel  ) / limit_efficiency );
            }
            else
            {
                adjusted_value = base_value - ( ( base_value * m_RoughLevel ) / limit_efficiency );
            }
        }
        else
        {
            if ( specialty_weight < 0 )
            {
                adjusted_value = base_value - ( ( base_value * m_PreciseLevel  ) );
            }
            else
            {
                adjusted_value = base_value - ( ( base_value * m_RoughLevel ) );
            }
        }
 
        SetBonusAfter( is_cacomponent, adjusted_value );
 
        return adjusted_value;  
    }
 
    // ----------------------------------------------------------------------------------------
    // Use AdjustCraftingTime if you want to decrease time for recipe crafting
    // limit_efficiency sets the max amount of bonus, the soft skill can provide: limit_efficiency = 2 is 50% bonus, limit_efficiency = 3 is 33% bonus etc
    float AdjustCraftingTime( float base_time, float specialty_weight, float limit_efficiency = 2 )
    {
        if ( specialty_weight == 0 )
        {
            return base_time;   
        }
        
        SetBonusBefore( false, base_time);
 
        float adjusted_time;
 
        GetPreciseRoughLevels();
 
        if ( specialty_weight < 0 )
        {
            adjusted_time = base_time - ( ( base_time * m_PreciseLevel ) / limit_efficiency );
        }
        else
        {
            adjusted_time = base_time - ( ( base_time * m_RoughLevel ) / limit_efficiency );
        }
 
        SetBonusAfter( false, adjusted_time );
 
        return adjusted_time;   
    }
 
    // ----------------------------------------------------------------------------------------
    PlayerBase GetSoftSkillsPlayer()
    {
        return m_Player;
    }
    
    // ----------------------------------------------------------------------------------------
    void SetSpecialtyLevel( float specialty_level )
    {
        m_SpecialtyLevel = specialty_level;
    }
    
    // ----------------------------------------------------------------------------------------
    float GetSpecialtyLevel()
    {
        return m_SpecialtyLevel;
    }
 
    // ----------------------------------------------------------------------------------------
    void SynchSpecialtyLevel()
    {   
        #ifdef SERVER
        Param1<float> specialty_level = new Param1<float>( m_SpecialtyLevel );
        GetGame().RPCSingleParam( m_Player, ERPCs.RPC_SOFT_SKILLS_SPECIALTY_SYNC, specialty_level, true, m_Player.GetIdentity() );
        #endif      
    }
 
    // ----------------------------------------------------------------------------------------
    void SetSoftSkillsState( bool state )
    {
        m_IsActive = state;
    }
 
    // ----------------------------------------------------------------------------------------
    bool GetSoftSkillsState()
    {
        return m_IsActive;
    }
 
    // ----------------------------------------------------------------------------------------
    void SetLinearState( bool model )
    {
        m_IsLinear = model;
    }
 
    // ----------------------------------------------------------------------------------------
    bool IsLinear()
    {
        return m_IsLinear;
    }
 
    // ----------------------------------------------------------------------------------------
    void GetPreciseRoughLevels()
    {
        if ( m_SpecialtyLevel > 0)
        {
            m_RoughLevel = m_SpecialtyLevel;
            m_PreciseLevel = DEFAULT_EFFICIENCY;
        }
        else if ( m_SpecialtyLevel < 0)
        {
            m_RoughLevel = DEFAULT_EFFICIENCY;
            m_PreciseLevel =  Math.AbsFloat( m_SpecialtyLevel );
        }
        else
        {
            m_RoughLevel = DEFAULT_EFFICIENCY;
            m_PreciseLevel = DEFAULT_EFFICIENCY;
        }
    }
 
    // ----------------------------------------------------------------------------------------
    void StartCoolDownTimer( float cooldown_value )
    {
        SetCoolDown( true );
        SetCoolDownValue( cooldown_value );
        m_CoolDownTimer.Run( cooldown_value, this, "SetCoolDown", new Param1<bool>( false ) );
    }
 
    // ----------------------------------------------------------------------------------------
    bool IsCoolDown()
    {
        return m_IsCoolDown;
    }
 
    // ----------------------------------------------------------------------------------------
    void SetCoolDown( bool cool_down )
    {
        m_IsCoolDown = cool_down;
    }
    
// ----------------------------------------------------------------------------------------
//  SoftSkillManagerDebug support
// ----------------------------------------------------------------------------------------
    void CreateDebugWindow( bool create )
    {
        if ( create )
        {
            m_DebugWindow = new SoftSkillManagerDebug( this );
            SetIsDebug( create );
        }
        else
        {
            ResetDebugWindow();
            SetIsDebug( create );
            delete m_DebugWindow;
        }
    }
    
    // ----------------------------------------------------------------------------------------
    void SynchDebugStats()
    {   
        if ( GetGame().IsServer() && GetGame().IsMultiplayer() )
        {
            Param5<float, float, float, float, bool> debug_stats = new Param5<float, float, float, float, bool>( m_GeneralBonusBefore, m_GeneralBonusAfter, m_LastUAValue, m_CoolDownValue, m_IsCoolDown );
            GetGame().RPCSingleParam( m_Player, ERPCs.RPC_SOFT_SKILLS_STATS_SYNC, debug_stats, true, m_Player.GetIdentity() );
        }       
    }
 
    // ----------------------------------------------------------------------------------------
    void SetIsDebug( bool is_debug )
    {
        m_IsDebugMode = is_debug;
    }
 
    // ----------------------------------------------------------------------------------------
    bool IsDebug()
    {
        return m_IsDebugMode;
    }
    
    // ----------------------------------------------------------------------------------------
    void SetCoolDownValue( float cooldown_value )
    {
        m_CoolDownValue = cooldown_value;
    }
 
    // ----------------------------------------------------------------------------------------
    float GetCoolDownValue()
    {
        return m_CoolDownValue;
    }
    
    // ----------------------------------------------------------------------------------------
    float GetLastUAValue()
    {
        return m_LastUAValue;
    }
 
    // ----------------------------------------------------------------------------------------
    void SetLastUAValue( float last_ua_value )
    {
        m_LastUAValue = last_ua_value;
    }
 
    // ----------------------------------------------------------------------------------------
    void SetBonusBefore( bool is_cacomponent, float base_value)
    {
        if ( IsDebug() )
        {
            if ( is_cacomponent )
            {
                SetComponentBonusBefore(base_value);
            }
            else
            {
                SetGeneralBonusBefore(base_value);
            }
        }   
    }
 
    // ----------------------------------------------------------------------------------------
    void SetBonusAfter( bool is_cacomponent, float adjusted_value )
    {
        if ( IsDebug() )
        {
            if ( is_cacomponent )
            {
                SetComponentBonusAfter(adjusted_value);
            }
            else
            {
                SetGeneralBonusAfter(adjusted_value);
            }
        }
    }
 
    // ----------------------------------------------------------------------------------------
    float GetComponentBonusBefore()
    {
        return m_ComponentBonusBefore;
    }
 
    // ----------------------------------------------------------------------------------------
    void SetComponentBonusBefore( float component_bonus_before )
    {
        m_ComponentBonusBefore = component_bonus_before;
    }
 
    // ----------------------------------------------------------------------------------------
    float GetComponentBonusAfter()
    {
        return m_ComponentBonusAfter;
    }
 
    // ----------------------------------------------------------------------------------------
    void SetComponentBonusAfter( float component_bonus_after )
    {
        m_ComponentBonusAfter = component_bonus_after;
    }
 
    // ----------------------------------------------------------------------------------------
    float GetGeneralBonusBefore()
    {
        return m_GeneralBonusBefore;
    }
 
    // ----------------------------------------------------------------------------------------
    void SetGeneralBonusBefore( float general_bonus_before )
    {
        m_GeneralBonusBefore = general_bonus_before;
    }
 
    // ----------------------------------------------------------------------------------------
    float GetGeneralBonusAfter()
    {
        return m_GeneralBonusAfter;
    }
 
    // ----------------------------------------------------------------------------------------
    void SetGeneralBonusAfter( float general_bonus_after )
    {
        m_GeneralBonusAfter = general_bonus_after;
    }
 
    // ----------------------------------------------------------------------------------------
    void StartSynchTimer()
    {
        SetIsDebug( true );
        m_SynchTimer = new Timer;
        m_SynchTimer.Run( 2, this, "SynchDebugStats", NULL, true );
    }
 
    // ----------------------------------------------------------------------------------------
    void StopSynchTimer()
    {
        SetIsDebug( false );
        
        if ( m_SynchTimer )
        {
            m_SynchTimer.Stop();
            delete m_SynchTimer;
        }
    }
        
    // ----------------------------------------------------------------------------------------
    void ResetDebugWindow()
    {
        SetSpecialtyLevel( 0 );
        SetLastUAValue( 0 );
        SetComponentBonusBefore( 0 );
        SetComponentBonusAfter( 0 );
        SetGeneralBonusBefore( 0 );
        SetGeneralBonusAfter( 0 );
        SetCoolDownValue( 0 );
        
        SynchSpecialtyLevel();
    }
}
 
// ----------------------------------------------------------------------------------------
//  SoftSkillManagerDebug
// ----------------------------------------------------------------------------------------
 
class SoftSkillManagerDebug
{
    SoftSkillsManager m_SoftSkillManager;
    ref Widget m_PanelSoftSkills;
    TextWidget SpecialtyTotal;
    TextWidget SpecialtyChange;
    TextWidget ComponentBonusBefore;
    TextWidget ComponentBonusAfter;
    TextWidget GeneralBonusBefore;
    TextWidget GeneralBonusAfter;
    TextWidget CoolDown;
    TextWidget IsCoolDown;
 
    void SoftSkillManagerDebug( SoftSkillsManager softskill_manager )
    {                   
        m_SoftSkillManager = softskill_manager;
        m_PanelSoftSkills = GetGame().GetWorkspace().CreateWidgets("gui/layouts/debug/day_z_hud_debug_softskills.layout");
        
        GetGame().GetUpdateQueue(CALL_CATEGORY_SYSTEM).Insert(this.OnUpdate);
 
        Class.CastTo(SpecialtyTotal,  m_PanelSoftSkills.FindWidget("SpecialtyTotal"));
        Class.CastTo(SpecialtyChange,  m_PanelSoftSkills.FindWidget("SpecialtyChange"));
        Class.CastTo(ComponentBonusBefore,  m_PanelSoftSkills.FindWidget("ComponentBonusBefore"));
        Class.CastTo(ComponentBonusAfter,  m_PanelSoftSkills.FindWidget("ComponentBonusAfter"));
        Class.CastTo(GeneralBonusBefore,  m_PanelSoftSkills.FindWidget("GeneralBonusBefore"));
        Class.CastTo(GeneralBonusAfter,  m_PanelSoftSkills.FindWidget("GeneralBonusAfter"));
        Class.CastTo(CoolDown,  m_PanelSoftSkills.FindWidget("CoolDown"));
        Class.CastTo(IsCoolDown,  m_PanelSoftSkills.FindWidget("IsCoolDown"));
        
        m_PanelSoftSkills.Show( true );
        SpecialtyTotal.Show( true );
        SpecialtyChange.Show( true );
        ComponentBonusBefore.Show( true );
        ComponentBonusAfter.Show( true );
        GeneralBonusBefore.Show( true );
        GeneralBonusAfter.Show( true );
        CoolDown.Show( true );
        IsCoolDown.Show( true );
    }
    
    void ~SoftSkillManagerDebug()
    {       
        if ( GetGame() )
        {
            GetGame().GetUpdateQueue(CALL_CATEGORY_SYSTEM).Remove(this.OnUpdate);
        }
        
        delete m_PanelSoftSkills;
    }
 
    SoftSkillsManager GetActiveSoftSkillManager()
    {
        return m_SoftSkillManager;
    }
    
    void OnUpdate()
    {
        if ( GetActiveSoftSkillManager().GetSoftSkillsPlayer().IsAlive() )
        {
            float speciality = GetActiveSoftSkillManager().GetSpecialtyLevel();
            speciality = speciality * 100;
            speciality = Math.Round( speciality );
            speciality = speciality * 0.01;
            
            SpecialtyTotal.SetText( "Specialty level: " + speciality.ToString() );
            SpecialtyChange.SetText( "Specialty change: " + GetActiveSoftSkillManager().GetLastUAValue() );
            ComponentBonusBefore.SetText( "Component/craft default: " + GetActiveSoftSkillManager().GetComponentBonusBefore() );
            ComponentBonusAfter.SetText( "Component/craft with bonus: " + GetActiveSoftSkillManager().GetComponentBonusAfter() );
            GeneralBonusBefore.SetText( "General default: " + GetActiveSoftSkillManager().GetGeneralBonusBefore() );
            GeneralBonusAfter.SetText( "General with bonus: " + GetActiveSoftSkillManager().GetGeneralBonusAfter() );
            CoolDown.SetText( "CoolDown value: " + GetActiveSoftSkillManager().GetCoolDownValue() );
            IsCoolDown.SetText( "Cooldown active: " + GetActiveSoftSkillManager().IsCoolDown() );
        }
        else
        {
            delete this;
        }
    }
 
}