plugindevelopersync.c

Go to the documentation of this file.

enum PDS_SYSTEMS
{
 STATS = 1,
 LEVELS = 2,
 MODS = 4,
 AGENTS = 8,
 STOMACH = 16,
 MODS_DETAILED = 32,
 TEMPERATURE = 64,
}
 
 
class RegisterPlayerData
{
 int m_Bitmask;
 int m_DetailedModifierIndex;
 
 void RegisterPlayerData()
 {
 m_Bitmask = 0;
 m_DetailedModifierIndex = 0;
 }
}
 
class PluginDeveloperSync extends PluginBase
{
 int m_DetailedInfoRequested = 0;
 ref Timer m_UpdateTimer;
 ref map<PlayerBase, ref RegisterPlayerData> m_RegisteredPlayers;
 
 ref array<ref SyncedValue> m_PlayerStatsSynced;
 ref array<ref Param> m_PlayerStomachSynced;
 ref array<ref SyncedValueLevel> m_PlayerLevelsSynced;
 ref array<ref SyncedValueModifier> m_PlayerModsSynced;
 string m_PlayerModsDetailedSynced;
 string m_EnvironmentDebugMessage;
 ref array<ref SyncedValueAgent> m_PlayerAgentsSynced;
 
 bool m_StatsUpdateStatus;
 bool m_LevelsUpdateStatus;
 bool m_ModsUpdateStatus;
 bool m_AgentsUpdateStatus;
 bool m_StomachUpdateStatus;
 
 void PluginDeveloperSync()
 {
 m_RegisteredPlayers = new map<PlayerBase, ref RegisterPlayerData>;
 m_PlayerStatsSynced = new array<ref SyncedValue>;
 m_PlayerLevelsSynced = new array<ref SyncedValueLevel>;
 m_PlayerModsSynced = new array<ref SyncedValueModifier>;
 m_PlayerAgentsSynced = new array<ref SyncedValueAgent>;
 m_PlayerStomachSynced = new array<ref Param>;
 
 m_StatsUpdateStatus = false;
 m_LevelsUpdateStatus = false;
 m_ModsUpdateStatus = false;
 m_AgentsUpdateStatus = false;
 m_StomachUpdateStatus = false;
 }
 
 //================================================================
 // Init / Update
 //================================================================
 override void OnInit()
 {
 super.OnInit();
 
 if ( GetGame().IsServer() )
 {
 //create timer
 m_UpdateTimer = new Timer( CALL_CATEGORY_GAMEPLAY );
 }
 }
 
 
 void EnableUpdate( bool enable, int type, PlayerBase player )
 {
 //set update by type
 if ( !IsPlayerRegistered(player))
 RegisterPlayer( player );
 
 
 switch ( type )
 {
 case ERPCs.DEV_STATS_UPDATE: 
 {
 SetSystemInBitmask(player, PDS_SYSTEMS.STATS, enable);
 break; 
 }
 
 case ERPCs.DEV_LEVELS_UPDATE: 
 {
 SetSystemInBitmask(player, PDS_SYSTEMS.LEVELS, enable);
 break; 
 }
 
 case ERPCs.DEV_MODS_UPDATE: 
 {
 SetSystemInBitmask(player, PDS_SYSTEMS.MODS, enable);
 break; 
 }
 
 case ERPCs.DEV_AGENTS_UPDATE: 
 {
 SetSystemInBitmask(player, PDS_SYSTEMS.AGENTS, enable);
 break; 
 } 
 
 case ERPCs.DEV_STOMACH_UPDATE: 
 {
 SetSystemInBitmask(player, PDS_SYSTEMS.STOMACH, enable);
 break; 
 }
 case ERPCs.DEV_TEMP_UPDATE: 
 {
 SetSystemInBitmask(player, PDS_SYSTEMS.TEMPERATURE, enable);
 break; 
 }
 } 
 
 //remove players with empty mask
 for (int i = 0; i < m_RegisteredPlayers.Count(); i++)
 {
 if (m_RegisteredPlayers.GetElement(i).m_Bitmask == 0)
 {
 m_RegisteredPlayers.RemoveElement(i);
 i = 0;
 }
 }
 
 //start/stop the tick based on existence/absence of players registered
 if ( m_UpdateTimer )
 {
 if ( m_RegisteredPlayers.Count() == 0)
 {
 m_UpdateTimer.Stop();
 }
 else if (!m_UpdateTimer.IsRunning())
 {
 m_UpdateTimer.Run( 1, this, "Update", NULL, true );
 }
 }
 }
 
 
 void Update()
 {
 if ( !GetDayZGame().IsMultiplayer() || GetDayZGame().IsServer() )
 {
 for ( int i = 0; i < m_RegisteredPlayers.Count(); i++ )
 {
 PlayerBase player = m_RegisteredPlayers.GetKey( i );
 if ( !player || !player.IsAlive() )
 {
 m_RegisteredPlayers.RemoveElement(i);
 i--;
 }
 else
 {
 int bit_mask = m_RegisteredPlayers.Get( player ).m_Bitmask;
 
 if ((PDS_SYSTEMS.MODS & bit_mask) != 0 )
 {
 SendRPCMods( player);
 if ( PDS_SYSTEMS.MODS_DETAILED & bit_mask )
 SendRPCModsDetail( player); 
 }
 if ((PDS_SYSTEMS.LEVELS & bit_mask) != 0 )
 {
 SendRPCLevels( player ); 
 }
 
 if ((PDS_SYSTEMS.STATS & bit_mask) != 0 )
 {
 SendRPCStats( player );
 } 
 if ((PDS_SYSTEMS.STOMACH & bit_mask) != 0 )
 {
 SendRPCStomach( player );
 } 
 if ((PDS_SYSTEMS.AGENTS & bit_mask) != 0 )
 {
 SendRPCAgents( player );
 } 
 if ((PDS_SYSTEMS.TEMPERATURE & bit_mask) )
 {
 SendRPCTemp( player );
 }
 }
 }
 } 
 }
 
 //turns on/off a bit for a given system marking it active/inactive
 void SetSystemInBitmask( PlayerBase player, int system_bit, bool state)
 {
 if ( IsPlayerRegistered(player) )
 {
 int current_mask = m_RegisteredPlayers.Get(player).m_Bitmask;
 if (state)
 m_RegisteredPlayers.Get(player).m_Bitmask = current_mask | system_bit;
 else
 m_RegisteredPlayers.Get(player).m_Bitmask = current_mask & ~system_bit;
 }
 
 }
 
 //turns on/off a bit for a given system marking it active/inactive
 bool IsSetSystemInBitmask( PlayerBase player, int system_bit)
 {
 if ( IsPlayerRegistered(player) )
 {
 return (m_RegisteredPlayers.Get(player).m_Bitmask & system_bit);
 }
 return false;
 }
 
 
 
 
 //--- Register / Unregister player
 void RegisterPlayer( PlayerBase player )
 {
 if ( !IsPlayerRegistered( player ) ) 
 {
 m_RegisteredPlayers.Insert( player, new RegisterPlayerData );
 }
 }
 
 /*
 void UnregisterPlayer( PlayerBase player )
 {
 if ( IsPlayerRegistered( player ) ) 
 {
 m_RegisteredPlayers.Remove( player );
 }
 }
*/
 bool IsPlayerRegistered( PlayerBase player )
 {
 if ( m_RegisteredPlayers.Contains( player ))
 {
 return true;
 }
 
 return false;
 }
 
 //================================================================
 // RPC
 //================================================================ 
 void OnRPC( PlayerBase player, int rpc_type, ParamsReadContext ctx )
 {
 if ( !GetGame().IsDebug() )
 {
 return;
 }
 
 switch ( rpc_type )
 {
 case ERPCs.DEV_STATS_UPDATE:
 {
 EnableUpdate( GetRPCUpdateState( ctx ), ERPCs.DEV_STATS_UPDATE, player ); break;
 }
 
 case ERPCs.DEV_LEVELS_UPDATE:
 {
 EnableUpdate( GetRPCUpdateState( ctx ), ERPCs.DEV_LEVELS_UPDATE, player ); break;
 }
 
 case ERPCs.DEV_MODS_UPDATE:
 {
 EnableUpdate( GetRPCUpdateState( ctx ), ERPCs.DEV_MODS_UPDATE, player ); break;
 }
 
 case ERPCs.DEV_AGENTS_UPDATE:
 {
 EnableUpdate( GetRPCUpdateState( ctx ), ERPCs.DEV_AGENTS_UPDATE, player ); break;
 }
 
 case ERPCs.DEV_STOMACH_UPDATE:
 {
 EnableUpdate( GetRPCUpdateState( ctx ), ERPCs.DEV_STOMACH_UPDATE, player ); break;
 }
 
 case ERPCs.DEV_RPC_STATS_DATA:
 {
 OnRPCStats( ctx ); break;
 }
 
 case ERPCs.DEV_RPC_LEVELS_DATA:
 {
 OnRPCLevels( ctx ); break;
 }
 
 case ERPCs.DEV_RPC_MODS_DATA:
 {
 OnRPCMods( ctx ); break;
 }
 
 case ERPCs.DEV_RPC_MODS_DATA_DETAILED:
 {
 OnRPCModsDetailed( ctx ); break;
 }
 
 case ERPCs.DEV_RPC_AGENTS_DATA:
 {
 OnRPCAgents( ctx ); break;
 } 
 case ERPCs.DEV_RPC_STOMACH_DATA:
 {
 OnRPCStomach( ctx ); break;
 }
 
 case ERPCs.DEV_RPC_MODS_ACTIVATE:
 {
 ActivateModifier( GetRPCModifierID( ctx ), player ); break;
 }
 case ERPCs.DEV_RPC_MODS_DETAILED:
 {
 RequestDetailedInfo( GetRPCModifierID( ctx ), player ); break;
 }
 
 case ERPCs.DEV_RPC_MODS_DEACTIVATE:
 {
 DeactivateModifier( GetRPCModifierID( ctx ), player ); break;
 }
 
 case ERPCs.DEV_RPC_MODS_LOCK:
 {
 int id;
 bool lock;
 GetRPCModifierLock( ctx, id, lock );
 LockModifier( id, lock, player ); break;
 }
 
 case ERPCs.DEV_RPC_MODS_RESET:
 {
 player.GetModifiersManager().DeactivateAllModifiers();
 break;
 } 
 
 case ERPCs.DEV_RPC_STATS_RESET:
 {
 player.GetPlayerStats().ResetAllStats();
 break;
 }
 
 case ERPCs.DEV_RPC_STAT_SET:
 {
 OnRPCStatSet(ctx, player);
 break;
 }
 case ERPCs.DEV_TEMP_UPDATE:
 {
 OnRPCTemp(ctx, player);
 break;
 }
 }
 }
 
 //get update status from ctx data
 bool GetRPCUpdateState( ParamsReadContext ctx )
 {
 Param1<bool> p = new Param1<bool>( 0 );
 if ( ctx.Read( p ) )
 {
 return p.param1;
 }
 
 return false;
 }
 
 //get modifier id from ctx data
 int GetRPCModifierID( ParamsReadContext ctx )
 {
 Param1<int> p = new Param1<int>( 0 );
 if ( ctx.Read( p ) )
 {
 return p.param1;
 }
 
 return 0;
 }
 
 //get modifier lock state from lock ctx data
 void GetRPCModifierLock( ParamsReadContext ctx, out int id, out bool lock )
 {
 Param2<int, bool> p = new Param2<int, bool>( 0, false );
 if ( ctx.Read( p ) )
 {
 id = p.param1;
 lock = p.param2;
 }
 }
 
 //============================================
 // STATS
 //============================================ 
 //send player stats through RPC
 void SendRPCStats( PlayerBase player )
 {
 //write and send values
 if ( player )
 {
 array<ref Param> rpc_params = new array<ref Param>;
 
 //param count
 for ( int i = 0; i < player.m_PlayerStats.GetPCO().Get().Count(); i++ ) 
 {
 string label = player.m_PlayerStats.GetPCO().Get().Get( i ).GetLabel();
 float value = (float) player.m_PlayerStats.GetPCO().Get().Get( i ).Get();
 float value_norm = (float) player.m_PlayerStats.GetPCO().Get().Get( i ).GetNormalized();
 rpc_params.Insert( new Param3<string, float, float>( label, value, value_norm ) );
 }
 rpc_params.Insert(new Param3<string, float, float>( "(NaS)Immunity", player.GetImmunity(),0 ));
 rpc_params.Insert(new Param3<string, float, float>( "(NaS)BrokenLegs", player.m_BrokenLegState,0 ));
 
 rpc_params.InsertAt( new Param1<int>(rpc_params.Count() ), 0);// param count
 //send params
 GetDayZGame().RPC( player, ERPCs.DEV_RPC_STATS_DATA, rpc_params, true, player.GetIdentity() );
 }
 }
 
 //Display player stats
 void OnRPCStats( ParamsReadContext ctx )
 {
 //clear values
 m_PlayerStatsSynced.Clear();
 
 
 Param1<int> p_count = new Param1<int>(0);
 
 Param3<string, float, float> p = new Param3<string, float, float>( "", 0, 0 );
 
 //get param count
 int param_count = 0;
 if ( ctx.Read(p_count) )
 {
 param_count = p_count.param1;
 }
 
 //read values and set 
 for ( int i = 0; i < param_count; i++ )
 {
 ctx.Read(p);
 m_PlayerStatsSynced.Insert( new SyncedValue( p.param1, p.param2, false, p.param3 ) );
 }
 }
 
 //Update data on local
 void UpdateStatsLocal()
 {
 PlayerBase player = PlayerBase.Cast( GetDayZGame().GetPlayer() );
 
 //clear values
 m_PlayerStatsSynced.Clear();
 
 //set values
 for ( int i = 0; i < player.m_PlayerStats.GetPCO().Get().Count(); i++ ) 
 {
 string label = player.m_PlayerStats.GetPCO().Get().Get( i ).GetLabel();
 float value = player.m_PlayerStats.GetPCO().Get().Get( i ).Get();
 float value_norm = player.m_PlayerStats.GetPCO().Get().Get( i ).GetNormalized();
 m_PlayerStatsSynced.Insert( new SyncedValue( label, value, false, value_norm ) );
 }
 
 m_PlayerStatsSynced.Insert(new SyncedValue( "(NaS)Immunity", player.GetImmunity() , false, 0));
 m_PlayerStatsSynced.Insert(new SyncedValue( "(NaS) BrokenLegs", player.m_BrokenLegState, false, 0));
 }
 
 void OnRPCStatSet( ParamsReadContext ctx , PlayerBase player)
 {
 Param2<string, float> p = new Param2<string, float>( "", 0 );
 if ( ctx.Read(p) )
 {
 for ( int i = 0; i < player.m_PlayerStats.GetPCO().Get().Count(); i++ ) 
 {
 string label = player.m_PlayerStats.GetPCO().Get().Get( i ).GetLabel();
 if ( label == p.param1 )
 {
 player.m_PlayerStats.GetPCO().Get().Get( i).SetByFloatEx(p.param2);
 }
 
 } 
 }
 
 }
 
 //============================================
 // LEVELS
 //============================================ 
 //send player stats through RPC
 void SendRPCLevels( PlayerBase player )
 {
 //write and send values
 if ( player )
 {
 array<ref Param> rpc_params = new array<ref Param>;
 
 rpc_params.Insert(new Param3<string, float, float>( "Immunity: "+ typename.EnumToString(EStatLevels, player.GetImmunityLevel() ),player.GetImmunityLevel(), player.GetBordersImmunity()));
 rpc_params.Insert(new Param3<string, float, float>( "Blood: "+ typename.EnumToString(EStatLevels, player.GetStatLevelBlood()),player.GetStatLevelBlood(), player.GetStatBordersBlood()));
 rpc_params.Insert(new Param3<string, float, float>( "Health: "+ typename.EnumToString(EStatLevels, player.GetStatLevelHealth() ),player.GetStatLevelHealth(), player.GetStatBordersHealth()));
 rpc_params.Insert(new Param3<string, float, float>( "Energy: "+ typename.EnumToString(EStatLevels, player.GetStatLevelEnergy() ),player.GetStatLevelEnergy(), player.GetStatBordersEnergy()));
 rpc_params.Insert(new Param3<string, float, float>( "Water: "+ typename.EnumToString(EStatLevels, player.GetStatLevelWater() ),player.GetStatLevelWater(), player.GetStatBordersWater()));
 
 int param_count = rpc_params.Count();
 rpc_params.InsertAt( new Param3<string, float, float>( "PARAM_COUNT", param_count,0 ), 0);
 //send params
 GetDayZGame().RPC( player, ERPCs.DEV_RPC_LEVELS_DATA, rpc_params, true, player.GetIdentity() );
 }
 }
 
 //Display player stats
 void OnRPCLevels( ParamsReadContext ctx )
 {
 //clear values
 m_PlayerLevelsSynced.Clear();
 
 Param3<string, float, float> p3 = new Param3<string, float, float>( "", 0,0 );
 
 //get param count
 int param_count = 0;
 if ( ctx.Read(p3) )
 {
 param_count = p3.param2;
 }
 
 //read values and set 
 for ( int i = 0; i < param_count; i++ )
 {
 if ( ctx.Read(p3) )
 m_PlayerLevelsSynced.Insert( new SyncedValueLevel( p3.param1, p3.param2, p3.param3 ) );
 }
 }
 
 
 void SendRPCMods( PlayerBase player )
 {
 //write and send values
 if ( player )
 {
 array<ref Param> rpc_params = new array<ref Param>;
 
 //get modifiers
 ModifiersManager mods_manager = player.GetModifiersManager();
 
 //param count
 array<ref ModifierDebugObj> modifiers = new array<ref ModifierDebugObj>;
 mods_manager.DbgGetModifiers( modifiers );
 
 float param_count = ( float ) modifiers.Count();
 rpc_params.Insert( new Param1<int>( param_count ));
 
 //set modifiers
 for ( int i = 0; i < modifiers.Count(); ++i ) 
 {
 int id = modifiers.Get(i).GetID();
 string name = modifiers.Get(i).GetName();
 bool active = modifiers.Get(i).IsActive();
 bool locked = modifiers.Get(i).IsLocked();
 
 rpc_params.Insert( new Param4<int, string, bool, bool>( id, name, active, locked ) );
 }
 
 //send params
 GetDayZGame().RPC( player, ERPCs.DEV_RPC_MODS_DATA, rpc_params, true, player.GetIdentity() );
 }
 }
 
 //============================================
 // MODS
 //============================================ 
 //send player mods through RPC
 void SendRPCModsDetail( PlayerBase player )
 {
 //write and send values
 if ( player )
 {
 Param1<string> p1 = new Param1<string>("");
 ModifiersManager mods_manager = player.GetModifiersManager();
 int mod_id = m_RegisteredPlayers.Get(player).m_DetailedModifierIndex;
 p1.param1 = mods_manager.GetModifier(mod_id).GetDebugText();
 //send params
 if (p1.param1 != "")
 GetDayZGame().RPCSingleParam( player, ERPCs.DEV_RPC_MODS_DATA_DETAILED, p1, true, player.GetIdentity() );
 }
 }
 
 //Display player modifiers
 void OnRPCMods( ParamsReadContext ctx )
 {
 //clear values
 m_PlayerModsSynced.Clear();
 
 //ref Param3<string, float, bool> p = new Param3<string, float, bool>( "", 0, false );
 Param1<int> p1 = new Param1<int>(0);
 Param4<int, string, bool, bool> p4 = new Param4<int, string, bool, bool>( 0,"", false, false );
 //get param count
 int param_count = 0;
 if ( ctx.Read(p1) )
 {
 param_count = (int) p1.param1;
 }
 
 //read values and set 
 for ( int i = 0; i < param_count; i++ )
 {
 if (ctx.Read(p4))
 {
 m_PlayerModsSynced.Insert( new SyncedValueModifier( p4.param1, p4.param2, p4.param3, p4.param4 ) );
 }
 }
 }
 
 void OnRPCModsDetailed( ParamsReadContext ctx )
 {
 Param1<string> p1 = new Param1<string>("");
 
 //get param count
 if ( ctx.Read(p1) )
 {
 m_PlayerModsDetailedSynced = p1.param1;
 }
 }
 
 
 /*
 //Activates modifier with given ID
 void RequestDetailedInfo( int id, PlayerBase player = NULL )
 {
 int modifier_id = Math.AbsInt( id );
 if(id == m_DetailedInfoRequested)
 {
 m_DetailedInfoRequested = 0;//repeated request --> disable
 }
 else
 {
 m_DetailedInfoRequested = modifier_id;
 }
 } 
 */
 //Activates modifier with given ID
 void RequestDetailedInfo( int id, notnull PlayerBase player)
 {
 int modifier_id = Math.AbsInt( id );
 m_RegisteredPlayers.Get(player).m_DetailedModifierIndex = modifier_id;
 
 if (IsSetSystemInBitmask(player, PDS_SYSTEMS.MODS_DETAILED ))
 {
 SetSystemInBitmask(player, PDS_SYSTEMS.MODS_DETAILED, false);
 }
 else
 {
 SetSystemInBitmask(player, PDS_SYSTEMS.MODS_DETAILED, true);
 }
 }
 
 
 //Activates modifier with given ID
 void ActivateModifier( int id, PlayerBase player = NULL )
 {
 if ( !player )
 {
 player = PlayerBase.Cast( GetDayZGame().GetPlayer() );
 }
 ModifiersManager mods_manager = player.GetModifiersManager();
 mods_manager.ActivateModifier( Math.AbsInt( id ) );
 }
 
 //Activates modifier with given ID
 void DeactivateModifier( int id, PlayerBase player = NULL )
 {
 if ( !player )
 {
 player = PlayerBase.Cast( GetDayZGame().GetPlayer() );
 }
 ModifiersManager mods_manager = player.GetModifiersManager();
 mods_manager.DeactivateModifier( Math.AbsInt( id ) );
 }
 
 //Activates modifier with given ID
 void LockModifier( int id, bool lock, PlayerBase player = NULL )
 {
 if ( !player )
 {
 player = PlayerBase.Cast( GetDayZGame().GetPlayer() );
 }
 ModifiersManager mods_manager = player.GetModifiersManager();
 mods_manager.SetModifierLock( Math.AbsInt( id ), lock );
 }
 
 bool IsModifierLocked( int id, PlayerBase player = NULL )
 {
 if ( !player )
 {
 player = PlayerBase.Cast( GetDayZGame().GetPlayer() );
 }
 ModifiersManager mods_manager = player.GetModifiersManager(); 
 
 return mods_manager.GetModifierLock( Math.AbsInt( id ) );
 }
 
 //============================================
 // TEMPERATURE
 //============================================ 
 
 void SendRPCTemp( PlayerBase player )
 {
 if ( player )
 {
 CachedObjectsParams.PARAM1_STRING.param1 = player.m_Environment.GetDebugMessage();
 GetDayZGame().RPCSingleParam( player, ERPCs.DEV_TEMP_UPDATE, CachedObjectsParams.PARAM1_STRING, true, player.GetIdentity() );
 }
 }
 
 void OnRPCTemp( ParamsReadContext ctx , PlayerBase player)
 {
 if (GetGame().IsServer() && GetGame().IsMultiplayer())
 {
 EnableUpdate( GetRPCUpdateState( ctx ), ERPCs.DEV_TEMP_UPDATE, player );
 }
 else if (!GetGame().IsMultiplayer() || GetGame().IsClient())
 {
 if ( ctx.Read(CachedObjectsParams.PARAM1_STRING) )
 {
 m_EnvironmentDebugMessage = CachedObjectsParams.PARAM1_STRING.param1;
 }
 }
 
 }
 
 //============================================
 // AGENTS
 //============================================ 
 //send player mods through RPC
 void SendRPCAgents( PlayerBase player )
 {
 //write and send values
 if ( ( player && player.GetIdentity() && player.m_AgentPool != null ) || ( player && !GetGame().IsMultiplayer() && player.m_AgentPool != null ) )
 {
 
 //get agent pool data
 array<ref Param> agent_pool = new array<ref Param>;
 player.m_AgentPool.GetDebugObject( agent_pool );
 
 GetDayZGame().RPC( player, ERPCs.DEV_RPC_AGENTS_DATA, agent_pool, true, player.GetIdentity() );
 }
 }
 
 //Display player modifiers
 void OnRPCAgents( ParamsReadContext ctx )
 {
 //clear values
 m_PlayerAgentsSynced.Clear();
 
 Param3<string, string, int> p3 = new Param3<string, string, int>( "", "" ,0 );
 Param1<int> p1 = new Param1<int>(0);
 
 //get param count
 int param_count = 0;
 if ( ctx.Read(p1) )
 {
 param_count = p1.param1;
 }
 
 //read values and set 
 for ( int i = 0; i < param_count; i++ )
 {
 ctx.Read(p3);
 m_PlayerAgentsSynced.Insert( new SyncedValueAgent( p3.param1, p3.param2, p3.param3 ) );
 }
 }
 
 //============================================
 // STOMACH
 //============================================ 
 
 void SendRPCStomach( PlayerBase player )
 {
 //write and send values
 if ( player )
 { 
 array<ref Param> stomach = new array<ref Param>;
 int count = player.m_PlayerStomach.GetDebugObject( stomach );
 stomach.InsertAt(new Param1<int>(count), 0);
 
 GetDayZGame().RPC( player, ERPCs.DEV_RPC_STOMACH_DATA, stomach, true, player.GetIdentity() );
 }
 }
 
 
 void OnRPCStomach( ParamsReadContext ctx )
 {
 //clear values
 m_PlayerStomachSynced.Clear();
 
 Param1<int> p1 = new Param1<int>(0);
 int param_count = 0;
 if ( ctx.Read(p1) )
 {
 param_count = p1.param1;
 }
 
 if (param_count)
 {
 //invidividual stomach items
 for ( int i = 0; i < param_count; i++ )
 {
 Param4<int,int,int,float> p4 = new Param4<int,int,int,float>(0,0,0,0);
 ctx.Read(p4);
 m_PlayerStomachSynced.Insert(p4);
 }
 //volume
 Param1<float> p1b = new Param1<float>(0);
 ctx.Read(p1b);
 m_PlayerStomachSynced.Insert(p1b);
 }
 }
 
 //Update data on local
 /*
 void UpdateAgentsLocal()
 {
 PlayerBase player = PlayerBase.Cast( GetDayZGame().GetPlayer() );
 
 if ( player )
 {
 //clear values
 m_PlayerAgentsSynced.Clear();
 
 //get agent pool data
 array<ref Param> agent_pool = new array<ref Param>;
 player.m_AgentPool.GetDebugObject( agent_pool );
 
 //get agents count 
 Param1<int> p1 = Param1<int>.Cast( agent_pool.Get( 0 ) );
 int agents_count = p1.param1;
 
 //set synced data
 for ( int i = 0; i < agents_count; i++ ) 
 {
 string name = Param2<string,string>.Cast(agent_pool.Get(i+1)).param1;
 string count = Param2<string,string>.Cast(agent_pool.Get(i+1)).param2;
 m_PlayerAgentsSynced.Insert( new SyncedValueAgent( name, count, false ) );
 }
 }
 }
 */
 //================================================================
 // FOCUS
 //================================================================ 
 void CaptureFocus()
 {
 GetGame().GetInput().ChangeGameFocus( 1 );
 GetGame().GetUIManager().ShowUICursor( true );
 }
 
 void ReleaseFocus()
 {
 GetGame().GetInput().ChangeGameFocus( -1 );
 GetGame().GetUIManager().ShowUICursor( false );
 }
 
 void ToggleFocus()
 {
 if ( GetGame().GetInput().HasGameFocus() )
 {
 GetGame().GetInput().ChangeGameFocus( 1 );
 GetGame().GetUIManager().ShowUICursor( true );
 }
 else
 {
 GetGame().GetInput().ResetGameFocus();
 GetGame().GetUIManager().ShowUICursor( false );
 }
 }
}