500 lines
No EOL
17 KiB
C++
500 lines
No EOL
17 KiB
C++
#pragma once
|
|
|
|
#include "MATransAction.h"
|
|
#include "DNPacket.h"
|
|
#include "RUDPCommonDef.h"
|
|
#include "DNUserSession.h"
|
|
#include "DnPlayerActor.h"
|
|
|
|
extern TGameConfig g_Config;
|
|
|
|
inline void SendConnectedGameServer(CDNUserSession * pSession, UINT nSessionID)
|
|
{
|
|
SCConnectedResult packet;
|
|
packet.nSessionID = nSessionID;
|
|
_strcpy(packet.szServerVersion, _countof(packet.szServerVersion), g_Config.szVersion, (int)strlen(g_Config.szVersion));
|
|
pSession->SendPacket( SC_SYSTEM, eSystem::SC_CONNECTED_RESULT, &packet, sizeof(packet), _RELIABLE);
|
|
}
|
|
|
|
inline void SendGameActorBundleMsg(CDNUserSession *pSession, USHORT nCount, BYTE *pBuf, int nSize, int nPrior )
|
|
{
|
|
SCActorBundleMessage packet;
|
|
|
|
packet.nSessionID = pSession->GetSessionID();
|
|
memcpy(packet.cBuf, pBuf, nSize);
|
|
|
|
pSession->SendPacket( SC_ACTORBUNDLE, nCount, &packet, sizeof(packet) - sizeof(packet.cBuf) + nSize, nPrior );
|
|
}
|
|
|
|
inline void SendGameSyncWait(CDNUserSession * pSession, UINT nSessionID )
|
|
{
|
|
SCSyncWait packet;
|
|
|
|
packet.nSessionID = nSessionID;
|
|
|
|
pSession->SendPacket( SC_ROOM, eRoom::SC_SYNC_WAIT, &packet, sizeof(packet), _RELIABLE);
|
|
}
|
|
|
|
inline void SendGameSyncStart(CDNUserSession * pSession)
|
|
{
|
|
SCSyncStart packet;
|
|
|
|
packet.nSessionID = pSession->GetSessionID();
|
|
|
|
pSession->SendPacket( SC_ROOM, eRoom::SC_SYNC_START, &packet, sizeof(packet), _RELIABLE);
|
|
|
|
#ifdef _DEBUG
|
|
g_Log.Log(LogType::_NORMAL, pSession->GetWorldSetID(), pSession->GetAccountDBID(), pSession->GetCharacterDBID(), pSession->GetSessionID(), L"Send StartSync CharName:[%s]\n", pSession->GetCharacterName());
|
|
#endif
|
|
}
|
|
|
|
inline void SendGameDatumTick( CDNUserSession* pSession )
|
|
{
|
|
_ASSERT( pSession );
|
|
CDnPlayerActor* pPlayer = pSession->GetPlayerActor();
|
|
_ASSERT( pPlayer );
|
|
pPlayer->SetSyncDatumTick();
|
|
pPlayer->SetSyncDatumSendTick();
|
|
|
|
pSession->SendPacket( SC_ROOM, eRoom::SC_SYNC_DATUMTICK, NULL, 0, _RELIABLE );
|
|
}
|
|
|
|
inline void SendRefreshPartyMember(CDNUserSession * pSession, UINT * pMember, int nCount)
|
|
{
|
|
SCRefreshMember packet;
|
|
memset(&packet, 0, sizeof(packet));
|
|
|
|
packet.cCount = (BYTE)nCount;
|
|
memcpy(&packet.nMemberSessionID, pMember, sizeof(UINT) * nCount);
|
|
|
|
pSession->SendPacket( SC_ROOM, eRoom::SC_REFRESH_MEMBER, &packet, sizeof(packet) - sizeof(packet.nMemberSessionID) + (sizeof(UINT) * nCount), _RELIABLE);
|
|
}
|
|
|
|
inline void SendGamePropMsg(CDNUserSession * pSession, UINT nUID, USHORT nProtocol, BYTE *pBuf, int nSize)
|
|
{
|
|
SCPropMessage packet;
|
|
|
|
packet.nUniqueID = nUID;
|
|
memcpy(packet.cBuf, pBuf, nSize);
|
|
|
|
pSession->SendPacket( SC_PROP, nProtocol, &packet, sizeof(packet) - sizeof(packet.cBuf) + nSize, _RELIABLE);
|
|
}
|
|
|
|
inline void SendGameCreateDropItem(CDNUserSession * pSession, UINT nUID, EtVector3 &vPos, UINT nItemID, UINT nRandomSeed, char cOption, USHORT nCount, USHORT nRotate, UINT nOwnerSessionID )
|
|
{
|
|
SCCreateDropItem packet;
|
|
|
|
packet.nSessionID = nUID;
|
|
packet.fpos[0] = vPos.x;
|
|
packet.fpos[1] = vPos.y;
|
|
packet.fpos[2] = vPos.z;
|
|
packet.nItemID = nItemID;
|
|
packet.nRandomSeed = nRandomSeed;
|
|
packet.nCount = nCount;
|
|
packet.nRotate = nRotate;
|
|
packet.nOwnerSessionID = nOwnerSessionID;
|
|
packet.cOption = cOption;
|
|
|
|
pSession->SendPacket( SC_ITEM, eItem::SC_CREATE_DROPITEM, &packet, sizeof(packet), _RELIABLE);
|
|
}
|
|
|
|
inline void SendGameDropItemList( CDNUserSession* pSession, EtVector3& vPos, DNVector(CDnItem::RealDropItemStruct)& vDropItem )
|
|
{
|
|
SCCreateDropItemList TxPacket;
|
|
memset( &TxPacket, 0, sizeof(TxPacket) );
|
|
|
|
for( UINT i=0 ; i<vDropItem.size() ; ++i )
|
|
{
|
|
TxPacket.sDropItem[TxPacket.nCount].nSessionID = vDropItem[i].dwUniqueID;
|
|
TxPacket.sDropItem[TxPacket.nCount].fpos[0] = vPos.x;
|
|
TxPacket.sDropItem[TxPacket.nCount].fpos[1] = vPos.y;
|
|
TxPacket.sDropItem[TxPacket.nCount].fpos[2] = vPos.z;
|
|
TxPacket.sDropItem[TxPacket.nCount].nItemID = vDropItem[i].nItemID;
|
|
TxPacket.sDropItem[TxPacket.nCount].nRandomSeed = vDropItem[i].nSeed;
|
|
TxPacket.sDropItem[TxPacket.nCount].nCount = vDropItem[i].nCount;
|
|
TxPacket.sDropItem[TxPacket.nCount].nRotate = vDropItem[i].nRotate;
|
|
TxPacket.sDropItem[TxPacket.nCount].nOwnerSessionID = vDropItem[i].nOwnerSessionID;
|
|
TxPacket.sDropItem[TxPacket.nCount].cOption = vDropItem[i].cOption;
|
|
|
|
++TxPacket.nCount;
|
|
if( TxPacket.nCount >= _countof(TxPacket.sDropItem) )
|
|
{
|
|
// Send
|
|
pSession->SendPacket( SC_ITEM, eItem::SC_CREATE_DROPITEMLIST, &TxPacket, sizeof(TxPacket), _RELIABLE );
|
|
// Reset
|
|
TxPacket.nCount = 0;
|
|
}
|
|
}
|
|
|
|
if( TxPacket.nCount )
|
|
{
|
|
// Send
|
|
pSession->SendPacket( SC_ITEM, eItem::SC_CREATE_DROPITEMLIST, &TxPacket, sizeof(TxPacket)-sizeof(TxPacket.sDropItem)+sizeof(SCCreateDropItem)*TxPacket.nCount, _RELIABLE );
|
|
}
|
|
}
|
|
|
|
inline void SendGameDropItemMsg(CDNUserSession * pSession, UINT nUID, USHORT nProtocol, BYTE *pBuf, int nSize )
|
|
{
|
|
SCDropItem packet;
|
|
|
|
packet.nSessionID = nUID;
|
|
packet.nItemProtocol= nProtocol;
|
|
memcpy(packet.cBuf, pBuf, nSize);
|
|
|
|
pSession->SendPacket(SC_ITEM, eItem::SC_DROPITEM_MSG, &packet, sizeof(packet) - sizeof(packet.cBuf) + nSize, _RELIABLE);
|
|
}
|
|
|
|
inline void SendGameGenerationMonsterMsg( CDNUserSession *pSession, int nSeed, UINT nMonsterID,
|
|
UINT nUniqueID, EtVector3 &vPos, EtVector3 &vVel, EtVector3 &vResistance,
|
|
int nEventAreaUniqueID, int nTeam, bool bRandomFrameSummon, EtQuat* pqRotation )
|
|
{
|
|
SCGenerationMonster packet;
|
|
|
|
packet.nSeed = nSeed;
|
|
packet.nMonsterID = nMonsterID;
|
|
packet.nSessionID = nUniqueID;
|
|
packet.vPos = vPos;
|
|
packet.vVel = vVel;
|
|
packet.vResistance = vResistance;
|
|
packet.nEventAreaUniqueID = nEventAreaUniqueID;
|
|
packet.nTeam = nTeam;
|
|
packet.bRandomFrameSummon = bRandomFrameSummon;
|
|
|
|
if( pqRotation )
|
|
{
|
|
packet.bUseRotationQuat = true;
|
|
packet.qRotation = *pqRotation;
|
|
}
|
|
else
|
|
packet.bUseRotationQuat = false;
|
|
|
|
pSession->SendPacket(SC_ROOM, eRoom::SC_GENERATION_MONSTER_MSG, &packet, sizeof(packet), _RELIABLE);
|
|
}
|
|
|
|
inline void SendGameGateInfo( CDNUserSession *pSession, char cCount, char *pGateList, char *pPermitFlag )
|
|
{
|
|
SCGateInfoMessage packet;
|
|
|
|
packet.cCount = cCount;
|
|
memcpy( packet.cGateIndex, pGateList, sizeof(char) * cCount );
|
|
memcpy( packet.cPermitFlag, pPermitFlag, sizeof(char) * cCount );
|
|
pSession->SendPacket(SC_ROOM, eRoom::SC_GATEINFO_MSG, &packet, sizeof(packet), _RELIABLE);
|
|
}
|
|
|
|
inline void SendGameGateEjectInfo( CDNUserSession *pSession, char cGateIndex, char cLessLevelCount, char cNotEnoughItemCount,char cExceedCount, char cNotRideVehicleCount , char *pActorIndex )
|
|
{
|
|
SCGateEjectInfo packet;
|
|
|
|
packet.cGateIndex = cGateIndex;
|
|
packet.cLessLevelCount = cLessLevelCount;
|
|
packet.cNotEnoughItemCount = cNotEnoughItemCount;
|
|
packet.cExceedCount = cExceedCount;
|
|
packet.cNotRideVehicleCount = cNotRideVehicleCount;
|
|
|
|
int nCount = 0;
|
|
if( cLessLevelCount > 0 ) {
|
|
memcpy( packet.cActorIndex, pActorIndex, cLessLevelCount * sizeof(char) );
|
|
nCount += cLessLevelCount;
|
|
}
|
|
if( cNotEnoughItemCount > 0 ) {
|
|
int nOffset = nCount * sizeof(char);
|
|
memcpy( packet.cActorIndex + nOffset, pActorIndex + nOffset, cNotEnoughItemCount * sizeof(char) );
|
|
nCount += cNotEnoughItemCount;
|
|
}
|
|
if( cExceedCount > 0 ) {
|
|
int nOffset = nCount * sizeof(char);
|
|
memcpy( packet.cActorIndex + nOffset, pActorIndex + nOffset, cExceedCount * sizeof(char) );
|
|
nCount += cExceedCount;
|
|
}
|
|
if( cNotRideVehicleCount > 0 ) {
|
|
int nOffset = nCount * sizeof(char);
|
|
memcpy( packet.cActorIndex + nOffset, pActorIndex + nOffset, cNotRideVehicleCount * sizeof(char) );
|
|
nCount += cNotRideVehicleCount;
|
|
}
|
|
|
|
pSession->SendPacket(SC_ROOM, eRoom::SC_GATEEJECTINFO_MSG, &packet, sizeof(packet) - sizeof(packet.cActorIndex) + ( sizeof(char) * nCount ), _RELIABLE);
|
|
}
|
|
|
|
inline void SendGameDungeonClear( CDNUserSession *pSession, int nDungeonClearTableID, DWORD dwClearTime, char cCurLevel, int nCurExp, bool bIgnoreRewardItem, char cCount, std::vector<TDungeonClearInfo> & vInfo )
|
|
{
|
|
SCDungeonClear packet;
|
|
|
|
packet.cCount = cCount;
|
|
packet.nDungeonClearTableID = nDungeonClearTableID;
|
|
packet.nClearTime = dwClearTime;
|
|
packet.cCurLevel = cCurLevel;
|
|
packet.nCurExp = nCurExp;
|
|
packet.bIgnoreRewardItem = bIgnoreRewardItem;
|
|
|
|
for( DWORD itr = 0; itr < vInfo.size(); ++itr )
|
|
memcpy( &packet.Info[itr], &vInfo[itr], sizeof(TDungeonClearInfo) );
|
|
|
|
pSession->SendPacket(SC_ROOM, eRoom::SC_DUNGEONCLEAR_MSG, &packet, sizeof(packet) - sizeof(packet.Info) + ( sizeof(TDungeonClearInfo) * cCount ), _RELIABLE);
|
|
}
|
|
|
|
inline void SendGameDungeonClearSelectRewardItem( CDNUserSession *pSession )
|
|
{
|
|
pSession->SendPacket(SC_ROOM, eRoom::SC_DUNGEONCLEAR_SELECTREWARDITEM, NULL, 0, _RELIABLE);
|
|
}
|
|
|
|
#if defined( PRE_ADD_NAMEDITEM_SYSTEM )
|
|
inline void SendGameDungeonClearRewardBoxType( CDNUserSession *pSession, char cCount, TRewardBoxTypeStruct *pInfo )
|
|
{
|
|
SCDungeonClearBoxType packet;
|
|
memset(&packet,0,sizeof(packet));
|
|
|
|
packet.cCount = cCount;
|
|
memcpy( packet.Info, pInfo, sizeof(TRewardBoxTypeStruct) * cCount );
|
|
|
|
pSession->SendPacket(SC_ROOM, eRoom::SC_DUNGEONCLEAR_REWARDBOXTYPE, &packet, sizeof(packet) - sizeof(packet.Info) + ( sizeof(TRewardBoxTypeStruct) * cCount ), _RELIABLE);
|
|
}
|
|
#endif
|
|
|
|
inline void SendGameDungeonClearRewardItem( CDNUserSession *pSession, char cCount, TRewardItemStruct *pInfo )
|
|
{
|
|
SCDungeonClearRewardItem packet;
|
|
|
|
packet.cCount = cCount;
|
|
memcpy( packet.Info, pInfo, sizeof(TRewardItemStruct) * cCount );
|
|
|
|
pSession->SendPacket(SC_ROOM, eRoom::SC_DUNGEONCLEAR_REWARDITEM, &packet, sizeof(packet) - sizeof(packet.Info) + ( sizeof(TRewardItemStruct) * cCount ), _RELIABLE);
|
|
}
|
|
|
|
inline void SendGameDungeonClearRewardItemResult( CDNUserSession *pSession, char cCount, TRewardItemResultStruct *pInfo )
|
|
{
|
|
SCDungeonClearRewardItemResult packet;
|
|
|
|
packet.cCount = cCount;
|
|
memcpy( packet.Info, pInfo, sizeof(TRewardItemResultStruct) * cCount );
|
|
pSession->SendPacket(SC_ROOM, eRoom::SC_DUNGEONCLEAR_REWARDITEMRESULT, &packet, sizeof(packet) - sizeof(packet.Info) + ( sizeof(TRewardItemResultStruct) * cCount ), _RELIABLE );
|
|
}
|
|
|
|
inline void SendGameWarpDungeonClear( CDNUserSession *pSession )
|
|
{
|
|
SCWarpDungeonClear packet;
|
|
#if defined(PRE_ADD_RETURN_VILLAGE_SHOWNAME)
|
|
packet.nLastVillageMapIndex = pSession->GetLastVillageMapIndex();
|
|
#endif // #if defined(PRE_ADD_RETURN_VILLAGE_SHOWNAME)
|
|
pSession->SendPacket( SC_ROOM, eRoom::SC_WARP_DUNGEONCLEAR, &packet, sizeof(packet), _RELIABLE );
|
|
}
|
|
|
|
inline void SendGameDLDungeonClear( CDNUserSession *pSession, int nClearRound, DWORD dwClearTime, bool bClear, char cCount, TDLDungeonClearInfo *pInfo )
|
|
{
|
|
SCDLDungeonClear packet;
|
|
|
|
packet.cCount = cCount;
|
|
packet.nClearRound = nClearRound;
|
|
packet.nClearTime = dwClearTime;
|
|
packet.bClear = bClear;
|
|
memcpy( packet.Info, pInfo, sizeof(TDLDungeonClearInfo) * cCount );
|
|
pSession->SendPacket(SC_ROOM, eRoom::SC_DLDUNGEONCLEAR_MSG, &packet, sizeof(packet) - sizeof(packet.Info) + ( sizeof(TDLDungeonClearInfo) * cCount ), _RELIABLE);
|
|
}
|
|
|
|
inline void SendGameDLRankResult( CDNUserSession *pSession, TDLRankHistoryPartyInfo *pCurrentScore, TDLRankHistoryPartyInfo *pTopScore, TDLRankHistoryPartyInfo *pHistoryScore )
|
|
{
|
|
SCDLRankInfo packet;
|
|
|
|
memset( &packet, 0, sizeof(packet) );
|
|
|
|
packet.CurScore = *pCurrentScore;
|
|
packet.TopScore = *pTopScore;
|
|
memcpy( packet.HistoryScore, pHistoryScore, sizeof(TDLRankHistoryPartyInfo) * DarkLair::Rank::SelectTop );
|
|
|
|
pSession->SendPacket(SC_ROOM, eRoom::SC_DLDUNGEONCLEAR_RANKINFO, &packet, sizeof(packet), _RELIABLE);
|
|
}
|
|
|
|
inline void SendGameDLChallengeRequest( CDNUserSession *pSession )
|
|
{
|
|
pSession->SendPacket( SC_ROOM, eRoom::SC_DLCHALLENGE_REQUEST, NULL, 0, _RELIABLE );
|
|
}
|
|
|
|
inline void SendGameDLChallengeResponse( CDNUserSession *pSession, bool bAccept )
|
|
{
|
|
SCDLChallengeResponse TxPacket;
|
|
memset( &TxPacket, 0, sizeof(TxPacket) );
|
|
|
|
TxPacket.bAccept = bAccept;
|
|
|
|
pSession->SendPacket( SC_ROOM, eRoom::SC_DLCHALLENGE_RESPONSE, &TxPacket, sizeof(TxPacket), _RELIABLE );
|
|
}
|
|
|
|
#if defined(PRE_MOD_DARKLAIR_RECONNECT)
|
|
inline void SendGameDLRoundInfo( CDNUserSession *pSession, int nCurrentRound, int nTotalRound, bool bBossRound )
|
|
{
|
|
SCDLRoundInfo TxPacket;
|
|
memset( &TxPacket, 0, sizeof(TxPacket) );
|
|
|
|
TxPacket.nCurrentRound = nCurrentRound;
|
|
TxPacket.nTotalRound = nTotalRound;
|
|
TxPacket.bBossRound = bBossRound;
|
|
|
|
pSession->SendPacket( SC_ROOM, eRoom::SC_DLROUND_INFO, &TxPacket, sizeof(TxPacket), _RELIABLE );
|
|
}
|
|
#endif
|
|
|
|
inline void SendGameSyncDungeonTimeAttack( CDNUserSession* pSession, int iSec, int iOrgSec )
|
|
{
|
|
if( pSession == NULL )
|
|
return;
|
|
|
|
SCSyncDungeonTimeAttack TxPacket;
|
|
memset( &TxPacket, 0, sizeof(TxPacket) );
|
|
|
|
TxPacket.iRemainSec = iSec;
|
|
TxPacket.iOrgSec = iOrgSec;
|
|
|
|
pSession->SendPacket( SC_ROOM, eRoom::SC_SYNC_DUNGEONTIMEATTACK, &TxPacket, sizeof(TxPacket), _RELIABLE );
|
|
}
|
|
|
|
inline void SendGameStopDungeonTimeAttack( CDNUserSession* pSession )
|
|
{
|
|
if( pSession == NULL )
|
|
return;
|
|
|
|
pSession->SendPacket( SC_ROOM, eRoom::SC_STOP_DUNGEONTIMEATTACK, NULL, 0, _RELIABLE );
|
|
}
|
|
|
|
inline void SendGameDungeonWarpOutFailed(CDNUserSession* pSession, int errCode)
|
|
{
|
|
SCDungeonClearWarpOutFail packet;
|
|
packet.nRet = errCode;
|
|
pSession->SendPacket(SC_ROOM, eRoom::SC_DUNGEONCLEAR_CANNOTWARP, &packet, sizeof(packet), _RELIABLE);
|
|
}
|
|
|
|
inline void SendGameEnableDungeonClearLeaderWarp(CDNUserSession* pSession, bool bEnable)
|
|
{
|
|
SCDungeonClearLeaderWarp packet;
|
|
packet.bEnable = bEnable;
|
|
|
|
pSession->SendPacket(SC_ROOM, eRoom::SC_DUNGEONCLEAR_ENABLE_LEADERWARP, &packet, sizeof(packet), _RELIABLE);
|
|
}
|
|
|
|
inline void SendGameDungeonFailed( CDNUserSession *pSession, bool bCanWarpWorldMap, bool bTimeOut=false )
|
|
{
|
|
SCDungeonFailed packet;
|
|
packet.bCanWarpWorldMap = bCanWarpWorldMap;
|
|
packet.bTimeOut = bTimeOut;
|
|
#if defined(PRE_ADD_RETURN_VILLAGE_SHOWNAME)
|
|
packet.nLastVillageMapIndex = pSession->GetLastVillageMapIndex();
|
|
#endif // #if defined(PRE_ADD_RETURN_VILLAGE_SHOWNAME)
|
|
|
|
pSession->SendPacket(SC_ROOM, eRoom::SC_DUNGEONFAILED_MSG, &packet, sizeof(packet), _RELIABLE);
|
|
}
|
|
|
|
inline void SendGameSelectRewardItem( CDNUserSession *pSession, UINT nApplySessionID, char cItemIndex )
|
|
{
|
|
SCSelectRewardItem packet;
|
|
packet.nSessionID = nApplySessionID;
|
|
packet.cItemIndex = cItemIndex;
|
|
|
|
pSession->SendPacket( SC_ROOM, eRoom::SC_SELECT_REWARDITEM, &packet, sizeof(packet), _RELIABLE );
|
|
}
|
|
|
|
inline void SendGameIdentifyRewardItem( CDNUserSession *pSession, char cItemIndex, char cBoxType )
|
|
{
|
|
SCIdentifyRewardItem packet;
|
|
packet.cItemIndex = cItemIndex;
|
|
packet.cBoxType = cBoxType;
|
|
|
|
pSession->SendPacket( SC_ROOM, eRoom::SC_DUNGEONCLEAR_IDENTIFYREWARDITEM, &packet, sizeof(packet), _RELIABLE );
|
|
}
|
|
|
|
inline void SendGameOpenDungeonLevel( CDNUserSession *pSession, int nMapIndex, char cDifficulty )
|
|
{
|
|
SCOpenDungeonOpenLevel packet;
|
|
|
|
packet.nMapIndex = nMapIndex;
|
|
packet.cDifficulty = cDifficulty;
|
|
|
|
pSession->SendPacket(SC_ROOM, eRoom::SC_OPENDUNGEONLEVEL_MSG, &packet, sizeof(packet), _RELIABLE );
|
|
}
|
|
|
|
inline void SendGameChangeGateState( CDNUserSession *pSession, char cGateIndex, int nPermitFlag )
|
|
{
|
|
SCChangeGateState packet;
|
|
|
|
packet.cGateInde = cGateIndex;
|
|
packet.nPermitFlag = nPermitFlag;
|
|
pSession->SendPacket(SC_ROOM, eRoom::SC_CHANGE_GATESTATE_MSG, &packet, sizeof(packet), _RELIABLE);
|
|
}
|
|
|
|
inline void SendGameGenerationPropMsg( CDNUserSession *pSession, int nSummonPropTableID, int nUniqueID, int nSeed, EtVector3 &vPosition, EtVector3 &vRotate, EtVector3 &vScale )
|
|
{
|
|
SCGenerationProp packet;
|
|
|
|
packet.nSummonPropTableID = nSummonPropTableID;
|
|
packet.nPropUniqueID = nUniqueID;
|
|
packet.nSeed = nSeed;
|
|
packet.vPos = vPosition;
|
|
packet.vRotate = vRotate;
|
|
packet.vScale = vScale;
|
|
|
|
pSession->SendPacket( SC_ROOM, eRoom::SC_GENERATION_PROP_MSG, &packet, sizeof(packet), _RELIABLE );
|
|
}
|
|
|
|
inline void SendGameChangeGameSpeed( CDNUserSession *pSession, float fPlaySpeed, DWORD dwDelay )
|
|
{
|
|
SCChangeGameSpeed packet;
|
|
|
|
packet.fSpeed = fPlaySpeed;
|
|
packet.dwDelay = dwDelay;
|
|
|
|
pSession->SendPacket( SC_ROOM, eRoom::SC_CHANGE_GAMESPEED, &packet, sizeof(packet), _RELIABLE );
|
|
};
|
|
|
|
inline void SendItemDisjointRes( CDNUserSession* pSession, int nItemID, bool bSuccess )
|
|
{
|
|
SCItemDisjointRes Packet;
|
|
Packet.nItemID = nItemID;
|
|
Packet.bSuccess = bSuccess;
|
|
|
|
pSession->SendPacket( SC_ITEM, eItem::SC_DISJOINT_RES, &Packet, sizeof(SCItemDisjointRes), _RELIABLE );
|
|
}
|
|
|
|
//rlkt_disjoint
|
|
inline void SendItemDisjointResNew(CDNUserSession* pSession, SCItemDisjointResNew *Packet)
|
|
{
|
|
//SCItemDisjointResNew Packet;
|
|
//ZeroMemory(&Packet, sizeof(Packet));
|
|
|
|
pSession->SendPacket(SC_ITEM, eItem::SC_DISJOINT_RES, Packet, sizeof(SCItemDisjointResNew), _RELIABLE);
|
|
}
|
|
|
|
inline void SendActorShadowMsg(CDNUserSession * pSession, UINT nUID, USHORT nProtocol, BYTE *pBuf, int nSize)
|
|
{
|
|
SCActorShadowMessage Packet;
|
|
ZeroMemory( &Packet, sizeof(Packet) );
|
|
|
|
Packet.nSessionID = nUID;
|
|
memcpy(Packet.cBuf, pBuf, nSize);
|
|
|
|
pSession->SendPacket(SC_ACTOR, nProtocol, &Packet, sizeof(Packet) - sizeof(Packet.cBuf) + nSize, _FAST);
|
|
}
|
|
|
|
inline void SendRoomSeqLevel(CDNUserSession * pSession, BYTE cSeqLevel)
|
|
{
|
|
SCRoomSyncSeqLevel packet;
|
|
memset(&packet, 0, sizeof(SCRoomSyncSeqLevel));
|
|
|
|
packet.cSeqLevel = cSeqLevel;
|
|
|
|
pSession->SendPacket(SC_ROOM, eRoom::SC_ROOMSYNC_SEQLEVEL, (char*)&packet, sizeof(packet), _RELIABLE);
|
|
}
|
|
|
|
#if defined(PRE_ADD_CP_RANK)
|
|
inline void SendAbyssStageClearBest(CDNUserSession* pSession, const TStageClearBest* sLegendClearBest, const TStageClearBest* sMonthlyClearBest)
|
|
{
|
|
SCAbyssStageClearBest Packet;
|
|
memset(&Packet, 0, sizeof(Packet));
|
|
|
|
if( sLegendClearBest )
|
|
memcpy(&Packet.sLegendClearBest, sLegendClearBest, sizeof(Packet.sLegendClearBest));
|
|
if( sMonthlyClearBest )
|
|
memcpy(&Packet.sMonthlyClearBest, sMonthlyClearBest, sizeof(Packet.sMonthlyClearBest));
|
|
|
|
Packet.nMyBestCP = pSession->GetStageClearBestCP();
|
|
Packet.cMyBestRank = pSession->GetStageClearBestRank();
|
|
|
|
pSession->SendPacket(SC_ROOM, eRoom::SC_ABYSS_STAGE_CLEAR_BEST, (char*)&Packet, sizeof(Packet), _RELIABLE);
|
|
};
|
|
#endif //#if defined(PRE_ADD_CP_RANK)
|