Example #1
0
void CGameClient::Disconnect( const char *fmt, ... )
{
	va_list		argptr;
	char		reason[1024];

	if ( m_nSignonState == SIGNONSTATE_NONE )
		return;	// no recursion

	va_start (argptr,fmt);
	Q_vsnprintf (reason, sizeof( reason ), fmt,argptr);
	va_end (argptr);

	// notify other clients of player leaving the game
	// send the username and network id so we don't depend on the CBasePlayer pointer
	IGameEvent *event = g_GameEventManager.CreateEvent( "player_disconnect" );

	if ( event )
	{
		event->SetInt("userid", GetUserID() );
		event->SetString("reason", reason );
		event->SetString("name", GetClientName() );
		event->SetString("networkid", GetNetworkIDString() ); 
		g_GameEventManager.FireEvent( event );
	}

	m_Server->RemoveClientFromGame( this );

	CBaseClient::Disconnect( "%s", reason );
}
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTeamControlPoint::SendCapString( int iCapTeam, int iNumCappers, int *pCappingPlayers )
{
	if ( strlen( STRING(m_iszPrintName) ) <= 0 )
		return;

	IGameEvent *event = gameeventmanager->CreateEvent( "teamplay_point_captured" );
	if ( event )
	{
		event->SetInt( "cp", m_iPointIndex );
		event->SetString( "cpname", STRING(m_iszPrintName) );
		event->SetInt( "team", iCapTeam );

		char cappers[9];	// pCappingPlayers is max length 8
		int i;
		for( i=0;i<iNumCappers;i++ )
		{
			cappers[i] = (char)pCappingPlayers[i];
		}

		cappers[i] = '\0';

		// pCappingPlayers is a null terminated list of player indices
		event->SetString( "cappers", cappers );
		event->SetInt( "priority", 9 );

		gameeventmanager->FireEvent( event );
	}
}
Example #3
0
void CGameRules::ClientSettingsChanged( CBasePlayer *pPlayer )
{
	const char *pszName = engine->GetClientConVarValue( pPlayer->entindex(), "name" );

	const char *pszOldName = pPlayer->GetPlayerName();

	// msg everyone if someone changes their name,  and it isn't the first time (changing no name to current name)
	// Note, not using FStrEq so that this is case sensitive
	if ( pszOldName[0] != 0 && Q_strcmp( pszOldName, pszName ) )
	{
		char text[256];
		Q_snprintf( text,sizeof(text), "%s changed name to %s\n", pszOldName, pszName );

		UTIL_ClientPrintAll( HUD_PRINTTALK, text );

		IGameEvent * event = gameeventmanager->CreateEvent( "player_changename" );
		if ( event )
		{
			event->SetInt( "userid", pPlayer->GetUserID() );
			event->SetString( "oldname", pszOldName );
			event->SetString( "newname", pszName );
			gameeventmanager->FireEvent( event );
		}
		
		pPlayer->SetPlayerName( pszName );
	}
} 
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTeamControlPoint::CaptureStart( int iCapTeam, int iNumCappingPlayers, int *pCappingPlayers )
{
	int iNumCappers = iNumCappingPlayers;

	IGameEvent *event = gameeventmanager->CreateEvent( "teamplay_point_startcapture" );
	if ( event )
	{
		event->SetInt( "cp", m_iPointIndex );
		event->SetString( "cpname", STRING( m_iszPrintName ) );
		event->SetInt( "team", m_iTeam );
		event->SetInt( "capteam", iCapTeam );

		// safety check
		if ( iNumCappers > 8 )
		{
			iNumCappers = 8;
		}

		char cappers[9];	// pCappingPlayers should be max length 8
		int i;
		for( i = 0 ; i < iNumCappers ; i++ )
		{
			cappers[i] = (char)pCappingPlayers[i];
		}

		cappers[i] = '\0';

		// pCappingPlayers is a null terminated list of player indices
		event->SetString( "cappers", cappers );
		event->SetInt( "priority", 7 );

		gameeventmanager->FireEvent( event );
	}
}
Example #5
0
// Ability to alter the objective:
//   DOBJ_ACTION_OPEN: Opens the objective door and starts spawning creeps (if round has started)
//   DOBJ_ACTION_CLOSE: Closes the objective door and stops spawning creeps (if this is the last door, the round will end)
int DotaObjective::TakeAction( int dobjAction ) { // Issue #24: AMP - 2013-10-04 - Lane manipulation
	if (dobjAction & DOBJ_ACTION_CLOSE) {
		PropSetAnim( "Close" );

		// Issue #35: JMS - 2013-10-27 - fire event to clients
		IGameEvent *pEvent = gameeventmanager->CreateEvent( "objectivegate_close" );
		if ( pEvent )
		{
			pEvent->SetString( "lane", GetLane() );
			pEvent->SetInt( "team", this->GetTeamNumber() );
			gameeventmanager->FireEvent( pEvent );
		}

		m_bMet = true;			
				
		//turn off the maker
		CreepMaker * maker = (CreepMaker*)gEntList.FindEntityByName( NULL, m_creepMakerName );
		if( maker )
			maker->m_enabled = false;

		//see if I'm the last one, if so, game over
		bool foundOne = false;
		for ( CBaseEntity *pEntity = gEntList.FirstEnt(); pEntity != NULL; pEntity = gEntList.NextEnt(pEntity) )
		{
			DotaObjective * obj = dynamic_cast<DotaObjective*>( pEntity );
			if ( obj && obj->GetTeamNumber() == this->GetTeamNumber() && !obj->m_bMet )
				foundOne = true;
		}
		if ( !foundOne )
		{
			CHL2MPRules *rules = (CHL2MPRules*)g_pGameRules;
			if ( rules && !rules->IsIntermission() )
			{
				rules->EndMultiplayerGame();
			}
		}
		return true;
	} else if (dobjAction & DOBJ_ACTION_OPEN) {

		// Issue #35: JMS - 2013-10-27 - fire event to clients
		IGameEvent *pEvent = gameeventmanager->CreateEvent( "objectivegate_open" );
		if ( pEvent )
		{
			pEvent->SetString( "lane", GetLane() );
			pEvent->SetInt( "team", this->GetTeamNumber() );
			gameeventmanager->FireEvent( pEvent );
		}

		m_timesHit = 0;
		m_bMet = false;
		CreepMaker * maker = (CreepMaker*)gEntList.FindEntityByName( NULL, m_creepMakerName );
		maker->m_enabled = true;
		PropSetAnim( "Open" );
		return true;
	}
	return false;
}
Example #6
0
/**
 * @brief Called when a client is authorized.
 *
 * @param client		Index of the client.
 * @param authstring	His SteamID.
 */	
void Left4Downtown::OnClientAuthorized(int client, const char *authstring)
{
	/* 
		Credits to Scott "DS" Ehlert from the SourceMod Dev Team for providing me with
		this super-easy method of selective event broadcasting. If it wasn't for him,
		I'd be stuck with a bunch of nasty code -- i.e. my initial idea of a NET_SendPacket
		vcall(bitbuffers, serializing events, casting IPs to netadr_t etc.)
		/blog
	*/
	
	if (!g_AddonsEclipse.GetBool())
	{
		L4D_DEBUG_LOG("l4d2_addons_eclipse set to 0, skipping function");
		return;
	}
	
	IGamePlayer *pPlayer = playerhelpers->GetGamePlayer(client);
	if (pPlayer->IsFakeClient())
	{
		L4D_DEBUG_LOG("Fake client %d connected, ignoring...", client);
		return;
	}
	
	cell_t result = Pl_Continue;
	if (g_pFwdOnAddonsEclipseUpdate)
	{
		g_pFwdOnAddonsEclipseUpdate->PushCell(client);
		g_pFwdOnAddonsEclipseUpdate->Execute(&result);
		
		if(result == Pl_Handled)
		{
			L4D_DEBUG_LOG("L4D2_OnAddonsEclipseUpdate(%d) will be skipped", client);
			return;
		}
		L4D_DEBUG_LOG("L4D2_OnAddonsEclipseUpdate(%d) has been sent out...", client);
	}
	
	// Getting the client event listener
	INetChannel *pNetChan = static_cast<INetChannel *>(engine->GetPlayerNetInfo(client));
	IClient *pClient = static_cast<IClient *>(pNetChan->GetMsgHandler());
	unsigned char *pBaseClient = reinterpret_cast<unsigned char *>(pClient) - 4;
	IGameEventListener2 *pClientListener = reinterpret_cast<IGameEventListener2 *>(pBaseClient);

	// Firing our event; it will tell the client to unload his addons
	IGameEvent *pEvent = gameeventmanager->CreateEvent("server_spawn");
	if (pEvent)
	{
		pEvent->SetString("address", "159.253.143.194:0");
        pEvent->SetString("mapname", STRING(gpGlobals->mapname));
		pClientListener->FireGameEvent(pEvent);
		
		L4D_DEBUG_LOG("Fired event for client %d", client);
	}

	// When done with event, must destroy it manually
	gameeventmanager->FreeEvent(pEvent);  
}
//=========================================================
// ClientUserInfoChanged
//=========================================================
void CTeamplayRules::ClientSettingsChanged( CBasePlayer *pPlayer )
{
	/* TODO: handle skin, model & team changes 

  	char text[1024];

	// skin/color/model changes
	int iTeam = Q_atoi( engine->GetClientConVarValue( pPlayer->entindex(), "cl_team" ) );
	int iClass = Q_atoi( engine->GetClientConVarValue( pPlayer->entindex(), "cl_class" ) );

	if ( defaultteam.GetBool() )
	{
		// int clientIndex = pPlayer->entindex();

		// engine->SetClientKeyValue( clientIndex, "model", pPlayer->TeamName() );
		// engine->SetClientKeyValue( clientIndex, "team", pPlayer->TeamName() );
		UTIL_SayText( "Not allowed to change teams in this game!\n", pPlayer );
		return;
	}

	if ( defaultteam.GetFloat() || !IsValidTeam( mdls ) )
	{
		// int clientIndex = pPlayer->entindex();

		// engine->SetClientKeyValue( clientIndex, "model", pPlayer->TeamName() );
		Q_snprintf( text,sizeof(text), "Can't change team to \'%s\'\n", mdls );
		UTIL_SayText( text, pPlayer );
		Q_snprintf( text,sizeof(text), "Server limits teams to \'%s\'\n", m_szTeamList );
		UTIL_SayText( text, pPlayer );
		return;
	}

	ChangePlayerTeam( pPlayer, mdls, true, true );
	// recound stuff
	RecountTeams(); */

	const char *pszName = engine->GetClientConVarValue( pPlayer->entindex(), "name" );

	const char *pszOldName = pPlayer->GetPlayerName();

	// msg everyone if someone changes their name,  and it isn't the first time (changing no name to current name)
	// Note, not using FStrEq so that this is case sensitive
	if ( pszOldName[0] != 0 && Q_strcmp( pszOldName, pszName ) )
	{
		IGameEvent * event = gameeventmanager->CreateEvent( "player_changename" );
		if ( event )
		{
			event->SetInt( "userid", pPlayer->GetUserID() );
			event->SetString( "oldname", pszOldName );
			event->SetString( "newname", pszName );
			gameeventmanager->FireEvent( event );
		}
		
		pPlayer->SetPlayerName( pszName );
	}
}
Example #8
0
static void NotifyConVar(ConVar *pConVar) {
	IGameEvent *pEvent = g_Interfaces.GameEventManagerInstance->CreateEvent("server_cvar");
	
	pEvent->SetString("cvarname", pConVar->GetName());
	
	if (IsFlagSet(pConVar, FCVAR_PROTECTED)) {
		pEvent->SetString("cvarvalue", "***PROTECTED***");
	}
	else {
		pEvent->SetString("cvarvalue", pConVar->GetString());
	}

	g_Interfaces.GameEventManagerInstance->FireEvent(pEvent);
}
Example #9
0
//-----------------------------------------------------------------------------
// Purpose: Displays a hint message to the player
// Input  : *pMessage -
//-----------------------------------------------------------------------------
void CHintSystem::HintMessage( const char *pMessage )
{
    Assert( m_pPlayer );

#ifdef GAME_DLL
    // On the server, we send it down to the queue who sends it to the client
    if ( !m_pPlayer->IsNetClient() || !m_pHintMessageQueue )
        return;

    if ( !m_bShowHints )
        return;

    m_pHintMessageQueue->AddMessage( pMessage );
#else
    // On the client, we just send it straight to the hint hud element
    if ( cl_showhelp.GetBool() )
    {
        IGameEvent *event = gameeventmanager->CreateEvent( "player_hintmessage" );
        if ( event )
        {
            event->SetString( "hintmessage", pMessage );
            gameeventmanager->FireEventClientSide( event );
        }
    }
#endif
}
void CGameFortsInfoZone::HandleOtherTeam(CBasePlayer *pPlayer)
{
	if(pPlayer == NULL)
		return;

	// Si on a les infos, passer dans le trigger ne fait rien
	if(IsPlayerCarryingInfos(pPlayer))
		return;
	// Les places sont prises §
	if(AreInfosSlotsFilled(pPlayer->GetTeamNumber()))
		return;

	// Bah, on peut prendre maintenant non ?
	AddPlayerToInfosList(pPlayer);
	pPlayer->IncrementFragCount(2);
	pPlayer->EmitSound("Gameplay.Forts.StoleData");
	if(pPlayer->GetTeamNumber() == TEAM_PINK)
		pPlayer->m_nSkin = PLAYER_BONUS_NROSE;
	else
		pPlayer->m_nSkin = PLAYER_BONUS_NVERT;

	IGameEvent *event = gameeventmanager->CreateEvent( "player_death" );
	if( event )
	{
		event->SetInt("userid", 0 );
		event->SetInt("attacker", pPlayer->GetUserID() );
		event->SetString("weapon", "fortssteal" );
		gameeventmanager->FireEvent( event );
	}
}
Example #11
0
//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pVictim - 
//			*pKiller - 
//			*pInflictor - 
//-----------------------------------------------------------------------------
void CSDKGameRules::DeathNotice( CBasePlayer *pVictim, const CTakeDamageInfo &info )
{
	int killer_ID = 0;

	// Find the killer & the scorer
	CSDKPlayer *pSDKPlayerVictim = ToSDKPlayer( pVictim );
	CBaseEntity *pInflictor = info.GetInflictor();
	CBaseEntity *pKiller = info.GetAttacker();
	CBasePlayer *pScorer = GetDeathScorer( pKiller, pInflictor, pVictim );
//	CSDKPlayer *pAssister = ToSDKPlayer( GetAssister( pVictim, pScorer, pInflictor ) );

	// Work out what killed the player, and send a message to all clients about it
	int iWeaponID;
	const char *killer_weapon_name = GetKillingWeaponName( info, pSDKPlayerVictim, &iWeaponID );

	if ( pScorer )	// Is the killer a client?
	{
		killer_ID = pScorer->GetUserID();
	}

	IGameEvent * event = gameeventmanager->CreateEvent( "player_death" );

	if ( event )
	{
		event->SetInt( "userid", pVictim->GetUserID() );
		event->SetInt( "attacker", killer_ID );
//		event->SetInt( "assister", pAssister ? pAssister->GetUserID() : -1 );
		event->SetString( "weapon", killer_weapon_name );
		event->SetInt( "weaponid", iWeaponID );
		event->SetInt( "damagebits", info.GetDamageType() );
		event->SetInt( "customkill", info.GetDamageCustom() );
		event->SetInt( "priority", 7 );	// HLTV event priority, not transmitted
		gameeventmanager->FireEvent( event );
	}		
}
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTeamControlPoint::CaptureStart( int iCapTeam, int iNumCappingPlayers, int *pCappingPlayers )
{
	int iNumCappers = iNumCappingPlayers;

	float flLastOwnershipChangeTime = -1.f;
	CBaseEntity *pEnt =	gEntList.FindEntityByClassname( NULL, GetControlPointMasterName() );
	while( pEnt )
	{
		CTeamControlPointMaster *pMaster = dynamic_cast<CTeamControlPointMaster *>( pEnt );
		if ( pMaster && pMaster->IsActive() )
		{
			flLastOwnershipChangeTime = pMaster->GetLastOwnershipChangeTime();
		}
		pEnt = gEntList.FindEntityByClassname( pEnt, GetControlPointMasterName() );
	}

	IGameEvent *event = gameeventmanager->CreateEvent( "teamplay_point_startcapture" );
	if ( event )
	{
		event->SetInt( "cp", m_iPointIndex );
		event->SetString( "cpname", STRING( m_iszPrintName ) );
		event->SetInt( "team", m_iTeam );
		event->SetInt( "capteam", iCapTeam );
		event->SetFloat( "captime", gpGlobals->curtime - flLastOwnershipChangeTime );

		// safety check
		if ( iNumCappers > 8 )
		{
			iNumCappers = 8;
		}

		char cappers[9];	// pCappingPlayers should be max length 8
		int i;
		for( i = 0 ; i < iNumCappers ; i++ )
		{
			cappers[i] = (char)pCappingPlayers[i];
		}

		cappers[i] = '\0';

		// pCappingPlayers is a null terminated list of player indices
		event->SetString( "cappers", cappers );
		event->SetInt( "priority", 7 );

		gameeventmanager->FireEvent( event );
	}
}
//---------------------------------------------------------------------------------
// Purpose: Player has said something we only want to ignore it x times
//---------------------------------------------------------------------------------
bool		ManiChatTriggers::ProcessIgnoreX
(
 player_t *player_ptr, 
 chat_trigger_t *chat_trigger_ptr,
 const	char *chat_string, 
 bool teamonly, 
 bool from_event
 )
{
	// This came from an event so just return true
	if (from_event) return true;

	// Check if we should let this one through or not based on this trigger count
	if (chat_trigger_ptr->ignore_count > 0)
	{
		if (chat_trigger_ptr->current_count == chat_trigger_ptr->ignore_count)
		{
			chat_trigger_ptr->current_count = 0;
			return true;
		}
	}

	chat_trigger_ptr->current_count ++;

	// Get CTeam pointer so we can use the proper team name in the log message
	// This will probably blow up on some mod when the CTeam header is changed :/
	// Yup this blows up on hl2mp so I've switched to using the gametypes.txt file
	// instead.

	if (!gpManiGameType->IsValidActiveTeam(player_ptr->team)) return false;

	char *team_name = gpManiGameType->GetTeamLogName(player_ptr->team);

	// Just log the chat in format HLstatsX can recognise

	if ( teamonly )
	{
		UTILLogPrintf( "\"%s<%i><%s><%s>\" say_team \"%s\"\n", player_ptr->name, player_ptr->user_id, player_ptr->steam_id, team_name , chat_string );
	}
	else
	{
		UTILLogPrintf( "\"%s<%i><%s><%s>\" say \"%s\"\n", player_ptr->name, player_ptr->user_id, player_ptr->steam_id, team_name, chat_string );
	}

	// Fire the event so other plugins can see it
	IGameEvent * event = gameeventmanager->CreateEvent( "player_say" );
	if ( event )	// will be null if there are no listeners!
	{
		event->SetInt("userid", player_ptr->user_id );
		event->SetString("text", chat_string );
		event->SetInt("priority", 1 );	// HLTV event priority, not transmitted
		gameeventmanager->FireEvent( event );
	}

	return false;
}
Example #14
0
void CGameRules::ClientSettingsChanged( CBasePlayer *pPlayer )
{
	const char *pszName = engine->GetClientConVarValue( pPlayer->entindex(), "name" );

	const char *pszOldName = pPlayer->GetPlayerName();

	// msg everyone if someone changes their name,  and it isn't the first time (changing no name to current name)
	// Note, not using FStrEq so that this is case sensitive
	if ( pszOldName[0] != 0 && Q_strcmp( pszOldName, pszName ) )
	{
		char text[256];
		Q_snprintf( text,sizeof(text), "%s changed name to %s\n", pszOldName, pszName );

		UTIL_ClientPrintAll( HUD_PRINTTALK, text );

		IGameEvent * event = gameeventmanager->CreateEvent( "player_changename" );
		if ( event )
		{
			event->SetInt( "userid", pPlayer->GetUserID() );
			event->SetString( "oldname", pszOldName );
			event->SetString( "newname", pszName );
			gameeventmanager->FireEvent( event );
		}
		
		pPlayer->SetPlayerName( pszName );
	}

	const char *pszFov = engine->GetClientConVarValue( pPlayer->entindex(), "fov_desired" );
	if ( pszFov )
	{
		int iFov = atoi(pszFov);
		iFov = clamp( iFov, 75, 90 );
		pPlayer->SetDefaultFOV( iFov );
	}

	// NVNT see if this user is still or has began using a haptic device
	const char *pszHH = engine->GetClientConVarValue( pPlayer->entindex(), "hap_HasDevice" );
	if( pszHH )
	{
		int iHH = atoi( pszHH );
		pPlayer->SetHaptics( iHH != 0 );
	}
}
Example #15
0
//---------------------------------------------------------
// Callback for the visibility monitor.
//---------------------------------------------------------
bool CASW_Ammo::VismonCallback( CBaseEntity *pPickup, CBasePlayer *pViewingPlayer )
{
	CASW_Ammo *pPickupPtr = dynamic_cast < CASW_Ammo* >( pPickup );

	if ( !pPickupPtr )
		return true;

	IGameEvent * event = gameeventmanager->CreateEvent( "entity_visible" );
	if ( event )
	{
		event->SetInt( "userid", pViewingPlayer->GetUserID() );
		event->SetInt( "subject", pPickupPtr->entindex() );
		event->SetString( "classname", pPickupPtr->GetClassname() );
		event->SetString( "entityname", STRING( pPickupPtr->GetEntityName() ) );
		gameeventmanager->FireEvent( event );
	}

	return false;
}
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTeamControlPoint::InternalSetLocked( bool bLocked )
{
	if ( !bLocked && m_bLocked )
	{
		// unlocked this point
		IGameEvent *event = gameeventmanager->CreateEvent( "teamplay_point_unlocked" );
		if ( event )
		{
			event->SetInt( "cp", m_iPointIndex );
			event->SetString( "cpname", STRING( m_iszPrintName ) );
			event->SetInt( "team", m_iTeam );
			gameeventmanager->FireEvent( event );
		}
	}
	else if ( bLocked && !m_bLocked )
	{
		// locked this point
		IGameEvent *event = gameeventmanager->CreateEvent( "teamplay_point_locked" );
		if ( event )
		{
			event->SetInt( "cp", m_iPointIndex );
			event->SetString( "cpname", STRING( m_iszPrintName ) );
			event->SetInt( "team", m_iTeam );
			gameeventmanager->FireEvent( event );
		}
	}

	m_bLocked = bLocked;

	if ( ObjectiveResource() && GetPointIndex() < ObjectiveResource()->GetNumControlPoints() )
	{
		ObjectiveResource()->SetCPLocked( GetPointIndex(), m_bLocked );
		ObjectiveResource()->SetCPUnlockTime( GetPointIndex(), 0.0f );
	}

	if ( !m_bLocked )
	{
		m_flUnlockTime = -1;
		m_OnUnlocked.FireOutput( this, this );
		SetContextThink( NULL, 0, CONTROL_POINT_UNLOCK_THINK );
	}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvInstructorHint::InputEndHint( inputdata_t &inputdata )
{
	static int s_InstructorServerHintEventStop = 0;
	IGameEvent * event = gameeventmanager->CreateEvent( "instructor_server_hint_stop", false, &s_InstructorServerHintEventStop );
	if ( event )
	{
		event->SetString( "hint_name", GetEntityName().ToCStr() );

		gameeventmanager->FireEvent( event );
	}
}
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTeamControlPoint::CaptureStart( void )
{
	IGameEvent *event = gameeventmanager->CreateEvent( "teamplay_point_startcapture" );
	if ( event )
	{
		event->SetInt( "cp", m_iPointIndex );
		event->SetString( "cpname", STRING(m_iszPrintName) );
		event->SetInt( "team", m_iTeam );

		// pCappingPlayers is a null terminated list of player indices

		char capper[8];

		Q_snprintf( capper, sizeof( capper ), "%d", entindex() );

		event->SetString( "cappers", capper );
		event->SetInt( "priority", 7 );

		gameeventmanager->FireEvent( event );
	}
}
Example #19
0
int DotaObjective::OnTakeDamage( const CTakeDamageInfo &inputInfo )
{
	if ( m_bMet )
		return 0;	

	if ( !(inputInfo.GetDamageType() & DMG_BULLET) )
	{
		CHL2MP_Player * playerAttacker = ToHL2MPPlayer( inputInfo.GetAttacker() );

		CreepMaker * maker = (CreepMaker*)gEntList.FindEntityByName( NULL, m_creepMakerName );
		if ( !maker )
			AssertMsg( false, "Objective can't find its creepmaker!\n" );
		
		CAI_BaseNPC * guardian = (CAI_BaseNPC*)gEntList.FindEntityByName( NULL, m_guardianName );	
		if( guardian && guardian->IsAlive() )
		{
			if( playerAttacker )
				ClientPrint( playerAttacker, HUD_PRINTTALK, UTIL_VarArgs("The guradian is alive in this lane, you can't hurt the gate.\n") );
		}
		else
		{
			m_timesHit++;
			m_timesHit = min(m_timesHit, OBJECTIVE_HEALTHI); // make sure times hit never goes above the maximum times an objective can be hit!

			CRecipientFilter user;
			user.AddRecipientsByTeam( this->GetTeam() );
			user.MakeReliable();
			char szText[200];
			Q_snprintf( szText, sizeof(szText), "Your ally gate is under attack from an enemy!" );
			UTIL_ClientPrintFilter( user, HUD_PRINTCENTER, szText );
			
			if( playerAttacker )
				ClientPrint( playerAttacker, HUD_PRINTTALK, UTIL_VarArgs("Gate has %i health left.\n", OBJECTIVE_HEALTHI - m_timesHit) );

			if (m_timesHit >= OBJECTIVE_HEALTHI)
			{
				TakeAction(DOBJ_ACTION_CLOSE);
			} else {
				IGameEvent *pEvent = gameeventmanager->CreateEvent( "objectivegate_attacked" );

				if ( pEvent )
				{
					pEvent->SetString( "lane", GetLane() );
					pEvent->SetInt( "team", this->GetTeamNumber() );
					pEvent->SetFloat( "health", (OBJECTIVE_HEALTHF - m_timesHit)/OBJECTIVE_HEALTHF );
					gameeventmanager->FireEvent( pEvent );
				}
			}
		}
	}

	return 0;
}
Example #20
0
void CGameClient::Connect(const char * szName, int nUserID, INetChannel *pNetChannel, bool bFakePlayer)
{
	CBaseClient::Connect( szName, nUserID, pNetChannel, bFakePlayer );

	edict = EDICT_NUM( m_nEntityIndex );
	
	// init PackInfo
	m_PackInfo.m_pClientEnt = edict;
	m_PackInfo.m_nPVSSize = sizeof( m_PackInfo.m_PVS );
				
	// fire global game event
	IGameEvent *event = g_GameEventManager.CreateEvent( "player_connect" );
	{
		event->SetInt( "userid", m_UserID );
		event->SetInt( "index", m_nClientSlot );
		event->SetString( "name", m_Name );
		event->SetString("networkid", GetNetworkIDString() ); 	
		event->SetString( "address", m_NetChannel?m_NetChannel->GetAddress():"none" );
		event->SetInt( "bot", m_bFakePlayer?1:0 );
		g_GameEventManager.FireEvent( event );
	}
}
Example #21
0
void CHL2MP_Player::UpdateAchievement(char *name, int amount)
{
	if(sv_cheats->GetInt() != 0)
		return;
	IGameEvent* pEvent = gameeventmanager->CreateEvent("player_update_achiev", true);
	if(pEvent)
	{
		pEvent->SetInt("userid", this->GetUserID());
		pEvent->SetString("name", name);
		pEvent->SetInt("amount", amount);
		gameeventmanager->FireEvent(pEvent);
	}
}
Example #22
0
void CASW_Jukebox::InputMusicStart( inputdata_t &inputdata )
{
	// Send each client the music start event
	IGameEvent * event = gameeventmanager->CreateEvent( "jukebox_play_random" );
	if ( event )
	{
		event->SetFloat( "fadeintime", m_fFadeInTime );
		event->SetString( "defaulttrack", m_szDefaultMusic );
		gameeventmanager->FireEvent( event );

		// Stop stim music if it's playing
		ASWGameRules()->m_fPreventStimMusicTime = 5.0f;
	}
}
void CGameDomCaptureZone::CaptureZoneTouch(CBaseEntity *pEntity)
{
	CBasePlayer *pPlayer = ToBasePlayer(pEntity);
	if(!pPlayer)
		return;
	if(pPlayer->m_lifeState != LIFE_ALIVE)
		return;
	if(m_iZoneID == -1)
		return;

	if(HL2MPRules()->m_iDomZones[m_iZoneID] == pPlayer->GetTeamNumber())
		return; // Déjà capturé par cette équipe

	if(gpGlobals->curtime < m_flLastCapture + 2.0f)
		return;
	m_flLastCapture = gpGlobals->curtime;
	HL2MPRules()->ResetDomTimer();
	EmitSound("Gameplay.Domambient");

	// Petite boucle moche pour reset toutes les zones
	CBaseEntity *pEntity2 = gEntList.FirstEnt();
	while( pEntity2 )
	{
		if(FClassnameIs(pEntity2, "game_dom_capturezone"))
		{
			CGameDomCaptureZone *pZone = dynamic_cast<CGameDomCaptureZone*>(pEntity2);
			pZone->ResetScoreTimer();
		}

		pEntity2 = gEntList.NextEnt( pEntity2 );
	}

	HL2MPRules()->m_iDomZones[m_iZoneID] = pPlayer->GetTeamNumber();
	if(pPlayer->GetTeamNumber() == TEAM_PINK)
		m_OnPinkCapture.FireOutput(pPlayer, this);
	else
		m_OnGreenCapture.FireOutput(pPlayer, this);

	DevMsg("Zone %d captured by team %d\n", m_iZoneID, pPlayer->GetTeamNumber());

	IGameEvent *event = gameeventmanager->CreateEvent( "player_death" );
	if( event )
	{
		event->SetInt("userid", 0 );
		event->SetInt("attacker", pPlayer->GetUserID() );
		event->SetString("weapon", "domcapture" );
		gameeventmanager->FireEvent( event );
	}
}
void C_ASW_Campaign_Save::OnDataChanged( DataUpdateType_t updateType )
{
	BaseClass::OnDataChanged( updateType );

	if ( Q_strcmp( m_szPreviousCampaignName, m_CampaignName ) )
	{
		Q_strncpy( m_szPreviousCampaignName, m_CampaignName, sizeof( m_szPreviousCampaignName ) );
		
		IGameEvent * event = gameeventmanager->CreateEvent( "campaign_changed" );
		if ( event )
		{
			event->SetString( "campaign", m_CampaignName );
			gameeventmanager->FireEventClientSide( event );
		}
	}
}
//-----------------------------------------------------------------------------
// Purpose: displays achievement progress notification in the HUD
//-----------------------------------------------------------------------------
void CBaseAchievement::ShowProgressNotification()
{
	if ( !ShouldShowProgressNotification() )
		return;

	IGameEvent *event = gameeventmanager->CreateEvent( "achievement_event" );
	if ( event )
	{
		event->SetString( "achievement_name", GetName() );
		event->SetInt( "cur_val", m_iCount );
		event->SetInt( "max_val", m_iGoal );
#ifdef GAME_DLL
		gameeventmanager->FireEvent( event );
#else
		gameeventmanager->FireEventClientSide( event );
#endif
	}	
}
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTeamControlPoint::CaptureBlocked( CBaseMultiplayerPlayer *pPlayer )
{
	if( strlen( STRING(m_iszPrintName) ) <= 0 )
		return;

	IGameEvent *event = gameeventmanager->CreateEvent( "teamplay_capture_blocked" );

	if ( event )
	{
		event->SetInt( "cp", m_iPointIndex );
		event->SetString( "cpname", STRING(m_iszPrintName) );
		event->SetInt( "blocker", pPlayer->entindex() );
		event->SetInt( "priority", 9 );

		gameeventmanager->FireEvent( event );
	}

	PlayerBlocked( pPlayer );
}
Example #27
0
void CHLTVDirector::StartDelayMessage()
{
	if ( m_nNextShotTick > gpGlobals->tickcount )
		return;

	// check the next 8 seconds for interrupts/important events
	m_nNextShotTick = gpGlobals->tickcount + TIME_TO_TICKS( DEF_SHOT_LENGTH );

	// game hasn't started yet, we are still in the broadcast delay hole
	IGameEvent *msg = gameeventmanager->CreateEvent( "hltv_message", true );

	if ( msg )
	{
		msg->SetString("text", "Please wait for broadcast to start ..." );

		// send spectators the HLTV director command as a game event
		m_pHLTVServer->BroadcastEvent( msg );
		gameeventmanager->FreeEvent( msg );
	}

	StartBestFixedCameraShot( true );
}
void CGameFortsInfoZone::HandleSameTeam(CBasePlayer *pPlayer)
{
	if(pPlayer == NULL)
		return;

	if(IsPlayerCarryingInfos(pPlayer))
	{
		g_Teams[pPlayer->GetTeamNumber()]->AddScore(1);
		pPlayer->IncrementFragCount(3);
		IGameEvent *event = gameeventmanager->CreateEvent( "player_death" );
		if( event )
		{
			event->SetInt("userid", 0 );
			event->SetInt("attacker", pPlayer->GetUserID() );
			event->SetString("weapon", "fortsscore" );
			gameeventmanager->FireEvent( event );
		}

		ResetAllInfos(true);

		if(pPlayer->GetTeamNumber() == TEAM_PINK)
			m_OnPinkScore.FireOutput(pPlayer, this);
		else
			m_OnGreenScore.FireOutput(pPlayer, this);

		CRecipientFilter allyFilter, ennemyFilter;
		allyFilter.AddRecipientsByTeam(pPlayer->GetTeam());
		ennemyFilter.AddRecipientsByTeam(g_Teams[pPlayer->GetTeamNumber()==TEAM_PINK?TEAM_GREEN:TEAM_PINK]);

		allyFilter.MakeReliable();
		ennemyFilter.MakeReliable();

		CBaseEntity::EmitSound(allyFilter, NULL, "Gameplay.Score.Friend");
		CBaseEntity::EmitSound(ennemyFilter, NULL, "Gameplay.Score.Ennemy");

	}
}
Example #29
0
//=========================================================
// Deathnotice.
//=========================================================
void CHL2MPRules::DeathNotice( CBasePlayer *pVictim, const CTakeDamageInfo &info )
{
#ifndef CLIENT_DLL
    // Work out what killed the player, and send a message to all clients about it
    const char *killer_weapon_name = "world";		// by default, the player is killed by the world
    int killer_ID = 0;

    // Find the killer & the scorer
    CBaseEntity *pInflictor = info.GetInflictor();
    CBaseEntity *pKiller = info.GetAttacker();
    CBasePlayer *pScorer = GetDeathScorer( pKiller, pInflictor );

    // Custom kill type?
    if ( info.GetDamageCustom() )
    {
        killer_weapon_name = GetDamageCustomString( info );
        if ( pScorer )
        {
            killer_ID = pScorer->GetUserID();
        }
    }
    else
    {
        // Is the killer a client?
        if ( pScorer )
        {
            killer_ID = pScorer->GetUserID();

            if ( pInflictor )
            {
                if ( pInflictor == pScorer )
                {
                    // If the inflictor is the killer,  then it must be their current weapon doing the damage
                    if ( pScorer->GetActiveWeapon() )
                    {
                        killer_weapon_name = pScorer->GetActiveWeapon()->GetClassname();
                    }
                }
                else
                {
                    killer_weapon_name = pInflictor->GetClassname();  // it's just that easy
                }
            }
        }
        else
        {
            killer_weapon_name = pInflictor->GetClassname();
        }

        // strip the NPC_* or weapon_* from the inflictor's classname
        if ( strncmp( killer_weapon_name, "weapon_", 7 ) == 0 )
        {
            killer_weapon_name += 7;
        }
        else if ( strncmp( killer_weapon_name, "npc_", 4 ) == 0 )
        {
            killer_weapon_name += 4;
        }
        else if ( strncmp( killer_weapon_name, "func_", 5 ) == 0 )
        {
            killer_weapon_name += 5;
        }
        else if ( strstr( killer_weapon_name, "physics" ) )
        {
            killer_weapon_name = "physics";
        }

        if ( strcmp( killer_weapon_name, "prop_combine_ball" ) == 0 )
        {
            killer_weapon_name = "combine_ball";
        }
        else if ( strcmp( killer_weapon_name, "grenade_ar2" ) == 0 )
        {
            killer_weapon_name = "smg1_grenade";
        }
        else if ( strcmp( killer_weapon_name, "satchel" ) == 0 || strcmp( killer_weapon_name, "tripmine" ) == 0)
        {
            killer_weapon_name = "slam";
        }


    }

    IGameEvent *event = gameeventmanager->CreateEvent( "player_death" );
    if( event )
    {
        event->SetInt("userid", pVictim->GetUserID() );
        event->SetInt("attacker", killer_ID );
        event->SetString("weapon", killer_weapon_name );
        event->SetInt( "priority", 7 );
        gameeventmanager->FireEvent( event );
    }
#endif

}
Example #30
0
void CHL2MPRules::RestartGame()
{
    // bounds check
    if ( mp_timelimit.GetInt() < 0 )
    {
        mp_timelimit.SetValue( 0 );
    }
    m_flGameStartTime = gpGlobals->curtime;
    if ( !IsFinite( m_flGameStartTime.Get() ) )
    {
        Warning( "Trying to set a NaN game start time\n" );
        m_flGameStartTime.GetForModify() = 0.0f;
    }

    CleanUpMap();

    // now respawn all players
    for (int i = 1; i <= gpGlobals->maxClients; i++ )
    {
        CHL2MP_Player *pPlayer = (CHL2MP_Player*) UTIL_PlayerByIndex( i );

        if ( !pPlayer )
            continue;

        if ( pPlayer->GetActiveWeapon() )
        {
            pPlayer->GetActiveWeapon()->Holster();
        }
        pPlayer->RemoveAllItems( true );
        respawn( pPlayer, false );
        pPlayer->Reset();
    }

    // Respawn entities (glass, doors, etc..)

    CTeam *pRebels = GetGlobalTeam( TEAM_REBELS );
    CTeam *pCombine = GetGlobalTeam( TEAM_COMBINE );

    if ( pRebels )
    {
        pRebels->SetScore( 0 );
    }

    if ( pCombine )
    {
        pCombine->SetScore( 0 );
    }

    m_flIntermissionEndTime = 0;
    m_flRestartGameTime = 0.0;
    m_bCompleteReset = false;

    IGameEvent * event = gameeventmanager->CreateEvent( "round_start" );
    if ( event )
    {
        event->SetInt("fraglimit", 0 );
        event->SetInt( "priority", 6 ); // HLTV event priority, not transmitted

        event->SetString("objective","DEATHMATCH");

        gameeventmanager->FireEvent( event );
    }
}