2337 lines
84 KiB
C++
2337 lines
84 KiB
C++
|
|
#include "BattleArenaManager.h"
|
|
#include "BattleArenaForExercise.h"
|
|
#include "BattleArenaWithWaitQueue.h"
|
|
#include "DB_Commands.h"
|
|
#include "PartyManager.h"
|
|
#include "ThreadPlayerHelper.h"
|
|
|
|
|
|
BattleArenaManager::BattleArenaManager()
|
|
: m_bInit( false )
|
|
{
|
|
}
|
|
|
|
BattleArenaManager::~BattleArenaManager()
|
|
{
|
|
for( std::vector< BattleArena* >::const_iterator it = m_vArenaList.begin() ; it != m_vArenaList.end() ; ++it )
|
|
{
|
|
BattleArena* pArena = (*it);
|
|
if( pArena != NULL )
|
|
{
|
|
delete pArena;
|
|
}
|
|
}
|
|
|
|
m_vArenaList.clear();
|
|
}
|
|
|
|
unsigned short BattleArenaManager::RegisterArena( const BattleArenaBaseServer* pArenaBase )
|
|
{
|
|
// Init 호출 전에만 RegisterArena 함수가 호출되어야 함
|
|
assert( !m_bInit );
|
|
|
|
std::vector< BattleArena* >::const_iterator it = m_vArenaList.begin();
|
|
for( ; it != m_vArenaList.end(); ++it )
|
|
{
|
|
BattleArena* pArena = (*it);
|
|
if( pArenaBase->nID == pArena->m_pArenaBase->nID )
|
|
{
|
|
// 리로딩?
|
|
assert( 0 );
|
|
return RESULT_ALREADY_EXIST;
|
|
}
|
|
}
|
|
|
|
if( !pArenaBase->IsExerciseGameArena() )
|
|
{
|
|
m_vArenaList.push_back( new BattleArenaWithWaitQueue( pArenaBase, &m_partyToArenaMap ) );
|
|
}
|
|
else
|
|
{
|
|
m_vArenaList.push_back( new BattleArenaForExercise( pArenaBase, &m_partyToArenaMap ) );
|
|
}
|
|
|
|
return RESULT_SUCCESS;
|
|
}
|
|
|
|
bool BattleArenaManager::Init()
|
|
{
|
|
assert( !m_bInit );
|
|
if( m_bInit )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
m_bInit = true;
|
|
|
|
// 1초에 한 번 onProcess로 충분한지는 잘 모르겠지만...
|
|
ArcadiaServer::Instance().SetObjectPriority( this, UPDATE_PRIORITY_HIGH );
|
|
return true;
|
|
}
|
|
|
|
bool BattleArenaManager::DeInit()
|
|
{
|
|
assert( m_bInit );
|
|
if( !m_bInit )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
m_bInit = false;
|
|
|
|
ArcadiaServer::Instance().SetObjectPriority( this, UPDATE_PRIORITY_IDLE );
|
|
return true;
|
|
}
|
|
|
|
void BattleArenaManager::RaiseUpdatePriority()
|
|
{
|
|
assert( m_bInit );
|
|
if( !m_bInit )
|
|
return;
|
|
|
|
ArcadiaServer::Instance().SetObjectPriority( this, UPDATE_PRIORITY_HIGHEST );
|
|
}
|
|
|
|
void BattleArenaManager::DownUpdatePriority()
|
|
{
|
|
if( !m_bInit )
|
|
return;
|
|
|
|
ArcadiaServer::Instance().SetObjectPriority( this, UPDATE_PRIORITY_HIGH );
|
|
}
|
|
|
|
unsigned short BattleArenaManager::JoinWaitQueue( StructPlayer* pPlayer, int nArenaID )
|
|
{
|
|
unsigned short nResult = checkJoinable( pPlayer, false );
|
|
if( nResult != RESULT_SUCCESS )
|
|
return nResult;
|
|
|
|
_BATTLE_GRADE eGrade = GetBattleArenaGrade( pPlayer->GetLevel() );
|
|
if( eGrade == BG_INVALID )
|
|
return RESULT_NOT_ENOUGH_LEVEL;
|
|
|
|
BattleArena* pArena = getArena( nArenaID );
|
|
if( pArena == NULL )
|
|
return RESULT_INVALID_ARGUMENT;
|
|
|
|
// 예외적으로 루키 등급 유저는 16:16 경기에 참여할 수 없음
|
|
if( eGrade == BG_ROOKIE && pArena->m_pArenaBase->nMaxMember == 32 )
|
|
return RESULT_NOT_ENOUGH_LEVEL;
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
// 대기열에 들어갈 때 일반 파티에 가입된 상태일 수도 있기 때문에 pPlayer->SetUseAlias를 여기서 호출하지 않고
|
|
// _joinWaitQueue 안에서 상황에 따라 호출함
|
|
|
|
// 현재 아레나에 참여 시도를 하긴 하니까 일단 BattleArenaID 세팅(참여 실패할 경우엔 다시 0 으로 돌려줘야 함)
|
|
pPlayer->SetBattleArenaID( pArena->m_pArenaBase->nID );
|
|
|
|
nResult = pArena->_joinWaitQueue( pPlayer, eGrade );
|
|
|
|
// 최근에 시작되었던 방에 바로 진입해버렸다면 여기서 추가 처리 중지하고 바로 리턴
|
|
if( nResult == RESULT_SUCCESS )
|
|
{
|
|
BattleArenaInstance * pBattleInstance = pArena->_getBattleInstance( pPlayer->GetBattleArenaInstanceNo() );
|
|
|
|
assert( pBattleInstance );
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
// 경기에 대한 정보 방송
|
|
SendBattleArenaBattleInfoMessage( pPlayer, pBattleInstance );
|
|
SendBattleArenaBattleStatusMessage( pPlayer, pBattleInstance );
|
|
|
|
// 현재 스코어 정보도 보내 줌
|
|
SendBattleArenaScoreMessage( pPlayer, pBattleInstance );
|
|
|
|
// 다른 유저들에게 현재 유저가 새로 참여했음을 알려 줌
|
|
BroadcastBattleArenaJoinBattleMessage( pBattleInstance, pPlayer );
|
|
|
|
return RESULT_SUCCESS;
|
|
}
|
|
|
|
// 최근에 시작되었던 경기에 바로 진입한 것도 아니고 대기열에 추가되지도 못했다면 바로 리턴(대기열 등록 실패)
|
|
if( nResult != RESULT_PENDING )
|
|
{
|
|
// 미리 세팅했던 ArenaID 초기화
|
|
pPlayer->SetBattleArenaID( 0 );
|
|
// 가명 사용 여부 설정도 초기화
|
|
pPlayer->SetUseAlias( false );
|
|
|
|
// 실패했을 때는 Caller 측에서 TS_SC_RESULT 패킷으로 클라한테 알려주고,
|
|
// 성공했을 때에는 여기서 상황따라 서로 다른 패킷으로 알려주는 게 일관성 없지만...;;
|
|
// * RESULT 패킷 송신과 그 외에 부가 동작에 따른 패킷 방송 순서를 맞출 방법이 없음 ㅠㅜ;
|
|
// 게다가 성공 시 전달해야 할 정보들이 csArena를 풀기 전에 얻어야 할 내용들이 대부분임.
|
|
return nResult;
|
|
}
|
|
|
|
// 일단 대기열에 추가는 성공했으니 클라에게 알려 줌
|
|
SendBattleArenaJoinQueueMessage( pPlayer, pArena, eGrade );
|
|
|
|
return RESULT_SUCCESS;
|
|
}
|
|
|
|
unsigned short BattleArenaManager::QuickJoin( StructPlayer* pPlayer )
|
|
{
|
|
unsigned short nResult = checkJoinable( pPlayer, false );
|
|
if( nResult != RESULT_SUCCESS )
|
|
return nResult;
|
|
|
|
_BATTLE_GRADE eGrade = GetBattleArenaGrade( pPlayer->GetLevel() );
|
|
if( eGrade == BG_INVALID )
|
|
return RESULT_NOT_ENOUGH_LEVEL;
|
|
|
|
// 빠른 참여는 기본적으로 현재 시작되어 있는 경기들에 대해 먼저 참여 체크
|
|
do
|
|
{
|
|
unsigned int nMaxBattleInstancePriority = 0;
|
|
int nCandidateArenaID = 0;
|
|
unsigned char nCandidateInstanceNo = 0;
|
|
|
|
for( std::vector< BattleArena* >::const_iterator it = m_vArenaList.begin() ; it != m_vArenaList.end() ; ++it )
|
|
{
|
|
const BattleArena* pArena = (*it);
|
|
|
|
// 연습 경기는 빠른 참여 대상 제외
|
|
if( pArena->m_pArenaBase->IsExerciseGameArena() )
|
|
continue;
|
|
|
|
// 루키 등급의 유저는 16:16 경기에 참여 불가
|
|
if( eGrade == BG_ROOKIE && pArena->m_pArenaBase->nMaxMember == 32 )
|
|
continue;
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
// 현재 진행 중인 경기의 체크
|
|
for( unsigned int nInstanceNo = 1; nInstanceNo <= MAX_BATTLE_ARENA_INSTANCE_NO_PER_ARENA; ++nInstanceNo )
|
|
{
|
|
const BattleArenaInstance* pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
if( pBattleInstance == NULL )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
if( pBattleInstance->m_eGrade != eGrade )
|
|
continue;
|
|
|
|
unsigned int nPriority = pBattleInstance->_getQuickJoinPriority();
|
|
if( nPriority > nMaxBattleInstancePriority )
|
|
{
|
|
nMaxBattleInstancePriority = nPriority;
|
|
nCandidateArenaID = pBattleInstance->m_pArenaBase->nID;
|
|
nCandidateInstanceNo = nInstanceNo;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 최우선순위의 방이 없었다면 진행 중인 경기에 대한 참여 시도는 실패로 패스
|
|
// 검색된 방이 있었다면 참여를 시도
|
|
// * 왜 시도냐믄 csArena/csBattle을 풀었다가 다시 걸기 때문에 그 사이에 참여할 수 없는 상태가 될 가능성이 있기 때문
|
|
// * csArena/csBattle을 풀었다 다시 걸기 때문에 모든 방들의 우선순위가 참여 시점에는 뒤바뀌어 있을 수도 있는데
|
|
// 그런 차이는 일단 무시함. 그거 다 챙기려면 전 경기에 동시에 락 걸고 검사하고 참여 처리까지 끝내고 락 풀어야되는데
|
|
// 성능상으로 보나 개념상으로 보나 잠깐 사이에 생기는 점수 차이 방지하자고 하는 짓 치곤 미친 짓이다 -_ -;
|
|
if( !nCandidateArenaID )
|
|
break;
|
|
|
|
BattleArena* pArena = getArena( nCandidateArenaID );
|
|
|
|
// pArena에 대한 NULL 체크를 안 했다. 서버 종료될 때 말고는 NULL이 될 수가 없다;;
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
BattleArenaInstance* pBattleInstance = pArena->_getBattleInstance( nCandidateInstanceNo );
|
|
|
|
// 검색됐던 방이 사라졌다는 건 있을 수 없는데(이것도 pArena처럼 서버 종료될 말고는 NULL이 될 수가 없음)
|
|
// 딴데서도 다 하던 체크니까 그냥 해 줌... -_ -;;
|
|
if( !pBattleInstance )
|
|
// 만에 하나라도 방이 사라졌다면 위에서 2, 3, 4 순위 등을 미리 뽑아놓지는 않는 관계로 다시 체크함...
|
|
// 위에서 2, 3, 4 순위 뽑아놓는다고 해도 결국은 재수없으면 미리 뽑아 둔 방 모두 참여 불가 상태가 될
|
|
// 가능성 자체를 무시할 수는 없기 때문에 다 소용없다고 판단. 참여 못하는 경우가 정말 드물거라 가정하고
|
|
// 비효율적인 거 알지만 일단 그냥 continue 해서 do 문부터 다시 함.
|
|
break;
|
|
|
|
// 빠른 입장의 경우는 별 의미는 없지만 pPlayer->SetBattleArenaID 를 호출하지 않고 _addPlayer를 호출함
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
if( pBattleInstance->m_eGrade == eGrade && pBattleInstance->_isQuickJoinAble() )
|
|
{
|
|
// 가명 사용 여부 설정
|
|
pPlayer->SetUseAlias( true );
|
|
|
|
unsigned short nResult = pBattleInstance->_addPlayer( pPlayer );
|
|
|
|
// 참여에 실패했으면 앞뒤 없이 닥치고 다른 방 찾기
|
|
if( nResult != RESULT_SUCCESS )
|
|
{
|
|
// 가명 사용 여부 설정 리셋
|
|
pPlayer->SetUseAlias( false );
|
|
break;
|
|
}
|
|
|
|
// 참여에 성공했으니 늦게나마 ArenaID 세팅
|
|
pPlayer->SetBattleArenaID( nCandidateArenaID );
|
|
|
|
// 그리고 경기에 대한 정보 방송
|
|
SendBattleArenaBattleInfoMessage( pPlayer, pBattleInstance );
|
|
SendBattleArenaBattleStatusMessage( pPlayer, pBattleInstance );
|
|
|
|
// 현재 스코어 정보도 보내 줌
|
|
SendBattleArenaScoreMessage( pPlayer, pBattleInstance );
|
|
|
|
// 다른 유저들에게 현재 유저가 새로 참여했음을 알려 줌
|
|
BroadcastBattleArenaJoinBattleMessage( pBattleInstance, pPlayer );
|
|
|
|
// 그리고 QuickJoin은 성공으로 종료 'ㅠ '
|
|
return RESULT_SUCCESS;
|
|
}
|
|
} while( false );
|
|
|
|
// 진행 중이던 경기에 참여를 못 한 경우에는 대기열들 중 참여할 대기열을 검색
|
|
{
|
|
BattleArenaWithWaitQueue* pLongestWaitingArena = NULL;
|
|
AR_TIME tEarliestWaitStart = INFINITE_TIME;
|
|
|
|
for( std::vector< BattleArena* >::iterator it = m_vArenaList.begin(); it != m_vArenaList.end(); ++it )
|
|
{
|
|
BattleArena* pArena = (*it);
|
|
|
|
// 연습 경기는 빠른 참여 대상 제외
|
|
if( pArena->m_pArenaBase->IsExerciseGameArena() )
|
|
continue;
|
|
|
|
// 루키 등급의 유저는 16:16 경기에 참여 불가
|
|
if( eGrade == BG_ROOKIE && pArena->m_pArenaBase->nMaxMember == 32 )
|
|
continue;
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
BattleArenaWithWaitQueue* pCurrentArena = static_cast< BattleArenaWithWaitQueue* >( pArena );
|
|
AR_TIME tWaitStart = pCurrentArena->_getWaitStartTime( eGrade );
|
|
if( tWaitStart == 0 )
|
|
continue;
|
|
|
|
if( tWaitStart < tEarliestWaitStart )
|
|
{
|
|
tEarliestWaitStart = tWaitStart;
|
|
pLongestWaitingArena = pCurrentArena;
|
|
}
|
|
}
|
|
|
|
// 참여할 대기열이 선택되지 않았다면 빠른 참여는 실패 'ㅠ ';
|
|
if( !pLongestWaitingArena )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
THREAD_SYNCHRONIZE( pLongestWaitingArena->m_csArena );
|
|
|
|
// 현재 아레나에 참여 시도를 하긴 하니까 일단 BattleArenaID 세팅(참여 실패할 경우엔 다시 0 으로 돌려줘야 함)
|
|
// * 빠른 입장이어도 대기열 대기는 ArenaID를 먼저 세팅해 줌
|
|
pPlayer->SetBattleArenaID( pLongestWaitingArena->m_pArenaBase->nID );
|
|
|
|
nResult = pLongestWaitingArena->_joinWaitQueue( pPlayer, eGrade );
|
|
|
|
// 여기서 최근에 시작된 경기에 바로 진입하는 경우도 있을 수 있나... '- ';?
|
|
if( nResult == RESULT_SUCCESS )
|
|
{
|
|
BattleArenaInstance* pBattleInstance = pLongestWaitingArena->_getBattleInstance( pPlayer->GetBattleArenaInstanceNo() );
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
// 경기에 대한 정보 방송
|
|
SendBattleArenaBattleInfoMessage( pPlayer, pBattleInstance );
|
|
SendBattleArenaBattleStatusMessage( pPlayer, pBattleInstance );
|
|
|
|
// 현재 스코어 정보도 보내 줌
|
|
SendBattleArenaScoreMessage( pPlayer, pBattleInstance );
|
|
|
|
// 다른 유저들에게 현재 유저가 새로 참여했음을 알려 줌
|
|
BroadcastBattleArenaJoinBattleMessage( pBattleInstance, pPlayer );
|
|
|
|
return RESULT_SUCCESS;
|
|
}
|
|
// 대기열에 대기 성공했다면 정보 보내주고 성공으로 종료
|
|
else if( nResult == RESULT_PENDING )
|
|
{
|
|
SendBattleArenaJoinQueueMessage( pPlayer, pLongestWaitingArena, eGrade );
|
|
|
|
return RESULT_SUCCESS;
|
|
}
|
|
// 최근에 시작되었던 경기에 바로 진입한 것도 아니고 대기열에 추가되지도 못했다면 바로 리턴(대기열 등록 실패)
|
|
else
|
|
{
|
|
// 미리 세팅했던 ArenaID 초기화
|
|
pPlayer->SetBattleArenaID( 0 );
|
|
|
|
// 가명 사용 여부 리셋
|
|
pPlayer->SetUseAlias( false );
|
|
}
|
|
}
|
|
|
|
// 여기까지 온 건 대기열 선택까지 됐는데 대기열 참여(_joinWaitQueue)조차 실패한 경우...
|
|
// JoinWaitQueue와 마찬가지로 실패했을 때는 Caller 측에서 TS_SC_RESULT 패킷으로 클라한테 알려주고,
|
|
// 성공했을 때에는 여기서 상황따라 서로 다른 패킷으로 알려주는 게 일관성 없지만...;;
|
|
// * RESULT 패킷 송신과 그 외에 부가 동작에 따른 패킷 방송 순서를 맞출 방법이 없음 ㅠㅜ;
|
|
// 게다가 성공 시 전달해야 할 정보들이 csArena를 풀기 전에 얻어야 할 내용들이 대부분임.
|
|
|
|
return nResult;
|
|
}
|
|
|
|
unsigned short BattleArenaManager::QuitGame( StructPlayer* pPlayer, bool bByKick, bool bAvoidPenalty, _ARENA_LEAVE_TYPE eLeaveType )
|
|
{
|
|
int nArenaID = pPlayer->GetBattleArenaID();
|
|
if( !nArenaID )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
BattleArena* pArena = getArena( nArenaID );
|
|
if( !pArena )
|
|
return RESULT_INVALID_ARGUMENT;
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
unsigned char nInstanceNo = pPlayer->GetBattleArenaInstanceNo();
|
|
|
|
if( nInstanceNo == 0 )
|
|
{
|
|
return pArena->_leaveWaitQueue( pPlayer, eLeaveType );
|
|
}
|
|
|
|
BattleArenaInstance* pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
// ?
|
|
if( !pBattleInstance )
|
|
{
|
|
assert( 0 );
|
|
return RESULT_INVALID_ARGUMENT;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
eLeaveType = ( bByKick ) ? ALT_EXERCISE_PARTY_KICK : ALT_USER_REQUEST;
|
|
unsigned short nResult = pBattleInstance->_removePlayer( pPlayer, eLeaveType );
|
|
|
|
// 경기 이탈에 실패했다면 오류 코드 리턴
|
|
if( nResult != RESULT_SUCCESS && nResult != RESULT_NOT_ENOUGH_BULLET )
|
|
return nResult;
|
|
|
|
// 경기 참여 상태에서 직접 이탈했으므로 페널티 부여(이미 종료된 경기나 연습 경기라면 페널티 없음)
|
|
if( !pBattleInstance->m_bEnd && !pBattleInstance->m_pArenaBase->IsExerciseGameArena() && !bAvoidPenalty )
|
|
{
|
|
pPlayer->IncBattleArenaPenalty();
|
|
pPlayer->DBQuery( new DB_UpdateBattleArenaPenalty( pPlayer ) );
|
|
|
|
SendBattleArenaPenaltyMessage( pPlayer );
|
|
}
|
|
|
|
BattleArenaQuitFunctor qf( eLeaveType, pBattleInstance->m_pArenaBase, nInstanceNo );
|
|
qf( pPlayer );
|
|
|
|
// nResult가 RESULT_NOT_ENOUGH_BULLET 인 경우라면 다음 번 BattleArenaManager::onProcess 에서 경기 종료 처리가 될 거니까 지금은 별 처리 안 함
|
|
|
|
return RESULT_SUCCESS;
|
|
}
|
|
|
|
unsigned short BattleArenaManager::QuitGame( int nPartyID, PlayerUID nPlayerUID, bool bByKick, _ARENA_LEAVE_TYPE eLeaveType )
|
|
{
|
|
if( !nPartyID || !PartyManager::GetInstance().IsBattleArenaTeamParty( nPartyID ) )
|
|
return RESULT_ACCESS_DENIED;
|
|
|
|
int nArenaID = m_partyToArenaMap.Get( nPartyID );
|
|
|
|
BattleArena* pArena = getArena( nArenaID );
|
|
if( !pArena )
|
|
{
|
|
return RESULT_NOT_EXIST;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
int nInstanceNo = pArena->m_partyToInstanceMap.Get( nPartyID );
|
|
|
|
// 방이 없거나 이미 해산됐다면...
|
|
if( nInstanceNo == 0 )
|
|
{
|
|
return pArena->_leaveWaitQueue( nPlayerUID, eLeaveType );
|
|
}
|
|
|
|
BattleArenaInstance* pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
// 이건 또 좀 이상하지만 여튼 체크...
|
|
if( pBattleInstance == NULL )
|
|
// 또 즐
|
|
return RESULT_NOT_EXIST;
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
// 체크하려는 파티의 팀 번호 얻기
|
|
int nTeamNo = pBattleInstance->_getTeamNo( nPartyID );
|
|
if( nTeamNo == INVALID_BATTLE_ARENA_TEAM_NO )
|
|
{
|
|
// 파티 ID 기준으로 아레나를 찾았는데 해당 파티가 소속된 팀은 없는 경우
|
|
// m_partyToArenaMap, m_partyToInstanceMap 이 락을 따로 쓰지 않아서 생길 가능성이 있긴 함(csBattle 걸기 직전에 파티 해산)
|
|
return RESULT_NOT_EXIST;
|
|
}
|
|
|
|
BattleArenaInstance::PlayerInfo* pPlayerInfo = pBattleInstance->_getPlayerInfo( nPlayerUID, nTeamNo );
|
|
if( !pPlayerInfo )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
// 온라인인 유저는 이 함수가 아니라 QuitGame( StructPlayer* pPlayer, bool bByKick ) 함수로 이탈 처리를 시도해야 함
|
|
if( pPlayerInfo->pPlayer )
|
|
return RESULT_INVALID_ARGUMENT;
|
|
|
|
unsigned short nResult = pBattleInstance->_removePlayer( nPlayerUID, (bByKick) ? ALT_EXERCISE_PARTY_KICK : ALT_DISCONNECT );
|
|
|
|
// 경기 이탈에 실패했다면 오류 코드 리턴
|
|
if( nResult != RESULT_SUCCESS && nResult != RESULT_NOT_ENOUGH_BULLET )
|
|
return nResult;
|
|
|
|
return RESULT_SUCCESS;
|
|
}
|
|
|
|
unsigned short BattleArenaManager::EnterArenaWhileCountdown( StructPlayer* pPlayer )
|
|
{
|
|
int nArenaID = pPlayer->GetBattleArenaID();
|
|
if( !nArenaID )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
BattleArena* pArena = getArena( nArenaID );
|
|
if( !pArena )
|
|
return RESULT_INVALID_ARGUMENT;
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
unsigned char nInstanceNo = pPlayer->GetBattleArenaInstanceNo();
|
|
|
|
if( !nInstanceNo )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
BattleArenaInstance* pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
if( !pBattleInstance )
|
|
return RESULT_INVALID_ARGUMENT;
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
return pBattleInstance->_pendEnterWhileCountdown( pPlayer );
|
|
}
|
|
|
|
unsigned short BattleArenaManager::OnPlayerDead( StructPlayer* pPlayer, StructPlayer* pKiller )
|
|
{
|
|
// 킬러가 없으면 아무것도 안 함
|
|
if( !pKiller )
|
|
return RESULT_SUCCESS;
|
|
|
|
int nArenaID = pPlayer->GetBattleArenaID();
|
|
if( !nArenaID )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
BattleArena* pArena = getArena( nArenaID );
|
|
if( !pArena )
|
|
return RESULT_INVALID_ARGUMENT;
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
unsigned char nInstanceNo = pPlayer->GetBattleArenaInstanceNo();
|
|
|
|
if( !nInstanceNo )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
BattleArenaInstance* pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
// ?
|
|
if( !pBattleInstance )
|
|
{
|
|
assert( 0 );
|
|
return RESULT_INVALID_ARGUMENT;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
return pBattleInstance->_onPlayerDead( pPlayer, pKiller );
|
|
}
|
|
|
|
unsigned short BattleArenaManager::OnDisconnect( StructPlayer* pPlayer )
|
|
{
|
|
int nArenaID = pPlayer->GetBattleArenaID();
|
|
if( !nArenaID )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
BattleArena* pArena = getArena( nArenaID );
|
|
// 으잉?
|
|
if( !pArena )
|
|
{
|
|
assert( 0 );
|
|
return RESULT_INVALID_ARGUMENT;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
unsigned char nInstanceNo = pPlayer->GetBattleArenaInstanceNo();
|
|
|
|
// 대기열에서 대기중이었던 유저면 대기열 이탈 처리만 해 줌
|
|
if( nInstanceNo == 0 )
|
|
{
|
|
return pArena->_leaveWaitQueue( pPlayer, ALT_DISCONNECT );
|
|
}
|
|
|
|
// 경기 내부에 있었으면 경기에서 오프라인 처리
|
|
BattleArenaInstance* pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
// ?
|
|
if( !pBattleInstance )
|
|
{
|
|
assert( 0 );
|
|
return RESULT_INVALID_ARGUMENT;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
return pBattleInstance->_disconnectPlayer( pPlayer );
|
|
}
|
|
|
|
unsigned short BattleArenaManager::OnReconnect( StructPlayer* pPlayer, ArPosition* pPosStart, unsigned char* pnLayer )
|
|
{
|
|
// 재접속 시에는 배틀 아레나 관련 정보가 세팅이 되어 있지 않기 때문에 파티 ID로 다 찾아야 함
|
|
int nPartyID = pPlayer->GetPartyID();
|
|
|
|
if( !nPartyID || !PartyManager::GetInstance().IsBattleArenaTeamParty( nPartyID ) )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
// smp_login_character 직후에 smp_set_party가 실행되어 해당 캐릭터의 party_id를 0으로 바꿔주게 되면
|
|
// 로그인 시점(지금 여기 롸잇 나우)에는 pPlayer->GetPartyID() != 0 이지만 실제 멤버는 아닌 상태가
|
|
// 발생할 수도 있으므로 여기서 실제 멤버인지 한 번 체크하고 아니면 그냥 패스
|
|
if( !PartyManager::GetInstance().IsMember( nPartyID, pPlayer->GetPlayerUID() ) )
|
|
// 여기서 그냥 return 해버리고나면 SendLoginResult 함수 안에서 PartyManager::onLogin을 호출해서 알아서 캐릭터의 파티ID가 리셋됨
|
|
return RESULT_NOT_EXIST;
|
|
|
|
int nArenaID = m_partyToArenaMap.Get( nPartyID );
|
|
if( !nArenaID )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
BattleArena* pArena = getArena( nArenaID );
|
|
if( !pArena )
|
|
{
|
|
// m_partyToArenaMap에 nArenaID가 없던 것도 아니고 아예 잘못된 nArenaID 가 들어있었다는 얘기가 되므로 있어서는 안되는 상황
|
|
assert( 0 );
|
|
return RESULT_NOT_EXIST;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
int nInstanceNo = pArena->m_partyToInstanceMap.Get( nPartyID );
|
|
|
|
// 방이 없거나 이미 해산됐다면...
|
|
if( !nInstanceNo )
|
|
// 즐
|
|
return RESULT_NOT_EXIST;
|
|
|
|
BattleArenaInstance* pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
// 이건 또 좀 이상하지만 여튼 체크...
|
|
if( !pBattleInstance )
|
|
// 또 즐
|
|
return RESULT_NOT_EXIST;
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
// 경기가 끝난 후에 재접속하는 경우는 그냥 경기에서 이탈시킴
|
|
if( pBattleInstance->m_bEnd )
|
|
{
|
|
// 필요한 경우에는 여기서 ALT_GAME_OVER 대신 ALT_DISCONNECT를 쓰는 것도 개념상 가능할 듯
|
|
pBattleInstance->_removePlayer( pPlayer, ALT_GAME_OVER );
|
|
|
|
// 이외의 처리는 여기서 직접 해줘도 되지만 어차피 DB_Login::readCharacterInfo 안에서 OnReconnect를 호출한 시점에는
|
|
// 캐릭터의 정보가 모두 다 로드된 상태가 아닌지라 완전히 처리는 못 해줌(Ex. 버프 삭제)
|
|
// 그래서 그냥 재접속 실패로 리턴해버려서 이탈 관련 나머지 처리는 readCharacterInfo에서 알아서 하게 해야 함
|
|
return RESULT_NOT_EXIST;
|
|
}
|
|
|
|
unsigned short nResult = pBattleInstance->_reconnectPlayer( pPlayer, pPosStart, pnLayer );
|
|
|
|
// 뭬야? 방도 있고 아레나 파티 소속이기도 한데 경기에 재참여는 실패;?
|
|
if( nResult != RESULT_SUCCESS )
|
|
{
|
|
assert( 0 );
|
|
|
|
// 무슨 상황인지도 불명확하니 일단 경기에서 해당 유저 제거
|
|
unsigned short nRemoveResult = pBattleInstance->_removePlayer( pPlayer, ALT_UNKNOWN );
|
|
|
|
// 캐릭터의 PlayerInfo가 아예 없는 경우
|
|
if( nRemoveResult != RESULT_SUCCESS && nRemoveResult != RESULT_NOT_ENOUGH_BULLET )
|
|
{
|
|
assert( nRemoveResult == RESULT_NOT_EXIST );
|
|
|
|
pBattleInstance->_deleteBattleArenaPartyPlayer( nPartyID, pPlayer );
|
|
return RESULT_UNKNOWN;
|
|
}
|
|
|
|
// 여기선 BattleArenaQuitFunctor 처리 안해주고 어차피 nResult != RESULT_SUCCESS 이기 때문에
|
|
// 경기장 밖으로 쫓겨나는 처리가 DB_Login 쪽에서 이루어 짐
|
|
}
|
|
|
|
return nResult;
|
|
}
|
|
|
|
void BattleArenaManager::OnReconnectPostProc( StructPlayer* pPlayer )
|
|
{
|
|
int nArenaID = pPlayer->GetBattleArenaID();
|
|
|
|
if( !nArenaID )
|
|
return;
|
|
|
|
BattleArena* pArena = getArena( nArenaID );
|
|
|
|
// 으잉?
|
|
if( !pArena )
|
|
{
|
|
assert( 0 );
|
|
return;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
unsigned char nInstanceNo = pPlayer->GetBattleArenaInstanceNo();
|
|
BattleArenaInstance * pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
if( !pBattleInstance )
|
|
{
|
|
assert( 0 );
|
|
return;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
// 경기가 끝난 후에 재접속하는 경우는 그냥 경기에서 이탈시킴
|
|
if( pBattleInstance->m_bEnd )
|
|
{
|
|
// 필요한 경우에는 여기서 ALT_GAME_OVER 대신 ALT_DISCONNECT를 쓰는 것도 개념상 가능할 듯
|
|
pBattleInstance->_removePlayer( pPlayer, ALT_GAME_OVER );
|
|
|
|
// 이외의 처리는 여기서 직접 해줘도 되지만 어차피 DB_Login::readCharacterInfo 안에서 OnReconnect를 호출한 시점에는
|
|
// 캐릭터의 정보가 모두 다 로드된 상태가 아닌지라 완전히 처리는 못 해줌(Ex. 버프 삭제)
|
|
// 그래서 그냥 재접속 실패로 리턴해버려서 이탈 관련 나머지 처리는 readCharacterInfo에서 알아서 하게 해야 함
|
|
return;
|
|
}
|
|
|
|
pBattleInstance->_reconnectPlayerPostProc( pPlayer );
|
|
}
|
|
|
|
size_t BattleArenaManager::DoEachPlayerInBattleInstance( int nArenaID, unsigned char nInstanceNo, ArObjectFunctor& fo )
|
|
{
|
|
if( !nArenaID || !IsValidBattleArenaInstanceNo( nInstanceNo ) )
|
|
{
|
|
assert( 0 );
|
|
return 0;
|
|
}
|
|
|
|
BattleArena* pArena = getArena( nArenaID );
|
|
if( !pArena )
|
|
{
|
|
assert( 0 );
|
|
return RESULT_INVALID_ARGUMENT;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
BattleArenaInstance* pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
if( !pBattleInstance )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
return pBattleInstance->_doEachPlayer( fo );
|
|
}
|
|
|
|
size_t BattleArenaManager::DoEachPlayerInBattleTeam( int nArenaID, unsigned char nInstanceNo, int nTeamNo, ArObjectFunctor& fo )
|
|
{
|
|
if( !nArenaID || !IsValidBattleArenaInstanceNo( nInstanceNo ) )
|
|
{
|
|
assert( 0 );
|
|
return 0;
|
|
}
|
|
|
|
BattleArena* pArena = getArena( nArenaID );
|
|
|
|
if( !pArena )
|
|
{
|
|
assert( 0 );
|
|
return RESULT_INVALID_ARGUMENT;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
BattleArenaInstance* pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
if( !pBattleInstance )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
return pBattleInstance->_doEachPlayerInTeam( nTeamNo, fo );
|
|
}
|
|
|
|
unsigned short BattleArenaManager::ActivateBattleInstanceProp( StructPlayer* pPlayer, int nPropIndex )
|
|
{
|
|
int nArenaID = pPlayer->GetBattleArenaID();
|
|
unsigned char nInstanceNo = pPlayer->GetBattleArenaInstanceNo();
|
|
if( !nArenaID || !IsValidBattleArenaInstanceNo( nInstanceNo ) || nPropIndex < 1 || nPropIndex > 9 )
|
|
{
|
|
assert( 0 );
|
|
return RESULT_INVALID_ARGUMENT;
|
|
}
|
|
|
|
BattleArena * pArena = getArena( nArenaID );
|
|
|
|
if( !pArena )
|
|
{
|
|
assert( 0 );
|
|
return RESULT_INVALID_ARGUMENT;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
BattleArenaInstance* pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
if( !pBattleInstance )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
return pBattleInstance->_activateProp( pPlayer, nPropIndex );
|
|
}
|
|
|
|
unsigned short BattleArenaManager::RequestAbsenceCheck( StructPlayer* pPlayer, AR_HANDLE hCheckTarget )
|
|
{
|
|
int nArenaID = pPlayer->GetBattleArenaID();
|
|
unsigned char nInstanceNo = pPlayer->GetBattleArenaInstanceNo();
|
|
if( !nArenaID || !IsValidBattleArenaInstanceNo( nInstanceNo ) )
|
|
{
|
|
assert( 0 );
|
|
return RESULT_NOT_EXIST;
|
|
}
|
|
|
|
BattleArena * pArena = getArena( nArenaID );
|
|
|
|
if( !pArena )
|
|
{
|
|
assert( 0 );
|
|
return RESULT_NOT_EXIST;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
BattleArenaInstance * pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
if( !pBattleInstance )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
return pBattleInstance->_requestAbsenceCheck( pPlayer, hCheckTarget );
|
|
}
|
|
|
|
unsigned short BattleArenaManager::AnswerAbsenceCheck( StructPlayer* pPlayer, bool bSuccess )
|
|
{
|
|
int nArenaID = pPlayer->GetBattleArenaID();
|
|
unsigned char nInstanceNo = pPlayer->GetBattleArenaInstanceNo();
|
|
if( !nArenaID || !IsValidBattleArenaInstanceNo( nInstanceNo ) )
|
|
{
|
|
assert( 0 );
|
|
return RESULT_NOT_EXIST;
|
|
}
|
|
|
|
BattleArena* pArena = getArena( nArenaID );
|
|
|
|
if( !pArena )
|
|
{
|
|
assert( 0 );
|
|
return RESULT_NOT_EXIST;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
BattleArenaInstance * pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
if( !pBattleInstance )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
return pBattleInstance->_answerAbsenceCheck( pPlayer, bSuccess );
|
|
}
|
|
|
|
unsigned short BattleArenaManager::CreateExerciseGame( StructPlayer * pPlayer )
|
|
{
|
|
// 지역락 걸지 않고 호출해야 함
|
|
assert( !ArcadiaServer::Instance().IsLocked( pPlayer ) );
|
|
|
|
{
|
|
ARCADIA_LOCK( ArcadiaServer::Instance().LockObject( pPlayer ) );
|
|
|
|
unsigned short nResult = checkJoinable( pPlayer, true );
|
|
|
|
if( nResult != RESULT_SUCCESS )
|
|
return nResult;
|
|
}
|
|
|
|
// 연습 경기의 경기 타입은 '슬로터 8:8'로 고정되어 있는 미리 지정된 아레나 ID 값을 사용함
|
|
BattleArena* pArena = getArena( GameRule::BATTLE_ARENA_EXERCISE_GAME_ARENA_ID );
|
|
|
|
// 고정 ID에 해당하는 연습 경기용 아레나 ID가 없는 경우...!?
|
|
if( !pArena )
|
|
{
|
|
assert( 0 );
|
|
return RESULT_ACCESS_DENIED;
|
|
}
|
|
|
|
// 새로운 경기가 생성되었을 때 부여될 인스턴스 번호
|
|
unsigned char nNewInstanceNo = INVALID_BATTLE_ARENA_INSTANCE_NO;
|
|
|
|
{
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
if( pArena->_isFull() )
|
|
return RESULT_LIMIT_MAX;
|
|
|
|
nNewInstanceNo = pArena->_allocNewInstanceNo();
|
|
if( nNewInstanceNo == INVALID_BATTLE_ARENA_INSTANCE_NO )
|
|
{
|
|
// 위에서는 _isFull() == false 였는데 새 방 번호 할당은 실패;? 정상은 아니지만 일단 방을 생성할 수 없다는 걸로 끝냄
|
|
return RESULT_LIMIT_MAX;
|
|
}
|
|
|
|
// 경기 생성(연습 경기는 등급 구분이 없이 기본 등급(BG_ROOKIE = 0)만 처리함)
|
|
unsigned short nErrorCode = pArena->_createNewBattle( BG_ROOKIE, nNewInstanceNo );
|
|
|
|
/* 로그 남겨야 할만한 오류 코드들은 로그 출력 및 성공 시 추가 뒷처리
|
|
// 현재는 따로 하는 일이 없어서 그냥 주석 처리
|
|
switch( nErrorCode )
|
|
{
|
|
// 로그 남길 리턴값들
|
|
case RESULT_LIMIT_MAX:
|
|
// 대기열 풀이면 방 만드는 시도 자체 이전에 대기열에 유저가 등록되는 액션 자체를 차단해야 하지 않나?
|
|
break;
|
|
case RESULT_ALREADY_EXIST:
|
|
// _addPlayer에서 기존에 가입되어 있던 파티에서 탈퇴시키는 처리 실패
|
|
break;
|
|
case RESULT_UNKNOWN:
|
|
// 뭐여;;
|
|
break;
|
|
|
|
// 일반적인 실패 케이스
|
|
case RESULT_LIMIT_MIN:
|
|
case RESULT_NOT_ENOUGH_BULLET:
|
|
break;
|
|
|
|
// 새로운 경기 생성 성공
|
|
case RESULT_SUCCESS:
|
|
break;
|
|
|
|
default:
|
|
// 예상 못 한 리턴값을 넘기는 곳을 찾아서 경우에 따라 로그를 남기거나 아무것도 안하는 그룹 case 들에 추가할 것
|
|
assert( 0 );
|
|
break;
|
|
}
|
|
로그 남겨야 할만한 오류 코드들은 로그 출력 및 성공 시 추가 뒷처리 */
|
|
|
|
// 플레이어 추가에 실패했다면 나머지 처리 중지
|
|
if( nErrorCode != RESULT_SUCCESS )
|
|
{
|
|
pArena->_freeInstanceNo( nNewInstanceNo );
|
|
return nErrorCode;
|
|
}
|
|
|
|
// 여기서 csArena가 풀리게 하는 이유는 스크립트 실행을 위한 지역락을 방금 할당된 레이어에만 걸기 위해서
|
|
// 단, 여기서 csArena를 풀었다가 지역락 걸고 다시 csArena를 걸기 전에 BattleArenaManager::onProcess -> BattleArenaInstance::_onProcess가
|
|
// 실행되면 방에 아무도 없기 때문에 한쪽 팀 전원 이탈로 방이 파괴될 수 있는데,
|
|
// 연습 경기의 경우에만 ReadyState가 없으면 _onProcess가 아무런 일도 하지 않게 되어있고, 이로 인해 방이 파괴되지 않음
|
|
// 다만 최초 1명이 경기에 참여된 이후에는 방이 파괴될 조건 체크(연습 경기는 사실상 첫 번째 팀이 0명인 경우만)가 이루어져야 하므로
|
|
// ReadyState를 0으로라도 세팅해줘야 함
|
|
}
|
|
|
|
{
|
|
ARCADIA_LOCK( pArena->LockWholeArena( nNewInstanceNo ) );
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
// csArena를 풀었다가 다시 거는 사이에 방이 파괴된 경우. 본래 파괴되지 않도록 보호되어야 하는데 왜 파괴되는지 확인해서 수정해야 함.
|
|
if( !pArena->_isOccupiedInstanceNo( nNewInstanceNo ) )
|
|
{
|
|
assert( 0 );
|
|
return RESULT_UNKNOWN;
|
|
}
|
|
|
|
BattleArenaInstance * pBattleInstance = pArena->_getBattleInstance( nNewInstanceNo );
|
|
|
|
if( !pBattleInstance )
|
|
{
|
|
// 위에서 _isOccupiedInstanceNo 체크를 했기 때문에 여기 올 수가 없는데;?
|
|
assert( 0 );
|
|
pArena->_freeInstanceNo( nNewInstanceNo );
|
|
return RESULT_LIMIT_MAX;
|
|
}
|
|
|
|
{
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
// 어딘가 다른쪽에서 이 경기의 레디 플래그를 손댄 경우
|
|
if( !pBattleInstance->_getFlag( FLAG_BATTLE_ARENA_EXERCISE_GAME_READY_STATE ).empty() )
|
|
{
|
|
// ... 고쳐야지;;
|
|
assert( 0 );
|
|
pArena->_freeInstanceNo( nNewInstanceNo );
|
|
return RESULT_UNKNOWN;
|
|
}
|
|
|
|
// 레디 플래그 세팅~(_setReadyExerciseGame 함수를 사용해서 복잡한 처리를 할 필요도 없이 레디 안 된 상태인 0으로 세팅)
|
|
pBattleInstance->_setFlag( FLAG_BATTLE_ARENA_EXERCISE_GAME_READY_STATE, "0" );
|
|
|
|
// 경기가 시작됐다면 스크립트 실행
|
|
// 지역락은 이미 걸려있고(경기를 생성한 유저 위치에 걸려있지만) csArena, csBattle도 걸린 상태
|
|
BattleArenaRunEventScript( pArena->m_pArenaBase, BASET_CREATE_INSTANCE, nNewInstanceNo, NULL );
|
|
|
|
// 플레이어가 참여 중인 아레나의 ID 값을 세팅해 줌(BattleArenaInstance::_addPlayer 호출을 준비하는 정도의 의미)
|
|
pPlayer->SetBattleArenaID( GameRule::BATTLE_ARENA_EXERCISE_GAME_ARENA_ID );
|
|
|
|
// 연습 경기는 가명이 사용되지 않음(다른데서 SetUseAlias( true )가 호출된 채로 여기에 들어오면 안 됨)
|
|
assert( !pPlayer->IsUsingAlias() );
|
|
|
|
// 경기를 생성한 유저를 첫 번째 팀의 첫 번째 유저로 추가(파티장이 됨)
|
|
unsigned short nErrorCode = pBattleInstance->_addPlayer( pPlayer, 0 );
|
|
|
|
if( nErrorCode != RESULT_SUCCESS )
|
|
{
|
|
// 이것도 보통은 일어날 수 없는 상황인데...;?
|
|
assert( 0 );
|
|
pPlayer->SetBattleArenaID( 0 );
|
|
|
|
// 일단 BASET_CREATE_INSTANCE 실행했으니 BASET_DESTROY_INSTANCE도 짝으로...
|
|
BattleArenaRunEventScript( pArena->m_pArenaBase, BASET_DESTROY_INSTANCE, nNewInstanceNo, NULL );
|
|
|
|
pArena->_freeInstanceNo( nNewInstanceNo );
|
|
return nErrorCode;
|
|
}
|
|
|
|
// 참여자에게 팀별 상세 정보 및 경기 시작 카운트(시작 시점: 시간값이 무조건 INFINITE_TIME 이겠지만...;;) 방송
|
|
SendBattleArenaBattleInfoMessage( pPlayer, pBattleInstance );
|
|
}
|
|
|
|
// 경기 생성 및 첫 번째 팀의 파티장도 추가됐으니 연습 경기 생성 처리는 완료
|
|
}
|
|
|
|
// 경기가 진행 중일 때는 BattleArenaManager의 update priority를 최상으로 높여 줌
|
|
// * UPDATE_PRIORITY_HIGH 정도여도 다 괜찮은데 빙고/킬 스크립트 예약/실행 딜레이가 너무 심해질 소지가 있어서;;
|
|
RaiseUpdatePriority();
|
|
|
|
return RESULT_SUCCESS;
|
|
}
|
|
|
|
unsigned short BattleArenaManager::JoinExerciseGameOpponentLeader( StructPlayer * pPlayer, int nInviterPartyID )
|
|
{
|
|
// 배틀 아레나 연습 경기용 파티에만 참여 가능(시작된 이후에는 파티 타입이 TYPE_BATTLE_ARENA_TEAM 으로 변경되므로 이 체크만으로도 어느정도 경기 상태를 포함해서 걸러짐)
|
|
if( !nInviterPartyID || PartyManager::GetInstance().GetPartyType( nInviterPartyID ) != PartyManager::TYPE_BATTLE_ARENA_EXERCISE_TEAM )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
int nArenaID = m_partyToArenaMap.Get( nInviterPartyID );
|
|
|
|
if( !nArenaID )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
BattleArena * pArena = getArena( nArenaID );
|
|
|
|
if( !pArena )
|
|
{
|
|
// m_partyToArenaMap에 nArenaID가 없던 것도 아니고 아예 잘못된 nArenaID 가 들어있었다는 얘기가 되므로 있어서는 안되는 상황
|
|
assert( 0 );
|
|
return RESULT_NOT_EXIST;
|
|
}
|
|
|
|
// 이하는 2개의 팀만 참여하는 경기 타입에 종속적인 코드를 포함하고 있음
|
|
if( pArena->m_pArenaBase->nTeamCount != 2 )
|
|
{
|
|
assert( 0 );
|
|
return RESULT_DB_ERROR;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
if( pPlayer->GetBattleArenaID() != 0 )
|
|
{
|
|
// 에러 코드가 모호하다.
|
|
return RESULT_NOT_EXIST;
|
|
}
|
|
|
|
int nInstanceNo = pArena->m_partyToInstanceMap.Get( nInviterPartyID );
|
|
|
|
// 방이 없거나 이미 해산됐다면...
|
|
if( !nInstanceNo )
|
|
// 즐
|
|
return RESULT_NOT_EXIST;
|
|
|
|
BattleArenaInstance * pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
// 이건 또 좀 이상하지만 여튼 체크...
|
|
if( !pBattleInstance )
|
|
// 또 즐
|
|
return RESULT_NOT_EXIST;
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
// 경기가 시작된 이후나 끝난 상태라면 참여 불가
|
|
if( pBattleInstance->m_bStart || pBattleInstance->m_bEnd )
|
|
return RESULT_NOT_ACTABLE;
|
|
|
|
// 초대 팀 상대편 팀에 아무도 없어야 함
|
|
int nInviterTeamNo = pBattleInstance->_getTeamNo( nInviterPartyID );
|
|
if( nInviterTeamNo == INVALID_BATTLE_ARENA_TEAM_NO )
|
|
{
|
|
// 응;? 초대 걸어놓고 나가서 초대자 파티가 해산된 경우라고 봐야 하나;? 어쨌든 정상 여부를 확인할 방법이 없으니 실패 처리.
|
|
assert( 0 );
|
|
return RESULT_NOT_EXIST;
|
|
}
|
|
|
|
// 초대한 팀 상대 팀에 파티가 결성되어 있다면 실패(두 명 이상에게 초대를 보내고 한 쪽이 먼저 수락하고 다른 쪽이 나중에 수락한 경우)
|
|
int nJoinTeamNo = 1 - nInviterTeamNo;
|
|
if( pBattleInstance->m_anPartyID[ nJoinTeamNo ][ 0 ] )
|
|
return RESULT_ALREADY_EXIST;
|
|
|
|
// _addPlayer 호출 전에 ArenaID 세팅
|
|
pPlayer->SetBattleArenaID( pArena->m_pArenaBase->nID );
|
|
|
|
// 연습 경기에 참여할 때는 가명 기능을 사용할 수 없음(다른데에서 SetUseAlias( true )가 호출됐던 채로 여기로 들어오면 안 됨)
|
|
assert( !pPlayer->IsUsingAlias() );
|
|
|
|
// 해당 팀에 유저 추가(파티 결성 등도 함께 처리)
|
|
unsigned short nResult = pBattleInstance->_addPlayer( pPlayer, nJoinTeamNo );
|
|
|
|
if( nResult != RESULT_SUCCESS )
|
|
{
|
|
pPlayer->SetBattleArenaID( 0 );
|
|
return nResult;
|
|
}
|
|
|
|
// 그리고 경기에 대한 정보 방송
|
|
SendBattleArenaBattleInfoMessage( pPlayer, pBattleInstance );
|
|
|
|
// 다른 유저들에게 현재 유저가 새로 참여했음을 알려 줌
|
|
BroadcastBattleArenaJoinBattleMessage( pBattleInstance, pPlayer );
|
|
|
|
return RESULT_SUCCESS;
|
|
}
|
|
|
|
unsigned short BattleArenaManager::JoinExerciseGameMember( StructPlayer * pPlayer, int nPartyID )
|
|
{
|
|
// 배틀 아레나 연습 경기용 파티에만 참여 가능(시작된 이후에는 파티 타입이 TYPE_BATTLE_ARENA_TEAM 으로 변경되므로 이 체크만으로도 어느정도 경기 상태를 포함해서 걸러짐)
|
|
if( !nPartyID || PartyManager::GetInstance().GetPartyType( nPartyID ) != PartyManager::TYPE_BATTLE_ARENA_EXERCISE_TEAM )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
int nArenaID = m_partyToArenaMap.Get( nPartyID );
|
|
|
|
if( !nArenaID )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
assert( nArenaID == GameRule::BATTLE_ARENA_EXERCISE_GAME_ARENA_ID );
|
|
BattleArena * pArena = getArena( nArenaID );
|
|
|
|
if( !pArena )
|
|
{
|
|
// m_partyToArenaMap에 nArenaID가 없던 것도 아니고 아예 잘못된 nArenaID 가 들어있었다는 얘기가 되므로 있어서는 안되는 상황
|
|
assert( 0 );
|
|
return RESULT_NOT_EXIST;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
if( pPlayer->GetBattleArenaID() != 0 )
|
|
{
|
|
return RESULT_NOT_EXIST;
|
|
}
|
|
|
|
unsigned char nInstanceNo = pArena->m_partyToInstanceMap.Get( nPartyID );
|
|
if( !nInstanceNo )
|
|
// 즐
|
|
return RESULT_NOT_EXIST;
|
|
|
|
BattleArenaInstance * pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
// 이건 또 좀 이상하지만 여튼 체크...
|
|
if( !pBattleInstance )
|
|
// 또 즐
|
|
return RESULT_NOT_EXIST;
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
// 경기가 시작된 이후나 끝난 상태라면 참여 불가
|
|
if( pBattleInstance->m_bStart || pBattleInstance->m_bEnd )
|
|
return RESULT_NOT_ACTABLE;
|
|
|
|
// 참여할 팀 번호 확인
|
|
int nTeamNo = pBattleInstance->_getTeamNo( nPartyID );
|
|
if( nTeamNo == INVALID_BATTLE_ARENA_TEAM_NO )
|
|
{
|
|
// 응;? 초대 걸어놓고 나가서 초대자 파티가 해산된 경우라고 봐야 하나;? 어쨌든 정상 여부를 확인할 방법이 없으니 실패 처리.
|
|
assert( 0 );
|
|
return RESULT_NOT_EXIST;
|
|
}
|
|
|
|
// 참여할 팀의 레디 상태 체크(초대한 후에 레디되었으면 그 이후에 수락 누른 유저는 참여 실패)
|
|
std::string strReady = pBattleInstance->_getFlag( FLAG_BATTLE_ARENA_EXERCISE_GAME_READY_STATE );
|
|
if( atoi( strReady.c_str() ) & ( 1 << nTeamNo ) )
|
|
return RESULT_ACCESS_DENIED;
|
|
|
|
// 플레이어가 참여 중인 아레나의 ID 값을 세팅해 줌(BattleArenaInstance::_addPlayer 호출을 준비하는 정도의 의미)
|
|
pPlayer->SetBattleArenaID( pArena->m_pArenaBase->nID );
|
|
|
|
// 연습 경기에 참여할 때는 가명 기능을 사용할 수 없음(다른데에서 SetUseAlias( true )가 호출됐던 채로 여기로 들어오면 안 됨)
|
|
assert( !pPlayer->IsUsingAlias() );
|
|
|
|
unsigned short nResult = pBattleInstance->_addPlayer( pPlayer, nTeamNo );
|
|
|
|
if( nResult != RESULT_SUCCESS )
|
|
{
|
|
pPlayer->SetBattleArenaID( 0 );
|
|
return nResult;
|
|
}
|
|
|
|
// 그리고 경기에 대한 정보 방송
|
|
SendBattleArenaBattleInfoMessage( pPlayer, pBattleInstance );
|
|
|
|
// 다른 유저들에게 현재 유저가 새로 참여했음을 알려 줌
|
|
BroadcastBattleArenaJoinBattleMessage( pBattleInstance, pPlayer );
|
|
|
|
return RESULT_SUCCESS;
|
|
}
|
|
|
|
unsigned short BattleArenaManager::SetReadyExerciseGame( StructPlayer * pPlayer, bool bReady )
|
|
{
|
|
// 배틀 아레나 연습 경기용 파티에 속한 상태에서만 레디 상태 변경 가능(시작된 이후에는 파티 타입이 TYPE_BATTLE_ARENA_TEAM 으로 변경되므로 이 체크만으로도 어느정도 경기 상태를 포함해서 걸러짐)
|
|
int nPartyID = pPlayer->GetPartyID();
|
|
if( !nPartyID || PartyManager::GetInstance().GetPartyType( nPartyID ) != PartyManager::TYPE_BATTLE_ARENA_EXERCISE_TEAM )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
int nArenaID = pPlayer->GetBattleArenaID();
|
|
|
|
if( !nArenaID )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
assert( nArenaID == GameRule::BATTLE_ARENA_EXERCISE_GAME_ARENA_ID && nArenaID == pPlayer->GetBattleArenaID() );
|
|
BattleArena * pArena = getArena( nArenaID );
|
|
|
|
if( !pArena )
|
|
{
|
|
// m_partyToArenaMap에 nArenaID가 없던 것도 아니고 아예 잘못된 nArenaID 가 들어있었다는 얘기가 되므로 있어서는 안되는 상황
|
|
assert( 0 );
|
|
return RESULT_NOT_EXIST;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
unsigned char nInstanceNo = pPlayer->GetBattleArenaInstanceNo();
|
|
assert( nInstanceNo == pArena->m_partyToInstanceMap.Get( nPartyID ) );
|
|
|
|
if( !nInstanceNo )
|
|
// 즐
|
|
return RESULT_NOT_EXIST;
|
|
|
|
BattleArenaInstance * pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
// 이건 또 좀 이상하지만 여튼 체크...
|
|
if( !pBattleInstance )
|
|
// 또 즐
|
|
return RESULT_NOT_EXIST;
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
return pBattleInstance->_setReadyExerciseGame( pPlayer, bReady );
|
|
}
|
|
|
|
unsigned short BattleArenaManager::StartExerciseGame( StructPlayer * pPlayer )
|
|
{
|
|
// 배틀 아레나 연습 경기용 파티에 속한 상태에서만 경기 시작 시도 가능(시작된 이후에는 파티 타입이 TYPE_BATTLE_ARENA_TEAM 으로 변경되므로 이 체크만으로도 어느정도 경기 상태를 포함해서 걸러짐)
|
|
int nPartyID = pPlayer->GetPartyID();
|
|
if( !nPartyID || PartyManager::GetInstance().GetPartyType( nPartyID ) != PartyManager::TYPE_BATTLE_ARENA_EXERCISE_TEAM )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
int nArenaID = m_partyToArenaMap.Get( nPartyID );
|
|
|
|
if( !nArenaID )
|
|
return RESULT_NOT_EXIST;
|
|
|
|
if( nArenaID != GameRule::BATTLE_ARENA_EXERCISE_GAME_ARENA_ID || nArenaID != pPlayer->GetBattleArenaID() )
|
|
return RESULT_ACCESS_DENIED;
|
|
|
|
BattleArena * pArena = getArena( nArenaID );
|
|
|
|
if( !pArena )
|
|
{
|
|
// m_partyToArenaMap에 nArenaID가 없던 것도 아니고 아예 잘못된 nArenaID 가 들어있었다는 얘기가 되므로 있어서는 안되는 상황
|
|
assert( 0 );
|
|
return RESULT_NOT_EXIST;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
unsigned char nInstanceNo = pPlayer->GetBattleArenaInstanceNo();
|
|
assert( nInstanceNo == pArena->m_partyToInstanceMap.Get( nPartyID ) );
|
|
|
|
if( !nInstanceNo )
|
|
// 즐
|
|
return RESULT_NOT_EXIST;
|
|
|
|
BattleArenaInstance * pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
// 이건 또 좀 이상하지만 여튼 체크...
|
|
if( !pBattleInstance )
|
|
// 또 즐
|
|
return RESULT_NOT_EXIST;
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
// 경기가 시작된 이후나 끝난 상태라면 변경 불가
|
|
if( pBattleInstance->m_bStart || pBattleInstance->m_bEnd )
|
|
return RESULT_NOT_ACTABLE;
|
|
|
|
// 시작은 해당 경기의 첫 번째 팀의 첫 번째 파티의 파티장만이 가능
|
|
if( nPartyID != pBattleInstance->m_anPartyID[ 0 ][ 0 ] || !PartyManager::GetInstance().IsLeader( nPartyID, pPlayer->GetPlayerUID() ) )
|
|
return RESULT_ACCESS_DENIED;
|
|
|
|
std::string strReady = pBattleInstance->_getFlag( FLAG_BATTLE_ARENA_EXERCISE_GAME_READY_STATE );
|
|
int nReadyState = atoi( strReady.c_str() );
|
|
|
|
// 전 팀의 레디 상태 체크
|
|
for( int nTeamNo = 0 ; nTeamNo < pBattleInstance->m_pArenaBase->nTeamCount ; ++nTeamNo )
|
|
{
|
|
if( !( nReadyState & ( 1 << nTeamNo ) ) )
|
|
return RESULT_NOT_READY;
|
|
}
|
|
|
|
// 파티 타입을 TYPE_BATTLE_ARENA_EXERCISE_TEAM 에서 TYPE_BATTLE_ARENA_TEAM 으로 변경해 줌
|
|
for( int nTeamNo = 0 ; nTeamNo < pBattleInstance->m_pArenaBase->nTeamCount ; ++nTeamNo )
|
|
{
|
|
if( !PartyManager::GetInstance().ChangeBattleArenaExerciseTeamType( pBattleInstance->m_anPartyID[ nTeamNo ][ 0 ], false ) )
|
|
{
|
|
// 중간에 실패했으면 모두 롤백 'ㅠ ';
|
|
for( int nPrevTeamNo = 0 ; nPrevTeamNo < nTeamNo ; ++nPrevTeamNo )
|
|
{
|
|
PartyManager::GetInstance().ChangeBattleArenaExerciseTeamType( pBattleInstance->m_anPartyID[ nPrevTeamNo ][ 0 ], true );
|
|
}
|
|
|
|
return RESULT_INVALID_ARGUMENT;
|
|
}
|
|
}
|
|
|
|
// 경기 시작
|
|
// BattleArenaInstance의 시작 및 그와 관련된 모든 시간값만 바꿔주고,
|
|
// 참여자 전원이 입장되도록 입장 시각 세팅해주고,
|
|
// 나머지는 onProcess에서 시작처리가 다 이루어지게만 함
|
|
AR_TIME tCurrent = GetArTime();
|
|
pBattleInstance->SetDefaultTimeByStartTime( tCurrent );
|
|
|
|
for( int nTeamNo = 0 ; nTeamNo < pBattleInstance->m_pArenaBase->nTeamCount ; ++nTeamNo )
|
|
{
|
|
std::vector< BattleArenaInstance::PlayerInfo >* pPlayerInfoList = pBattleInstance->_getPlayerInfoList( nTeamNo );
|
|
for( std::vector< BattleArenaInstance::PlayerInfo >::iterator it = pPlayerInfoList->begin() ; it != pPlayerInfoList->end() ; ++it )
|
|
{
|
|
(*it).nPendedEnterTime = tCurrent;
|
|
}
|
|
}
|
|
|
|
BroadcastBattleArenaBattleInfoMessage( pBattleInstance );
|
|
|
|
return RESULT_SUCCESS;
|
|
}
|
|
|
|
bool BattleArenaManager::IsReadyExerciseTeam( int nPartyID ) const
|
|
{
|
|
if( !nPartyID || PartyManager::GetInstance().GetPartyType( nPartyID ) != PartyManager::TYPE_BATTLE_ARENA_EXERCISE_TEAM )
|
|
return false;
|
|
|
|
int nArenaID = m_partyToArenaMap.Get( nPartyID );
|
|
|
|
if( nArenaID != GameRule::BATTLE_ARENA_EXERCISE_GAME_ARENA_ID )
|
|
{
|
|
assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
const BattleArena * pArena = getArena( nArenaID );
|
|
|
|
if( !pArena )
|
|
{
|
|
// m_partyToArenaMap에 nArenaID가 없던 것도 아니고 아예 잘못된 nArenaID 가 들어있었다는 얘기가 되므로 있어서는 안되는 상황
|
|
assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
int nInstanceNo = pArena->m_partyToInstanceMap.Get( nPartyID );
|
|
|
|
// 방이 없거나 이미 해산됐다면...
|
|
if( !nInstanceNo )
|
|
// 즐
|
|
return false;
|
|
|
|
const BattleArenaInstance * pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
// 이건 또 좀 이상하지만 여튼 체크...
|
|
if( !pBattleInstance || pBattleInstance->m_bEnd )
|
|
// 또 즐
|
|
return false;
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
// 체크하려는 파티의 팀 번호 얻기
|
|
int nTeamNo = pBattleInstance->_getTeamNo( nPartyID );
|
|
if( nTeamNo == INVALID_BATTLE_ARENA_TEAM_NO )
|
|
{
|
|
// 파티 ID 기준으로 아레나를 찾았는데 해당 파티가 소속된 팀은 없는 경우
|
|
// m_partyToArenaMap, m_partyToInstanceMap 이 락을 따로 쓰지 않아서 생길 가능성이 있긴 함(csBattle 걸기 직전에 파티 해산)
|
|
return false;
|
|
}
|
|
|
|
std::string strReady = pBattleInstance->_getFlag( FLAG_BATTLE_ARENA_EXERCISE_GAME_READY_STATE );
|
|
int nReadyState = atoi( strReady.c_str() );
|
|
|
|
return !!( nReadyState & ( 1 << nTeamNo ) );
|
|
}
|
|
|
|
bool BattleArenaManager::HasOpponent( StructPlayer * pPlayer ) const
|
|
{
|
|
int nPartyID = pPlayer->GetPartyID();
|
|
|
|
if( !nPartyID || !PartyManager::GetInstance().IsBattleArenaTeamParty( nPartyID ) )
|
|
return false;
|
|
|
|
int nArenaID = pPlayer->GetBattleArenaID();
|
|
if( !nArenaID )
|
|
return false;
|
|
|
|
const BattleArena * pArena = getArena( nArenaID );
|
|
|
|
if( !pArena )
|
|
{
|
|
assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
int nInstanceNo = pPlayer->GetBattleArenaInstanceNo();
|
|
if( !nInstanceNo )
|
|
return false;
|
|
|
|
const BattleArenaInstance * pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
if( !pBattleInstance )
|
|
{
|
|
assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
int nTeamNo = pBattleInstance->_getTeamNo( nPartyID );
|
|
if( nTeamNo == INVALID_BATTLE_ARENA_TEAM_NO )
|
|
{
|
|
assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
int nOpponentTeamNo = 1 - nTeamNo;
|
|
return (pBattleInstance->_getTeamMemberCount( nOpponentTeamNo ) != 0);
|
|
}
|
|
|
|
bool BattleArenaManager::IsMoreMemberInvitable( StructPlayer * pPlayer ) const
|
|
{
|
|
int nPartyID = pPlayer->GetPartyID();
|
|
|
|
if( !nPartyID || PartyManager::GetInstance().GetPartyType( nPartyID ) != PartyManager::TYPE_BATTLE_ARENA_EXERCISE_TEAM )
|
|
return false;
|
|
|
|
int nArenaID = pPlayer->GetBattleArenaID();
|
|
if( !nArenaID )
|
|
return false;
|
|
|
|
const BattleArena * pArena = getArena( nArenaID );
|
|
|
|
if( !pArena )
|
|
{
|
|
assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
int nInstanceNo = pPlayer->GetBattleArenaInstanceNo();
|
|
if( !nInstanceNo )
|
|
return false;
|
|
|
|
const BattleArenaInstance * pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
if( !pBattleInstance )
|
|
{
|
|
assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
int nTeamNo = pBattleInstance->_getTeamNo( nPartyID );
|
|
if( nTeamNo == INVALID_BATTLE_ARENA_TEAM_NO )
|
|
{
|
|
assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
return ( pBattleInstance->m_pArenaBase->nMaxMember / pBattleInstance->m_pArenaBase->nTeamCount ) >= pBattleInstance->_getTeamMemberCount( nTeamNo );
|
|
}
|
|
|
|
bool BattleArenaManager::SetBattleInstanceFlag( int nArenaID, unsigned char nInstanceNo, const char * pszName, const char * pszValue )
|
|
{
|
|
if( !nArenaID || !nInstanceNo )
|
|
return false;
|
|
|
|
BattleArena * pArena = getArena( nArenaID );
|
|
|
|
if( !pArena )
|
|
{
|
|
assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
BattleArenaInstance * pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
if( !pBattleInstance )
|
|
return false;
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
pBattleInstance->_setFlag( pszName, pszValue );
|
|
return true;
|
|
}
|
|
|
|
std::string BattleArenaManager::GetBattleInstanceFlag( int nArenaID, unsigned char nInstanceNo, const char * pszName ) const
|
|
{
|
|
if( !nArenaID || !nInstanceNo )
|
|
return "";
|
|
|
|
const BattleArena * pArena = getArena( nArenaID );
|
|
|
|
if( !pArena )
|
|
{
|
|
assert( 0 );
|
|
return "";
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
const BattleArenaInstance * pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
if( !pBattleInstance )
|
|
return "";
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
return pBattleInstance->_getFlag( pszName );
|
|
}
|
|
|
|
int BattleArenaManager::GetTeamNo( const StructPlayer * pPlayer ) const
|
|
{
|
|
int nArenaID = pPlayer->GetBattleArenaID();
|
|
unsigned char nInstanceNo = pPlayer->GetBattleArenaInstanceNo();
|
|
int nPartyID = pPlayer->GetPartyID();
|
|
|
|
if( !nArenaID || !IsValidBattleArenaInstanceNo( nInstanceNo ) || !nPartyID )
|
|
return INVALID_BATTLE_ARENA_TEAM_NO;
|
|
|
|
const BattleArena * pArena = getArena( nArenaID );
|
|
|
|
if( !pArena )
|
|
return INVALID_BATTLE_ARENA_TEAM_NO;
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
const BattleArenaInstance * pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
if( !pBattleInstance )
|
|
return INVALID_BATTLE_ARENA_TEAM_NO;
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
return pBattleInstance->_getTeamNo( nPartyID );
|
|
}
|
|
|
|
bool BattleArenaManager::IsOpponent( const StructPlayer * pPlayer, const StructPlayer * pTarget ) const
|
|
{
|
|
int nPartyID = pPlayer->GetPartyID();
|
|
int nTargetPartyID = pTarget->GetPartyID();
|
|
|
|
if( !nPartyID || !nTargetPartyID ||
|
|
PartyManager::GetInstance().GetPartyType( nPartyID ) != PartyManager::TYPE_BATTLE_ARENA_TEAM ||
|
|
PartyManager::GetInstance().GetPartyType( nTargetPartyID ) != PartyManager::TYPE_BATTLE_ARENA_TEAM )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
int nArenaID = pPlayer->GetBattleArenaID();
|
|
int nInstanceNo = pPlayer->GetBattleArenaInstanceNo();
|
|
|
|
if( !nArenaID || !nInstanceNo || nArenaID != pTarget->GetBattleArenaID() || nInstanceNo != pTarget->GetBattleArenaInstanceNo() )
|
|
return false;
|
|
|
|
const BattleArena * pArena = getArena( nArenaID );
|
|
|
|
if( !pArena )
|
|
{
|
|
assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
const BattleArenaInstance * pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
if( !pBattleInstance )
|
|
return false;
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
if( !pBattleInstance->m_bStart || pBattleInstance->m_bEnd )
|
|
return false;
|
|
|
|
int nTeamNo = pBattleInstance->_getTeamNo( nPartyID );
|
|
int nTargetTeamNo = pBattleInstance->_getTeamNo( nTargetPartyID );
|
|
if( nTeamNo == INVALID_BATTLE_ARENA_TEAM_NO || nTargetTeamNo == INVALID_BATTLE_ARENA_TEAM_NO )
|
|
return false;
|
|
|
|
return nTeamNo != nTargetTeamNo;
|
|
}
|
|
|
|
bool BattleArenaManager::GetRevivePosition( const StructPlayer * pPlayer, ArPosition & posRevive ) const
|
|
{
|
|
int nPartyID = pPlayer->GetPartyID();
|
|
if( !nPartyID )
|
|
return false;
|
|
|
|
int nArenaID = pPlayer->GetBattleArenaID();
|
|
if( !nArenaID )
|
|
return false;
|
|
|
|
const BattleArena * pArena = getArena( nArenaID );
|
|
if( !pArena )
|
|
return false;
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
unsigned char nInstanceNo = pPlayer->GetBattleArenaInstanceNo();
|
|
if( !nInstanceNo )
|
|
return false;
|
|
|
|
const BattleArenaInstance * pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
if( !pBattleInstance )
|
|
return false;
|
|
|
|
THREAD_SYNCHRONIZE2( pBattleInstance->m_csBattle );
|
|
|
|
int nTeamNo = pBattleInstance->_getTeamNo( nPartyID );
|
|
if( nTeamNo == INVALID_BATTLE_ARENA_TEAM_NO )
|
|
return false;
|
|
|
|
posRevive = pArena->m_pArenaBase->posStart[ nTeamNo ];
|
|
return true;
|
|
}
|
|
|
|
bool BattleArenaManager::IsCastablePropForTeam( int nArenaID, unsigned char nInstanceNo, const StructFieldProp * pProp, int nPartyID ) const
|
|
{
|
|
if( !nArenaID || !nInstanceNo )
|
|
return false;
|
|
|
|
const BattleArena * pArena = getArena( nArenaID );
|
|
|
|
if( !pArena )
|
|
{
|
|
assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
const BattleArenaInstance * pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
if( !pBattleInstance )
|
|
return false;
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
// 진행 중이지 않은 경기는 프랍 사용 불가
|
|
if( !pBattleInstance->m_bStart || pBattleInstance->m_bEnd )
|
|
return false;
|
|
|
|
int nTeamNo = pBattleInstance->_getTeamNo( nPartyID );
|
|
if( nTeamNo == INVALID_BATTLE_ARENA_TEAM_NO )
|
|
return false;
|
|
|
|
return pBattleInstance->_isCastablePropForTeam( pProp, nTeamNo );
|
|
}
|
|
|
|
// 다각형과 점의 포함관계 체크에서 CCW 체크 이상 빠르고 간단한 로직을 못 봤음. 그래서 일단 이걸로 ㄱㄱ싱.
|
|
// 단, 이걸 쓰기 위해서는 다각형이 아래의 조건을 만족해야 함
|
|
// 1. 볼록 다각형이어야 함
|
|
// (둔각인 내각이 생기면 다각형의 각 선분에 대해 점이 왼쪽 혹은 오른쪽에 있다는 판정만으로 포함관계를 확인할 수 없음)
|
|
// 2. 원점이 왼쪽 위인 2차원 좌표계(그림판 또는 포샵)에서 봤을 때 각 꼭지점 목록이 CCW 방향으로 이어져야 함
|
|
// (순서가 반대가 되면 내외부 판정이 반대로 나옴)
|
|
|
|
// CheckCCW: (x1, y1) - (x2, y2) 선분(벡터)과 (x2, y2) - (ptx, pty) 선분(벡터)의 내적을 계산해 줌
|
|
// 리턴값이 0 이면 두 선분이 나란함을 의미하며,
|
|
// 0 보다 작은 경우는 (x1, y1) - (x2, y2) 선분의 진행 방향 기준으로 왼쪽에 (ptx, pty)가 있다는 것을,
|
|
// 0 보다 큰 경우는 반대로 오른쪽에 (ptx, pty)가 있다는 것을 의미함
|
|
AR_UNIT CheckCCW( AR_UNIT x1, AR_UNIT y1, AR_UNIT x2, AR_UNIT y2, AR_UNIT ptx, AR_UNIT pty )
|
|
{
|
|
return ( x2 - x1 ) * ( pty - y1 ) - ( y2 - y1 ) * ( ptx - x1 );
|
|
}
|
|
|
|
// IsPointIncludedCCW: CheckCCW만을 이용해서 다각형과 점 사이의 포함 관계 체크
|
|
// 모든 선분에 대해 지정된 점이 한 방향(CCW로 각 변이 진행되는 다각형의 경우 왼쪽)에 있다면 다각형 내부에 있다는 것이 됨
|
|
// 단, 이 로직의 전제 조건은 다각형이 볼록 다각형이라는 것(오목 다각형은 도형 내부의 점인데 특정 변의 오른쪽에 점이 위치하기도 함)
|
|
bool IsPointIncludedCCW( const X2D::Polygon< AR_UNIT > * pPolygon, const ArPosition & pt, bool bIncludeOnEdge )
|
|
{
|
|
if( !pPolygon )
|
|
{
|
|
assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
const size_t nVertexCount = pPolygon->Size();
|
|
if( !nVertexCount )
|
|
{
|
|
assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
const X2D::Point< AR_UNIT > * pPointList = pPolygon->GetRawPoint();
|
|
for( size_t i = 0 ; i < nVertexCount ; ++i )
|
|
{
|
|
const X2D::Point< AR_UNIT > & lineBegin = pPointList[ i ];
|
|
const X2D::Point< AR_UNIT > & lineEnd = pPointList[ ( i + 1 ) % nVertexCount ];
|
|
|
|
AR_UNIT fCCW = CheckCCW( lineBegin.x, lineBegin.y, lineEnd.x, lineEnd.y, pt.x, pt.y );
|
|
if( bIncludeOnEdge && fCCW > 0 )
|
|
return false;
|
|
if( !bIncludeOnEdge && fCCW >= 0 )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// GetCollidedPointCCW: CheckCCW를 응용한 두 선분 사이의 충돌점 계산
|
|
// 두 선분(다각형의 각 변과 이동 경로)의 각 방향에 대한 내적 값을 계산해서 정규화 시키면 서로의 내적 값이 0.0 ~ 1.0 이면 두 선분이 교차하는 것이 됨
|
|
bool GetCollidedPointCCW( const X2D::Polygon< AR_UNIT > * pPolygon, const ArPosition & ptBegin, const ArPosition & ptEnd, ArPosition & ptCollision )
|
|
{
|
|
if( !pPolygon )
|
|
{
|
|
assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
const size_t nVertexCount = pPolygon->Size();
|
|
if( !nVertexCount )
|
|
{
|
|
assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
const X2D::Point< AR_UNIT > * pPointList = pPolygon->GetRawPoint();
|
|
for( size_t i = 0 ; i < nVertexCount ; ++i )
|
|
{
|
|
const X2D::Point< AR_UNIT > & lineBegin = pPointList[ i ];
|
|
const X2D::Point< AR_UNIT > & lineEnd = pPointList[ ( i + 1 ) % nVertexCount ];
|
|
|
|
// 두 선분이 각각 포함되는 AABB가 서로 겹치지 않는다면 충돌 체크 불필요
|
|
if( std::min( lineBegin.x, lineEnd.x ) > std::max( ptBegin.x, ptEnd.x ) ||
|
|
std::max( lineBegin.x, lineEnd.x ) < std::min( ptBegin.x, ptEnd.x ) ||
|
|
std::min( lineBegin.y, lineEnd.y ) > std::max( ptBegin.y, ptEnd.y ) ||
|
|
std::max( lineBegin.y, lineEnd.y ) < std::min( ptBegin.y, ptEnd.y ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// 교차 체크
|
|
AR_UNIT numeratorAB = ( lineBegin.y - ptBegin.y ) * ( ptEnd.x - ptBegin.x ) - ( lineBegin.x - ptBegin.x ) * ( ptEnd.y - ptBegin.y );
|
|
AR_UNIT denominator = ( lineEnd.x - lineBegin.x ) * ( ptEnd.y - ptBegin.y ) - ( lineEnd.y - lineBegin.y ) * ( ptEnd.x - ptBegin.x );
|
|
|
|
// 두 선분의 기울기가 동일
|
|
if( !denominator )
|
|
{
|
|
// 공선(위상도 같음, 두 선분을 무한 연장하면 같은 선이 됨)
|
|
if( !numeratorAB )
|
|
{
|
|
// 게다가 이미 AABB가 겹친다는 것도 확인했기 때문에 충돌 점이 생기는 게 아니라 겹치는 선분 영역이 발생됨
|
|
// 번거로우니 이번 선분의 시작점을 그냥 교차점으로 반환 -ㅠ -
|
|
ptCollision = ptBegin;
|
|
return true;
|
|
}
|
|
|
|
// 평행선(절대 만나지 않음)
|
|
continue;
|
|
}
|
|
|
|
AR_UNIT numeratorCD = ( lineBegin.y - ptBegin.y ) * ( lineEnd.x - lineBegin.x ) - ( lineBegin.x - ptBegin.x ) * ( lineEnd.y - lineBegin.y );
|
|
|
|
// numeratorCD == 0.0f 인 경우는 ptBegin이 [lineBegin, lineEnd]인 변과 맞닿아 있었다는 이야기가 됨
|
|
// 이건 충돌점으로 뽑아내면 안되고 무시해야 함
|
|
if( numeratorCD == 0.0f )
|
|
continue;
|
|
|
|
if( denominator < 0 )
|
|
{
|
|
denominator *= -1;
|
|
numeratorAB *= -1;
|
|
numeratorCD *= -1;
|
|
}
|
|
|
|
float factorAB = ( (float)numeratorAB ) / denominator;
|
|
float factorCD = ( (float)numeratorCD ) / denominator;
|
|
|
|
if( factorCD >= 0.0f && factorCD <= 1.0f )
|
|
{
|
|
if( factorAB >= 0.0f && factorAB <= 1.0f )
|
|
{
|
|
X2D::Point< AR_UNIT > ptCol = lineBegin + ( ( lineEnd - lineBegin ) * factorAB );
|
|
ptCollision.x = ptCol.x;
|
|
ptCollision.y = ptCol.y;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool BattleArenaManager::ValidateMovableRoute( int nArenaID, unsigned char nInstanceNo, int nPartyID, const ArPosition & posStart, std::vector< ArPosition > & vMoveInfo ) const
|
|
{
|
|
if( !nArenaID || !nInstanceNo || vMoveInfo.empty() )
|
|
return false;
|
|
|
|
const BattleArena * pArena = getArena( nArenaID );
|
|
|
|
if( !pArena )
|
|
{
|
|
assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
// csArena, csBattle 걸고 체크해야 할 것만 체크하고 락 해제
|
|
// * 이동 경로 조정 대상으로 확인된 경우의 처리는 락 없이 할 수 있지만 부하가 높은 편이므로.
|
|
int nTeamNo = 0;
|
|
{
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
const BattleArenaInstance * pBattleInstance = pArena->_getBattleInstance( nInstanceNo );
|
|
|
|
if( !pBattleInstance )
|
|
return false;
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
if( pBattleInstance->m_bStart )
|
|
return false;
|
|
|
|
nTeamNo = pBattleInstance->_getTeamNo( nPartyID );
|
|
// 소속 팀이 없는 경우;? 아레나 내부에 있는데;?
|
|
if( nTeamNo == INVALID_BATTLE_ARENA_TEAM_NO )
|
|
{
|
|
assert( 0 );
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// { 시작 전의 경기장 내에서 이동임이 확인되었으므로 이동 경로 체크 및 시작 영역을 벗어나려는 경우 경로 제한
|
|
|
|
// * 출발점은 경로 조정에서 제외됨
|
|
|
|
// 충돌 체크 대상이 될 폴리곤 선정(시작 영역 정보가 없는 경우에는 아무 체크도 안 함)
|
|
const X2D::Polygon< AR_UNIT > * pBeginArea = pArena->m_pArenaBase->apBeginAreaList[ nTeamNo ];
|
|
if( !pBeginArea )
|
|
return false;
|
|
|
|
// 출발점의 시작 영역 내외부 판정
|
|
bool bPrevPosIsInside = IsPointIncludedCCW( pBeginArea, posStart, true );
|
|
|
|
// 출발점이 영역 외부라면 직선으로 영역 내부로 이동하는 것만 허용(가다 멈추더라도 어차피 영역쪽으로 점점 가까워지니까...)
|
|
if( !bPrevPosIsInside )
|
|
{
|
|
if( vMoveInfo.size() != 1 || !IsPointIncludedCCW( pBeginArea, vMoveInfo.front(), false ) )
|
|
{
|
|
vMoveInfo.clear();
|
|
return true;
|
|
}
|
|
|
|
// 여기 오면 한 방에 영역 내부로 이동을 시도하는 경우이므로 별도의 검사 없이 넘겨 줌
|
|
return false;
|
|
}
|
|
|
|
// 출발점이 영역 내부이므로 이후 이동 경로 지점이 영역 밖으로 나간 점이 있는지 체크
|
|
for( std::vector< ArPosition >::iterator it = vMoveInfo.begin() ; it != vMoveInfo.end() ; ++it )
|
|
{
|
|
const ArPosition & prevPos = ( it == vMoveInfo.begin() ) ? posStart : ( *( it - 1 ) );
|
|
ArPosition & nextPos = (*it);
|
|
|
|
// 선분의 도착점이 외부로 나가는 경우만 경로 재조정(경로 최초 출발점부터 현재 체크 선분의 출발점까지 모두 도형 안쪽이었던 상태)
|
|
if( IsPointIncludedCCW( pBeginArea, nextPos, false ) )
|
|
{
|
|
// 시작 영역 내부로의 이동이라면 별다른 처리 없이 다음 이동 지점 체크
|
|
continue;
|
|
}
|
|
|
|
// 시작 영역 외부로의 이동이므로 경로를 잘라냄(도착점 보정)
|
|
ArPosition posCollision;
|
|
if( GetCollidedPointCCW( pBeginArea, prevPos, nextPos, posCollision ) )
|
|
{
|
|
// 충돌은 했는데 prevPos와 같은 점이 충돌점이라고 나왔으면 그냥 nextPos부터 다 삭제
|
|
if( prevPos == posCollision )
|
|
{
|
|
vMoveInfo.erase( it, vMoveInfo.end() );
|
|
}
|
|
else
|
|
{
|
|
// 충돌점이 확인됐으면 nextPos를 충돌점으로 변경해서 경로를 잘라 내고 이후 이동 경로를 모두 제거
|
|
nextPos = posCollision;
|
|
vMoveInfo.erase( it + 1, vMoveInfo.end() );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// prevPos가 영역 안에 있었고, nextPos가 영역 밖으로 나갔는데 충돌이 감지되지 않은 경우
|
|
// 경계선 위에 서 있던 채로 밖으로 나가는 경우에 최초 출발점의 내외부 판정에서는
|
|
// 일단 이번 선분의 시작 점에서 경로가 종료되도록 조정
|
|
vMoveInfo.erase( it, vMoveInfo.end() );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// } 시작 전의 경기장 내에서 이동임이 확인되었으므로 이동 경로 체크 및 시작 영역을 벗어나려는 경우 경로 제한
|
|
|
|
// 여기까지 왔다는 건 중간에 경로 보정이 발생하지 않았다는 의미이므로 충돌하지 않았다는 걸로 반환
|
|
return false;
|
|
}
|
|
|
|
bool BattleArenaManager::IsOfflinePenaltyReceivedPlayer( PlayerUID nPlayerUID )
|
|
{
|
|
THREAD_SYNCHRONIZE( m_csOfflinePenaltyReceivedPlayer );
|
|
|
|
std::vector< PlayerUID >::iterator it = std::find( m_vOfflinePenaltyReceivedPlayerUIDList.begin(), m_vOfflinePenaltyReceivedPlayerUIDList.end(), nPlayerUID );
|
|
|
|
if( it != m_vOfflinePenaltyReceivedPlayerUIDList.end() )
|
|
{
|
|
m_vOfflinePenaltyReceivedPlayerUIDList.erase( it );
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void BattleArenaManager::AddOfflinePenaltyReceivedPlayer( PlayerUID nPlayerUID )
|
|
{
|
|
THREAD_SYNCHRONIZE( m_csOfflinePenaltyReceivedPlayer );
|
|
|
|
if( std::find( m_vOfflinePenaltyReceivedPlayerUIDList.begin(), m_vOfflinePenaltyReceivedPlayerUIDList.end(), nPlayerUID ) != m_vOfflinePenaltyReceivedPlayerUIDList.end() )
|
|
{
|
|
assert( 0 );
|
|
return;
|
|
}
|
|
|
|
m_vOfflinePenaltyReceivedPlayerUIDList.push_back( nPlayerUID );
|
|
}
|
|
|
|
void BattleArenaManager::RemoveOfflinePenaltyReceivedPlayer( PlayerUID nPlayerUID )
|
|
{
|
|
THREAD_SYNCHRONIZE( m_csOfflinePenaltyReceivedPlayer );
|
|
|
|
std::vector< PlayerUID >::iterator it = std::find( m_vOfflinePenaltyReceivedPlayerUIDList.begin(), m_vOfflinePenaltyReceivedPlayerUIDList.end(), nPlayerUID );
|
|
|
|
if( it != m_vOfflinePenaltyReceivedPlayerUIDList.end() )
|
|
m_vOfflinePenaltyReceivedPlayerUIDList.erase( it );
|
|
}
|
|
|
|
void BattleArenaManager::onProcess( int nThreadIdx )
|
|
{
|
|
// onProcess가 할 일들
|
|
// - 유효한 경기에 대한 개별 처리
|
|
// * 해제되어야 할 경기 인스턴스의 뒷처리
|
|
// * 진행 중인 경기의 개별 처리(BattleArenaInstance::_onProcess)
|
|
// * 진행 중인 경기에 입장해야 하는 유저 처리
|
|
// - 등급별 각 대기열에 대한 경기 시작 가능성 체크 및 경기 시작 처리
|
|
|
|
// 시험적인 락 정책
|
|
// - 지역 락 -> csArena -> csBattle 의 순서로 락을 걸어야 하는데, 지역 락을 먼저 걸고 방 목록을 순회하려면
|
|
// 특정 레이어만 락을 걸지 못하고 전체 레이어에 락을 걸어야 하기 때문에 같은 타입의 경기끼리 지역락 간섭이 심하게 발생할 가능성이 높음.
|
|
// 따라서 아래와 같은 순서로 처리를 시도해 봄.(성능이 별로거나 문제가 있으면 그냥 전체 레이어 걸고 ㄱㄱ싱~)
|
|
// * csArena 만 걸고 현재 게임이 진행 중인 레이어 목록 수집(로컬 std::vector 인스턴스에)
|
|
// * 로컬 std::vector 인스턴스인 레이어 목록 순회
|
|
// v 현재 순회 대상인 레이어에만 지역락
|
|
// v csArena
|
|
// v 현재 순회 대상인 레이어에 해당하는 BattleArenaInstance 검색
|
|
// v csBattle
|
|
// v csArena, csBattle이 풀렸다가 걸렸기 때문에 그 사이에 경기가 종료되지 않았는지 체크
|
|
// 경기가 종료됐다면 다음 레이어로 진행
|
|
// v 처리해야 할 내용 처리
|
|
//
|
|
// 이 방식을 사용하면 지역락을 레이어별로 걸고 처리할 수 있지만 csArena를 한 번 풀었다가 다시 걸어야 한다는 문제점 때문에
|
|
// csArena가 풀렸다가 걸리는 사이에 새로 생성된 방의 경우는 최초 1회의 처리가 누락됨
|
|
|
|
// BattleArenaManager의 update priority 조절을 위한 체크
|
|
bool bActiveBattleInstanceExist = false;
|
|
|
|
for( std::vector< BattleArena * >::iterator itArena = m_vArenaList.begin() ; itArena != m_vArenaList.end() ; ++itArena )
|
|
{
|
|
BattleArena * pArena = (*itArena);
|
|
|
|
// 경기 정보가 유효한 레이어 번호 수집
|
|
std::vector< unsigned char > vActiveLayerList;
|
|
{
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
vActiveLayerList = pArena->m_vActiveLayerList;
|
|
}
|
|
|
|
// 유효한 레이어에 대해 레이어별로 지역락부터 다시 걸고 처리
|
|
for( std::vector< unsigned char >::iterator itLayer = vActiveLayerList.begin() ; itLayer != vActiveLayerList.end() ; ++itLayer )
|
|
{
|
|
unsigned char nLayer = (*itLayer);
|
|
|
|
// 여기서 사용하는 각종 락(아레나 지역락, csArena, csBattle)이 걸린 상태에서는
|
|
// 아레나 외부에 있는 유저를 아레나 내부로 강제로 워프시키거나 스크립트 처리를 할 수 없기 때문에
|
|
// 내부로 강제 워프시켜야 하는 유저 목록만 따로 수집하고, 모든 락을 푼 시점에 해당 처리를 몰아서 함
|
|
// * pair의 first 멤버 타입이 StructPlayer * 가 아니라 StructPlayer::iterator 인 이유는
|
|
// 아래쪽에서 이 벡터를 처리할 때는 아무런 락도 걸려있지 않은 상태이기 때문에
|
|
// 리스트에 내용을 채울 당시에는 유효하던 StructPlayer * 가 처리 시점에는 무효화되어 있을 수 있기 때문
|
|
std::vector< std::pair< StructPlayer::iterator /* itPlayer */, int /* nTeamNo */ > > vPendedEnterPlayerList;
|
|
|
|
{
|
|
ARCADIA_LOCK( pArena->LockWholeArena( nLayer ) );
|
|
|
|
// 인스턴스 해제 처리가 필요한 경우에는 실제 해제 처리 전에 스크립트를 먼저 실행해야 하므로
|
|
// 락 풀고 스크립트 실행이 필요한지 여부만 체크할 수 있게 변수를 둠
|
|
// 그리고 스크립트 실행 처리가 완료된 후에 실제 인스턴스 해제 처리를 다시 함
|
|
// * 이 과정에서 한 번 csArena, csBattle을 해제했다 다시 걸게 되는데 어차피 BattleArenaInstance가 해제되지만 않으면 상관없을 뿐더러,
|
|
// 해제 처리는 이 코드(BattleArenaManager::onProcess)에서 밖에 하지 않고 이 코드가 멀티 쓰레드로 동시에 여러개가 실행될 일은 없으므로 문제 발생 가능성은 없다고 예상됨
|
|
|
|
{
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
// csArena 풀었다 거는 사이에 방이 파괴된 경우에 대해 체크 필요
|
|
if( !pArena->_isOccupiedInstanceNo( nLayer ) )
|
|
continue;
|
|
|
|
BattleArenaInstance * pBattleInstance = pArena->_getBattleInstance( nLayer );
|
|
|
|
#ifdef _DEBUG
|
|
if( !pBattleInstance )
|
|
{
|
|
// pArena->_isOccupiedInstanceNo( nLayer ) == true 인데 pArena->apBattleList[ nLayer ] == NULL 인 건 의도된 로직이 아님
|
|
// 어딘가에서 aInstanceNoUseFlag 만 true로 세팅하고 BattleArenaInstance의 인스턴스는 생성하지 않고 있거나, 혹은 다른 문제 사례 확인/수정 필요
|
|
assert( 0 );
|
|
continue;
|
|
}
|
|
#endif
|
|
// 활성화 상태의 경기가 있다는 것이 확인됨
|
|
bActiveBattleInstanceExist = true;
|
|
bool bWrapUpInstance = false;
|
|
|
|
{
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
// 예약해 둔 스크립트 처리
|
|
// * 끝난 경기라도 밀린 스크립트가 있다면 실행시켜주는 게 맞겠지만, 로직 처리상 문제가 발생한다면 BattleArenaInstance::_onProcess 안으로 넣으면 될듯
|
|
pBattleInstance->_procPendedScript();
|
|
|
|
// 종료된 경기면
|
|
if( pBattleInstance->m_bEnd )
|
|
{
|
|
// 경기 종료된 후에 점수판 보여준 상태에서 대기 시간이 다 경과해서 유저 모두 내쫓고 경기 인스턴스를 해제(라고 쓰고 초기화해서 재활용 준비라고 읽음)해야 하는 경우
|
|
if( GetArTime() >= pBattleInstance->m_nForceQuitTime )
|
|
{
|
|
// BattleArenaInstance 내부에서 처리할만한 건 일단 해주셈 'ㅠ '(인스턴스 해제 스크립트도 실행됨)
|
|
pBattleInstance->_wrapUpInstance( ALT_GAME_OVER );
|
|
|
|
// 방 관련 처리는 csBattle 풀고 나서 처리~
|
|
bWrapUpInstance = true;
|
|
}
|
|
|
|
// 위의 경우 아니면 아무것도 안하고 그냥 멍 때림
|
|
}
|
|
// 종료 전 경기면 일단 _onProcess ㄱㄱ싱
|
|
else
|
|
{
|
|
pBattleInstance->_onProcess();
|
|
|
|
// 경기가 _onProcess 안에서 종료되지 않았다면 입장 대기 유저들로 선정된 목록 처리 준비
|
|
if( !pBattleInstance->m_bEnd )
|
|
{
|
|
std::vector< StructPlayer* >::iterator it = pBattleInstance->m_vPendedEnterPlayerList.begin();
|
|
for( ; it != pBattleInstance->m_vPendedEnterPlayerList.end() ; ++it )
|
|
{
|
|
vPendedEnterPlayerList.push_back( std::make_pair(
|
|
StructPlayer::iterator( *it ),
|
|
pBattleInstance->_getTeamNo( (*it)->GetPartyID() )
|
|
) );
|
|
}
|
|
|
|
pBattleInstance->m_vPendedEnterPlayerList.clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
// 인스턴스가 해제되어야 한다면 해제 처리
|
|
if( bWrapUpInstance )
|
|
{
|
|
// 입장 대기 상태인 유저가 있을리는 없지만 만에 하나의 경우를 위해 모두 제거
|
|
assert( vPendedEnterPlayerList.empty() );
|
|
vPendedEnterPlayerList.clear();
|
|
|
|
pArena->_freeInstanceNo( nLayer );
|
|
|
|
// 인스턴스 해제 처리가 되었으니 추가적으로 현재 인스턴스에 대한 어떤 처리도 일어나지 않도록 다음 레이어로 진행
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 입장 처리가 필요한 유저들이 실행할 스크립트 준비(추가로 재접속에 의한 것이 아니라는 파라미터를 세팅해 줌)
|
|
std::vector< std::string > vTagReplacement;
|
|
vTagReplacement.push_back( "#@reconnect@#" );
|
|
vTagReplacement.push_back( "0" );
|
|
std::string & strScript = GetBattleArenaEventScript( pArena->m_pArenaBase, BASET_ENTER_INSTANCE, nLayer, &vTagReplacement );
|
|
|
|
// 입장 처리가 필요한 유저들에 대한 처리
|
|
// * 이 위치는 지역락, csArena, csBattle 아무것도 걸려있지 않기 때문에 다른 쪽에서 현재 입장하려는 유저들이 입장해야 할 경기가
|
|
// 중간에 종료되는 사태가 발생할 수도 있으며, 이렇게 되면 입장은 했는데 이미 경기는 끝난 상태가 될 수 있음.
|
|
// 다만 그런 경우는 경기 시간 만료(BattleArenaInstance::_onProcess 안에서 발생하므로)가 아닌 최대 점수 도달 혹은 경기 취소의 경우에 해당하며,
|
|
// 어떤 경우든 BattleArenaInstance 자체가 즉시 해제되는 경우는 없으므로(모두 점수판을 보고 있다가 알아서 나가든 1분 지나서 쫓겨나든 함)
|
|
// 큰 문제로 번지지는 않을 거라고 예상됨. 또한, 이번 onProcess 실행 후에 다시 onProcess가 실행될 때는 이미 bEnd == true 라는 것을
|
|
// 각 락을 걸고 처리하는 단계에서 확인 가능하기 때문에, 해당 증상이 장시간 반복되진 않음(즉, 경기 완료되는 순간 1회만 발생함)
|
|
// 여하튼 깔끔하지 않은 처리이지만 락 순서 문제와 지역락에 있어서 아레나 내부에 있지 않은 유저를 핸들링해야 한다는 점에서 깔끔한 답이 안 보이는 상태임... Orz...
|
|
bool bBattleCanceled = false;
|
|
for( std::vector< std::pair< StructPlayer::iterator, int > >::iterator it = vPendedEnterPlayerList.begin() ; it != vPendedEnterPlayerList.end() ; ++it )
|
|
{
|
|
StructPlayer * pPlayer = (*(*it).first);
|
|
|
|
// 유저가 락 풀고 다시 거는 사이에 로그아웃해버렸다면 그냥 패스
|
|
// 대개 이 상황이면 BattleArenaInstance::vPlayerInfo[ nTeamNo ].at( ~~ ).pPlayer == NULL 이 되어 있을 가능성이 높음(로그아웃하면서 이탈 처리도 됐을테니까)
|
|
if( !pPlayer->IsLogin() )
|
|
continue;
|
|
|
|
ARCADIA_LOCK( ArcadiaServer::Instance().LockObjectWithVisibleRange( pPlayer ) );
|
|
|
|
// 이용 불가 상태 체크
|
|
unsigned short nErrorCode = RESULT_SUCCESS;
|
|
|
|
int nPartyID = pPlayer->GetPartyID();
|
|
int nTeamNo = (*it).second;
|
|
// 위에서 vPendedEnterPlayerList.push_back 할 때 이미 캐릭터가 파티에서 이탈된 상태였던 경우
|
|
// 경기용 파티에 참여된 이후에 정상적인 루트가 아닌 다른 루트에 의해 파티에서 이탈되거나 파티가 해산됐다는 것을 의미함
|
|
// 이 경우에는 파티를 해산시키거나 문제가 되는 루트를 찾아서 수정해야 함(문제 재현하면서 PartyManager::LeaveParty/DestroyParty에 Breakpoint 걸면 잡기 쉬움)
|
|
if( nTeamNo == INVALID_BATTLE_ARENA_TEAM_NO )
|
|
{
|
|
assert( 0 );
|
|
nErrorCode = RESULT_UNKNOWN;
|
|
}
|
|
// 락을 풀었다 다시 거는 사이에 팀에서 이탈했거나 파티가 해산된 경우에는 이탈 처리
|
|
// * onProcess 실행 중에 _wrapUpInstance가 다른 곳에서 호출되진 않기 때문에 경기 인스턴스가 완전히 해제되는 경우는 없고
|
|
// 입장 시점이 되는 순간 자진해서 이탈해버린 경우에는 파티 소속이 아닐 수 있음
|
|
// * 이탈 후 다른 파티에 가입했으면 nPartyID != 0 이고 입장하려는 인스턴스의 팀별 파티 ID에 nPartyID가 없겠지만
|
|
// 여기서 BattleArenaInstance에 접근하려면 다시 락을 걸어야 하고, 그런 락 풀었다 걸었다 하며 반복하는 체크는
|
|
// 최종 처리를 락을 푼 상태로 해야 하는 이상 아무런 의미가 없음. 그리고 시간상으로 봤을 때 위에서 락 풀자마자 탈퇴+다른 파티 가입까지 한다는건 인간적으로 무리;;
|
|
// 그래서 nPartyID != 0 와 파티 타입만 체크함
|
|
else if( !nPartyID || !PartyManager::GetInstance().IsBattleArenaTeamParty( nPartyID ) )
|
|
{
|
|
// 정상적으로 경기가 종료됐다고 해도 락 잠깐 풀었다 거는 사이에 파티까지 해산되기는 쉽지 않음(_wrapUpInstance가 호출되어야 하니까)
|
|
// 그래서 어떤 상황인지 예측 가능한 경우가 없음
|
|
assert( 0 );
|
|
nErrorCode = RESULT_UNKNOWN;
|
|
}
|
|
// 사망 상태로는 이용 불가
|
|
else if( pPlayer->IsDead() ) nErrorCode = RESULT_NOT_ENOUGH_HP;
|
|
// 거래 중엔 이용 불가
|
|
else if( pPlayer->IsTrading() ) nErrorCode = RESULT_NOT_ACTABLE_WHILE_TRADING;
|
|
// 베어로드, 데스매치, 인던에서는 이용 불가
|
|
else if( pPlayer->IsInHuntaholic() ) nErrorCode = RESULT_NOT_ACTABLE_IN_HUNTAHOLIC;
|
|
else if( pPlayer->IsInDeathmatch() ) nErrorCode = RESULT_NOT_ACTABLE_IN_DEATHMATCH;
|
|
else if( pPlayer->IsInInstanceDungeon() ) nErrorCode = RESULT_NOT_ACTABLE_IN_INSTANCE_DUNGEON;
|
|
|
|
// 실패 시에는 이탈 처리(페널티 부여도 있음)
|
|
if( nErrorCode != RESULT_SUCCESS )
|
|
{
|
|
// 경기에서 이탈 처리
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
BattleArenaInstance * pBattleInstance = pArena->_getBattleInstance( nLayer );
|
|
|
|
// csArena 풀었다 거는 사이에 방이 파괴된 경우에 대해 체크 필요
|
|
if( !pBattleInstance )
|
|
{
|
|
// 입장 타이머가 다 돌아갔는데 죽어 있었거나 할 때 락 풀었다 거는 사이에 방이 폭파돼버리면 여기 걸릴 수 있을지도...
|
|
// * pArena->_isOccupiedInstanceNo( nLayer ) == true 인데 pArena->apBattleList[ nLayer ] == NULL 인 건 의도된 로직이 아님
|
|
// 어딘가에서 aInstanceNoUseFlag 만 true로 세팅하고 BattleArenaInstance의 인스턴스는 생성하지 않고 있거나, 혹은 다른 문제 사례 확인/수정 필요
|
|
assert( !pArena->_isOccupiedInstanceNo( nLayer ) );
|
|
break;
|
|
}
|
|
|
|
THREAD_SYNCHRONIZE1( pBattleInstance->m_csBattle );
|
|
|
|
// csBattle 풀고 다시 거는 사이에 경기가 종료되어 버렸으면 아무것도 안 함(어차피 끝나고 보상처리도 끝났을텐데 페널티주고 쫓아내서 뭐 함?)
|
|
if( pBattleInstance->m_bEnd )
|
|
break;
|
|
|
|
// 한 팀이 완전히 비워져서 경기가 취소되어야 하는 경우는 다음 _onProcess가 실행되는 시점(약 1초 후)에 처리되도록 함
|
|
// * _removePlayer 호출할 때마다 바로 처리해 주면 너무 방 파괴되어야 하는 코드가 여기저기 붙는 것 같아서 -_ -;;
|
|
// 대신 방이 파괴되어야 할 상황이라면 아직 방에 입장시키지 않은 유저들은 그냥 밖에 놔 둠
|
|
bBattleCanceled = ( pBattleInstance->_removePlayer( pPlayer, ALT_FAILED_TO_JOIN_BATTLE ) == RESULT_NOT_ENOUGH_BULLET );
|
|
|
|
// 페널티 부여(연습 경기이거나 원인 불명의 상태로 이탈된 경우라면 페널티 없음)
|
|
if( !pArena->m_pArenaBase->IsExerciseGameArena() && nErrorCode != RESULT_UNKNOWN )
|
|
{
|
|
pPlayer->IncBattleArenaPenalty();
|
|
pPlayer->DBQuery( new DB_UpdateBattleArenaPenalty( pPlayer ) );
|
|
|
|
SendBattleArenaPenaltyMessage( pPlayer );
|
|
}
|
|
|
|
// bBattleCanceled의 값과 관계없이 모든 참여자에 대해 확인해서 페널티를 줘야 하는 경우는 페널티를 줘야 하기 때문에
|
|
// 여기서 break를 쓰면 안되고 무조건 continue가 되어야 함
|
|
continue;
|
|
}
|
|
|
|
// 한 팀의 멤버가 모두 이탈되었다는 것이 확인됐으면 입장 처리를 하지 않음
|
|
if( bBattleCanceled )
|
|
continue;
|
|
|
|
// 입장 시 실행되어야 할 스크립트 실행
|
|
ThreadPlayerHelper TPHelper( pPlayer );
|
|
BattleArenaRunScriptWithLog( pArena->m_pArenaBase, BASET_ENTER_INSTANCE, nLayer, strScript, pPlayer );
|
|
|
|
// 입장 전 좌표 보관
|
|
pPlayer->StoreCurrentStatesOnEnterInstanceGame( false );
|
|
|
|
// 입장 워프(DB상의 입장 좌표 기준 +-2 미터씩 랜덤으로 옮겨 줌)
|
|
ArPosition posEnter = pArena->m_pArenaBase->posStart[ nTeamNo ];
|
|
posEnter.x += XRandom( GameRule::DEFAULT_UNIT_SIZE * -2, GameRule::DEFAULT_UNIT_SIZE * 2 );
|
|
posEnter.y += XRandom( GameRule::DEFAULT_UNIT_SIZE * -2, GameRule::DEFAULT_UNIT_SIZE * 2 );
|
|
|
|
pPlayer->PendWarp( posEnter.GetX(), posEnter.GetY(), nLayer );
|
|
pPlayer->SetMove( pPlayer->GetCurrentPosition( GetArTime() ), 0 );
|
|
ArcadiaServer::Instance().SetObjectPriority( pPlayer, UPDATE_PRIORITY_HIGHEST );
|
|
}
|
|
}
|
|
|
|
// 새로 시작되는 경기에 대해 경기 생성 스크립트를 csBattle, csArena는 풀고, 해당 레이어의 지역락만 다시 걸고 실행하기 위해
|
|
unsigned char nNewInstanceNo = INVALID_BATTLE_ARENA_INSTANCE_NO;
|
|
{
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
nNewInstanceNo = pArena->_tryStartNewBattle();
|
|
}
|
|
|
|
if( nNewInstanceNo != INVALID_BATTLE_ARENA_INSTANCE_NO )
|
|
{
|
|
// 경기가 진행 중일 때는 BattleArenaManager의 update priority를 최상으로 높여 줌
|
|
// * UPDATE_PRIORITY_HIGH 정도여도 다 괜찮은데 빙고/킬 스크립트 예약/실행 딜레이가 너무 심해질 소지가 있어서;;
|
|
RaiseUpdatePriority();
|
|
bActiveBattleInstanceExist = true;
|
|
|
|
// 경기장 영역 내에 지역락을 걸고 스크립트 실행(csArena, csBattle 중 아무것도 걸리지 않은 상태)
|
|
ARCADIA_LOCK( pArena->LockWholeArena( nNewInstanceNo ) );
|
|
|
|
// 방금 생성됐지만, 경기 자체가 파괴된 경우에 스크립트 실행을 방지하기 위해서 csArena는 걸고 방 상태 다시 체크
|
|
THREAD_SYNCHRONIZE( pArena->m_csArena );
|
|
|
|
// 근데 이거 가능한 경우가 있나 ` `;? _wrapUpInstance가
|
|
// BattleArenaManager::onProcess (지금 이 함수)의 위쪽에서 실행되기 때문에 사실상 불가능일텐데...
|
|
if( !pArena->_isOccupiedInstanceNo( nNewInstanceNo ) )
|
|
continue;
|
|
|
|
BattleArenaRunEventScript( pArena->m_pArenaBase, BASET_CREATE_INSTANCE, nNewInstanceNo, NULL );
|
|
}
|
|
}
|
|
|
|
// 활성화 된 경기도 없고 새로 생성된 경기도 없다면 update priority 낮춤
|
|
if( !bActiveBattleInstanceExist )
|
|
DownUpdatePriority();
|
|
}
|
|
|
|
BattleArena * BattleArenaManager::getArena( int nArenaID )
|
|
{
|
|
assert( m_bInit );
|
|
|
|
for( std::vector< BattleArena * >::iterator it = m_vArenaList.begin() ; it != m_vArenaList.end() ; ++it )
|
|
{
|
|
BattleArena* pArena = (*it);
|
|
if( pArena->m_pArenaBase->nID != nArenaID )
|
|
continue;
|
|
|
|
return (*it);
|
|
}
|
|
|
|
assert( 0 );
|
|
return NULL;
|
|
}
|
|
|
|
const BattleArena * BattleArenaManager::getArena( int nArenaID ) const
|
|
{
|
|
assert( m_bInit );
|
|
|
|
for( std::vector< BattleArena * >::const_iterator it = m_vArenaList.begin() ; it != m_vArenaList.end() ; ++it )
|
|
{
|
|
BattleArena* pArena = (*it);
|
|
if( pArena->m_pArenaBase->nID != nArenaID )
|
|
continue;
|
|
|
|
return (*it);
|
|
}
|
|
|
|
assert( 0 );
|
|
return NULL;
|
|
}
|
|
|
|
unsigned short BattleArenaManager::checkJoinable( StructPlayer * pPlayer, bool bIgnorePenalty )
|
|
{
|
|
// { 캐릭터의 상태 체크
|
|
|
|
// 캐릭터 페널티 상태 체크
|
|
if( !bIgnorePenalty && pPlayer->GetBattleArenaBlockTime() > time( NULL ) )
|
|
return RESULT_COOL_TIME;
|
|
|
|
// 사망 상태로는 이용 불가
|
|
if( pPlayer->IsDead() )
|
|
return RESULT_NOT_ENOUGH_HP;
|
|
// 거래 중엔 이용 불가
|
|
if( pPlayer->IsTrading() )
|
|
return RESULT_NOT_ACTABLE_WHILE_TRADING;
|
|
|
|
// 베어로드, 데스매치, 인던에서는 이용 불가
|
|
if( pPlayer->IsInHuntaholic() )
|
|
return RESULT_NOT_ACTABLE_IN_HUNTAHOLIC;
|
|
if( pPlayer->IsInDeathmatch() )
|
|
return RESULT_NOT_ACTABLE_IN_DEATHMATCH;
|
|
if( pPlayer->IsInInstanceDungeon() )
|
|
return RESULT_NOT_ACTABLE_IN_INSTANCE_DUNGEON;
|
|
|
|
// 일반 파티 외의 파티에 가입된 상태에서는 이용 불가
|
|
int nPrevPartyID = pPlayer->GetPartyID();
|
|
if( nPrevPartyID && PartyManager::GetInstance().GetPartyType( nPrevPartyID ) != PartyManager::TYPE_NORMAL_PARTY )
|
|
return RESULT_NOT_ACTABLE_IN_SIEGE_OR_RAID;
|
|
|
|
// 다른 아레나 대기열에 대기되어 있거나 참여 중인 상태에서는 이용 불가
|
|
if( pPlayer->GetBattleArenaID() )
|
|
return RESULT_ALREADY_EXIST;
|
|
|
|
// } 캐릭터의 상태 체크
|
|
|
|
return RESULT_SUCCESS;
|
|
}
|