SoftSkillsManager.c

Go to the documentation of this file.

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