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 GTH_SendMessageRequestItemTimeSet(const enum sItemUseTimeInfo::enumInventoryType type, int iItemIdx, int iinvenIdx)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, ITEM_EXTEND_SYSTEM);
MSG_WriteShort(&netMessage, REQUEST_ITEM_TIME_SET);
MSG_WriteLong(&netMessage, (int)type);
MSG_WriteLong(&netMessage, iItemIdx);
MSG_WriteLong(&netMessage, iinvenIdx);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CDanBattleSys::SendBattleReward(i3socket_t* sock,int type,int danFame,int userFame)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_DAN_BATTLE);
MSG_WriteByte(&netMessage, DANB_BATTLE_REWARD);
MSG_WriteLong(&netMessage, type);
MSG_WriteLong(&netMessage, danFame);
MSG_WriteLong(&netMessage, userFame);
NET_SendMessage( 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);
}
int GTH_SendMessage_Request_SkillLevelUp( int skillIdx, int genType )
{
if( !GTH_LockSending() ) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_REQUEST_SKILLLEVELUP );
MSG_WriteByte(&netMessage, skillIdx);
MSG_WriteByte(&netMessage, genType);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
return 1;
}
void GTH_SendMessageRequest_BuyGambleItem(int SlotIdx, int Num)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GAMBLE_SYSTEM );
MSG_WriteShort(&netMessage, BUY_GAMBLE_ITEM_REQUEST );
MSG_WriteLong(&netMessage, SlotIdx);
MSG_WriteLong(&netMessage, Num);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
/*
* SV_InitClientMessage
*/
void SV_InitClientMessage( client_t *client, msg_t *msg, uint8_t *data, size_t size )
{
if( client->edict && ( client->edict->r.svflags & SVF_FAKECLIENT ) )
return;
if( data && size )
MSG_Init( msg, data, size );
MSG_Clear( msg );
// write the last client-command we received so it's acknowledged
if( !client->reliable )
{
MSG_WriteByte( msg, svc_clcack );
MSG_WriteLong( msg, client->clientCommandExecuted );
MSG_WriteLong( msg, client->UcmdReceived ); // acknowledge the last ucmd
}
}
void CHelperManager_Encoder::SendMessage_UpdatePointInfo_toPlayer(playerCharacter_t* pPlayer)
{
MSG_BeginWriting ( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte( &netMessage,EXTEND_SECOND);
MSG_WriteShort( &netMessage, HELPER_SYSTEM );
MSG_WriteShort( &netMessage, SC_UPDATE_POINTINFO_SEND_toPlayer );
MSG_WriteLong( &netMessage,pPlayer->tHelper.tPoint.iMyPoint);
MSG_WriteLong( &netMessage,pPlayer->tHelper.tPoint.iHelpPoint);
MSG_WriteLong( &netMessage,pPlayer->tHelper.tPoint.iTotalHelpPoint);
NET_SendMessage ( &pPlayer->sock, &netMessage );
}
MSG_EndWriting(&netMessage);
}
/*
=======================
SV_SendClientSnapshot
Also called by SV_FinalMessage
=======================
*/
void SV_SendClientSnapshot( client_t* client )
{
byte msg_buf[MAX_MSGLEN];
msg_s msg;
// build the snapshot
SV_BuildClientSnapshot( client );
// bots need to have their snapshots build, but
// the query them directly without needing to be sent
//if ( client->gentity && client->gentity->r.svFlags & SVF_BOT ) {
// return;
//}
MSG_Init( &msg, msg_buf, sizeof( msg_buf ) );
msg.allowoverflow = true;
// compression byte is the first byte in all server->client messages
msg.oob = true;
MSG_WriteByte( &msg, 0 );
msg.oob = false;
// NOTE, MRE: all server->client messages now acknowledge
// let the client know which reliable clientCommands we have received
MSG_WriteLong( &msg, client->lastClientCommand );
// (re)send any reliable server commands
SV_UpdateServerCommandsToClient( client, &msg );
// send over all the relevant entityState_s
// and the playerState_s
SV_WriteSnapshotToClient( client, &msg );
#ifdef USE_VOIP
SV_WriteVoipToClient( client, &msg );
#endif
// check for overflow
if ( msg.overflowed )
{
Com_Printf( "WARNING: msg overflowed for %s\n", client->name );
MSG_Clear( &msg );
}
SV_SendMessageToClient( &msg, client );
}
void CGs_To_Cc::Send(playerCharacter_t* pPlayer,int SystemType,int mainType, int subType,char *requestPlayerName,char *TargetPlayerName)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, SystemType);
MSG_WriteShort(&netMessage, mainType);
MSG_WriteShort(&netMessage, subType);
MSG_WriteString(&netMessage, requestPlayerName);
MSG_WriteString(&netMessage, TargetPlayerName);
NET_SendMessage(&pPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CPostFunc::GTH_SendMessage_PostSystem_State()
{
int state = g_cgv.myCharacterInfo->m_PostMng.GetState();
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_POSTSYSTEM );
MSG_WriteByte(&netMessage, POSTSYSTEM_STATE );
MSG_WriteByte(&netMessage, state);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CHelperManager_Encoder::SendMessage_Invite_Request_toTaker (
playerCharacter_t* pTaker,
char* pHelperName
)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, HELPER_SYSTEM);
MSG_WriteShort(&netMessage, SC_INVITE_Req_toTAKER);
MSG_WriteString(&netMessage, pHelperName);
NET_SendMessage(&pTaker->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CDanBattleSys::SendBattleStatus()
{
if ( g_config.isManager )
{
g_pDanBattleManager->SetStatus(DBTL_STATUS_STARTUP);
}
else
{
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( &localSocket, &netMessage );
MSG_EndWriting( &netMessage );
}
}
int CPostFunc::GTH_SendMessage_MailBox_Exit()
{
g_ifMng->m_mailBoxWin->UndoMailBoxInventory();
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_MAILBOX );
MSG_WriteByte(&netMessage, MAILBOX_EXIT );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
return 1;
}
void CTerraBillingCtrl_Decoder::
Transmite_TerraGCPacket_Remain_Minute_NoticeMessage(
playerCharacter_t* pToPlayerRecord,
const int RemainMinute) const
{
MSG_BeginWriting(&netMessage);
MSG_Clear(&netMessage);
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_EXTEND_TERRA);
MSG_WriteByte(&netMessage, tagTerraGCPacket::Remain_Minute_NoticeMessage);
MSG_WriteLong(&netMessage, RemainMinute);
NET_SendMessage(&pToPlayerRecord->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CHelperManager_Encoder::SendMessage_Mypoint_toTaker(
playerCharacter_t* pPlayer, char* pTakerName,char* pHelperName, int MyPoint)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort( &netMessage, HELPER_SYSTEM );
MSG_WriteShort(&netMessage, SC_SENDMYPOINT_toAllPlayer);
MSG_WriteString(&netMessage,pTakerName);
MSG_WriteString(&netMessage,pHelperName);
MSG_WriteLong(&netMessage,MyPoint);
NET_SendMessage(&pPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CPostFunc::GTH_SendMessage_PostSystem_Send()
{
char name[NAMESTRING+1];
char title[CPostManager::POST_TITLESIZE+1];
char message[CPostManager::POST_STRSIZE+1];
strncpy(name,g_ifMng->m_mailBoxWin->m_name,NAMESTRING);
name[NAMESTRING]=NULL;
CTools::Replace_singleQUOTATIONmark_by_doubleQUOTATIONmark(name);
strncpy(title,g_ifMng->m_mailBoxWin->m_title,CPostManager::POST_TITLESIZE);
title[CPostManager::POST_TITLESIZE]=NULL;
CTools::Replace_singleQUOTATIONmark_by_doubleQUOTATIONmark(title);
strncpy(message,g_ifMng->m_mailBoxWin->m_message,CPostManager::POST_STRSIZE);
message[CPostManager::POST_STRSIZE]=NULL;
CTools::Replace_singleQUOTATIONmark_by_doubleQUOTATIONmark(message);
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND);
MSG_WriteByte(&netMessage, CC_POSTSYSTEM);
MSG_WriteByte(&netMessage, POSTSYSTEM_SEND);
MSG_WriteString(&netMessage, name);
MSG_WriteString(&netMessage, title);
MSG_WriteString(&netMessage, message);
MSG_WriteLong(&netMessage, g_ifMng->m_mailBoxWin->m_nak);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void GTH_SendMessage_AddMultiItemObject( itemObject_t itemObject[], int number, vec3_t origin )
{
int i;
int idx;
GTH_GetPCListInValidRange( itemObject[0].worldIdx, itemObject[0].position );
if ( g_zonePCListNumber < 1 ) return;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_ADDMULTIITEMOBJECT);
MSG_WritePosition(&netMessage, origin);
MSG_WriteByte(&netMessage, number );
for( i = 0; i < number; i ++ )
{
MSG_WriteShort(&netMessage, itemObject[i].idx);
MSG_WritePosition(&netMessage, itemObject[i].position);
MSG_WriteByte(&netMessage, itemObject[i].objectType);
if( itemObject[i].objectType == OBJECT_TYPE_ITEM )
{
MSG_WriteShort(&netMessage, itemObject[i].item.itemTableIdx);
} else if( itemObject[i].objectType == OBJECT_TYPE_PORTAL )
{
MSG_WriteShort(&netMessage, itemObject[i].portal.portalType );
}
}
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendMessage(&g_pc[idx].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);
}
int CPostFunc::GTH_SendMessage_MailBox_Open(int PostType, int PostIdx)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_MAILBOX );
MSG_WriteByte(&netMessage, MAILBOX_OPEN );
MSG_WriteLong(&netMessage, PostType );
MSG_WriteLong(&netMessage, PostIdx );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
return 1;
}
void CHelperManager_Encoder::SendMessage_Invite_Respond_toHelper (
playerCharacter_t* pHelper,
int errorCode
)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, HELPER_SYSTEM);
MSG_WriteShort(&netMessage, SC_INVITE_Res_toHELPER);
MSG_WriteShort(&netMessage, errorCode);
NET_SendMessage(&pHelper->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
int CPostFunc::GTH_SendMessage_MailBox_Item( int idx, int pos )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_MAILBOX );
MSG_WriteByte(&netMessage, MAILBOX_ITEM );
MSG_WriteByte(&netMessage, pos );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
return 1;
}
void GTH_SendMessage_ReplyDropItem(playerCharacter_t *pc, int reply, int error, int itemIdx)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_DROPITEM);
MSG_WriteByte(&netMessage, reply);
if (reply > 0)
{
MSG_WriteByte(&netMessage, itemIdx);
MSG_WriteShort(&netMessage, pc->curItemWeight);
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CTerraBillingCtrl_Decoder::
Transmite_TerraGCPacket_NoticeMessage(
playerCharacter_t* pToPlayerRecord,
enum tagTerraGCPacket_NoticeMessage::enumLPACKType LPACKType,
const int LPACKIdx) const
{
MSG_BeginWriting(&netMessage);
MSG_Clear(&netMessage);
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_EXTEND_TERRA);
MSG_WriteByte(&netMessage, tagTerraGCPacket::NoticeMessage);
MSG_WriteByte(&netMessage, LPACKType);
MSG_WriteByte(&netMessage, LPACKIdx);
NET_SendMessage(&pToPlayerRecord->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 GTH_SendMessage_DeleteInvItem( playerCharacter_t *pc, int reply, int error, int itemIdx, int number )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_DELETEITEMINV);
MSG_WriteByte(&netMessage, reply);
if( reply )
{
MSG_WriteShort(&netMessage, itemIdx);
MSG_WriteShort(&netMessage, number);
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
int GTH_SendMessage_SyncItemObject( playerCharacter_t *pc )
{
int i;
int idx;
if( !pc->ready ) return 0;
GTH_GetObjectListInValidRange(pc->worldIdx, pc->position);
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_SYNCITEMOBJECT);
MSG_WriteByte(&netMessage, g_zoneObjectListNumber);
for (i=0; i < g_zoneObjectListNumber; i++)
{
idx = g_zoneObjectList[i].idx;
MSG_WriteShort(&netMessage, g_object[idx].idx);
MSG_WritePosition(&netMessage, g_object[idx].position);
MSG_WriteByte(&netMessage, g_object[idx].objectType);
if( g_object[idx].objectType == OBJECT_TYPE_ITEM )
{
MSG_WriteShort(&netMessage, g_object[idx].item.itemTableIdx);
} else if( g_object[idx].objectType == OBJECT_TYPE_PORTAL )
{
MSG_WriteShort(&netMessage, g_object[idx].portal.portalType );
}
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
return 1;
}
