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