mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2024-11-22 04:12:09 +00:00
593 lines
No EOL
16 KiB
C++
593 lines
No EOL
16 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 BFG Edition GPL Source Code
|
|
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
|
|
|
|
Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Doom 3 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
#pragma hdrstop
|
|
#include "../idlib/precompiled.h"
|
|
#include "sys_voicechat.h"
|
|
|
|
/*
|
|
================================================
|
|
idVoiceChatMgr::Init
|
|
================================================
|
|
*/
|
|
void idVoiceChatMgr::Init( void * pXAudio2 ) {
|
|
}
|
|
|
|
/*
|
|
================================================
|
|
idVoiceChatMgr::Shutdown
|
|
================================================
|
|
*/
|
|
void idVoiceChatMgr::Shutdown() {
|
|
|
|
// We shouldn't have voice users if everything shutdown correctly
|
|
assert( talkers.Num() == 0 );
|
|
assert( remoteMachines.Num() == 0 );
|
|
}
|
|
|
|
/*
|
|
================================================
|
|
idVoiceChatMgr::RegisterTalker
|
|
================================================
|
|
*/
|
|
void idVoiceChatMgr::RegisterTalker( lobbyUser_t * user, int lobbyType, bool isLocal ) {
|
|
|
|
int i = FindTalkerIndex( user, lobbyType );
|
|
|
|
if ( !verify( i == -1 ) ) {
|
|
assert( talkers[i].lobbyType == lobbyType );
|
|
idLib::Printf( "RegisterTalker: Talker already registered.\n" );
|
|
return;
|
|
}
|
|
|
|
// Talker not found, need to create a new one
|
|
|
|
talker_t newTalker;
|
|
|
|
newTalker.user = user;
|
|
newTalker.isLocal = isLocal;
|
|
newTalker.lobbyType = lobbyType;
|
|
newTalker.registered = false;
|
|
newTalker.registeredSuccess = false;
|
|
newTalker.machineIndex = -1;
|
|
newTalker.groupIndex = 0; // 0 is default group
|
|
|
|
if ( !newTalker.IsLocal() ) { // If this is a remote talker, register his machine address
|
|
newTalker.machineIndex = AddMachine( user->address, lobbyType );
|
|
}
|
|
|
|
talkers.Append( newTalker );
|
|
|
|
// Since we added a new talker, make sure he is registered. UpdateRegisteredTalkers will catch all users, including this one.
|
|
UpdateRegisteredTalkers();
|
|
}
|
|
|
|
/*
|
|
================================================
|
|
idVoiceChatMgr::UnregisterTalker
|
|
================================================
|
|
*/
|
|
void idVoiceChatMgr::UnregisterTalker( lobbyUser_t * user, int lobbyType, bool isLocal ) {
|
|
int i = FindTalkerIndex( user, lobbyType );
|
|
|
|
if ( !verify( i != -1 ) ) {
|
|
idLib::Printf( "UnregisterTalker: Talker not found.\n" );
|
|
return;
|
|
}
|
|
|
|
talker_t & talker = talkers[i];
|
|
|
|
assert( talker.IsLocal() == ( talker.machineIndex == -1 ) );
|
|
assert( talker.IsLocal() == isLocal );
|
|
|
|
talker.lobbyType = -1; // Mark for removal
|
|
UpdateRegisteredTalkers(); // Make sure the user gets unregistered before we remove him/her
|
|
|
|
if ( talker.machineIndex != -1 ) {
|
|
// Unregister the talkers machine (unique address) handle
|
|
RemoveMachine( talker.machineIndex, lobbyType );
|
|
}
|
|
|
|
talkers.RemoveIndex( i ); // Finally, remove the talker
|
|
}
|
|
|
|
/*
|
|
================================================
|
|
idVoiceChatMgr::GetActiveLocalTalkers
|
|
================================================
|
|
*/
|
|
void idVoiceChatMgr::GetActiveLocalTalkers( idStaticList< int, MAX_PLAYERS > & localTalkers ) {
|
|
|
|
localTalkers.Clear();
|
|
|
|
for ( int i = 0; i < talkers.Num(); i++ ) {
|
|
|
|
if ( !talkers[i].IsLocal() ) {
|
|
continue;
|
|
}
|
|
|
|
if ( !talkers[i].registeredSuccess ) {
|
|
continue;
|
|
}
|
|
|
|
if ( !TalkerHasData( i ) ) {
|
|
continue;
|
|
}
|
|
|
|
localTalkers.Append( i );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================================================
|
|
idVoiceChatMgr::GetRecipientsForTalker
|
|
================================================
|
|
*/
|
|
void idVoiceChatMgr::GetRecipientsForTalker( int talkerIndex, idStaticList< const lobbyAddress_t *, MAX_PLAYERS > & recipients ) {
|
|
|
|
recipients.Clear();
|
|
|
|
talker_t & talker = talkers[talkerIndex];
|
|
|
|
if ( !talker.IsLocal() ) {
|
|
return;
|
|
}
|
|
|
|
sendFrame++;
|
|
|
|
for ( int i = 0; i < talkers.Num(); i++ ) {
|
|
if ( !talkers[i].registeredSuccess ) {
|
|
continue;
|
|
}
|
|
|
|
if ( talkers[i].IsLocal() ) {
|
|
continue; // Only want to send to remote talkers
|
|
}
|
|
|
|
if ( !CanSendVoiceTo( talkerIndex, i ) ) {
|
|
continue;
|
|
}
|
|
|
|
if ( !sendGlobal && talkers[i].groupIndex != activeGroupIndex ) {
|
|
continue;
|
|
}
|
|
|
|
assert( talkers[i].machineIndex >= 0 );
|
|
|
|
remoteMachine_t & remoteMachine = remoteMachines[ talkers[i].machineIndex ];
|
|
|
|
assert( remoteMachine.refCount > 0 );
|
|
assert( remoteMachine.lobbyType == activeLobbyType );
|
|
|
|
if ( remoteMachine.sendFrame == sendFrame ) {
|
|
continue; // Already on the recipient list
|
|
}
|
|
|
|
remoteMachine.sendFrame = sendFrame;
|
|
|
|
recipients.Append( &remoteMachine.address );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================================================
|
|
idVoiceChatMgr::SetTalkerGroup
|
|
================================================
|
|
*/
|
|
void idVoiceChatMgr::SetTalkerGroup( const lobbyUser_t * user, int lobbyType, int groupIndex ) {
|
|
int i = FindTalkerIndex( user, lobbyType );
|
|
|
|
if ( !verify( i != -1 ) ) {
|
|
idLib::Printf( "SetTalkerGroup: Talker not found.\n" );
|
|
return;
|
|
}
|
|
|
|
// Assign the new group index to this talker
|
|
talkers[i].groupIndex = groupIndex;
|
|
|
|
// Since the group index of this player changed, call UpdateRegisteredTalkers, which will register the
|
|
// appropriate users based on the current active group and session
|
|
UpdateRegisteredTalkers();
|
|
}
|
|
|
|
/*
|
|
================================================
|
|
idVoiceChatMgr::SetActiveLobby
|
|
================================================
|
|
*/
|
|
void idVoiceChatMgr::SetActiveLobby( int lobbyType ) {
|
|
if ( activeLobbyType != lobbyType ) {
|
|
activeLobbyType = lobbyType;
|
|
// When the active session changes, we need to immediately call UpdateRegisteredTalkers,
|
|
// which will make sure the appropriate talkers are registered depending on the activeSession.
|
|
UpdateRegisteredTalkers();
|
|
}
|
|
}
|
|
|
|
/*
|
|
================================================
|
|
idVoiceChatMgr::SetActiveChatGroup
|
|
================================================
|
|
*/
|
|
void idVoiceChatMgr::SetActiveChatGroup( int groupIndex ) {
|
|
if ( activeGroupIndex != groupIndex ) {
|
|
activeGroupIndex = groupIndex;
|
|
// When the active group changes, we need to immediately call UpdateRegisteredTalkers,
|
|
// which will make sure the appropriate talkers are registered depending on the activeGroup.
|
|
UpdateRegisteredTalkers();
|
|
}
|
|
}
|
|
|
|
/*
|
|
================================================
|
|
idVoiceChatMgr::FindTalkerByUserId
|
|
================================================
|
|
*/
|
|
int idVoiceChatMgr::FindTalkerByUserId( lobbyUserID_t userID, int lobbyType ) {
|
|
for ( int i = 0; i < talkers.Num(); i++ ) {
|
|
if ( talkers[i].user->lobbyUserID == userID && talkers[i].lobbyType == lobbyType ) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1; // Not found
|
|
}
|
|
|
|
/*
|
|
================================================
|
|
idVoiceChatMgr::GetLocalChatData
|
|
================================================
|
|
*/
|
|
bool idVoiceChatMgr::GetLocalChatData( int talkerIndex, byte * data, int & dataSize ) {
|
|
talker_t & talker = talkers[talkerIndex];
|
|
|
|
if ( !talker.IsLocal() ) {
|
|
idLib::Printf( "GetLocalChatData: Talker not local.\n" );
|
|
return false; // Talker is remote
|
|
}
|
|
|
|
if ( !talker.registeredSuccess ) {
|
|
return false;
|
|
}
|
|
|
|
idBitMsg voiceMsg;
|
|
voiceMsg.InitWrite( data, dataSize );
|
|
|
|
talker.user->lobbyUserID.WriteToMsg( voiceMsg );
|
|
voiceMsg.WriteByteAlign();
|
|
|
|
// Remove the size of the userid field from the available buffer size
|
|
int voiceDataSize = dataSize - voiceMsg.GetSize();
|
|
|
|
if ( !GetLocalChatDataInternal( talkerIndex, voiceMsg.GetWriteData() + voiceMsg.GetSize(), voiceDataSize ) ) {
|
|
dataSize = 0;
|
|
return false;
|
|
}
|
|
|
|
dataSize = voiceDataSize + voiceMsg.GetSize();
|
|
|
|
// Mark the user as talking
|
|
talker.talking = true;
|
|
talker.talkingTime = Sys_Milliseconds();
|
|
|
|
return dataSize > 0 ? true : false;
|
|
}
|
|
|
|
/*
|
|
================================================
|
|
idVoiceChatMgr::SubmitIncomingChatData
|
|
================================================
|
|
*/
|
|
void idVoiceChatMgr::SubmitIncomingChatData( const byte * data, int dataSize ) {
|
|
lobbyUserID_t lobbyUserID;
|
|
|
|
idBitMsg voiceMsg;
|
|
voiceMsg.InitRead( data, dataSize );
|
|
|
|
lobbyUserID.ReadFromMsg( voiceMsg );
|
|
voiceMsg.ReadByteAlign();
|
|
|
|
int i = FindTalkerByUserId( lobbyUserID, activeLobbyType );
|
|
|
|
if ( i == -1 ) {
|
|
idLib::Printf( "SubmitIncomingChatData: Talker not found in session.\n" );
|
|
return; // Talker is not in this session
|
|
}
|
|
|
|
talker_t & talker = talkers[i];
|
|
|
|
if ( talker.registeredSuccess && !talker.isMuted ) {
|
|
// Mark the user as talking
|
|
talker.talking = true;
|
|
talker.talkingTime = Sys_Milliseconds();
|
|
|
|
SubmitIncomingChatDataInternal( i, voiceMsg.GetReadData() + voiceMsg.GetReadCount(), voiceMsg.GetRemainingData() );
|
|
}
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idVoiceChatMgr::GetVoiceState
|
|
========================
|
|
*/
|
|
voiceState_t idVoiceChatMgr::GetVoiceState( const lobbyUser_t * user ) {
|
|
int i = FindTalkerByUserId( user->lobbyUserID, activeLobbyType );
|
|
|
|
if ( i == -1 ) {
|
|
return VOICECHAT_STATE_NO_MIC;
|
|
}
|
|
|
|
talker_t & talker = talkers[i];
|
|
|
|
if ( !talker.hasHeadset ) {
|
|
return VOICECHAT_STATE_NO_MIC;
|
|
}
|
|
|
|
if ( talker.isMuted ) {
|
|
return VOICECHAT_STATE_MUTED_LOCAL;
|
|
}
|
|
|
|
if ( talker.talking && Sys_Milliseconds() - talker.talkingTime > 200 ) {
|
|
talker.talking = false;
|
|
}
|
|
|
|
return talker.talking ? (talker.talkingGlobal ? VOICECHAT_STATE_TALKING_GLOBAL : VOICECHAT_STATE_TALKING ) : VOICECHAT_STATE_NOT_TALKING;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idVoiceChatMgr::CanSendVoiceTo
|
|
========================
|
|
*/
|
|
bool idVoiceChatMgr::CanSendVoiceTo( int talkerFromIndex, int talkerToIndex ) {
|
|
talker_t & talkerFrom = talkers[talkerFromIndex];
|
|
|
|
if ( !talkerFrom.IsLocal() ) {
|
|
return false;
|
|
}
|
|
|
|
talker_t & talkerTo = talkers[talkerToIndex];
|
|
|
|
if ( talkerTo.isMuted ) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idVoiceChatMgr::IsRestrictedByPrivleges
|
|
========================
|
|
*/
|
|
bool idVoiceChatMgr::IsRestrictedByPrivleges() {
|
|
return ( disableVoiceReasons & REASON_PRIVILEGES ) != 0;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idVoiceChatMgr::ToggleMuteLocal
|
|
========================
|
|
*/
|
|
void idVoiceChatMgr::ToggleMuteLocal( const lobbyUser_t * src, const lobbyUser_t * target ) {
|
|
int fromTalkerIndex = FindTalkerByUserId( src->lobbyUserID, activeLobbyType );
|
|
|
|
if ( fromTalkerIndex == -1 ) {
|
|
return;
|
|
}
|
|
|
|
int toTalkerIndex = FindTalkerByUserId( target->lobbyUserID, activeLobbyType );
|
|
|
|
if ( toTalkerIndex == -1 ) {
|
|
return;
|
|
}
|
|
|
|
talker_t & targetTalker = talkers[toTalkerIndex];
|
|
|
|
targetTalker.isMuted = targetTalker.isMuted ? false : true;
|
|
}
|
|
|
|
//================================================
|
|
// **** INTERNAL **********
|
|
//================================================
|
|
|
|
/*
|
|
================================================
|
|
idVoiceChatMgr::FindTalkerIndex
|
|
================================================
|
|
*/
|
|
int idVoiceChatMgr::FindTalkerIndex( const lobbyUser_t * user, int lobbyType ) {
|
|
for ( int i = 0; i < talkers.Num(); i++ ) {
|
|
if ( talkers[i].user == user && talkers[i].lobbyType == lobbyType ) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1; // Not found
|
|
}
|
|
|
|
/*
|
|
================================================
|
|
idVoiceChatMgr::FindMachine
|
|
================================================
|
|
*/
|
|
int idVoiceChatMgr::FindMachine( const lobbyAddress_t & address, int lobbyType ) {
|
|
for ( int i = 0; i < remoteMachines.Num(); i++ ) {
|
|
if ( remoteMachines[i].refCount == 0 ) {
|
|
continue;
|
|
}
|
|
if ( remoteMachines[i].lobbyType == lobbyType && remoteMachines[i].address.Compare( address ) ) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1; // Not found
|
|
}
|
|
|
|
/*
|
|
================================================
|
|
idVoiceChatMgr::AddMachine
|
|
================================================
|
|
*/
|
|
int idVoiceChatMgr::AddMachine( const lobbyAddress_t & address, int lobbyType ) {
|
|
|
|
int machineIndex = FindMachine( address, lobbyType );
|
|
|
|
if ( machineIndex != -1 ) {
|
|
// If we find an existing machine, just increase the ref
|
|
remoteMachines[machineIndex].refCount++;
|
|
return machineIndex;
|
|
}
|
|
|
|
//
|
|
// We didn't find a machine, we'll need to add one
|
|
//
|
|
|
|
// First, see if there is a free machine slot to take
|
|
int index = -1;
|
|
|
|
for ( int i = 0; i < remoteMachines.Num(); i++ ) {
|
|
if ( remoteMachines[i].refCount == 0 ) {
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
remoteMachine_t newMachine;
|
|
|
|
newMachine.lobbyType = lobbyType;
|
|
newMachine.address = address;
|
|
newMachine.refCount = 1;
|
|
newMachine.sendFrame = -1;
|
|
|
|
if ( index == -1 ) {
|
|
// If we didn't find a machine slot, then add one
|
|
index = remoteMachines.Append( newMachine );
|
|
} else {
|
|
// Re-use the machine slot we found
|
|
remoteMachines[index] = newMachine;
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
/*
|
|
================================================
|
|
idVoiceChatMgr::RemoveMachine
|
|
================================================
|
|
*/
|
|
void idVoiceChatMgr::RemoveMachine( int machineIndex, int lobbyType ) {
|
|
|
|
assert( remoteMachines[machineIndex].refCount > 0 );
|
|
assert( remoteMachines[machineIndex].lobbyType == lobbyType );
|
|
|
|
// Don't remove the machine. refCount will eventually reach 0, which will free up the slot to reclaim.
|
|
// We don't want to remove it, because that would invalidate users machineIndex handles into the array
|
|
remoteMachines[machineIndex].refCount--;
|
|
}
|
|
|
|
/*
|
|
================================================
|
|
idVoiceChatMgr::UpdateRegisteredTalkers
|
|
================================================
|
|
*/
|
|
void idVoiceChatMgr::UpdateRegisteredTalkers() {
|
|
for ( int pass = 0; pass < 2; pass++ ) {
|
|
for ( int i = 0; i < talkers.Num(); i++ ) {
|
|
talker_t & talker = talkers[i];
|
|
|
|
bool shouldBeRegistered = ( talker.lobbyType != -1 && disableVoiceReasons == 0 && talker.lobbyType == activeLobbyType );
|
|
|
|
if ( shouldBeRegistered && pass == 0 ) {
|
|
continue; // Only unregister on first pass to make room for when the second pass will possibly register new talkers
|
|
}
|
|
|
|
if ( talker.registered != shouldBeRegistered ) {
|
|
if ( !talker.registered ) {
|
|
talker.registeredSuccess = RegisterTalkerInternal( i );
|
|
} else if ( talker.registeredSuccess ) {
|
|
UnregisterTalkerInternal( i );
|
|
talker.registeredSuccess = false;
|
|
}
|
|
|
|
talker.registered = shouldBeRegistered;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
================================================
|
|
idVoiceChatMgr::SetDisableVoiceReason
|
|
================================================
|
|
*/
|
|
void idVoiceChatMgr::SetDisableVoiceReason( disableVoiceReason_t reason ) {
|
|
if ( ( disableVoiceReasons & reason ) == 0 ) {
|
|
disableVoiceReasons |= reason;
|
|
UpdateRegisteredTalkers();
|
|
}
|
|
}
|
|
|
|
/*
|
|
================================================
|
|
idVoiceChatMgr::ClearDisableVoiceReason
|
|
================================================
|
|
*/
|
|
void idVoiceChatMgr::ClearDisableVoiceReason( disableVoiceReason_t reason ) {
|
|
if ( ( disableVoiceReasons & reason ) != 0 ) {
|
|
disableVoiceReasons &= ~reason;
|
|
UpdateRegisteredTalkers();
|
|
}
|
|
}
|
|
|
|
/*
|
|
================================================
|
|
idVoiceChatMgr::SetHeadsetState
|
|
================================================
|
|
*/
|
|
void idVoiceChatMgr::SetHeadsetState( int talkerIndex, bool state ) {
|
|
talker_t & talker = talkers[ talkerIndex ];
|
|
|
|
talker.hasHeadset = state;
|
|
}
|
|
|
|
/*
|
|
================================================
|
|
idVoiceChatMgr::HasHeadsetStateChanged
|
|
================================================
|
|
*/
|
|
bool idVoiceChatMgr::HasHeadsetStateChanged( int talkerIndex )
|
|
{
|
|
talker_t & talker = talkers[ talkerIndex ];
|
|
|
|
// We should only be checking this on the local user
|
|
assert( talker.IsLocal() );
|
|
|
|
bool ret = talker.hasHeadsetChanged;
|
|
talker.hasHeadsetChanged = false;
|
|
|
|
return ret;
|
|
} |