void CHelperManager_Encoder::SendMessage_ReplySummons(int reply, char* toName, char* fromName)
{
int idx = GTH_FindPCByName(toName);
if ( 0 <= idx)
{
playerCharacter_t* pTaker=gcpTools->GetPlayerRecordPointer(idx);
if(NULL == pTaker) return;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort ( &netMessage, HELPER_SYSTEM );
MSG_WriteShort(&netMessage, SC_SPAWN_Res_toTaker);
MSG_WriteByte(&netMessage, reply);
MSG_WriteString(&netMessage, fromName);
NET_SendMessage(&pTaker->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
else
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort ( &netMessage, HELPER_SYSTEM );
MSG_WriteShort(&netMessage, SS_SPAWN_Res_fromServer);
MSG_WriteByte(&netMessage, reply);
MSG_WriteString(&netMessage, toName);
MSG_WriteString(&netMessage, fromName);
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 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);
}
}
}
/*
=====================
CL_Disconnect
Sends a disconnect message to the server
This is also called on Host_Error, so it shouldn't cause any errors
=====================
*/
void
CL_Disconnect(void)
{
// stop sounds (especially looping!)
S_StopAllSounds(true);
/* Clear up view, remove palette shift */
scr_centertime_off = 0;
cl.cshifts[0].percent = 0;
VID_SetPalette(host_basepal);
// if running a local server, shut it down
if (cls.demoplayback)
CL_StopPlayback();
else if (cls.state >= ca_connected) {
if (cls.demorecording)
CL_Stop_f();
Con_DPrintf("Sending clc_disconnect\n");
SZ_Clear(&cls.message);
MSG_WriteByte(&cls.message, clc_disconnect);
NET_SendUnreliableMessage(cls.netcon, &cls.message);
SZ_Clear(&cls.message);
NET_Close(cls.netcon);
cls.state = ca_disconnected;
if (sv.active)
Host_ShutdownServer(false);
}
cls.demoplayback = false;
cls.timedemo = false;
cls.signon = 0;
cl.intermission = 0; /* FIXME - for SCR_UpdateScreen */
}
/**
* Sends a disconnect message to the server
* This is also called on Host_Error, so it shouldn't cause any errors
*/
void CL_Disconnect(void) {
// stop sounds (especially looping!)
S_StopAllSounds(true);
// bring the console down and fade the colors back to normal
// SCR_BringDownConsole ();
// if running a local server, shut it down
if (cls.demoplayback)
CL_StopPlayback();
else if (cls.state == ca_connected) {
if (cls.demorecording)
CL_Stop_f();
Con_DPrintf("Sending clc_disconnect\n");
SZ_Clear(&cls.message);
MSG_WriteByte(&cls.message, clc_disconnect);
NET_SendUnreliableMessage(cls.netcon, &cls.message);
SZ_Clear(&cls.message);
NET_Close(cls.netcon);
cls.state = ca_disconnected;
if (sv.active)
Host_ShutdownServer(false);
}
cls.demoplayback = cls.timedemo = false;
cls.signon = 0;
}
void CDanBattleFunc::SendGSM_BattleReady(i3socket_t* sock)
{
int Status = g_pDanBattleSys->GetStatus();
DWORD StatusStartTime = g_pDanBattleSys->GetStatusStartTime();
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_DAN_BATTLE);
MSG_WriteByte(&netMessage, DANB_BATTLE_READY);
NET_SendUnreliableMessage(sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CDanBattleFunc::SendGSM_SuggestResult(BYTE isallow)
{
LPREQUEST_RECORD pSuggest=g_pDanBattleManager->GetSuggester();
LPREQUEST_RECORD pRequest=static_cast<LPREQUEST_RECORD>(g_pDanBattleManager->GetRequestPointer(NULL));
if ( pRequest->ServerID >= MAX_PCS || pRequest->ServerID < 0)
return;
if (pSuggest==NULL)
{
SendErrorCode(&g_pc[pRequest->ServerID].sock,GSC_DAN_BATTLE,1,0);
return;
}
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_DAN_BATTLE);
MSG_WriteByte(&netMessage, DANB_SUGGEST_RESULT);
MSG_WriteByte(&netMessage, isallow);
NET_SendUnreliableMessage(&g_pc[pRequest->ServerID].sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CHelperManager::MemberList_Request_List_OtherServer ( playerCharacter_t* pHelper )
{
MSG_BeginWriting ( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, HELPER_SYSTEM);
MSG_WriteShort( &netMessage, SS_REQUESTMemberList_toServer);
MSG_WriteString ( &netMessage, pHelper->name );
MSG_WriteByte ( &netMessage, pHelper->tHelper.List.count );
MSG_WriteShort(&netMessage, pHelper->tHelper.List.mode);
for (int idx = 0; idx < pHelper->tHelper.List.count; idx++ )
{
MSG_WriteString ( &netMessage, pHelper->tHelper.List.Member[idx].id );
MSG_WriteString ( &netMessage, pHelper->tHelper.List.Member[idx].name );
MSG_WriteByte(&netMessage, pHelper->tHelper.List.Member[idx].bIsMatchHELPERandTACKER);
}
NET_SendUnreliableMessage ( &localSocket, &netMessage );
}
MSG_EndWriting(&netMessage);
}
void CHelperManager::ProcessMessage_ServerReplySummons(void)
{
int idx=-1;
char toName[NAMESTRING+1], fromName[NAMESTRING+1];
int reply = MSG_ReadByte();
strncpy(toName, MSG_ReadString(),NAMESTRING);
toName[NAMESTRING]=NULL;
strncpy(fromName, MSG_ReadString(),NAMESTRING);
fromName[NAMESTRING]=NULL;
idx = GTH_FindPCByName(toName);
if (0 <= idx)
{
playerCharacter_t * pTaker=gcpTools->GetPlayerRecordPointer(idx);
if(NULL==pTaker) return;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLYSUMMONS);
MSG_WriteByte(&netMessage, reply);
MSG_WriteString(&netMessage, fromName);
NET_SendMessage(&pTaker->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
else
{
if (TRUE == g_config.isManager )
{
int fromMemberIdx = MSG_ReadByte();
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLYSUMMONS);
MSG_WriteByte(&netMessage, reply);
MSG_WriteString(&netMessage, toName);
MSG_WriteString(&netMessage, fromName);
for (int severidx=1; severidx < MAX_MEMBER_SERVER; severidx++)
{
if ( !g_memberServer[severidx].active ) continue;
if ( severidx == fromMemberIdx ) continue;
NET_SendUnreliableMessage(&g_memberServer[severidx].sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
}
}
inline void CGMCtrl::TransmitePacket_NProtect_gsms_request_change(const BOOL in_bEnable) const
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_NProtect);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagNProtect::gsms_request_change);
MSG_WriteLong(&netMessage,in_bEnable);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CHelperManager::MemberList_Request_Update_OtherServer ( playerCharacter_t* pHelper, int fstate )
{
MSG_BeginWriting ( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort ( &netMessage, HELPER_SYSTEM );
MSG_WriteShort ( &netMessage, SS_REQUEST_UPDATE_MemberList_toServer);
MSG_WriteString ( &netMessage, pHelper->name );
MSG_WriteByte ( &netMessage, fstate );
NET_SendUnreliableMessage ( &localSocket, &netMessage );
}
MSG_EndWriting(&netMessage);
}
void CDanBattleFunc::SendGSM_SetStatus()
{
BYTE bStatus = MSG_ReadByte();
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, CC_EXTEND);
MSG_WriteByte(&netMessage, GSM_DAN_BATTLE);
MSG_WriteByte(&netMessage, DANB_SETSTATUS);
MSG_WriteByte(&netMessage, bStatus);
NET_SendUnreliableMessage(&localSocket, &netMessage);
MSG_EndWriting(&netMessage);
}
void CDanBattleFunc::SendGSM_RequestBattle()
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, CC_EXTEND);
MSG_WriteByte(&netMessage, GSM_DAN_BATTLE);
MSG_WriteByte(&netMessage, DANB_REQUEST_BATTLE);
MSG_WriteString(&netMessage, g_curPC->name);
MSG_WriteString(&netMessage, g_curPC->guildName);
NET_SendUnreliableMessage(&localSocket, &netMessage);
MSG_EndWriting(&netMessage);
}
void CAhnLab::GTH_SendMessageAhnLabMessage(playerCharacter_t *pPlayer)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, AHNLAB);
for (int nMsgIdx = 0; nMsgIdx < ANTICPSVRREQLEN; nMsgIdx++)
MSG_WriteByte(&netMessage, pPlayer->m_AhnLabMsg.byReqMsg[nMsgIdx]);
NET_SendUnreliableMessage(&pPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CDanBattleManager::SendGSM_Refresh_PersonData(playerCharacter_t* pc, int type, int etc1, int etc2)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_DAN_BATTLE);
MSG_WriteByte(&netMessage, DANB_BATTLE_REFRESH_PERSONDATA);
MSG_WriteLong(&netMessage, type);
switch(type)
{
case 0:
MSG_WriteLong(&netMessage, pc->curChargeSE);
break;
case 1:
MSG_WriteLong(&netMessage, pc->rankPoint);
MSG_WriteLong(&netMessage, g_guild[pc->guildIdx].famePoint);
case 2:
MSG_WriteLong(&netMessage, etc1);
break;
case 3:
MSG_WriteLong(&netMessage, etc1);
break;
}
NET_SendUnreliableMessage(&pc->sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CDanBattleFunc::SendErrorCode(i3socket_t* sock,BYTE msgType,BYTE eCode,BYTE eType)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, msgType);
MSG_WriteByte(&netMessage, DANB_ERROR);
MSG_WriteByte(&netMessage, eCode);
MSG_WriteByte(&netMessage, eType);
switch ( msgType )
{
case GMS_DAN_BATTLE : NET_SendUnreliableMessage(sock, &netMessage); break;
case GSC_DAN_BATTLE : NET_SendMessage( sock, &netMessage); break;
}
MSG_EndWriting(&netMessage);
}
inline void CGMCtrl::TransmitePacket_NProtect_msgs_notify_change(const BOOL in_bEnable) const
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_NProtect);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagNProtect::msgs_notify_change);
MSG_WriteLong(&netMessage,in_bEnable);
for(int i=1; i < MAX_MEMBER_SERVER; i++){
if ( !g_memberServer[i].active ) continue;
NET_SendUnreliableMessage(&g_memberServer[i].sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_LootValue( playerCharacter_t *pc, __int64 exp, __int64 genExp, int lootNSE, int genCapability, int sharingType )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_LOOTVALUE);
MSG_Write64Int(&netMessage, exp);
MSG_Write64Int(&netMessage, genExp);
MSG_WriteLong(&netMessage, lootNSE);
MSG_WriteLong(&netMessage, genCapability);
MSG_WriteByte(&netMessage, sharingType);
NET_SendUnreliableMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CHelperManager_Encoder::SendMessage_RequestSummons(playerCharacter_t* pHelper,char* toName)
{
int idx=GTH_FindPCByName(toName);
if (0 <= idx)
{
playerCharacter_t* pTaker=gcpTools->GetPlayerRecordPointer(idx);
if(NULL == pTaker) return;
if( (playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER
== pTaker->GonryunBattlePractice.MemberShip) ||
(playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_OPENENT
== pTaker->GonryunBattlePractice.MemberShip)) return;
if((pTaker->worldIdx == tagGolryunBattle::Golryun_Battle_Map_Index) ||
(pTaker->worldIdx == DAN_BATTLEMAP_NO)) return;
if(BUSY_STATE_NONE != pTaker->busyState) return;
PC_SetSummonsInfo(pTaker, pHelper->name, pHelper->worldIdx, pHelper->position);
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort ( &netMessage, HELPER_SYSTEM );
MSG_WriteShort(&netMessage, SC_SPAWN_Req_toTaker);
MSG_WriteString(&netMessage, pHelper->name);
NET_SendMessage(&pTaker->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
else
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort ( &netMessage, HELPER_SYSTEM );
MSG_WriteShort(&netMessage, SS_SPAWN_Req_fromServer);
MSG_WriteString(&netMessage, toName);
MSG_WriteString(&netMessage, pHelper->name);
MSG_WriteByte(&netMessage, pHelper->worldIdx);
MSG_WritePosition(&netMessage, pHelper->position);
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 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);
}
}
/*
==============
CL_SendMove
==============
*/
void CL_SendMove (usercmd_t *cmd)
{
int i;
int bits;
sizebuf_t buf;
byte data[128];
buf.maxsize = 128;
buf.cursize = 0;
buf.data = data;
cl.cmd = *cmd;
//
// send the movement message
//
MSG_WriteByte (&buf, clc_move);
MSG_WriteFloat (&buf, cl.mtime[0]); // so server can get ping times
for (i=0 ; i<3 ; i++)
MSG_WriteAngle (&buf, cl.viewangles[i]);
MSG_WriteShort (&buf, cmd->forwardmove);
MSG_WriteShort (&buf, cmd->sidemove);
MSG_WriteShort (&buf, cmd->upmove);
//
// send button bits
//
bits = 0;
if ( in_attack.state & 3 )
bits |= 1;
in_attack.state &= ~2;
if (in_jump.state & 3)
bits |= 2;
in_jump.state &= ~2;
MSG_WriteByte (&buf, bits);
MSG_WriteByte (&buf, in_impulse);
in_impulse = 0;
//
// deliver the message
//
if (cls.demoplayback)
return;
//
// allways dump the first two message, because it may contain leftover inputs
// from the last level
//
if (++cl.movemessages <= 2)
return;
if (NET_SendUnreliableMessage (cls.netcon, &buf) == -1)
{
Con_Printf ("CL_SendMove: lost server connection\n");
CL_Disconnect ();
}
}
void CHelperManager::ProcessMessage_SC_REMOVE_NOTIFY_toPlayer()
{
int idx=-1;
char removeName[NAMESTRING+1], playerName[NAMESTRING+1];
sstrncpy( removeName, MSG_ReadString(), NAMESTRING);
removeName[NAMESTRING]=NULL;
sstrncpy( playerName, MSG_ReadString(), NAMESTRING);
playerName[NAMESTRING]=NULL;
idx = GTH_FindPCByName(removeName);
if (0 <= idx )
{
playerCharacter_t* pRemover=gcpTools->GetPlayerRecordPointer(idx);
if(NULL == pRemover) 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, playerName);
NET_SendUnreliableMessage(&pRemover->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
GTH_SendMessage_AckMessage(playerName);
}
else
{
if (TRUE == g_config.isManager )
{
int fromMemberIdx = MSG_ReadByte();
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, removeName);
MSG_WriteString(&netMessage, playerName);
for (int gameseridx=1; gameseridx < MAX_MEMBER_SERVER; gameseridx++)
{
if ( !g_memberServer[gameseridx].active ) continue;
if ( gameseridx == fromMemberIdx ) continue;
NET_SendUnreliableMessage(&g_memberServer[gameseridx].sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
}
}
void CHelperManager::ProcessMessage_ServerRequestSummons()
{
int idx =-1;
char toName[NAMESTRING+1], summoner[NAMESTRING+1];
vec3_t position;
strncpy(toName, MSG_ReadString(),NAMESTRING);
toName[NAMESTRING]=NULL;
strncpy(summoner, MSG_ReadString(),NAMESTRING);
summoner[NAMESTRING]=NULL;
int worldIdx = MSG_ReadByte();
MSG_ReadPosition( position );
idx = GTH_FindPCByName(toName);
if (0 <= idx)
{
playerCharacter_t* pTaker=gcpTools->GetPlayerRecordPointer(idx);
if(NULL == pTaker) return;
if( (playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_LEADER
== pTaker->GonryunBattlePractice.MemberShip) ||
(playerCharacter_t::tagGonryunBattlePractice::MEMBERSHIP_OPENENT
== pTaker->GonryunBattlePractice.MemberShip)) return;
if( (pTaker->worldIdx == tagGolryunBattle::Golryun_Battle_Map_Index) ||
(pTaker->worldIdx == DAN_BATTLEMAP_NO)) return;
if(BUSY_STATE_NONE != pTaker->busyState) return;
PC_SetSummonsInfo(pTaker, summoner,worldIdx, position);
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort ( &netMessage, HELPER_SYSTEM);
MSG_WriteShort(&netMessage, SC_SPAWN_Req_toTaker);
MSG_WriteString(&netMessage, summoner);
NET_SendMessage(&pTaker->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
else
{
if (TRUE == g_config.isManager )
{
int fromMemberIdx = MSG_ReadByte();
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort ( &netMessage, HELPER_SYSTEM );
MSG_WriteShort(&netMessage, SS_SPAWN_Req_fromServer);
MSG_WriteString(&netMessage, toName);
MSG_WriteString(&netMessage, summoner);
MSG_WriteByte(&netMessage, worldIdx);
MSG_WritePosition(&netMessage, position);
for (int serveridx =1; serveridx < MAX_MEMBER_SERVER; serveridx++)
{
if ( !g_memberServer[serveridx].active ) continue;
if ( serveridx == fromMemberIdx ) continue;
NET_SendUnreliableMessage(&g_memberServer[serveridx].sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
}
}
void CDanBattleFunc::RecvCC_SuggestBattle()
{
if ( !IsGuildMasters( g_curPC ) )
return;
REQUEST_RECORD reqRecord;
REQUEST_RECORD sugRecord;
reqRecord.No = 0;
reqRecord.ServerNo = g_config.gameServerNo;
reqRecord.ServerID = g_curPC->idx;
reqRecord.DanIdx = g_curPC->guildIdx;
memcpy(reqRecord.DanName,g_curPC->guildName,GUILDNAMESTRING);
memcpy(reqRecord.MasterName,g_curPC->name,NAMESTRING);
if ( !g_pDanBattleManager->isSuggester(&reqRecord))
{
SendErrorCode(&g_curPC->sock,GSC_DAN_BATTLE,1,0);
return;
}
if ( g_curPC->curChargeSE < g_logic.DanBattlePrice)
{
SendGSM_SuggestResult(2);
return;
}
sugRecord.DanIdx=MSG_ReadLong();
sstrncpy( sugRecord.DanName, MSG_ReadString(), GUILDNAMESTRING - 1 );
if ( !g_pDanBattleManager->SetSuggester(&sugRecord))
{
SendErrorCode(&g_curPC->sock,GSC_DAN_BATTLE,1,0);
return;
}
LPREQUEST_RECORD pSuggest=g_pDanBattleManager->GetSuggester();
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_DAN_BATTLE);
MSG_WriteByte(&netMessage, DANB_SUGGEST_BATTLE);
LPREQUEST_RECORD pSugg=static_cast<LPREQUEST_RECORD>(g_pDanBattleManager->GetRequestPointer(&sugRecord));
if ( pSuggest->ServerID >= MAX_PCS || pSuggest->ServerID <0)
return;
NET_SendUnreliableMessage(&g_pc[pSuggest->ServerID].sock, &netMessage);
MSG_EndWriting(&netMessage);
}
void CHelperManager::MemberList_Send_toPlayer( entityPCList_t* pl )
{
struct tagHelper *helperlist=GetHelperPtr(pl->idx);
if(NULL == helperlist)return;
MSG_BeginWriting ( &netMessage );
MSG_Clear( &netMessage );
{
if ( pl->serverIdx == 0 )
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, HELPER_SYSTEM);
MSG_WriteShort(&netMessage, SC_SEND_MEMBERLIST_toAllPlayer);
}
else
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, HELPER_SYSTEM);
MSG_WriteShort( &netMessage, SS_REPLYMemberList_toServer);
MSG_WriteByte ( &netMessage, pl->serverIdx );
MSG_WriteString(&netMessage, pl->name);
MSG_WriteShort ( &netMessage, pl->idxOnServer );
}
MSG_WriteByte(&netMessage, helperlist->List.count );
MSG_WriteShort(&netMessage, helperlist->List.mode);
for ( int listcount = 0; listcount < helperlist->List.count; listcount++ )
{
entityPCList_t target = { 0, };
int idx = g_entityListMng.FindPCList ( helperlist->List.Member[listcount].name, &target);
MSG_WriteByte ( &netMessage, target.level );
MSG_WriteByte ( &netMessage, target.job );
MSG_WriteByte ( &netMessage, idx < 0 ? -1 : target.worldIdx );
MSG_WriteString ( &netMessage, helperlist->List.Member[listcount].name );
helperlist->List.Member[listcount].bIsMatchHELPERandTACKER = FALSE;
struct tagHelper* Memperlist = GetHelperPtr(idx);
if(NULL != Memperlist)
{
int memberidx=0;
for(memberidx=0; memberidx<Memperlist->List.count; memberidx++)
{
if(NULL == strcmp(pl->name,Memperlist->List.Member[memberidx].name))
{
helperlist->List.Member[listcount].bIsMatchHELPERandTACKER = FALSE;
break;
}
}
if(memberidx>=Memperlist->List.count)
{
helperlist->List.Member[listcount].bIsMatchHELPERandTACKER = TRUE;
}
}
MSG_WriteByte( &netMessage,helperlist->List.Member[listcount].bIsMatchHELPERandTACKER);
}
if ( pl->serverIdx == 0 )
{
playerCharacter_t* pPlayer = gcpTools->GetPlayerRecordPointer(pl->idxOnServer);
if(NULL == pPlayer)
{
MSG_EndWriting(&netMessage);
return;
}
if (TRUE == pPlayer->ready )
{
NET_SendMessage ( &pPlayer->sock, &netMessage );
}
}
else
{
NET_SendUnreliableMessage ( &g_memberServer[pl->serverIdx].sock, &netMessage );
}
}
MSG_EndWriting(&netMessage);
}
