bool SFNETDispatcher::ReleasePacket(BasePacket* pPacket)
{
//사용한 패킷을 수거한다. 패킷의 타입에 따라 릴리즈 형태가 다름
switch (pPacket->GetPacketType())
{
case SFPACKET_DATA:
SFEngine::GetInstance()->ReleasePacket(pPacket);
break;
case SFPACKET_CONNECT:
case SFPACKET_DISCONNECT:
case SFPACKET_TIMER:
case SFPACKET_SHOUTER:
case SFPACKET_SERVERSHUTDOWN:
delete pPacket;
break;
case SFPACKET_DB:
SFASSERT(0);
break;
default:
SFASSERT(0);
return false;
}
return true;
}
bool SFCGSFPacketProtocol::DisposePacket(BasePacket* pPacket)
{
SFPacket* pSFPacket = static_cast<SFPacket*>(pPacket);
SFASSERT(pSFPacket != NULL);
return SFPacketPool::GetInstance()->Release(pSFPacket);
}
BOOL SGBattle::OnEnter( int gameMode )
{
SFRoom* pRoom = GetOwner()->GetOwner();
SFRoom::RoomMemberMap& roomMember = pRoom->GetRoomMemberMap();
m_nGameState = SG_GAME_PLAY;
m_dwLastPlayTickCount = GetTickCount();
SFASSERT(roomMember.size() != 0 && roomMember.size() <= SEVENGAME_MEMBER_NUM);
m_pSevenGameManager->Reset();
int playerCount = 0;
for (auto& iter : roomMember)
{
SFPlayer* pPlayer = iter.second;
m_pSevenGameManager->AddUser(pPlayer->GetSerial());
playerCount++;
}
int botSerial = -1;
while(playerCount < SEVENGAME_MEMBER_NUM)
{
m_pSevenGameManager->AddUser(botSerial);
botSerial--;
playerCount++;
}
ResetGame();
return TRUE;
}
void SGBattle::SendCurrentTurn()
{
SFRoom* pRoom = GetOwner()->GetOwner();
auto& roomMember = pRoom->GetRoomMemberMap();
int currentUserID = m_pSevenGameManager->GetCurrentUserID();
SGUser* pSGUser = m_pSevenGameManager->FindUser(currentUserID);
SFProtobufPacket<SevenGamePacket::CurrentTurn> currentTurn(SevenGame::CurrentTurn);
if (pSGUser->GetID() <= 0)
{
currentTurn.GetData().set_playerindex(pSGUser->GetID());
currentTurn.GetData().set_playername("AI");
}
else
{
auto& iter = roomMember.find(pSGUser->GetID());
SFASSERT(iter != roomMember.end());
SFPlayer* pCurrentTurnPlayer = iter->second;
currentTurn.GetData().set_playerindex(pCurrentTurnPlayer->GetSerial());
currentTurn.GetData().set_playername(pCurrentTurnPlayer->GetPlayerName());
}
m_dwLastPlayTickCount = GetTickCount();
BroadCast(currentTurn);
}
BOOL SFLogicEntry::OnDBResult(SFMessage* pMessage)
{
PlayerMap::iterator iter = m_PlayerMap.find(pMessage->GetSerial());
if(iter == m_PlayerMap.end())
{
SFASSERT(0);
return FALSE;
}
SFPlayer* pPlayer = iter->second;
return pPlayer->ProcessDBResult(pMessage);
}
BOOL SFLogicEntry::OnPlayerData( BasePacket* pPacket )
{
PlayerMap::iterator iter = m_PlayerMap.find(pPacket->GetSerial());
if(iter == m_PlayerMap.end())
{
SFASSERT(0);
return FALSE;
}
SFPlayer* pPlayer = iter->second;
return pPlayer->ProcessPacket(pPacket);
}
SFRoom* SFRoomManager::GetEmptyRoom()
{
EmptyRoomMap::iterator iter = m_EmptyRoomMap.begin();
if(iter == m_EmptyRoomMap.end())
return NULL;
SFRoom* pRoom = iter->second;
SFASSERT(pRoom->GetRoomState() == ROOM_STATE_NONE);
m_EmptyRoomMap.erase(iter);
return pRoom;
}
SFRoom* SFRoomManager::GetRoom( int RoomIndex )
{
if(RoomIndex < 0 || RoomIndex >= MAX_ROOM_COUNT)
{
SFASSERT(0);
return NULL;
}
SFRoom* pRoom = m_RoomArray[RoomIndex];
if(pRoom->GetRoomState() == ROOM_STATE_NONE)
{
return NULL;
}
return pRoom;
}
bool SFEngine::SendDelayedRequest(BasePacket* pPacket, std::vector<int>* pOwnerList)
{
SFPacketDelaySendTask* pTask = PacketDelayedSendTask::instance()->Alloc();
SFASSERT(NULL != pTask);
if (pOwnerList == NULL)
{
std::vector<int> owner;
owner.push_back(pPacket->GetSerial());
pTask->SetPacket(pPacket, owner);
}
else
{
pTask->SetPacket(pPacket, *pOwnerList);
}
return PacketSendSingleton::instance()->PushTask(pTask);
}
BOOL SFRoomManager::OnCreateRoom( SFPlayerLobby* pLobbyState, int GameMode )
{
SFRoom* pRoom = GetEmptyRoom();
SFPlayer* pPlayer = pLobbyState->GetOwner();
if(NULL == pRoom)
return FALSE;
SFASSERT(pRoom->GetRoomState() == ROOM_STATE_NONE);
pRoom->Open(pPlayer);
pRoom->ChangeState(ROOM_STATE_WAIT);
pPlayer->SetRoomIndex(pRoom->GetRoomIndex());
_GameModeInfo* pInfo = pRoom->GetGameModeInfo();
pInfo->SetGameMode(GameMode);
m_ActiveRoomMap.insert(std::make_pair(pRoom->GetRoomIndex(), pRoom));
return TRUE;
}
void SFCasualGameDispatcher::LogicThreadProc(void* Args)
{
UNREFERENCED_PARAMETER(Args);
SFEngine* pEngine = SFEngine::GetInstance();
while (m_bLogicEnd == false)
{
//로직게이트웨이 큐에서 패킷을 꺼낸다.
BasePacket* pPacket = LogicGatewaySingleton::instance()->PopPacket();
//로직엔트리 객체의 ProcessPacket 메소드를 호출해서 패킷 처리를 수행한다.
LogicEntrySingleton::instance()->ProcessPacket(pPacket);
//사용한 패킷을 수거한다. 패킷의 타입에 따라 릴리즈 형태가 다름
switch (pPacket->GetPacketType())
{
case SFPACKET_DATA:
pEngine->ReleasePacket(pPacket);
break;
case SFPACKET_CONNECT:
case SFPACKET_DISCONNECT:
case SFPACKET_TIMER:
case SFPACKET_SHOUTER:
delete pPacket;
break;
case SFPACKET_DB:
SFDatabase::RecallDBMsg((SFMessage*)pPacket);
break;
case SFPACKET_SERVERSHUTDOWN:
return;
default:
SFASSERT(0);
}
}
}
BOOL SFLogicEntry::OnDisconnectPlayer(int serial)
{
PlayerMap::iterator iter = m_PlayerMap.find(serial);
if(iter == m_PlayerMap.end())
{
SFASSERT(0);
return FALSE;
}
SFPlayer* pPlayer = iter->second;
m_pPlayerManager->DelPlayer(pPlayer);
///////////////////////////////////////////////////////////
//20120619 이런식으로 짜면 실수할 여지가 크다.... 나중에 수정할 수 있도록 한다.
///////////////////////////////////////////////////////////
if (pPlayer->GetPlayerState() == PLAYER_STATE_LOADING ||
pPlayer->GetPlayerState() == PLAYER_STATE_ROOM ||
pPlayer->GetPlayerState() == PLAYER_STATE_PLAY ||
pPlayer->GetPlayerState() == PLAYER_STATE_PLAYEND ||
pPlayer->GetPlayerState() == PLAYER_STATE_PLAYREADY)
{
SFRoomManager* pManager = GetRoomManager();
SFRoom* pRoom = pManager->GetRoom(pPlayer->GetRoomIndex());
pRoom->GetRoomFSM()->OnLeaveRoom(pPlayer);
}
pPlayer->ChangeState(PLAYER_STATE_NONE);
m_pPlayerPool->Release(pPlayer);
m_PlayerMap.erase(iter);
return TRUE;
}
BOOL SGBattle::Update( DWORD dwTickcount )
{
if(m_nGameState == SG_GAME_PLAY)
{
int playerID = m_pSevenGameManager->GetCurrentUserID();
if(playerID < 0) //AI
{
if(GetTickCount() > m_dwLastPlayTickCount + SG_AI_WAIT_TIME)
{
SGUser* pBot = m_pSevenGameManager->FindUser(playerID);
SFASSERT(pBot != NULL);
SCardInfo cardInfo = m_pSevenGameManager->ProcessAI(pBot);
if(cardInfo.iCardNum == -1)
{
SendTurnPass(pBot->GetID());
}
else
{
m_pSevenGameManager->UpdateTableState(&cardInfo);
SendCardSubmit(pBot->GetID(), cardInfo);
}
m_pSevenGameManager->SetCurrentUserID(m_pSevenGameManager->GetNextUserID(pBot->GetID()));
if (-1 == m_pSevenGameManager->EvaluateUser(pBot))
{
SendUserDie(pBot->GetID());
}
if (FALSE == m_pSevenGameManager->CheckGameEnd())
SendCurrentTurn();
else
{
if (m_pSevenGameManager->CheckGameEnd())
{
SendWinner();
m_nGameState = SG_GAME_GAMEOVER;
m_dwLastTickCount = GetTickCount();
return TRUE;
}
}
}
}
else
{
if(GetTickCount() > m_dwLastPlayTickCount + SG_PLAYER_WAIT_TIME)
{
ProcessTurnPass(playerID);
}
}
}
else if (m_nGameState == SG_GAME_GAMEOVER)
{
DWORD dwTickCount = GetTickCount();
if(dwTickCount - m_dwLastTickCount> SG_DELAY_GAMEOVER)
{
m_nGameState = SG_GAME_PLAY;
ResetGame();
}
}
return TRUE;
}
BOOL SGBattle::SendMyCardInfo()
{
SFRoom* pRoom = GetOwner()->GetOwner();
auto& roomMember = pRoom->GetRoomMemberMap();
for (auto& iter : roomMember)
{
SFProtobufPacket<SevenGamePacket::MyCardInfo> myCardInfo(SevenGame::MyCardInfo);
SFPlayer* pPlayer = iter.second;
myCardInfo.SetSerial(pPlayer->GetSerial());
SGUser* pSGUser = m_pSevenGameManager->FindUser(pPlayer->GetSerial());
SFASSERT(pSGUser != NULL);
int* pArray = pSGUser->GetSpadeArray();
int CardCount = 0;
for( int i=1 ; i<= MAX_CARD_NUM ; i++)
{
if( pArray[i] != -1)
{
SevenGamePacket::MyCardInfo::PlayerCard* pPlayerCard = myCardInfo.GetData().add_card();
pPlayerCard->set_cardnum(i);
pPlayerCard->set_cardtype(TYPE_SPADE);
CardCount++;
printf("%d %d\n", i, TYPE_SPADE);
}
}
pArray = pSGUser->GetHeartArray();
for( int i=1 ; i<= MAX_CARD_NUM ; i++)
{
if( pArray[i] != -1)
{
SevenGamePacket::MyCardInfo::PlayerCard* pPlayerCard = myCardInfo.GetData().add_card();
pPlayerCard->set_cardnum(i);
pPlayerCard->set_cardtype(TYPE_HEART);
CardCount++;
printf("%d %d\n", i, TYPE_HEART);
}
}
pArray = pSGUser->GetDiamondArray();
for( int i=1 ; i<= MAX_CARD_NUM ; i++)
{
if( pArray[i] != -1)
{
SevenGamePacket::MyCardInfo::PlayerCard* pPlayerCard = myCardInfo.GetData().add_card();
pPlayerCard->set_cardnum(i);
pPlayerCard->set_cardtype(TYPE_DIAMOND);
CardCount++;
printf("%d %d\n", i, TYPE_DIAMOND);
}
}
pArray = pSGUser->GetCloverArray();
for( int i=1 ; i<= MAX_CARD_NUM ; i++)
{
if( pArray[i] != -1)
{
SevenGamePacket::MyCardInfo::PlayerCard* pPlayerCard = myCardInfo.GetData().add_card();
pPlayerCard->set_cardnum(i);
pPlayerCard->set_cardtype(TYPE_CLOVER);
CardCount++;
printf("%d %d\n", i, TYPE_CLOVER);
}
}
SFASSERT(pSGUser->GetRemainCard() == CardCount);
SFEngine::GetInstance()->SendRequest(&myCardInfo);
}
return TRUE;
}
BasePacket* SFDefaultPacketProtocol::GetPacket(int& ErrorCode)
{
SFPacket* pPacket = PacketPoolSingleton::instance()->Alloc();
pPacket->Initialize();
if(FALSE == m_pPacketIOBuffer->GetPacket(pPacket, ErrorCode))
{
PacketPoolSingleton::instance()->Release(pPacket);
return NULL;
}
SFPacketHeader* pHeader = pPacket->GetHeader();
if(TRUE == pHeader->CheckDataCRC())
{
DWORD dwDataCRC = 0;
BOOL Result = SFPacket::GetDataCRC((BYTE*)pPacket->GetDataBuffer(), pHeader->PacketLen - sizeof(SFPacketHeader), dwDataCRC);
if(TRUE != Result || pHeader->DataCRC != dwDataCRC)
{
//SFLOG_WARN(L"Packet CRC Check Fail!! %d %d", pHeader->DataCRC, dwDataCRC);
ErrorCode = PACKETIO_ERROR_DATA_CRC;
PacketPoolSingleton::instance()->Release(pPacket);
return NULL;
}
}
if (TRUE == pHeader->CheckEncryption())
{
if(FALSE == SFEncrytion<SFEncryptionXOR>::Decrypt((BYTE*)pPacket->GetDataBuffer(), pHeader->PacketLen - sizeof(SFPacketHeader)))
{
SFASSERT(0);
PacketPoolSingleton::instance()->Release(pPacket);
ErrorCode = PACKETIO_ERROR_DATA_ENCRYPTION;
return FALSE;
}
}
if(TRUE == pHeader->CheckCompressed())
{
BYTE pSrcBuf[MAX_PACKET_DATA] = {0,};
int DestSize = MAX_PACKET_DATA;
memcpy(pSrcBuf, pPacket->GetDataBuffer(), pPacket->GetDataSize());
pPacket->ResetDataBuffer();
if(FALSE == SFCompressor<SFCompressLzf>::GetCompressor()->Uncompress(pPacket->GetDataBuffer(), DestSize, pSrcBuf, pPacket->GetDataSize()))
{
//SFLOG_WARN(L"Packet Uncompress Fail!! %d %d", pHeader->DataCRC, dwDataCRC);
PacketPoolSingleton::instance()->Release(pPacket);
ErrorCode = PACKETIO_ERROR_DATA_COMPRESS;
return FALSE;
}
pHeader->PacketLen = DestSize + sizeof(SFPacketHeader);
}
return pPacket;
}
