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