scripts/4_World/DayZ/Plugins/PluginBase/PluginDeveloperSync.c

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); //!!!!! Highly suspect
					}
					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 );
		}
	}
}