PluginLifespan.c

Go to the documentation of this file.

//-----------------------------
// LIFESPAN plugin
//-----------------------------
/*
  Lifespan plugin handles player facial hair, bloody hands, blood type in HUD
*/
 
enum eBloodyHandsTypes
{
  CLEAN = 0,//clean needs to be 0
  SALMONELA,
  JUST_BLOOD,
  //--- ONLY LAST_INDEX BELLOW !!!
  LAST_INDEX,
}
 
enum LifeSpanState
{
  BEARD_NONE = 0,
  BEARD_MEDIUM = 1,
  BEARD_LARGE = 2,
  BEARD_EXTRA = 3,
  COUNT = 4,
}
 
class PluginLifespan extends PluginBase
{
  protected static const int LIFESPAN_MIN = 0;
  protected static const int LIFESPAN_MAX = 240; // value in minutes when player achieved maximum age in order to have full beard
  protected int m_FakePlaytime;
 
  protected ref map<PlayerBase, ref LifespanLevel> m_PlayerCurrentLevel;
  protected ref map<string, ref array< ref LifespanLevel>> m_LifespanLevels;
  protected ref map<string, ref BloodyHands> m_BloodyHands;
  protected ref map<PlayerBase, int> m_BloodType;
 
  //========================================
  // GetInstance
  //========================================
  static PluginLifespan GetInstance()
  {
    return PluginLifespan.Cast(GetPlugin(PluginLifespan));
  }
 
  void PluginLifespan()
  {
    LoadFromCfg();
    m_PlayerCurrentLevel = new map<PlayerBase, ref LifespanLevel>;
    m_BloodType = new map<PlayerBase, int>;
    m_FakePlaytime = 0;
  }
 
  //-----------------------------
  // Player load from config
  //-----------------------------
  void LoadFromCfg()
  {
    m_LifespanLevels = new map<string, ref array< ref LifespanLevel>>;
    m_BloodyHands = new map<string, ref BloodyHands>;
 
    const int LIFESPAN_LENGTH = LIFESPAN_MAX - LIFESPAN_MIN;
 
    //cfg_name = 'CfgVehicles'
    // config_name = 'CfgVehicles'
    //cfg_class_count = 2348
    // config_count = 2348
    //cfg_class_name = 'SurvivorMale_Base'
    // survivor_name = 'SurvivorMale_Base'
    //cfg_class_fullname = 'CfgVehicles SurvivorMale_Base'
    // survivor_path = 'CfgVehicles SurvivorMale_Base'
    //cfg_class_member_count = 10
    // survivor_lifespan_count = 10
    //cfg_class_member_name = 'Lifespan'
    // survivor_lifespan_name = 'Lifespan'
    //cfg_class_member_fullname = 'CfgVehicles SurvivorMale_Base Lifespan';
    // survivor_lifespan_path = 'CfgVehicles SurvivorMale_Base Lifespan';
    //cfg_class_member_member_count = 1
    // survivor_lifespan_beard_count = 1
    //cfg_class_member_member_name = 'Beard'
    // survivor_lifespan_beard_name = 'Beard'
    //cfg_class_member_member_fullname = 'CfgVehicles SurvivorMale_Base Lifespan Beard'
    // survivor_lifespan_beard_path = 'CfgVehicles SurvivorMale_Base Lifespan Beard'
    //cfg_class_member_member_variable_name = 'mat'
    // survivor_lifespan_beard_material_name = 'mat'
    //cfg_class_member_member_variable_fullname = 'CfgVehicles SurvivorMale_Base Lifespan Beard mat'
    // survivor_lifespan_beard_material_path = 'CfgVehicles SurvivorMale_Base Lifespan Beard mat'
 
    string config_name = "CfgVehicles";
    int config_count = GetGame().ConfigGetChildrenCount(config_name);
 
    int i, j, k, l, m;
 
    //Print( "config_count: " + config_count );
    for (i = 0; i < config_count; i++)
    {
      string survivor_name = "";
      GetGame().ConfigGetChildName(config_name, i, survivor_name);
 
      if (survivor_name != "" && survivor_name != "access")
      {
        if (GetGame().IsKindOf(survivor_name, "SurvivorMale_Base") || GetGame().IsKindOf(survivor_name, "SurvivorFemale_Base"))
        {
          string survivor_path = config_name + " " + survivor_name;
          int survivor_lifespan_count = GetGame().ConfigGetChildrenCount(survivor_path);
 
          //Print( "survivor_path: " + survivor_path );
          for (j = 0; j < survivor_lifespan_count; j++)
          {
            string survivor_lifespan_name = "";
            GetGame().ConfigGetChildName(survivor_path, j, survivor_lifespan_name);
 
            string survivor_lifespan_path = survivor_path + " " + survivor_lifespan_name;
 
            if (survivor_lifespan_name == "Lifespan")
            {
              int survivor_lifespan_beard_count = GetGame().ConfigGetChildrenCount(survivor_lifespan_path);
 
              for (k = 0; k < survivor_lifespan_beard_count; k++)
              {
                string survivor_lifespan_beard_name = "";
                GetGame().ConfigGetChildName(survivor_lifespan_path, k, survivor_lifespan_beard_name);
 
                string survivor_lifespan_beard_path = survivor_lifespan_path + " " + survivor_lifespan_beard_name;
 
                if (survivor_lifespan_beard_name == "Beard")
                {
                  TStringArray materials = new TStringArray;
                  int cfg_class_member_member_variable_count = GetGame().ConfigGetChildrenCount(survivor_lifespan_beard_path);
 
                  for (l = 0; l < cfg_class_member_member_variable_count; l++)
                  {
                    string survivor_lifespan_beard_material_name = "";
                    GetGame().ConfigGetChildName(survivor_lifespan_beard_path, l, survivor_lifespan_beard_material_name);
                    string survivor_lifespan_beard_material_path = survivor_lifespan_beard_path + " " + survivor_lifespan_beard_material_name;
 
                    if (survivor_lifespan_beard_material_name == "mat")
                    {
                      GetGame().ConfigGetTextArray(survivor_lifespan_beard_material_path, materials);
 
                      array<ref LifespanLevel> lifespan_levels = new array< ref LifespanLevel>;
 
                      int level_count = materials.Count() / 2;
                      for (m = 0; m < level_count; m++)
                      {
                        int tex = m * 2;
                        int mat = ((m * 2) + 1);
                        if (mat < materials.Count())
                        {
                          float threshold = (((float)m / (float)(level_count - 1)) * (float)LIFESPAN_LENGTH) + (float)LIFESPAN_MIN;
                          lifespan_levels.Insert(new LifespanLevel(m, threshold, materials.Get(tex), materials.Get(mat)));
                          //Print("material a textura a threshold: " + materials.Get(tex) + " " + materials.Get(mat) + " " + threshold );
                        }
                      }
 
                      if (lifespan_levels.Count() > 0)
                        m_LifespanLevels.Set(survivor_name, lifespan_levels);
                    }
                  }
                }
              }
            }
            else if (survivor_lifespan_name == "BloodyHands")
            {
              string bloody_material, normal_material;
              string path_normal = survivor_lifespan_path + " mat_normal";
              string path_bloody = survivor_lifespan_path + " mat_blood";
              GetGame().ConfigGetText(path_normal, normal_material);
              GetGame().ConfigGetText(path_bloody, bloody_material);
              m_BloodyHands.Set(survivor_name, new BloodyHands(normal_material, bloody_material));
            }
          }
        }
      }
    }
 
    /*for ( int cl = 0; cl < m_LifespanLevels.Count(); cl++ )
      {
      string class_name = m_LifespanLevels.GetKey( cl );
      array<ref LifespanLevel> levels = m_LifespanLevels.GetElement( cl );
 
      Print( class_name );
 
      for ( int ll = 0; ll < levels.Count(); ll++)
      {
        Print( "lvl: " + levels.Get( ll ).GetLevel() );
        Print( "treshold: " + levels.Get( ll ).GetThreshold() );
        Print( "texture: " + levels.Get( ll ).GetTextureName() );
        Print( "material: " + levels.Get( ll ).GetMaterialName() );
      }
      }*/
  }
 
  //-----------------------------
  // Support functions
  //-----------------------------
 
  void SynchLifespanVisual(PlayerBase player, int beard_state_visible, bool bloody_hands_visible, bool blood_type_visible, int blood_type)
  {
    SynchBeardVisual(player, beard_state_visible);
    SynchBloodyHandsVisual(player, bloody_hands_visible);
    SynchShowBloodTypeVisual(player, blood_type_visible);
    SynchShowBloodType(player, blood_type);
  }
 
  void ChangeFakePlaytime(PlayerBase player, int change)
  {
    if (!GetGame().IsMultiplayer())
    {
      m_FakePlaytime = change;
      UpdateLifespan(player, true);
    }
  }
 
  //-----------------------------
  // Facial hair
  //-----------------------------
 
  void UpdateLifespan(PlayerBase player, bool force_update = false)
  {
    if (player != null)
    {
      float playerPlaytime = m_FakePlaytime;
 
      if (GetGame().IsMultiplayer() && GetGame().IsServer())
        playerPlaytime = player.StatGet(AnalyticsManagerServer.STAT_PLAYTIME);
 
      float playerBeard = playerPlaytime - player.GetLastShavedSeconds();
      playerBeard = playerBeard / 60.0;
 
      UpdateLifespanLevel(player, playerBeard, force_update);
    }
  }
 
  protected void UpdateLifespanLevel(PlayerBase player, float player_beard, bool force_update = false)
  {
    if (!player.IsAlive())
      return;
 
    if (m_PlayerCurrentLevel.Contains(player))
    {
      LifespanLevel current_level = m_PlayerCurrentLevel.Get(player);
 
      if (player_beard > current_level.GetThreshold() || force_update)
      {
        LifespanLevel next_level = GetLifespanLevel(player.GetPlayerClass(), player_beard);
 
        if (next_level != NULL)
        {
          SetPlayerLifespanLevel(player, next_level);
          m_PlayerCurrentLevel.Set(player, next_level);
        }
      }
    }
    else
    {
      if (m_LifespanLevels.Contains(player.GetPlayerClass()))
      {
        LifespanLevel level = GetLifespanLevel(player.GetPlayerClass(), player_beard);
 
        if (level != NULL)
        {
          SetPlayerLifespanLevel(player, level);
          m_PlayerCurrentLevel.Set(player, level);
        }
      }
    }
  }
 
  protected LifespanLevel GetLifespanLevel(string player_class, float age = 0)
  {
    array<ref LifespanLevel> lifespan_levels = m_LifespanLevels.Get(player_class);
 
    if (lifespan_levels != NULL)
    {
      for (int i = lifespan_levels.Count() - 1; i >= 0; i--)
      {
        LifespanLevel level = lifespan_levels.Get(i);
 
        if (age >= level.GetThreshold())
          return level;
      }
    }
 
    return NULL;
  }
 
  protected void SetPlayerLifespanLevel(PlayerBase player, LifespanLevel level)
  {
    if (player.m_CorpseState != 0)
      return;
    int slot_id = InventorySlots.GetSlotIdFromString("Head");
    EntityAI players_head = player.GetInventory().FindPlaceholderForSlot(slot_id);
 
    if (players_head)
    {
      switch (level.GetLevel())
      {
      case LifeSpanState.BEARD_NONE:
      {
        players_head.SetObjectTexture(0, "");
        players_head.SetObjectMaterial(0, "");
 
        player.SetFaceTexture(level.GetTextureName());
        player.SetFaceMaterial(level.GetMaterialName());
 
        player.SetLifeSpanStateVisible(LifeSpanState.BEARD_NONE);
        //Print("LifeSpanState.BEARD_NONE");
        break;
      }
      case LifeSpanState.BEARD_MEDIUM:
      {
        players_head.SetObjectTexture(0, "");
        players_head.SetObjectMaterial(0, "");
 
        player.SetFaceTexture(level.GetTextureName());
        player.SetFaceMaterial(level.GetMaterialName());
 
        player.SetLifeSpanStateVisible(LifeSpanState.BEARD_MEDIUM);
        //Print("LifeSpanState.BEARD_MEDIUM");
        break;
      }
 
      case LifeSpanState.BEARD_LARGE:
      {
        players_head.SetObjectTexture(0, "");
        players_head.SetObjectMaterial(0, "");
 
        player.SetFaceTexture(level.GetTextureName());
        player.SetFaceMaterial(level.GetMaterialName());
 
        player.SetLifeSpanStateVisible(LifeSpanState.BEARD_LARGE);
        //Print("LifeSpanState.BEARD_LARGE");
        break;
      }
 
      case LifeSpanState.BEARD_EXTRA:
      {
        players_head.SetObjectTexture(0, level.GetTextureName());
        players_head.SetObjectMaterial(0, level.GetMaterialName());
 
        array< ref LifespanLevel> lifespan_levels = m_LifespanLevels.Get(player.GetPlayerClass());
        LifespanLevel prev_level = lifespan_levels.Get(LifeSpanState.BEARD_LARGE);
 
        player.SetFaceTexture(prev_level.GetTextureName());
        player.SetFaceMaterial(prev_level.GetMaterialName());
 
        player.SetLifeSpanStateVisible(LifeSpanState.BEARD_EXTRA);
        //Print("LifeSpanState.BEARD_EXTRA");
        break;
      }
 
      default:
      {
        Print("Lifespan state missing");
        break;
      }
      }
    }
  }
 
  void SynchBeardVisual(PlayerBase player, int state)
  {
    float player_beard;
 
    switch (state)
    {
    case LifeSpanState.BEARD_NONE:
    {
      // first out of 4 states
      player_beard = LIFESPAN_MIN;
      break;
    }
    case LifeSpanState.BEARD_MEDIUM:
    {
      // second out of 4 states
      player_beard = LIFESPAN_MAX / 3;
      break;
    }
 
    case LifeSpanState.BEARD_LARGE:
    {
      // third out of 4 states
      player_beard = LIFESPAN_MAX / 1.5;
      break;
    }
 
    case LifeSpanState.BEARD_EXTRA:
    {
      // fourth out of 4 states
      player_beard = LIFESPAN_MAX;
      break;
    }
 
    default:
    {
      Print("Lifespan state missing");
      break;
    }
    }
 
    UpdateLifespanLevel(player, player_beard, true);
  }
 
  //-----------------------------
  // Bloody hands
  //-----------------------------
 
  void UpdateBloodyHandsVisibilityEx(PlayerBase player, eBloodyHandsTypes type)
  {
    if (CanMakeHandsBloody(player))
      SetBloodyHandsEx(player, type);
  }
 
  void UpdateBloodyHandsVisibility(PlayerBase player, bool show)
  {
    if (CanMakeHandsBloody(player))
      SetBloodyHands(player, show);
  }
 
  void SynchBloodyHandsVisual(PlayerBase player, bool has_bloody_hands)
  {
    UpdateBloodyHandsVisibility(player, has_bloody_hands);
  }
 
 
  void SetBloodyHandsEx(PlayerBase player, eBloodyHandsTypes type)
  {
    player.SetBloodyHandsEx(type);
 
    if (type)
      SetHandsMaterial(player, BloodyHands.MATERIAL_TYPE_BLOODY);
    else
      SetHandsMaterial(player, BloodyHands.MATERIAL_TYPE_NORMAL);
 
  }
 
  void SetBloodyHands(PlayerBase player, bool show)
  {
    player.SetBloodyHands(show);
 
    if (show)
      SetHandsMaterial(player, BloodyHands.MATERIAL_TYPE_BLOODY);
    else
      SetHandsMaterial(player, BloodyHands.MATERIAL_TYPE_NORMAL);
  }
 
  protected void SetHandsMaterial(PlayerBase player, int material_type)
  {
    string player_class = player.GetPlayerClass();
    int slot_id;
    EntityAI eai;
 
    if (m_BloodyHands.Contains(player_class))
    {
      slot_id = InventorySlots.GetSlotIdFromString("Gloves");
      eai = player.GetInventory().FindPlaceholderForSlot(slot_id);
 
      if (eai)
        eai.SetObjectMaterial(0, m_BloodyHands.Get(player_class).GetMaterial(material_type));
    }
    else
    {
      //Print("Error! Player class <" + player_class + "> does not contain valid configuration for bloody hands!");
    }
  }
 
  bool CanMakeHandsBloody(PlayerBase player)
  {
    return !player.FindAttachmentBySlotName("Gloves"));
  }
 
  //-----------------------------
  // Blood type in HUD
  //-----------------------------
 
  void UpdateBloodTypeVisibility(PlayerBase player, bool show)
  {
    player.SetBloodTypeVisible(show);
 
    if (player.m_Hud)
      player.m_Hud.UpdateBloodName();
  }
 
  void UpdateBloodType(PlayerBase player, int blood_type)
  {
    player.SetBloodType(blood_type);
  }
 
  void SynchShowBloodTypeVisual(PlayerBase player, bool show)
  {
    UpdateBloodTypeVisibility(player, show);
  }
 
  void SynchShowBloodType(PlayerBase player, int blood_type)
  {
    UpdateBloodType(player, blood_type);
  }
 
  //-----------------------------
  // Getters for other systems
  //-----------------------------
 
  string GetCurrentHeadTexture(PlayerBase player)
  {
    if (m_PlayerCurrentLevel.Contains(player))
    {
      LifespanLevel current_level = m_PlayerCurrentLevel.Get(player);
      return current_level.GetTextureName();
    }
    return "";
  }
 
  string GetCurrentHeadMaterial(PlayerBase player)
  {
    if (m_PlayerCurrentLevel.Contains(player))
    {
      LifespanLevel current_level = m_PlayerCurrentLevel.Get(player);
      return current_level.GetMaterialName();
    }
    return "";
  }
}