void CDanBattleSys::SendBattleStart()
{
TEAM_ITOR iLoop;
int userIdx;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
MSG_WriteByte( &netMessage, GSC_EXTEND );
MSG_WriteByte( &netMessage, GSC_DAN_BATTLE );
MSG_WriteByte( &netMessage, DANB_BATTLE_START );
for (iLoop=m_BattleTeam[0].begin();iLoop!=m_BattleTeam[0].end();iLoop++)
{
userIdx=(*iLoop);
NET_SendMessage( &g_pc[userIdx].sock, &netMessage );
ShowLogInfo("SendName = %s",g_pc[userIdx].name);
}
for (iLoop=m_BattleTeam[1].begin();iLoop!=m_BattleTeam[1].end();iLoop++)
{
userIdx=(*iLoop);
NET_SendMessage( &g_pc[userIdx].sock, &netMessage );
ShowLogInfo("SendName = %s",g_pc[userIdx].name);
}
MSG_EndWriting( &netMessage );
}
void CHelperManager::ProcessMessage_Helper_GivePoint_Req_fromHelper(playerCharacter_t* pTaker)
{
if(TRUE == IsBadWritePtr(pTaker,sizeof(playerCharacter_t))
|| TRUE == IsBadReadPtr(pTaker,sizeof(playerCharacter_t)))
{
SetLastError(ERROR_INVALID_PARAMETER);
ShowLogInfo("ProcessMessage_Helper_GivePointtoHelperUser(playerCharacter_t * pTaker)");
return;
}
int point=MSG_ReadLong();
char cHelperName[NAMESTRING+1];
strncpy(cHelperName,MSG_ReadString(),NAMESTRING);
cHelperName[NAMESTRING]=NULL;
int idx = GTH_FindPCByName( cHelperName );
playerCharacter_t* pHelper=gcpTools->GetPlayerRecordPointer(idx);
if(NULL == pHelper) return;
if(FALSE == isMyChild(pTaker,pHelper->name)) return;
if(HELPER_STANDARD_LEVEL > pHelper->level) return;
if(0 > point) return;
if( point > pTaker->tHelper.tPoint.iMyPoint )
{
return;
}
if( HELPER_STANDARD_LEVEL <= pTaker->level )
{
return;
}
pTaker->tHelper.tPoint.iMyPoint=pTaker->tHelper.tPoint.iMyPoint-point;
pHelper->tHelper.tPoint.iHelpPoint=pHelper->tHelper.tPoint.iHelpPoint+point;
pHelper->tHelper.tPoint.iTotalHelpPoint=pHelper->tHelper.tPoint.iTotalHelpPoint+point;
SendMessage_Mypoint_toTaker(pTaker,pTaker->name,pHelper->name,point);
ShowLogInfo(
"pTaker MYPOINT: pTaker->NAME: %s, POINT: %d",pTaker->name,pTaker->tHelper.tPoint.iMyPoint);
SendMessage_Helppoint_toHelper(pHelper,pTaker->name,point);
ShowLogInfo("TARGETpPlayer HELPPOINT: TARGETpPlayer->NAME: %s, HELPPOINT: %d"
,pHelper->name,pHelper->tHelper.tPoint.iHelpPoint);
}
void CHelperManager::ProcessMessage_Recall_Req_fromHelper(playerCharacter_t * pHelper)
{
if(TRUE == IsBadWritePtr(pHelper,sizeof(playerCharacter_t))
|| TRUE == IsBadReadPtr(pHelper,sizeof(playerCharacter_t)))
{
SetLastError(ERROR_INVALID_PARAMETER);
ShowLogInfo("ProcessMessage_Recall_Req_fromHelper(playerCharacter_t * pHelper)");
return;
}
char cTakerName[NAMESTRING+1];
strncpy(cTakerName,MSG_ReadString(),NAMESTRING);
cTakerName[NAMESTRING]=NULL;
if(FALSE == isMyChild(pHelper,cTakerName)) return;
for(int idx = 0; idx < pHelper->tHelper.List.count; idx++)
{
if( NULL == strcmp(cTakerName, pHelper->tHelper.List.Member[idx].name))
{
if( TRUE == pHelper->tHelper.List.Member[idx].bIsMatchHELPERandTACKER )
{
return;
}
}
}
SendMessage_RequestSummons(pHelper,cTakerName);
}
void CHelperManager::Add_toMemberList( playerCharacter_t* pPlayer, playerCharacter_t* pTater )
{
struct tagHelper::tagMemberList::tagMember* pMember=
&(pPlayer->tHelper.List.Member[pPlayer->tHelper.List.count]);
strncpy(pMember->name, pTater->name, NAMESTRING );
pMember->id[IDSTRING]=NULL;
strncpy(pMember->id,pTater->userID,IDSTRING);
pMember->name[NAMESTRING]=NULL;
pMember->bIsMatchHELPERandTACKER=FALSE;
pPlayer->tHelper.List.count++;
g_DBGameServer->SaveHelpList( pPlayer );
SendMessage_Added_toPlayer(
pPlayer, pTater->name, pTater->level, pTater->pcJob, pTater->worldIdx );
ShowLogInfo("ADDUSER :pPlayer->name:%s,add name:%s,pTater->level: %d, pPlayer of count:%d"
,pPlayer->name,pTater->name,pTater->level,pPlayer->tHelper.List.count);
MemberList_Request_List( pPlayer );
}
void Magazin::appLoop()
{
switch(_state)
{
case exitingState:
_mainWindow.close();
break;
case showingSplashState:
ShowSplash();
break;
case showingMenuState:
ShowMenu();
break;
case showingLogInfoState:
ShowLogInfo();
break;
case loggingState:
ShowLogScreen();
break;
case registeringState:
ShowRegisterScreen();
break;
case displayingCarsState:
DisplayCars();
break;
case showingCarScreenState:
ShowCarScreen();
break;
case showingMyCartState:
ShowMyCartScreen();
break;
}
}
void CHelperManager::MemberListInfo_Send_toAllPlayer(entityPCList_t* pl, int fstate )
{
struct tagHelper *helperlist = GetHelperPtr(pl->idx);
if(NULL == helperlist) return;
entityPCList_t target = { 0, };
for (int idx = 0; idx < helperlist->List.count; idx++ )
{
if ( g_entityListMng.FindPCList ( helperlist->List.Member[idx].name, &target ) < 0) continue;
if( TRUE == helperlist->List.Member[idx].bIsMatchHELPERandTACKER) continue;
if ( target.serverIdx == 0 )
{
MSG_BeginWriting ( &netMessage );
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort ( &netMessage, HELPER_SYSTEM );
MSG_WriteShort ( &netMessage, SC_LISTINFO_toAllPlayer );
MSG_WriteByte ( &netMessage, pl->level );
MSG_WriteByte ( &netMessage, pl->job );
MSG_WriteByte ( &netMessage, fstate == HelpersLogout ? -1 : pl->worldIdx );
MSG_WriteString ( &netMessage, pl->name );
MSG_WriteShort ( &netMessage, helperlist->List.mode);
playerCharacter_t* pPlayer=gcpTools->GetPlayerRecordPointer(target.idxOnServer);
if(NULL == pPlayer) {
MSG_EndWriting(&netMessage);
return;
}
NET_SendMessage ( &pPlayer->sock, &netMessage );
MSG_EndWriting(&netMessage);
ShowLogInfo("SC_LISTINFO_toAllPlayer: PlayName= %s, level= %d, job= %d, fstate=%d,mode=%d,",
pl->name,pl->level, pl->job,fstate,helperlist->List.mode );
}else{
MSG_BeginWriting ( &netMessage );
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort ( &netMessage, HELPER_SYSTEM );
MSG_WriteShort ( &netMessage, SS_REPLY_UPDATE_MemberList_toServer);
MSG_WriteByte ( &netMessage, target.serverIdx );
MSG_WriteShort ( &netMessage, target.idxOnServer );
MSG_WriteByte ( &netMessage, pl->level );
MSG_WriteByte ( &netMessage, pl->job );
MSG_WriteByte ( &netMessage, fstate == HelpersLogout ? -1 : pl->worldIdx );
MSG_WriteString ( &netMessage, pl->name );
MSG_WriteShort ( &netMessage, helperlist->List.mode);
NET_SendUnreliableMessage ( &g_memberServer[target.serverIdx].sock, &netMessage );
MSG_EndWriting(&netMessage);
}
}
}
void CHelperManager::ProcessMessage_HelpPointConfirm(playerCharacter_t* pHelper)
{
if(TRUE == IsBadWritePtr(pHelper,sizeof(playerCharacter_t))
|| TRUE == IsBadReadPtr(pHelper,sizeof(playerCharacter_t)))
{
SetLastError(ERROR_INVALID_PARAMETER);
ShowLogInfo("ProcessMessage_HelpPointConfirm(playerCharacter_t * pHelper)");
return;
}
SendMessage_Helper_Helppoint(pHelper);
}
void CHelperManager::ProcessMessage_CS_REMOVE_REQ_fromPlayer(playerCharacter_t* pPlayer)
{
if(TRUE == IsBadWritePtr(pPlayer,sizeof(playerCharacter_t))
|| TRUE == IsBadReadPtr(pPlayer,sizeof(playerCharacter_t)))
{
SetLastError(ERROR_INVALID_PARAMETER);
ShowLogInfo("ProcessMessage_CS_REMOVE_REQ_fromPlayer (playerCharacter_t * pHelper)");
return;
}
char removeName[NAMESTRING+1] ;
strncpy ( removeName, MSG_ReadString (),NAMESTRING );
removeName[NAMESTRING]=NULL;
Remove_toMemberList( pPlayer, removeName );
}
void CHelperManager::ProcessMessage_Change_WepPoint(playerCharacter_t* pHelper)
{
if(TRUE == IsBadWritePtr(pHelper,sizeof(playerCharacter_t))
|| TRUE == IsBadReadPtr(pHelper,sizeof(playerCharacter_t)))
{
SetLastError(ERROR_INVALID_PARAMETER);
ShowLogInfo("ProcessMessage_Change_WepPoint(playerCharacter_t * pHelper)");
return;
}
int wepPoint=MSG_ReadLong();
if(0 >= wepPoint) return;
SendMessage_UpdatePointInfo_toPlayer(pHelper);
}
void CHelperManager_Encoder::SendMessage_Remove_Respond_toPlayer(
playerCharacter_t* pPlayer, char* removeName,int errorcode )
{
MSG_BeginWriting ( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, HELPER_SYSTEM);
MSG_WriteShort(&netMessage, SC_REMOVE_Res_toPlayer);
MSG_WriteShort(&netMessage, errorcode);
MSG_WriteString ( &netMessage, removeName);
if ( pPlayer->ready )
{
NET_SendMessage ( &pPlayer->sock, &netMessage );
}
}
MSG_EndWriting(&netMessage);
ShowLogInfo("RemoveUser :pPlayer->name:%s, removeName:%s",pPlayer->name,removeName);
}
void CDanBattleManager::SetStatus( int bStatus )
{
m_iBattleStatus = bStatus;
m_dwStatusStartTime = g_globalTime;
switch (m_iBattleStatus)
{
case DBTL_STATUS_STARTUP : ShowLogInfo("BattleManager Status : DBTL_STATUS_STARTUP"); break;
case DBTL_STATUS_READY : ShowLogInfo("BattleManager Status : DBTL_STATUS_READY"); break;
case DBTL_STATUS_MOVE : ShowLogInfo("BattleManager Status : DBTL_STATUS_MOVE"); break;
case DBTL_STATUS_START : ShowLogInfo("BattleManager Status : DBTL_STATUS_START"); break;
case DBTL_STATUS_END : ShowLogInfo("BattleManager Status : DBTL_STATUS_END"); break;
case DBTL_STATUS_CLEAR : ShowLogInfo("BattleManager Status : DBTL_STATUS_CLEAR"); break;
}
if (m_iBattleStatus==DBTL_STATUS_STARTUP)
return;
if ( g_config.isDanBattleMap )
{
g_pDanBattleSys->SetStatus(m_iBattleStatus);
}
else
{
i3socket_t* pDestSock=FindBattleMapServer();
if (pDestSock==NULL)
return;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
MSG_WriteByte( &netMessage, GSC_EXTEND );
MSG_WriteByte( &netMessage, GMS_DAN_BATTLE );
MSG_WriteByte( &netMessage, DANB_SETSTATUS );
MSG_WriteByte( &netMessage, m_iBattleStatus );
NET_SendMessage( pDestSock, &netMessage );
MSG_EndWriting( &netMessage );
}
}
void CHelperManager_Encoder::SendMessage_Remove_Notify_toRemovePlayer(
playerCharacter_t* pPlayer,char* premoveName)
{
int idx=GTH_FindPCByName(premoveName);
if (0 <= idx )
{
playerCharacter_t* pRemoveUser=gcpTools->GetPlayerRecordPointer(idx);
if(NULL == pRemoveUser)return;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort( &netMessage, HELPER_SYSTEM );
MSG_WriteShort( &netMessage, SC_REMOVE_NOTIFY_toPlayer );
MSG_WriteString(&netMessage, pPlayer->name);
NET_SendUnreliableMessage(&pRemoveUser->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
ShowLogInfo("RemoveUser :pRemoveUser->name:%s, pRemoveUser->name:%s",
pRemoveUser->name,premoveName);
}
else
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort( &netMessage, HELPER_SYSTEM);
MSG_WriteShort( &netMessage, SS_REMOVE_NOTIFY_toPlayer );
MSG_WriteString(&netMessage, premoveName);
MSG_WriteString(&netMessage, pPlayer->name);
if ( TRUE == g_config.isManager )
{
for (int serveridx=1; serveridx < MAX_MEMBER_SERVER; serveridx++)
{
if ( !g_memberServer[serveridx].active ) continue;
NET_SendUnreliableMessage(&g_memberServer[serveridx].sock, &netMessage);
}
}
else
{
MSG_WriteByte(&netMessage, g_config.gameServerNo);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
}
void CGonryunPractice_Decoder::
recvRespond_NormalResult_fromOpenent(playerCharacter_t* pPlayer)
{
if((TRUE == IsBadWritePtr(pPlayer,sizeof(playerCharacter_t))) ||
(TRUE == IsBadReadPtr(pPlayer,sizeof(playerCharacter_t)))) {
return;
}
if(pPlayer->GonryunBattlePractice.MemberShip == playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER) {
char szWaiterName[NAMESTRING+1]="";
strncpy(szWaiterName,MSG_ReadString(),NAMESTRING); szWaiterName[NAMESTRING-1] = NULL;
playerCharacter_t* pWaiter = gcpTools->GetPlayerRecordPointer(szWaiterName);
if( NULL == pWaiter){
m_cpVirtualEncoder->SendBattleMsg(pPlayer,tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::unkonwn);
}
else if(pWaiter->GonryunBattlePractice.MemberShip != playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_WAITER){
GTH_DisconnectPlayer(pPlayer,FALSE);
}
else{
m_cpVirtualEncoder->SendMessage_NormalReject_toPlayer( pWaiter );
}
pPlayer->GonryunBattlePractice.bisWaitrespond = FALSE;
return;
}
if(playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_WAITER != pPlayer->GonryunBattlePractice.MemberShip ) {
GTH_DisconnectPlayer(pPlayer,FALSE);
return;
}
int LeaderPCIdx = MSG_ReadLong();
char szLeaderName[NAMESTRING+1]="";
strncpy(szLeaderName,MSG_ReadString(),NAMESTRING); szLeaderName[NAMESTRING-1] = NULL;
playerCharacter_t* pLeaderPlayer = gcpTools->GetPlayerRecordPointer(LeaderPCIdx);
if(NULL == pLeaderPlayer){
m_cpVirtualEncoder->SendBattleMsg(pPlayer,tagGonryunPracticePacket_BATTLE_PRACTICE_MSG::unkonwn);
return;
}
if((playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER !=
pLeaderPlayer->GonryunBattlePractice.MemberShip ) ||
(pLeaderPlayer->idx != m_cpVirtualProcessCtrl->m_Leader.pcIdx) ||
(0 != strcmp(szLeaderName,pLeaderPlayer->name)) ||
(0 != strcmp(szLeaderName,m_cpVirtualProcessCtrl->m_Leader.Name)) ||
(pLeaderPlayer->GonryunBattlePractice.bisWaitrespond != TRUE)){
GTH_DisconnectPlayer(pPlayer,FALSE);
return;
}
BOOL bAccept = (BOOL)MSG_ReadByte();
if(FALSE == bAccept ){
m_cpVirtualEncoder->SendMessage_NormalReject_toPlayer( pLeaderPlayer );
pLeaderPlayer->GonryunBattlePractice.bisWaitrespond = FALSE;
return;
}
playerCharacter_t* pOpenentPlayer=pPlayer;
int royalty = g_logic.PCBGonryunCondition.m_iroyalty;
m_cpVirtualEncoder->SendWaitUserBattleEnd();
m_cpVirtualEncoder->SendWaitUserBattleEnd(pLeaderPlayer);
m_cpVirtualWaiterCtrl->DeleteAll();
m_cpVirtualProcessCtrl->SetOpenent(pOpenentPlayer);
pOpenentPlayer->busyState = BUSY_STATE_BATTLEPRACTICE;
pOpenentPlayer->curChargeSE = pOpenentPlayer->curChargeSE-royalty;
if(pOpenentPlayer->curChargeSE < 0) pOpenentPlayer->curChargeSE=0;
m_cpVirtualEncoder->SendMessageNake( pOpenentPlayer );
pLeaderPlayer->busyState = BUSY_STATE_BATTLEPRACTICE;
pLeaderPlayer->curChargeSE = pLeaderPlayer->curChargeSE-royalty;
if(pLeaderPlayer->curChargeSE < 0) pLeaderPlayer->curChargeSE =0;
m_cpVirtualEncoder->SendMessageNake(pLeaderPlayer);
m_cpVirtualProcessCtrl->SetBattleType(CGonryunPractice_ProcessCtrl::PCB_BATTLE_NORMAL);
m_cpVirtualProcessCtrl->SetStep(CGonryunPractice_ProcessCtrl::Step::STEP_BATTLE_READY);
m_cpVirtualProcessCtrl->MakeTransPosition(pLeaderPlayer,pOpenentPlayer);
pLeaderPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount -= 1;
if(0 > pLeaderPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount)
pLeaderPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount = 0;
pOpenentPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount -= 1;
if(0 > pOpenentPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount)
pOpenentPlayer->PremiumInfo.GonyounPracticeBattle.iDecreseCount = 0;
g_logSystem->Write("TransPort_In_Generater: LeaderName = %s Openent = %s WordIdx = %d",
pLeaderPlayer->name,
pOpenentPlayer->name,
pOpenentPlayer->worldIdx);
m_cpVirtualEncoder->SendStatus(pLeaderPlayer);
m_cpVirtualEncoder->SendEffect(pLeaderPlayer,CGonryunPractice_ProcessCtrl::PCB_EFF_READY);
m_cpVirtualEncoder->SendStatus(pOpenentPlayer);
m_cpVirtualEncoder->SendEffect(pOpenentPlayer,CGonryunPractice_ProcessCtrl::PCB_EFF_READY);
ShowLogInfo("BattlePractic_WaiterCount: %d",m_cpVirtualWaiterCtrl->GetNum());
g_logSystem->Write(
"recvRespond_NormalResult_fromOpenent!! Leader_Name = %s Openent_Name = %s ",
pLeaderPlayer->name,
pOpenentPlayer->name);
return;
}
void CHelperManager::ProcessMessage_Recall_Res_fromTaker(playerCharacter_t* pTaker)
{
if(TRUE == IsBadWritePtr(pTaker,sizeof(playerCharacter_t))
|| TRUE == IsBadReadPtr(pTaker,sizeof(playerCharacter_t)))
{
SetLastError(ERROR_INVALID_PARAMETER);
ShowLogInfo("ProcessMessage_Recall_Res_tsTaker(playerCharacter_t *pTaker)");
return;
}
int worldIdx =-1;
vec3_t position;
vec3_t savePosition;
int reply = MSG_ReadByte();
worldIdx = pTaker->summonsInfo.worldIdx;
vec_copy( pTaker->summonsInfo.position, position );
if( pTaker->isTransform ) GTH_DeleteTransform( pTaker );
if (RESPOND_YES == reply)
{
if ( GTH_IsLocalServiceWorld(worldIdx) )
{
if( worldIdx == pTaker->worldIdx )
{
vec_copy( position, pTaker->position );
pTaker->reliableWorldIdx = pTaker->worldIdx;
vec_copy( pTaker->position, pTaker->reliablePosition );
int zoneIdx = GTH_Zone_UpdateCurrentZone(
ENTITY_PC, pTaker->idx, pTaker->worldIdx, pTaker->zoneIdx, pTaker->position);
pTaker->zoneIdx = zoneIdx;
GTH_SendPCEventMessage_Respawn( pTaker );
GTH_SendMessage_SyncItemObject( pTaker );
}
else
{
GTH_Zone_DeleteEntityList(
pTaker->worldIdx, pTaker->zoneIdx, pTaker->entityType, pTaker->idx);
pTaker->worldIdx = worldIdx;
vec_copy( position, pTaker->position );
pTaker->reliableWorldIdx = pTaker->worldIdx;
vec_copy( pTaker->position, pTaker->reliablePosition );
pTaker->zoneIdx = GTH_Zone_GetZoneIdx( pTaker->position );
GTH_Zone_AddEntityList(
pTaker->worldIdx, pTaker->zoneIdx, pTaker->entityType, pTaker->idx);
GTH_SendPCEventMessage_Respawn( pTaker );
pTaker->ready = FALSE;
g_logSystem->Write(
"User [%s] Move To Summonning Pos. Pos(%.2f, %.2f, %.2f), World : %d",
pTaker->userID, pTaker->position[0], pTaker->position[1], pTaker->position[2],
pTaker->worldIdx);
}
}
else
{
int memberIdx = GTH_FindServerWithinGroup( worldIdx );
if (0 > memberIdx)
{
g_logSystem->Write(
"User [%s] Summon Error(worldIdx:%d)", pTaker->name, pTaker->worldIdx);
return;
}
else
{
int saveWorldIdx = pTaker->worldIdx;
vec_copy(pTaker->position, savePosition);
pTaker->worldIdx = worldIdx;
vec_copy(position, pTaker->position);
pTaker->flagChangeServer = 1;
pTaker->changeServerWorldIdx = worldIdx;
DB_SaveGameData( pTaker, SAVEGAMEDATA_QUIT);
pTaker->worldIdx = saveWorldIdx;
vec_copy(savePosition, pTaker->position);
}
}
}
SendMessage_ReplySummons(reply, pTaker->summonsInfo.summoner, pTaker->name);
PC_InitSummonsInfo( pTaker );
}
void CDanBattleSys::MakeDanBattlePortal(int type)
{
LPREQUEST_RECORD requester = static_cast<LPREQUEST_RECORD>(g_pDanBattleManager->GetBattleRequestDan());
LPREQUEST_RECORD suggester = static_cast<LPREQUEST_RECORD>(g_pDanBattleManager->GetBattleSuggestDan());
if ( requester->ServerID < 0 || suggester->ServerID < 0 )
{
return;
}
if ( type == DBTL_STATUS_READY)
{
GTH_MakePortal_fordan(LOOTTYPE_DANBATTLE_TEAMS, g_curPC->entityType,
g_logic.danBattleStatusTime[DBTL_STATUS_MOVE] /2 ,
g_logic.danbattlePortal[DANBATTLE_START_PORTAL].StartworldIdx,
g_logic.danbattlePortal[DANBATTLE_START_PORTAL].StartPos,
g_logic.danbattlePortal[DANBATTLE_START_PORTAL].TargetWorldIdx,
g_logic.danbattlePortal[DANBATTLE_START_PORTAL].TargetPos,
g_logic.danbattlePortal[DANBATTLE_START_PORTAL].TargetWorldIdx2,
g_logic.danbattlePortal[DANBATTLE_START_PORTAL].TargetPos2
);
ShowLogInfo(" RequestUserName = %s", g_pc[requester->ServerID].name);
ShowLogInfo(" SussgstUserName = %s", g_pc[suggester->ServerID].name);
GTH_DeleteNoticePC(&g_pc[requester->ServerID]);
GTH_DeleteNoticePC(&g_pc[suggester->ServerID]);
ShowLogInfo(" RequestUserState = %d", g_pc[requester->ServerID].busyState);
ShowLogInfo(" SussgstUserState = %d", g_pc[suggester->ServerID].busyState);
}
else if ( type == DBTL_STATUS_START)
{
GTH_MakePortal_fordan(ENTITY_NPC, NULL,
g_logic.danBattleStatusTime[DBTL_STATUS_MOVE] / 2,
g_logic.danbattlePortal[DANBATTLE_ATEAM_PORTAL].StartworldIdx,
g_logic.danbattlePortal[DANBATTLE_ATEAM_PORTAL].StartPos,
g_logic.danbattlePortal[DANBATTLE_ATEAM_PORTAL].TargetWorldIdx,
g_logic.danbattlePortal[DANBATTLE_ATEAM_PORTAL].TargetPos,
NULL,NULL);
GTH_MakePortal_fordan(ENTITY_NPC, NULL,
g_logic.danBattleStatusTime[DBTL_STATUS_MOVE] / 2,
g_logic.danbattlePortal[DANBATTLE_BTEAM_PORTAL].StartworldIdx,
g_logic.danbattlePortal[DANBATTLE_BTEAM_PORTAL].StartPos,
g_logic.danbattlePortal[DANBATTLE_BTEAM_PORTAL].TargetWorldIdx,
g_logic.danbattlePortal[DANBATTLE_BTEAM_PORTAL].TargetPos,
NULL, NULL);
}
}
void CHelperManager::ProcessMessage_Invite_RES_fromTAKER (playerCharacter_t * pTaker)
{
if(TRUE == IsBadWritePtr(pTaker,sizeof(playerCharacter_t))
|| TRUE == IsBadReadPtr(pTaker,sizeof(playerCharacter_t)))
{
SetLastError(ERROR_INVALID_PARAMETER);
ShowLogInfo("ProcessMessage_Invite_RES_fromTAKER (playerCharacter_t * pTaker)");
return;
}
int respond = MSG_ReadShort();
if(RESPOND_NO == respond)
{
SendMessage_Invite_Respond_toHelper(
pTaker,tagHelperPacket_SC_INVITE_RES_toHELPER::enumCode::Fail_RegistrationReject);
return;
}
else if(RESPOND_YES == respond)
{
playerCharacter_t* pHelper = gcpTools->GetPlayerRecordPointer(pTaker->HelperAdd.RequestPlayer.pcIdx);
if((NULL == pHelper) || (0 != strncmp(pTaker->HelperAdd.RequestPlayer.Name,pHelper->name,NAMESTRING)))
{
g_logSystem->Write("Fail_RegistrationRequest_invalidUser" );
return;
}
if ( pTaker->worldIdx != pHelper->worldIdx )
{
SendMessage_Invite_Respond_toHelper(
pHelper,tagHelperPacket_SC_INVITE_RES_toHELPER::enumCode::Fail_RegistrationRequest_invalidWorldIndex);
g_logSystem->Write("Fail_RegistrationRequest_invalidWorldIndex" );
return ;
}
SendMessage_Invite_Respond_toHelper(
pHelper,tagHelperPacket_SC_INVITE_RES_toHELPER::enumCode::Success_RegistrationRequest);
pHelper->tHelper.List.mode =tagHelper::tagMemberList::enumMode::HELPER;
pTaker->tHelper.List.mode =tagHelper::tagMemberList::enumMode::TAKER;
if((pHelper->tHelper.List.count < 0) ||
(pHelper->tHelper.List.count >= tagHelper::MAX_MEMBER) ||
(pTaker->tHelper.List.count !=0 )){
SendMessage_Invite_Respond_toHelper(pHelper,tagHelperPacket_SC_INVITE_RES_toHELPER::enumCode::Fail_RegistrationRequest_invalidUser);
SendMessage_Invite_Respond_toTaker(pTaker,tagHelperPacket_SC_INVITE_RES_toHELPER::enumCode::Fail_RegistrationRequest_invalidUser);
return;
}
Add_toMemberList( pHelper, pTaker );
SendMessage_Invite_Respond_toTaker(
pTaker,tagHelperPacket_SC_INVITE_RES_toHELPER::enumCode::Success_RegistrationRequest);
Add_toMemberList( pTaker, pHelper );
pTaker->HelperAdd.RequestPlayer.pcIdx=-1;
}
}
void CHelperManager::ProcessMessage_Invite_REQ_fromHELPER(playerCharacter_t* pHelper)
{
if(TRUE == IsBadWritePtr(pHelper,sizeof(playerCharacter_t))
|| TRUE == IsBadReadPtr(pHelper,sizeof(playerCharacter_t)))
{
return;
}
if( tagHelper::tagMemberList::HELPER != pHelper->tHelper.List.mode)
{
SendMessage_Invite_Respond_toHelper(
pHelper,tagHelperPacket_SC_INVITE_RES_toHELPER::Fail_RegistrationRequest_invalidMode );
g_logSystem->Write("Fail_RegistrationRequest_invalidMode" );
return ;
}
char cz_tempTakerName[NAMESTRING+1];
strncpy(cz_tempTakerName,MSG_ReadString(),NAMESTRING);
cz_tempTakerName[NAMESTRING]=NULL;
int idx = GTH_FindPCByName(cz_tempTakerName);
playerCharacter_t * pTaker=gcpTools->GetPlayerRecordPointer(idx);
if(NULL == pTaker){
SendMessage_Invite_Respond_toHelper(
pHelper,tagHelperPacket_SC_INVITE_RES_toHELPER::Fail_RegistrationRequest_invalidUser);
g_logSystem->Write("Fail_RegistrationRequest_invalidUser" );
return;
}
if( tagHelper::tagMemberList::TAKER != pTaker->tHelper.List.mode)
{
SendMessage_Invite_Respond_toHelper(
pHelper,tagHelperPacket_SC_INVITE_RES_toHELPER::Fail_RegistrationRequest_invalidTakerMode );
g_logSystem->Write("Fail_RegistrationRequest_invalidMode" );
return ;
}
if(pTaker->idx == pHelper->idx)
{
SendMessage_Invite_Respond_toHelper(
pHelper,tagHelperPacket_SC_INVITE_RES_toHELPER::Fail_RegistrationRequest_invalidUser);
g_logSystem->Write("Fail_RegistrationRequest_invalidUser" );
return;
}
if ( pHelper->tHelper.List.count > tagHelper::MAX_MEMBER)
{
SendMessage_Invite_Respond_toHelper(
pHelper,tagHelperPacket_SC_INVITE_RES_toHELPER::Fail_RegistrationRequest_invalidTakersCount);
g_logSystem->Write("Fail_RegistrationRequest_invalidTakersCount" );
return;
}
if(pTaker->tHelper.List.count >= tagHelper::MAX_Accept_HELPERS)
{
SendMessage_Invite_Respond_toHelper(
pHelper,tagHelperPacket_SC_INVITE_RES_toHELPER::Fail_RegistrationRequest_invalidHelperCount);
g_logSystem->Write("Fail_RegistrationRequest_invalidHelperCount" );
return;
}
if ( pHelper->worldIdx != pTaker->worldIdx )
{
SendMessage_Invite_Respond_toHelper(
pHelper,tagHelperPacket_SC_INVITE_RES_toHELPER::Fail_RegistrationRequest_invalidWorldIndex);
g_logSystem->Write("Fail_RegistrationRequest_invalidWorldIndex" );
return ;
}
if(TRUE == isMyChild(pHelper,pTaker->name))
{
SendMessage_Invite_Respond_toHelper(
pHelper,tagHelperPacket_SC_INVITE_RES_toHELPER::Fail_RegistrationRequest_invaliChild);
g_logSystem->Write("Fail_RegistrationRequest_invaliChild" );
return ;
}
strncpy(pTaker->HelperAdd.RequestPlayer.Name,pHelper->name,NAMESTRING);
pTaker->HelperAdd.RequestPlayer.Name[NAMESTRING]=NULL;
pTaker->HelperAdd.RequestPlayer.pcIdx=pHelper->idx;
SendMessage_Invite_Respond_toHelper(
pHelper,tagHelperPacket_SC_INVITE_RES_toHELPER::Ready_Registration);
ShowLogInfo("Helper_Invite_Suggest: name:%s,level:%d ",pHelper->name,pHelper->level);
SendMessage_Invite_Request_toTaker( pTaker,pHelper->name);
ShowLogInfo("Helper_Invite_Suggest: name:%s,level:%d ",pTaker->name,pTaker->level);
}
void CDanBattleSys::SetStatus(int iStatus)
{
int oldStatus = m_iBattleStatus;
m_iBattleStatus = iStatus;
m_dwStatusStartTime = g_globalTime;
m_dwBroadCastTime = g_globalTime;
int tempcount =0;
switch (m_iBattleStatus)
{
case DBTL_STATUS_STARTUP : ShowLogInfo("Battle Sys Status : DBTL_STATUS_STARTUP"); break;
case DBTL_STATUS_READY : ShowLogInfo("Battle Sys Status : DBTL_STATUS_READY"); break;
case DBTL_STATUS_MOVE : ShowLogInfo("Battle Sys Status : DBTL_STATUS_MOVE"); break;
case DBTL_STATUS_START :
{
ShowLogInfo("Battle Sys Status : DBTL_STATUS_START");
SendBattleStart();
m_BattleTeamInfo[0].startDanUserCount=m_BattleTeam[0].size();
m_BattleTeamInfo[1].startDanUserCount=m_BattleTeam[1].size();
AutoMoveDanMember();
SendBattleInfo();
break;
}
case DBTL_STATUS_END :
{
ShowLogInfo("Battle Sys Status : DBTL_STATUS_END");
SendBattleResult();
CalcBattleResult();
ShowLogInfo("MessageCount = %d", tempcount);
tempcount++;
break;
}
case DBTL_STATUS_LOOSE_MOVE :
{
ShowLogInfo("Battle Sys Status : DBTL_STATUS_LOOSE_MOVE");
int looseTeam=GetLooseTeam();
if (looseTeam!=2)
{
ClearTeam(looseTeam);
}
else
{
ClearTeam(0);
ClearTeam(1);
}
break;
}
case DBTL_STATUS_CLEAR :
{
ShowLogInfo("Battle Sys Status : DBTL_STATUS_CLEAR");
ClearTeam(0);
ClearTeam(1);
break;
}
case DBTL_STATUS_EVENT:
{
ShowLogInfo("Battle Sys Status : DBTL_STATUS_EVENT");
break;
}
}
int SendStatus =0;
if ( oldStatus == DBTL_STATUS_EVENT)
SendStatus = m_iBattleStatus;
if ( m_iBattleStatus == DBTL_STATUS_EVENT)
SendStatus = 5;
if ( SendStatus ==0 )return;
if ( g_config.isDanBattleMap == FALSE)
return;
for (int idx =0; idx < MAX_PCS; idx++){
playerCharacter_t *pPC = gcpTools->GetPlayerRecordPointer(idx);
if ( pPC == NULL) continue;
if ( pPC->worldIdx == DAN_BATTLEMAP_NO){
g_pDanBattleManager->SendGSM_Refresh_PersonData(pPC, 3, SendStatus);
}
}
}
