code stringlengths 1 2.06M | language stringclasses 1 value |
|---|---|
#include "../Global.h"
#include "AhnLab.h"
#include "AntiCpSvrFunc.h"
#include "..\Tools\CTools.h"
extern CTools* gcpTools;
extern void TransmitePacket_sc_disconnect(playerCharacter_t* pPlayer, int MessageIdx =0);
extern void GTH_DisconnectPlayer(playerCharacter_t* pPlayer,const BOOL bForceQuit);
CAhnLab::CAhnLab(const char* filename)
{
m_bOK = FALSE;
m_pBasePointer = NULL;
m_dmMemSize = 0;
m_NextSendTime = 0;
m_CheckPcIdx = 0;
if ( NULL == filename)
return;
DWORD dwRet = _AntiCpSvr_Initialize( filename, &m_pBasePointer, &m_dmMemSize);
if( dwRet != ERROR_SUCCESS )
{
TRACE("_AntiCp_Initialize failed. %x", dwRet);
return;
}
m_bOK = TRUE;
}
CAhnLab::~CAhnLab()
{
_AntiCpSvr_Finalize(m_pBasePointer);
}
BOOL CAhnLab::IsOK()
{
return m_bOK;
}
void CAhnLab::UpdateAhnLab()
{
if ( FALSE == IsOK()) return;
if ( NULL == m_pBasePointer) return;
if ( g_globalTime < m_NextSendTime )
return;
int nSendCount = 0;
for (int nIdx = 0; nIdx < MAX_PCS ; nIdx++, m_CheckPcIdx++)
{
playerCharacter_t* pPlayer = NULL;
if ( m_CheckPcIdx >= MAX_PCS) m_CheckPcIdx = 0;
pPlayer =gcpTools->GetPlayerRecordPointer(m_CheckPcIdx);
if(NULL == pPlayer) continue;
if(FALSE == gcpTools->isReady(pPlayer)) continue;
if ( pPlayer->m_AhnLabMsg.MessageSend == TRUE)
continue;
playerCharacter_t::sUserHackAckMsg* Msg = NULL;
Msg = &(pPlayer->m_AhnLabMsg);
if ( NULL == Msg ) return;
memset(Msg->byReqInfo, 0, ANTICPSVRREQLEN);
memset(Msg->byReqMsg, 0, ANTICPSVRREQLEN);
memset(Msg->byAckMsg, 0, ANTICPCNTACKLEN);
DWORD dwRet = _AntiCpSvr_MakeReqMsg(m_pBasePointer, m_dmMemSize,
Msg->byReqMsg, Msg->byReqInfo);
if ( dwRet != ERROR_SUCCESS )
continue;
GTH_SendMessageAhnLabMessage(pPlayer);
pPlayer->m_AhnLabMsg.MessageSend = TRUE;
pPlayer->m_AhnLabMsg.SendTime = g_globalTime;
pPlayer->m_AhnLabMsg.SendCount += 1;
nSendCount++;
if ( nSendCount > PROCESSNUMperFRAME)
break;
}
m_NextSendTime = g_globalTime + SEND_DELAY;
}
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 CAhnLab::GTH_ProcessMessageAhnLabMessage(playerCharacter_t *pPlayer)
{
if ( NULL == pPlayer)
return;
for (int nMsgIdx = 0; nMsgIdx < ANTICPCNTACKLEN; nMsgIdx++)
pPlayer->m_AhnLabMsg.byAckMsg[nMsgIdx] = MSG_ReadByte();
if ( pPlayer->m_AhnLabMsg.MessageSend == FALSE )
return;
DWORD dwRet = _AntiCpSvr_AnalyzeAckMsg(pPlayer->m_AhnLabMsg.byAckMsg,
m_pBasePointer, pPlayer->m_AhnLabMsg.byReqInfo);
switch( dwRet )
{
case ERROR_ANTICPSVR_ANALACKMSG_HSHIELD_ERROR:
{
TransmitePacket_sc_disconnect(pPlayer, ERROR_ANTICPSVR_ANALACKMSG_HSHIELD_ERROR);
GTH_DisconnectPlayer(pPlayer,FALSE);
g_logSystem->Write("User [%s] was HackShield Error(1). Closed.", pPlayer->userID);
}break;
case ERROR_ANTICPSVR_ANALACKMSG_PACKET_ERROR:
{
TransmitePacket_sc_disconnect(pPlayer, ERROR_ANTICPSVR_ANALACKMSG_PACKET_ERROR);
GTH_DisconnectPlayer(pPlayer,FALSE);
g_logSystem->Write("User [%s] was HackShield Error(2). Closed.", pPlayer->userID);
}break;
case ERROR_ANTICPSVR_ANALACKMSG_FILE_ERROR:
{
TransmitePacket_sc_disconnect(pPlayer, ERROR_ANTICPSVR_ANALACKMSG_FILE_ERROR);
GTH_DisconnectPlayer(pPlayer,FALSE);
g_logSystem->Write("User [%s] was HackShield Error(3). Closed.", pPlayer->userID);
}break;
}
pPlayer->m_AhnLabMsg.MessageSend = FALSE;
pPlayer->m_AhnLabMsg.SendCount = 0;
}
void CAhnLab::GTH_CheckReciveTIme(playerCharacter_t *pPlayer)
{
if ( pPlayer->m_AhnLabMsg.MessageSend == FALSE)
return;
if ( (g_globalTime - pPlayer->m_AhnLabMsg.SendTime ) > DisConnectTIme )
{
if ( pPlayer->m_AhnLabMsg.SendCount < AhnLabMessageSendCount )
{
GTH_SendMessageAhnLabMessage(pPlayer);
pPlayer->m_AhnLabMsg.MessageSend = TRUE;
pPlayer->m_AhnLabMsg.SendTime = g_globalTime;
pPlayer->m_AhnLabMsg.SendCount += 1;
return;
}
TransmitePacket_sc_disconnect(pPlayer, ERROR_ANTICPSVR_ANALACKMSG_PACKET_ERROR);
GTH_DisconnectPlayer(pPlayer,FALSE);
g_logSystem->Write("User [%s] was HackShield Error(2). Closed.", pPlayer->userID);
}
} | C++ |
#if !defined(AFX_AHNLAB_H__56B2DC40_CF48_4429_8A4F_830574D0063F__INCLUDED_)
#define AFX_AHNLAB_H__56B2DC40_CF48_4429_8A4F_830574D0063F__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "AntiCpSvrFunc.h"
#include "AntiCpCnt.h"
class CAhnLab
{
public:
enum{
SEND_DELAY = 30 * 1000,
PROCESSNUMperFRAME = 40,
DisConnectTIme = 15 * 1000,
AhnLabMessageSendCount = 8
};
enum enumAhnLabPacket{
CC_AHNLAB = 0X0000,
GSC_AHNLAB = 0X0001
};
protected:
BOOL m_bOK;
BYTE *m_pBasePointer;
DWORD m_dmMemSize;
FLOAT m_NextSendTime;
int m_CheckPcIdx;
public:
BOOL IsOK();
void UpdateAhnLab();
void GTH_SendMessageAhnLabMessage(playerCharacter_t *pPlayer);
void GTH_ProcessMessageAhnLabMessage(playerCharacter_t *pPlayer);
void GTH_CheckReciveTIme(playerCharacter_t *pPlayer);
public:
CAhnLab(const char* filename);
virtual ~CAhnLab();
};
#endif
| C++ |
#include "global.h"
void GTH_SystemAdmin_ServerShutdown()
{
if ( g_config.isManager )
{
GTH_SendMessage_DropServerGroup();
GTH_SendMessage_SystemShutdownToMember();
GTH_SystemAdmin_SetShutDownTimer();
GTH_ProcessDanbattlePowerEnd();
}
else
{
GTH_SendMessage_SystemShutdownToManager();
}
}
void GTH_SystemAdmin_SetShutDownTimer()
{
g_serverShutdownTimer.active = true;
g_serverShutdownTimer.setTime = g_globalTime;
g_serverShutdownTimer.setSecond = 20 + (NewDanBattleSystem::POWE_END_WAIT_SEC/1000);
g_serverShutdownTimer.countdown = g_serverShutdownTimer.setSecond * 1000 + SERVER_SHUTDOWN_DELAYTIME;
g_serverShutdownTimer.isComplete = false;
}
void GTH_Init_ServerShutdownTimer()
{
g_serverShutdownTimer.active = false;
g_serverShutdownTimer.setTime = 0;
g_serverShutdownTimer.setSecond = 0;
g_serverShutdownTimer.countdown = 0;
g_serverShutdownTimer.isComplete = false;
}
void GTH_Process_ServerShutdownTimer()
{
int count;
int i;
playerCharacter_t *pc;
if ( g_serverShutdownTimer.active )
{
if (g_globalTime - g_serverShutdownTimer.setTime > g_serverShutdownTimer.countdown )
g_serverShutdownTimer.isComplete = true;
if ( g_serverShutdownTimer.isComplete )
{
g_serverShutdownTimer.isComplete = false;
PostMessage( g_hWnd, WM_COMMAND, IDM_EXIT, 0 );
return;
}
pc = &g_pc[0];
for (i=0; i<MAX_PCS; i++, pc++)
{
if ( !pc->active ) continue;
if ( !pc->ready ) continue;
if ( pc->isSetServerShutdown ) continue;
GTH_SendMessage_SetShutdownTimer( pc );
pc->isSetServerShutdown = true;
count ++;
if ( count > 20 ) break;
}
}
}
void GTH_SystemAdmin_GoToPlayer(playerCharacter_t *pc)
{
int idx;
char toName[NAMESTRING];
int worldIdx, zoneIdx;
vec3_t position;
strcpy(toName, MSG_ReadString());
idx = GTH_FindPCByName( toName );
if (idx >= 0)
{
worldIdx = g_pc[idx].worldIdx;
vec_copy(g_pc[idx].position, position);
if( worldIdx == pc->worldIdx )
{
vec_copy( position, pc->position );
zoneIdx = GTH_Zone_UpdateCurrentZone(ENTITY_PC, pc->idx, pc->worldIdx, pc->zoneIdx, pc->position);
pc->zoneIdx = zoneIdx;
GTH_SendPCEventMessage_Respawn( pc );
GTH_SendMessage_SyncItemObject( pc );
g_logSystem->Write("User (%s) Move to '%s' Character Pos. (World:%d, %.2f, %.2f, %.2f)", pc->userID, toName, pc->worldIdx, pc->position[0], pc->position[1], pc->position[2]);
}
else
{
GTH_Zone_DeleteEntityList(pc->worldIdx, pc->zoneIdx, pc->entityType, pc->idx);
pc->worldIdx = worldIdx;
vec_copy( position, pc->position );
pc->zoneIdx = GTH_Zone_GetZoneIdx( pc->position );
GTH_Zone_AddEntityList(pc->worldIdx, pc->zoneIdx, pc->entityType, pc->idx);
GTH_SendPCEventMessage_Respawn( pc );
pc->ready = false;
g_logSystem->Write("User (%s) Move to '%s' Character Pos. (World:%d, %.2f, %.2f, %.2f)", pc->userID, toName, pc->worldIdx, pc->position[0], pc->position[1], pc->position[2]);
}
}
else
{
if ( g_config.isManager )
{
GTH_SendMessage_RequestFindPCToMember( g_config.gameServerNo, toName, pc->name );
}
else
{
GTH_SendMessage_RequestFindPCToManager( g_config.gameServerNo, toName, pc->name );
}
}
}
void GTH_SystemAdmin_Notice()
{
char notice[256];
strcpy(notice, MSG_ReadString());
if ( g_config.isManager )
{
GTH_SendMessage_NoticeToMember( notice );
GTH_SystemAdmin_SetNoticeInfo( notice );
}
else
{
GTH_SendMessage_NoticeToManager( notice );
}
}
void GTH_SystemAdmin_SetNoticeInfo( char *notice )
{
g_noticeInfo.active = true;
g_noticeInfo.setTime = g_globalTime;
g_noticeInfo.setRepeatCount = 3;
g_noticeInfo.setTerm = 10000;
g_noticeInfo.nextTime = g_globalTime;
g_noticeInfo.curRepeatCount = 0;
g_noticeInfo.curPC = 0;
strcpy(g_noticeInfo.notice, notice);
}
void GTH_Init_ServerNoticeInfo()
{
g_noticeInfo.active = false;
g_noticeInfo.setTime = 0;
g_noticeInfo.setRepeatCount = 0;
g_noticeInfo.setTerm = 0;
g_noticeInfo.nextTime = 0;
g_noticeInfo.curRepeatCount = 0;
g_noticeInfo.curPC = 0;
strcpy(g_noticeInfo.notice, "");
}
void GTH_Process_NoticeInfo()
{
int count;
int i;
playerCharacter_t *pc;
int start;
if ( g_noticeInfo.active )
{
if ( g_globalTime >= g_noticeInfo.nextTime)
{
start = g_noticeInfo.curPC;
pc = &g_pc[start];
for (i=start; i<MAX_PCS; i++, pc++)
{
if ( !pc->active ) continue;
if ( !pc->ready ) continue;
GTH_SendMessage_NoticeMessage( pc, g_noticeInfo.notice );
count ++;
if ( count >= 20 )
{
i++;
break;
}
}
if (i >= MAX_PCS)
{
g_noticeInfo.curPC = 0;
g_noticeInfo.nextTime = g_globalTime + g_noticeInfo.setTerm;
g_noticeInfo.curRepeatCount ++;
if (g_noticeInfo.curRepeatCount >= g_noticeInfo.setRepeatCount)
g_noticeInfo.active = false;
}
else
{
g_noticeInfo.curPC = i;
}
}
}
}
int GTH_CheckValidation_GameMaster( playerCharacter_t *pc )
{
if ( pc->gameMaster < 1) return 0;
return 1;
}
void GTH_SystemAdmin_RequestFindPC()
{
int idx;
char toName[NAMESTRING], fromName[NAMESTRING];
int worldIdx, reqMemberIdx;
vec3_t position;
reqMemberIdx = MSG_ReadByte();
strcpy(toName, MSG_ReadString());
strcpy(fromName, MSG_ReadString());
idx = GTH_FindPCByName( toName );
if (idx >= 0)
{
worldIdx = g_pc[idx].worldIdx;
vec_copy(g_pc[idx].position, position);
if ( g_config.isManager )
{
GTH_SendMessage_ReplyFindPCToMember( reqMemberIdx, worldIdx, position, fromName );
}
else
{
GTH_SendMessage_ReplyFindPCToManager( reqMemberIdx, worldIdx, position, fromName );
}
}
else
{
if ( g_config.isManager )
{
GTH_SendMessage_RequestFindPCToMember( reqMemberIdx, toName, fromName );
}
}
}
void GTH_SystemAdmin_ReplyFindPC()
{
int idx;
int worldIdx, reqMemberIdx, memberIdx;
char fromName[NAMESTRING];
vec3_t position;
playerCharacter_t *pc;
vec3_t savePosition;
int saveWorldIdx;
reqMemberIdx = MSG_ReadByte();
worldIdx = MSG_ReadByte();
MSG_ReadPosition(position);
strcpy(fromName, MSG_ReadString());
if ( reqMemberIdx == g_config.gameServerNo )
{
idx = GTH_FindPCByName( fromName );
if ( idx >= 0 )
{
pc = &g_pc[idx];
memberIdx = GTH_FindServerWithinGroup( worldIdx );
if (memberIdx < 0)
{
g_logSystem->Write("Move Error!! in GTH_SystemAdmin_ReplyFindPC(reqMemberIdx:%d, worldIdx:%d, fromName:%s", reqMemberIdx, worldIdx, fromName);
}
else
{
saveWorldIdx = pc->worldIdx;
vec_copy(pc->position, savePosition);
pc->worldIdx = worldIdx;
vec_copy(position, pc->position);
pc->flagChangeServer = 1;
pc->changeServerWorldIdx = worldIdx;
DB_SaveGameData( pc, SAVEGAMEDATA_QUIT);
pc->worldIdx = saveWorldIdx;
vec_copy(savePosition, pc->position);
}
}
}
else
{
if ( g_config.isManager )
{
GTH_SendMessage_ReplyFindPCToMember( reqMemberIdx, worldIdx, position, fromName );
}
}
}
void GTH_SystemAdmin_GoToMonster(playerCharacter_t *pc)
{
if( !pc->gameMaster ) return;
int zoneIdx;
int monsterIdx;
monsterIdx = MSG_ReadShort();
if (monsterIdx < 0 || monsterIdx >= MAX_MONSTERS)
return;
if( !g_monster[monsterIdx].active ) return;
if ( pc->worldIdx == g_monster[monsterIdx].worldIdx )
{
vec_copy( g_monster[monsterIdx].position, pc->position );
zoneIdx = GTH_Zone_UpdateCurrentZone(ENTITY_PC, pc->idx, pc->worldIdx, pc->zoneIdx, pc->position);
pc->zoneIdx = zoneIdx;
GTH_SendPCEventMessage_Respawn( pc );
GTH_SendMessage_SyncItemObject( pc );
g_logSystem->Write("User (%s) Move to Monster(%d) Pos. (World:%d, %.2f, %.2f, %.2f)", pc->userID, monsterIdx, pc->worldIdx, pc->position[0], pc->position[1], pc->position[2]);
}
}
void GTH_SystemAdmin_GMBusyOnOff(playerCharacter_t *pc)
{
if( !pc->gameMaster ) return;
pc->gmBusy = !pc->gmBusy;
}
void GTH_SystemAdmin_GMHideOnOff(playerCharacter_t *pc)
{
if( !pc->gameMaster ) return;
pc->gmHide = !pc->gmHide;
}
void GTH_SystemAdmin_SummonMonster( playerCharacter_t *pc )
{
int worldIdx, monsterTableIdx, aiType, entityType;
int summonerType, summonerIdx;
int num;
float validTime;
vec3_t position;
int reply = 1, error = 0;
if( !pc->gameMaster ) return;
summonerIdx = MSG_ReadShort();
summonerType = MSG_ReadByte();
monsterTableIdx = MSG_ReadShort();
aiType = MSG_ReadShort();
worldIdx = MSG_ReadByte();
MSG_ReadPosition( position );
validTime = (float)MSG_ReadShort();
validTime = validTime * 1000.0f;
num = MSG_ReadShort();
if( num > 5 ) num = 5;
entityType = ENTITY_MONSTER;
for( int i = 0; i < num; i ++ )
{
reply = MONSTER_Summon( monsterTableIdx, worldIdx, position, aiType, ENTITY_MONSTER, summonerIdx, summonerIdx, validTime );
}
}
extern i3sizebuf_t netMessage;
| C++ |
#include "../global.h"
extern i3sizebuf_t netMessage;
extern i3socket_t msSocket[MAX_MASTERSERVER];
extern i3socket_t localSocket;
#include "..\\Guild\\CGuildCtrl.h"
extern CGuildCtrl* gcpGuildCtrl;
int GTH_GetMemberServerIdx(i3packet_t *p)
{
int command;
int idx;
if ( !NET_PreviewMessage(p) ) return -1;
MSG_BeginReading();
command = MSG_ReadByte();
if (command != GSC_MYSERVERINFO) return -1;
idx = MSG_ReadByte();
return idx;
}
int GTH_RegistMemberServer()
{
int i;
memberServer_t *member;
if (g_config.gameServerNo >= MAX_MEMBER_SERVER || g_config.gameServerNo < 0)
return false;
member = &g_memberServer[ g_config.gameServerNo ];
member->idx = g_config.gameServerNo;
member->active = true;
member->isManager = g_config.isManager;
strcpy( member->name, g_config.gameServerName );
strcpy( member->hostName, g_hostName );
strcpy( member->serviceIP, g_config.serviceIP );
member->servicePort = g_config.servicePort;
strcpy( member->localIP, g_config.localIP );
member->localPort = g_config.localPort;
member->serviceWorldNumber = g_config.serviceWorldNumber;
for (i=0; i<g_config.serviceWorldNumber; i ++)
member->serviceWorldList[i] = g_config.serviceWorldList[i];
member->curClientNumber = 0;
member->maxClientNumber = 0;
g_memberServerNumber = 1;
return true;
}
void GTH_UpdateMyServerInfo()
{
memberServer_t *member;
member = &g_memberServer[ g_config.gameServerNo ];
member->curClientNumber = g_pcNumber;
member->maxClientNumber = g_maxPCNumber;
}
int GTH_AddToServerGroup(int memberIdx, struct sockaddr_in *addr)
{
memberServer_t *member;
if (memberIdx >= MAX_MEMBER_SERVER || memberIdx < 0) return -1;
member = &g_memberServer[memberIdx];
if ( member->active ) return -1;
member->idx = memberIdx;
member->active = true;
NET_InitSocket(&member->sock, addr, localSocket.socket, SocketType_Unreliable);
g_memberServerNumber++;
return memberIdx;
}
int GTH_FindMemberServerWithAddr(struct sockaddr_in *addr)
{
memberServer_t *member;
int i;
member = &g_memberServer[1];
for (i = 1; i < MAX_MEMBER_SERVER; i++, member++)
{
if (!member->active)
continue;
if (NET_AddrCompare((struct sockaddr *)addr, (struct sockaddr *)&member->sock.addr) == 0)
return i;
}
return -1;
}
int GTH_DropMyServer()
{
int memberIdx;
memberServer_t *member;
memberIdx = MSG_ReadByte();
if (memberIdx >= MAX_MEMBER_SERVER || memberIdx < 0) return -1;
member = &g_memberServer[memberIdx];
if ( !member->active ) return false;
if ( member->idx != memberIdx ) return false;
member->active = false;
g_memberServerNumber --;
return true;
}
int GTH_MyServerInfo()
{
int memberIdx;
memberServer_t *member;
int i;
memberIdx = MSG_ReadByte();
if (memberIdx >= MAX_MEMBER_SERVER || memberIdx < 0) return 0;
member = &g_memberServer[memberIdx];
strcpy( member->name, MSG_ReadString() );
strcpy( member->hostName, MSG_ReadString() );
strcpy( member->serviceIP, MSG_ReadString() );
member->servicePort = MSG_ReadShort();
strcpy( member->localIP, MSG_ReadString() );
member->localPort = MSG_ReadShort();
member->serviceWorldNumber = MSG_ReadByte();
for (i=0; i<member->serviceWorldNumber; i++)
member->serviceWorldList[i] = MSG_ReadByte();
member->curClientNumber = MSG_ReadShort();
member->maxClientNumber = MSG_ReadShort();
member->updateTime = g_globalTime;
member->active = true;
return 1;
}
int GTH_InitMemberServer()
{
int memberIdx;
memberServer_t *member;
int i;
memset(&g_memberServer[0], 0, sizeof(memberServer_t)*MAX_MEMBER_SERVER);
memberIdx = g_config.gameServerNo;
if (memberIdx >= MAX_MEMBER_SERVER || memberIdx < 0)
{
MessageBox(g_hWnd, "Member Server'number is wrong!!", "Error!", MB_OK);
return 0;
}
member = &g_memberServer[memberIdx];
member->active = true;
strcpy( member->name, g_config.gameServerName );
strcpy( member->hostName, "" );
strcpy( member->serviceIP, g_config.serviceIP );
member->servicePort = g_config.servicePort;
strcpy( member->localIP, g_config.localIP );
member->localPort = g_config.localPort;
member->serviceWorldNumber = g_config.serviceWorldNumber;
for (i=0; i<member->serviceWorldNumber; i++)
member->serviceWorldList[i] = g_config.serviceWorldList[i];
member->curClientNumber = 0;
member->maxClientNumber = 0;
member->updateTime = g_globalTime;
return 1;
}
void GTH_SendMessage_GameServerGroupInfo()
{
int i, j;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_SERVERGROUPINFO);
MSG_WriteByte(&netMessage, g_config.serverGroupNo);
MSG_WriteString(&netMessage, g_config.serverGroupName);
MSG_WriteString(&netMessage, g_config.gameDatabase);
for (i=0; i < MAX_MEMBER_SERVER; i++)
{
MSG_WriteByte(&netMessage, g_memberServer[i].active);
if ( !g_memberServer[i].active ) continue;
MSG_WriteString(&netMessage, g_memberServer[i].name);
MSG_WriteString(&netMessage, g_memberServer[i].hostName);
MSG_WriteString(&netMessage, g_memberServer[i].serviceIP);
MSG_WriteShort(&netMessage, g_memberServer[i].servicePort);
MSG_WriteString(&netMessage, g_memberServer[i].localIP);
MSG_WriteShort(&netMessage, g_memberServer[i].localPort);
MSG_WriteByte(&netMessage, g_memberServer[i].serviceWorldNumber);
for (j=0; j < g_memberServer[i].serviceWorldNumber; j++)
MSG_WriteByte(&netMessage, g_memberServer[i].serviceWorldList[j]);
MSG_WriteShort(&netMessage, g_memberServer[i].curClientNumber);
MSG_WriteShort(&netMessage, g_memberServer[i].maxClientNumber);
}
for (i=0; i<g_config.masterServerNumber; i++)
NET_SendUnreliableMessage(&msSocket[i], &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_DropServerGroup()
{
int i;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_DROPSERVERGROUP);
MSG_WriteByte(&netMessage, g_config.serverGroupNo);
for (i=0; i<g_config.masterServerNumber; i++)
NET_SendUnreliableMessage(&msSocket[i], &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_MemberServerInfo()
{
int i, j;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte( &netMessage, GSC_MEMBERSERVERINFO );
for (i=0; i < MAX_MEMBER_SERVER; i++)
{
MSG_WriteByte(&netMessage, g_memberServer[i].active);
if ( !g_memberServer[i].active ) continue;
MSG_WriteString(&netMessage, g_memberServer[i].name);
MSG_WriteString(&netMessage, g_memberServer[i].hostName);
MSG_WriteString(&netMessage, g_memberServer[i].serviceIP);
MSG_WriteShort(&netMessage, g_memberServer[i].servicePort);
MSG_WriteString(&netMessage, g_memberServer[i].localIP);
MSG_WriteShort(&netMessage, g_memberServer[i].localPort);
MSG_WriteByte(&netMessage, g_memberServer[i].serviceWorldNumber);
for (j=0; j < g_memberServer[i].serviceWorldNumber; j++)
MSG_WriteByte(&netMessage, g_memberServer[i].serviceWorldList[j]);
MSG_WriteShort(&netMessage, g_memberServer[i].curClientNumber);
MSG_WriteShort(&netMessage, g_memberServer[i].maxClientNumber);
}
for (i=1; i < MAX_MEMBER_SERVER; i++)
{
if ( !g_memberServer[i].active ) continue;
NET_SendUnreliableMessage(&g_memberServer[i].sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
int GTH_MemberServerInfo()
{
int i, j;
int count;
count = 0;
for (i=0; i < MAX_MEMBER_SERVER; i++)
{
g_memberServer[i].idx = i;
g_memberServer[i].active = MSG_ReadByte();
if ( !g_memberServer[i].active ) continue;
strcpy( g_memberServer[i].name, MSG_ReadString() );
strcpy( g_memberServer[i].hostName, MSG_ReadString() );
strcpy( g_memberServer[i].serviceIP, MSG_ReadString() );
g_memberServer[i].servicePort = MSG_ReadShort();
strcpy( g_memberServer[i].localIP, MSG_ReadString() );
g_memberServer[i].localPort = MSG_ReadShort();
g_memberServer[i].serviceWorldNumber = MSG_ReadByte();
for (j=0; j < g_memberServer[i].serviceWorldNumber; j++ )
g_memberServer[i].serviceWorldList[j] = MSG_ReadByte();
g_memberServer[i].curClientNumber = MSG_ReadShort();
g_memberServer[i].maxClientNumber = MSG_ReadShort();
count++;
}
g_memberServer[0].updateTime = g_globalTime;
g_memberServerNumber = count;
return 1;
}
void GTH_SendMessage_MyServerInfo()
{
int i;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_MYSERVERINFO);
MSG_WriteByte(&netMessage, g_config.gameServerNo);
MSG_WriteString(&netMessage, g_config.gameServerName);
MSG_WriteString(&netMessage, g_hostName );
MSG_WriteString(&netMessage, g_config.serviceIP);
MSG_WriteShort(&netMessage, g_config.servicePort);
MSG_WriteString(&netMessage, g_config.localIP);
MSG_WriteShort(&netMessage, g_config.localPort);
MSG_WriteByte(&netMessage, g_config.serviceWorldNumber);
for (i=0; i < g_config.serviceWorldNumber; i++)
MSG_WriteByte(&netMessage, g_config.serviceWorldList[i]);
MSG_WriteShort(&netMessage, g_pcNumber);
MSG_WriteShort(&netMessage, g_maxPCNumber);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_DropMyServer()
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_DROPMYSERVER);
MSG_WriteByte(&netMessage, g_config.gameServerNo);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
int GTH_FindServerWithinGroup(int worldIdx)
{
int i, j;
memberServer_t *member;
member = &g_memberServer[0];
for (i=0; i<MAX_MEMBER_SERVER; i++, member++)
{
if ( !member->active ) continue;
for (j=0; j<member->serviceWorldNumber; j++)
{
if ( member->serviceWorldList[j] == worldIdx )
return i;
}
}
return -1;
}
int GTH_IsLocalServiceWorld(int worldIdx)
{
int i;
memberServer_t *member;
member = &g_memberServer[ g_config.gameServerNo ];
if ( !member->active ) return false;
for (i=0; i<member->serviceWorldNumber; i++)
{
if ( member->serviceWorldList[i] == worldIdx )
return true;
}
return false;
}
void GTH_CheckProblemMemberServer()
{
int i;
memberServer_t *ms;
ms = &g_memberServer[0];
for (i=0; i<MAX_MEMBER_SERVER; i++, ms++)
{
if ( !ms->active ) continue;
if ( ms->isManager ) continue;
if ( g_globalTime - ms->updateTime > 3000 )
{
ms->active = false;
}
}
}
void GTH_CheckProblemMasterServer()
{
memberServer_t *ms;
ms = &g_memberServer[0];
if ( ms->active )
{
if ( g_globalTime - ms->updateTime > 3000 )
{
ms->active = false;
localSocket.unreliableReceiveSequence = 0;
localSocket.receiveSequence = 0;
}
}
}
void GTH_ProcessMessage_SystemAdmin()
{
int command;
char notice[256];
command = MSG_ReadByte();
switch ( command )
{
case SYSTEMADMIN_SERVERSHUTDOWN:
GTH_SystemAdmin_ServerShutdown();
break;
case SYSTEMADMIN_SETSHUTDOWNTIMER:
GTH_SystemAdmin_SetShutDownTimer();
GTH_ProcessDanbattlePowerEnd();
break;
case SYSTEMSDMIN_GOTOPLAYER:
GTH_SystemAdmin_GoToPlayer( g_curPC );
break;
case SYSTEMSDMIN_NOTICE:
GTH_SystemAdmin_Notice();
break;
case SYSTEMADMIN_SETNOTICEINFO:
strcpy(notice, MSG_ReadString());
GTH_SystemAdmin_SetNoticeInfo( notice );
break;
case SYSTEMADMIN_REQUESTFINDPC:
GTH_SystemAdmin_RequestFindPC();
break;
case SYSTEMADMIN_REPLYFINDPC:
GTH_SystemAdmin_ReplyFindPC();
break;
case SYSTEMSDMIN_GOTOMONSTER:
GTH_SystemAdmin_GoToMonster( g_curPC );
break;
case SYSTEMSDMIN_GMBUSYONOFF:
GTH_SystemAdmin_GMBusyOnOff( g_curPC );
break;
case SYSTEMSDMIN_GMHIDEONOFF :
GTH_SystemAdmin_GMHideOnOff( g_curPC );
break;
case SYSTEMSDMIN_REQUESTSUMMONMONSTER :
GTH_SystemAdmin_SummonMonster( g_curPC );
break;
default:
break;
}
}
void GTH_SendMessage_SystemShutdownToMember()
{
int i;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_SYSTEMADMIN);
MSG_WriteByte(&netMessage, SYSTEMADMIN_SETSHUTDOWNTIMER);
for (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_SystemShutdownToManager()
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_SYSTEMADMIN);
MSG_WriteByte(&netMessage, SYSTEMADMIN_SERVERSHUTDOWN);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_NoticeToMember( char *notice )
{
int i;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_SYSTEMADMIN);
MSG_WriteByte(&netMessage, SYSTEMADMIN_SETNOTICEINFO);
MSG_WriteString(&netMessage, notice);
for (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_NoticeToManager( char *notice )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_SYSTEMADMIN);
MSG_WriteByte(&netMessage, SYSTEMSDMIN_NOTICE);
MSG_WriteString(&netMessage, notice);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProccessMessage_ValidationServerAdmin( playerCharacter_t *pc )
{
#ifndef _DEV_TEST
if ( !GTH_CheckValidation_GameMaster( pc ) )
{
int command = MSG_ReadByte();
g_logSystem->Write("User '%s'(ID: %s) Use Operator Command(%d), User is Not Operator.", g_curPC->name, g_curPC->userID, command);
return;
}
#endif
GTH_ProcessMessage_SystemAdmin();
}
void GTH_SendMessage_RequestFindPCToManager(int reqMemberIdx, char *toName, char *fromName )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_SYSTEMADMIN);
MSG_WriteByte(&netMessage, SYSTEMADMIN_REQUESTFINDPC);
MSG_WriteByte(&netMessage, reqMemberIdx);
MSG_WriteString(&netMessage, toName);
MSG_WriteString(&netMessage, fromName);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_RequestFindPCToMember( int reqMemberIdx, char *toName, char *fromName )
{
int i;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_SYSTEMADMIN);
MSG_WriteByte(&netMessage, SYSTEMADMIN_REQUESTFINDPC);
MSG_WriteByte(&netMessage, reqMemberIdx);
MSG_WriteString(&netMessage, toName);
MSG_WriteString(&netMessage, fromName);
for (i=1; i < MAX_MEMBER_SERVER; i++)
{
if ( !g_memberServer[i].active ) continue;
if ( i == reqMemberIdx ) continue;
NET_SendUnreliableMessage(&g_memberServer[i].sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ReplyFindPCToManager(int reqMemberIdx, int worldIdx, vec3_t position, char *fromName )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_SYSTEMADMIN);
MSG_WriteByte(&netMessage, SYSTEMADMIN_REPLYFINDPC);
MSG_WriteByte(&netMessage, reqMemberIdx);
MSG_WriteByte(&netMessage, worldIdx);
MSG_WritePosition(&netMessage, position);
MSG_WriteString(&netMessage, fromName);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ReplyFindPCToMember(int reqMemberIdx, int worldIdx, vec3_t position, char *fromName )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_SYSTEMADMIN);
MSG_WriteByte(&netMessage, SYSTEMADMIN_REPLYFINDPC);
MSG_WriteByte(&netMessage, reqMemberIdx);
MSG_WriteByte(&netMessage, worldIdx);
MSG_WritePosition(&netMessage, position);
MSG_WriteString(&netMessage, fromName);
NET_SendUnreliableMessage(&g_memberServer[reqMemberIdx].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ReplySummonMonster( playerCharacter_t* pc, int reply, int error )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_SYSTEMADMIN);
MSG_WriteByte(&netMessage, SYSTEMADMIN_REPLYSUMMONMONSTER );
MSG_WriteByte(&netMessage, reply );
MSG_WriteByte(&netMessage, error );
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_Request_PartyInfo()
{
int command;
command = MSG_ReadByte();
switch( command )
{
case PARTY_REQUEST_ORGANIZE :
GTH_ProcessMessage_PartyInfo_Request_Organize();
break;
case PARTY_REQUEST_JOIN :
GTH_ProcessMessage_PartyInfo_Request_Join();
break;
case PARTY_OUT :
GTH_ProcessMessage_PartyInfo_Request_Out();
break;
case PARTY_FORCEDOUT :
GTH_ProcessMessage_PartyInfo_Request_ForcedOut();
break;
case PARTY_DISORGANIZE :
GTH_ProcessMessage_PartyInfo_Request_Disorganize();
break;
case PARTY_SENDALL:
GTH_ProcessMessage_PartyInfo_Request_SendAll();
break;
case PARTY_UPDATE:
GTH_ProcessMessage_PartyInfo_Request_Update();
break;
case PARTY_ITEMDIVIDETYPE :
break;
case PARTY_HOLDING :
GTH_ProcessMessage_PartyInfo_Request_Holding();
break;
case PARTY_CHATMESSAGE :
GTH_ProcessMessage_PartyInfo_Request_ChatMessage();
break;
}
}
void GTH_ProcessMessage_PartyInfo_Request_Organize()
{
partyMember_t l, m;
int organizeTime;
MSG_ReadMember( &l );
MSG_ReadMember( &m );
organizeTime = MSG_ReadLong();
GTH_PartyInfo_Organize( &l, &m, organizeTime );
}
void GTH_SendMessage_PartyInfo_Reply_Organize( int memberServerIdx, int partyIdx, partyMember_t *l, partyMember_t *m, int organizeTime, int isLeader )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PARTYINFO);
MSG_WriteByte(&netMessage, PARTY_REQUEST_ORGANIZE);
MSG_WriteShort(&netMessage, partyIdx);
MSG_WriteByte(&netMessage, isLeader);
MSG_WriteMember(&netMessage, l);
MSG_WriteMember(&netMessage, m);
MSG_WriteLong(&netMessage, organizeTime);
NET_SendUnreliableMessage(&g_memberServer[memberServerIdx].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_PartyInfo_Request_Join()
{
partyMember_t m;
char organizerName[NAMESTRING];
int organizeTime, organizeServer;
MSG_ReadMember( &m );
strcpy( organizerName, MSG_ReadString() );
organizeServer = MSG_ReadChar();
organizeTime = MSG_ReadLong();
GTH_PartyInfo_Join( &m, organizerName, organizeServer, organizeTime );
}
void GTH_SendMessage_PartyInfo_Reply_Join( serverPartyInfo_t *pi, int memberServerIdx, int pcIdx, int isNewMember )
{
int i;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PARTYINFO);
MSG_WriteByte(&netMessage, PARTY_REQUEST_JOIN);
MSG_WriteByte( &netMessage, isNewMember );
MSG_WriteShort( &netMessage, pcIdx );
MSG_WriteByte( &netMessage, pi->canJoin );
MSG_WriteShort( &netMessage, pi->idx );
MSG_WriteByte( &netMessage, pi->itemDivideType );
MSG_WriteByte( &netMessage, pi->memberNumber );
MSG_WriteString( &netMessage, pi->organizerName );
MSG_WriteChar( &netMessage, pi->organizeServer );
MSG_WriteLong( &netMessage, pi->organizeTime );
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( pi->member[i].serverIndex == -1 ) continue;
MSG_WriteMember( &netMessage, &pi->member[i] );
}
NET_SendUnreliableMessage(&g_memberServer[memberServerIdx].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_PartyInfo_Request_Out()
{
char memberName[NAMESTRING];
char organizerName[NAMESTRING];
int organizeServer, organizeTime;
strcpy( memberName, MSG_ReadString() );
strcpy( organizerName, MSG_ReadString() );
organizeServer = MSG_ReadChar();
organizeTime = MSG_ReadLong();
GTH_PartyInfo_Out( false, memberName, organizerName, organizeServer, organizeTime );
}
void GTH_ProcessMessage_PartyInfo_Request_ForcedOut()
{
char memberName[NAMESTRING];
char organizerName[NAMESTRING];
int organizeServer, organizeTime;
strcpy( memberName, MSG_ReadString() );
strcpy( organizerName, MSG_ReadString() );
organizeServer = MSG_ReadChar();
organizeTime = MSG_ReadLong();
GTH_PartyInfo_Out( true, memberName, organizerName, organizeServer, organizeTime );
}
void GTH_SendMessage_PartyInfo_Reply_Out( int isForced, partyMember_t *m, int memberIdx, int nextLeaderIdx, int reqFlag )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PARTYINFO);
if( !isForced ) MSG_WriteByte(&netMessage, PARTY_OUT);
else MSG_WriteByte(&netMessage, PARTY_FORCEDOUT);
MSG_WriteMember( &netMessage, m );
MSG_WriteByte( &netMessage, memberIdx );
MSG_WriteByte( &netMessage, nextLeaderIdx );
MSG_WriteByte( &netMessage, reqFlag );
NET_SendUnreliableMessage(&g_memberServer[m->serverIndex].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_PartyInfo_Request_Disorganize()
{
char organizerName[NAMESTRING];
int organizeServer, organizeTime;
strcpy( organizerName, MSG_ReadString() );
organizeServer = MSG_ReadChar();
organizeTime = MSG_ReadLong();
GTH_PartyInfo_Disorganize( organizerName, organizeServer, organizeTime );
}
void GTH_SendMessage_PartyInfo_Reply_Disorganize( partyMember_t *m )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PARTYINFO);
MSG_WriteByte(&netMessage, PARTY_DISORGANIZE);
MSG_WriteMember( &netMessage, m );
NET_SendUnreliableMessage(&g_memberServer[m->serverIndex].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_PartyInfo_Request_SendAll()
{
int pcIdx, serverIdx;
char organizerName[NAMESTRING];
int organizeServer, organizeTIme;
serverIdx = MSG_ReadChar();
pcIdx = MSG_ReadShort();
strcpy( organizerName, MSG_ReadString() );
organizeServer = MSG_ReadChar();
organizeTIme = MSG_ReadLong();
GTH_PartyInfo_SendAll( serverIdx, pcIdx, organizerName, organizeServer, organizeTIme );
}
void GTH_SendMessage_PartyInfo_Reply_SendAll( int reply, int serverIdx, int pcIdx, serverPartyInfo_t *pi )
{
int i;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PARTYINFO);
MSG_WriteByte(&netMessage, PARTY_SENDALL);
MSG_WriteByte( &netMessage, reply );
if( reply )
{
MSG_WriteShort( &netMessage, pcIdx );
MSG_WriteByte( &netMessage, pi->canJoin );
MSG_WriteShort( &netMessage, pi->idx );
MSG_WriteByte( &netMessage, pi->itemDivideType );
MSG_WriteByte( &netMessage, pi->memberNumber );
MSG_WriteString( &netMessage, pi->organizerName );
MSG_WriteChar( &netMessage, pi->organizeServer );
MSG_WriteLong( &netMessage, pi->organizeTime );
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( pi->member[i].serverIndex == -1 ) continue;
MSG_WriteMember( &netMessage, &pi->member[i] );
}
}
else
{
MSG_WriteShort(&netMessage, pcIdx);
}
NET_SendUnreliableMessage(&g_memberServer[serverIdx].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_PartyInfo_Request_Update()
{
char memberName[NAMESTRING];
int active, serverIdx, pcIdx, level, worldIdx;
char organizerName[NAMESTRING];
int organizeServer, organizeTime;
strcpy( memberName, MSG_ReadString() );
active = MSG_ReadByte();
serverIdx = MSG_ReadChar();
pcIdx = MSG_ReadShort();
level = MSG_ReadByte();
worldIdx = MSG_ReadByte();
strcpy( organizerName, MSG_ReadString() );
organizeServer = MSG_ReadChar();
organizeTime = MSG_ReadLong();
GTH_PartyInfo_Update( memberName, active, serverIdx, pcIdx, level, worldIdx, organizerName, organizeServer, organizeTime );
}
void GTH_SendMessage_PartyInfo_Reply_Update( partyMember_t *m, int memberIdx, int nextLeaderIdx, int active, int serverIdx, int pcIdx, int level, int worldIdx )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PARTYINFO);
MSG_WriteByte(&netMessage, PARTY_UPDATE);
MSG_WriteMember( &netMessage, m );
MSG_WriteByte( &netMessage, memberIdx );
MSG_WriteByte( &netMessage, nextLeaderIdx );
MSG_WriteByte( &netMessage, active );
MSG_WriteChar( &netMessage, serverIdx );
MSG_WriteShort( &netMessage, pcIdx );
MSG_WriteByte( &netMessage, level );
MSG_WriteShort( &netMessage, worldIdx );
NET_SendUnreliableMessage(&g_memberServer[m->serverIndex].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_PartyInfo_Request_ItemDivideType()
{
char organizerName[NAMESTRING];
int organizeServer, organizeTime, type;
strcpy( organizerName, MSG_ReadString() );
organizeServer = MSG_ReadChar();
organizeTime = MSG_ReadLong();
type = MSG_ReadByte();
GTH_PartyInfo_ItemDivideType( organizerName, organizeServer, organizeTime, type );
}
void GTH_SendMessage_PartyInfo_Reply_ItemDivideType( partyMember_t *m, int type )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PARTYINFO);
MSG_WriteByte(&netMessage, PARTY_ITEMDIVIDETYPE);
MSG_WriteMember( &netMessage, m );
MSG_WriteByte( &netMessage, type );
NET_SendUnreliableMessage(&g_memberServer[m->serverIndex].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_PartyInfo_Request_Holding()
{
char organizerName[NAMESTRING];
int organizeServer, organizeTime, holdingFlag;
strcpy( organizerName, MSG_ReadString() );
organizeServer = MSG_ReadChar();
organizeTime = MSG_ReadLong();
holdingFlag = MSG_ReadChar();
GTH_PartyInfo_Holding( organizerName, organizeServer, organizeTime, holdingFlag );
}
void GTH_ProcessMessage_PartyInfo_Request_ChatMessage()
{
char fromName[NAMESTRING];
char organizerName[NAMESTRING], message[256];
int organizeServer, organizeTime;
strcpy( fromName, MSG_ReadString() );
strcpy( organizerName, MSG_ReadString() );
organizeServer = MSG_ReadChar();
organizeTime = MSG_ReadLong();
strcpy( message, MSG_ReadString() );
GTH_PartyInfo_ChatMessage( fromName, organizerName, organizeServer, organizeTime, message );
}
void GTH_SendMessage_PartyInfo_Reply_ChatMessage( partyMember_t *m, char* fromName, char *message )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PARTYINFO);
MSG_WriteByte(&netMessage, PARTY_CHATMESSAGE);
MSG_WriteMember( &netMessage, m );
MSG_WriteString( &netMessage, fromName );
MSG_WriteString( &netMessage, message );
NET_SendUnreliableMessage(&g_memberServer[m->serverIndex].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_Reply_PartyInfo()
{
int command;
command = MSG_ReadByte();
switch( command )
{
case PARTY_REQUEST_ORGANIZE :
GTH_ProcessMessage_PartyInfo_Reply_Organize();
break;
case PARTY_REQUEST_JOIN :
GTH_ProcessMessage_PartyInfo_Reply_Join();
break;
case PARTY_OUT :
GTH_ProcessMessage_PartyInfo_Reply_Out();
break;
case PARTY_FORCEDOUT :
GTH_ProcessMessage_PartyInfo_Reply_ForcedOut();
break;
case PARTY_DISORGANIZE :
GTH_ProcessMessage_PartyInfo_Reply_Disorganize();
break;
case PARTY_SENDALL:
GTH_ProcessMessage_PartyInfo_Reply_SendAll();
break;
case PARTY_UPDATE:
GTH_ProcessMessage_PartyInfo_Reply_Update();
break;
case PARTY_ITEMDIVIDETYPE :
GTH_ProcessMessage_PartyInfo_Reply_ItemDivideType();
break;
case PARTY_CHATMESSAGE :
GTH_ProcessMessage_PartyInfo_Reply_ChatMessage();
break;
}
}
void GTH_SendMessage_PartyInfo_Request_Organize( partyMember_t* l, partyMember_t *m, int organizeTime)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REQUEST_PARTYINFO);
MSG_WriteByte(&netMessage, PARTY_REQUEST_ORGANIZE);
MSG_WriteMember(&netMessage, l);
MSG_WriteMember(&netMessage, m);
MSG_WriteLong(&netMessage, organizeTime);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_PartyInfo_Reply_Organize()
{
partyMember_t l, m;
int organizeTime, partyIdx, isLeader;
partyIdx = MSG_ReadShort();
isLeader = MSG_ReadByte();
MSG_ReadMember( &l );
MSG_ReadMember( &m );
organizeTime = MSG_ReadLong();
GTH_PartyInfo_Reply_Organize( &l, &m, partyIdx, organizeTime, isLeader );
}
void GTH_SendMessage_PartyInfo_Request_Join( partyMember_t *m, char *organizerName, int organizeServer, int organizeTime )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REQUEST_PARTYINFO);
MSG_WriteByte(&netMessage, PARTY_REQUEST_JOIN);
MSG_WriteMember(&netMessage, m);
MSG_WriteString(&netMessage, organizerName);
MSG_WriteChar(&netMessage, organizeServer);
MSG_WriteLong(&netMessage, organizeTime);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_PartyInfo_Reply_Join()
{
serverPartyInfo_t pi;
partyMember_t m;
int i, pcIdx;
int isNewMember;
GTH_InitPartyInfo( &pi );
isNewMember = MSG_ReadByte();
if( isNewMember )
i = 0;
pcIdx = MSG_ReadShort();
pi.canJoin = MSG_ReadByte();
pi.idx = MSG_ReadShort();
pi.itemDivideType = MSG_ReadByte();
pi.memberNumber = MSG_ReadByte();
strcpy( pi.organizerName, MSG_ReadString() );
pi.organizeServer = MSG_ReadChar();
pi.organizeTime = MSG_ReadLong();
for( i = 0; i < pi.memberNumber; i ++ )
{
MSG_ReadMember( &m );
memcpy( &pi.member[m.idx], &m, sizeof( partyMember_t ) );
}
GTH_PartyInfo_Reply_Join( &pi, pcIdx, isNewMember );
}
void GTH_SendMessage_PartyInfo_Request_Out( int isForced, char* memberName, char* organizerName, int organizeServer, int organizeTime )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REQUEST_PARTYINFO);
if( !isForced ) MSG_WriteByte(&netMessage, PARTY_OUT);
else MSG_WriteByte(&netMessage, PARTY_FORCEDOUT);
MSG_WriteString(&netMessage, memberName);
MSG_WriteString(&netMessage, organizerName);
MSG_WriteChar(&netMessage, organizeServer);
MSG_WriteLong(&netMessage, organizeTime);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_PartyInfo_Reply_Out()
{
partyMember_t m;
int memberIdx, nextLeaderIdx, reqFlag;
memset( &m, 0, sizeof( partyMember_t ) );
MSG_ReadMember( &m );
memberIdx = MSG_ReadByte();
nextLeaderIdx = MSG_ReadByte();
reqFlag = MSG_ReadByte();
GTH_PartyInfo_Reply_Out( false, &m, memberIdx, nextLeaderIdx, reqFlag );
}
void GTH_ProcessMessage_PartyInfo_Reply_ForcedOut()
{
partyMember_t m;
int memberIdx, nextLeaderIdx, reqFlag;
memset( &m, 0, sizeof( partyMember_t ) );
MSG_ReadMember( &m );
memberIdx = MSG_ReadByte();
nextLeaderIdx = MSG_ReadByte();
reqFlag = MSG_ReadByte();
GTH_PartyInfo_Reply_Out( true, &m, memberIdx, nextLeaderIdx, reqFlag );
}
void GTH_SendMessage_PartyInfo_Request_Disorganize( char *organizerName, int organizeServer, int organizeTime )
{
MSG_BeginWriting(&netMessage);
{
MSG_WriteByte(&netMessage, GSC_REQUEST_PARTYINFO);
MSG_WriteByte(&netMessage, PARTY_DISORGANIZE);
MSG_WriteString(&netMessage, organizerName);
MSG_WriteChar(&netMessage, organizeServer);
MSG_WriteLong(&netMessage, organizeTime);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_PartyInfo_Reply_Disorganize()
{
partyMember_t m;
memset( &m, 0, sizeof( partyMember_t ) );
MSG_ReadMember( &m );
GTH_PartyInfo_Reply_Disorganize( &m );
}
void GTH_SendMessage_PartyInfo_Request_SendAll( playerCharacter_t *pc )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REQUEST_PARTYINFO);
MSG_WriteByte(&netMessage, PARTY_SENDALL);
MSG_WriteByte(&netMessage, g_config.gameServerNo);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteString(&netMessage, pc->organizerName);
MSG_WriteChar(&netMessage, pc->organizeServer);
MSG_WriteLong(&netMessage, pc->organizeTime);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_PartyInfo_Reply_SendAll()
{
serverPartyInfo_t pi;
partyMember_t m;
int i, pcIdx;
int reply;
GTH_InitPartyInfo( &pi );
reply = MSG_ReadByte();
if( reply )
{
pcIdx = MSG_ReadShort();
pi.canJoin = MSG_ReadByte();
pi.idx = MSG_ReadShort();
pi.itemDivideType = MSG_ReadByte();
pi.memberNumber = MSG_ReadByte();
strcpy( pi.organizerName, MSG_ReadString() );
pi.organizeServer = MSG_ReadChar();
pi.organizeTime = MSG_ReadLong();
for( i = 0; i < pi.memberNumber; i ++ )
{
MSG_ReadMember( &m );
memcpy( &pi.member[m.idx], &m, sizeof( partyMember_t ) );
}
}
else
{
pcIdx = MSG_ReadShort();
}
GTH_PartyInfo_Reply_SendAll( reply, pcIdx, &pi );
}
void GTH_SendMessage_PartyInfo_Request_Update( char* memberName, int active, int serverIdx, int pcIdx, int level, int worldIdx, char *organizerName, int organizeServer, int organizeTime )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REQUEST_PARTYINFO);
MSG_WriteByte(&netMessage, PARTY_UPDATE);
MSG_WriteString(&netMessage, memberName);
MSG_WriteByte(&netMessage, active);
MSG_WriteChar(&netMessage, serverIdx);
MSG_WriteShort(&netMessage, pcIdx);
MSG_WriteByte(&netMessage, level);
MSG_WriteByte(&netMessage, worldIdx);
MSG_WriteString(&netMessage, organizerName);
MSG_WriteChar(&netMessage, organizeServer);
MSG_WriteLong(&netMessage, organizeTime);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_PartyInfo_Reply_Update()
{
partyMember_t m;
int memberIdx, nextLeaderIdx, active, pcIdx, level, serverIdx;
int worldIdx;
memset( &m, 0, sizeof( partyMember_t ) );
MSG_ReadMember( &m );
memberIdx = MSG_ReadByte();
nextLeaderIdx = MSG_ReadByte();
active = MSG_ReadByte();
serverIdx = MSG_ReadChar();
pcIdx = MSG_ReadShort();
level = MSG_ReadByte();
worldIdx = MSG_ReadShort();
GTH_PartyInfo_Reply_Update( &m, memberIdx, nextLeaderIdx, active, serverIdx, pcIdx, level, worldIdx );
}
void GTH_SendMessage_PartyInfo_Request_ItemDivideType( char *organizerName, int organizeServer, int organizeTime, int type )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REQUEST_PARTYINFO);
MSG_WriteByte(&netMessage, PARTY_ITEMDIVIDETYPE);
MSG_WriteString(&netMessage, organizerName);
MSG_WriteChar(&netMessage, organizeServer);
MSG_WriteLong(&netMessage, organizeTime);
MSG_WriteByte(&netMessage, type);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_PartyInfo_Reply_ItemDivideType()
{
partyMember_t m;
int type;
memset( &m, 0, sizeof( partyMember_t ) );
MSG_ReadMember( &m );
type = MSG_ReadByte();
GTH_PartyInfo_Reply_ItemDivideType( &m, type );
}
void GTH_SendMessage_PartyInfo_Request_Holding( char *organizerName, int organizeServer, int organizeTime, int holdingFlag )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REQUEST_PARTYINFO);
MSG_WriteByte(&netMessage, PARTY_HOLDING);
MSG_WriteString(&netMessage, organizerName);
MSG_WriteChar(&netMessage, organizeServer);
MSG_WriteLong(&netMessage, organizeTime);
MSG_WriteChar(&netMessage, holdingFlag);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_PartyInfo_Request_ChatMessage( char* fromName, char *organizerName, int organizeServer, int organizeTime, char *message )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REQUEST_PARTYINFO);
MSG_WriteByte(&netMessage, PARTY_CHATMESSAGE);
MSG_WriteString(&netMessage, fromName);
MSG_WriteString(&netMessage, organizerName);
MSG_WriteChar(&netMessage, organizeServer);
MSG_WriteLong(&netMessage, organizeTime);
MSG_WriteString(&netMessage, message);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_PartyInfo_Reply_ChatMessage()
{
partyMember_t m;
char fromName[256], message[256];
memset( &m, 0, sizeof( partyMember_t ) );
MSG_ReadMember( &m );
strcpy( fromName, MSG_ReadString() );
strcpy( message, MSG_ReadString() );
GTH_PartyInfo_Reply_ChatMessage( &m, fromName, message );
}
void GTH_ProcessMessage_Request_OtherServer()
{
int command;
command = MSG_ReadByte();
switch( command )
{
case PCLIST_ADD :
GTH_ProcessMessage_PCList_Request_Add();
break;
case PCLIST_DELETE :
GTH_ProcessMessage_PCList_Request_Delete();
break;
case PCLIST_UPDATE:
GTH_ProcessMessage_PCList_Request_Update ();
break ;
case PCLIST_FRIENDS_LIST:
GTH_ProcessMessage_FriendsList_Request_List ();
break;
case PCLIST_FRIENDS_UPDATE:
GTH_ProcessMessage_FriendsList_Request_Update ();
break;
}
}
void GTH_ProcessMessage_PCList_Request_Update ()
{
entityPCList_t pl;
MSG_ReadPCList ( &pl );
g_entityListMng.UpdatePCList ( &pl );
}
void GTH_ProcessMessage_PCList_Request_Add()
{
entityPCList_t pl;
MSG_ReadPCList ( &pl );
g_entityListMng.AddPCList ( &pl );
}
void GTH_ProcessMessage_PCList_Request_Delete()
{
entityPCList_t pl;
MSG_ReadPCList ( &pl );
g_entityListMng.DeletePCList ( &pl );
}
void GTH_SendMessage_PCList_Request_Add( entityPCList_t *pl )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REQUEST_OTHERSERVER);
MSG_WriteByte(&netMessage, PCLIST_ADD);
MSG_WritePCList(&netMessage, pl);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_PCList_Request_Delete( entityPCList_t *pl )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REQUEST_OTHERSERVER);
MSG_WriteByte(&netMessage, PCLIST_DELETE);
MSG_WritePCList(&netMessage, pl);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_PCList_Request_Update( entityPCList_t *pl )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REQUEST_OTHERSERVER);
MSG_WriteByte(&netMessage, PCLIST_UPDATE);
MSG_WritePCList(&netMessage, pl);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_PCList_Reply_Add( entityPCList_t *pl )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_OTHERSERVER);
MSG_WriteByte(&netMessage, PCLIST_ADD);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_PCList_Reply_Delete( entityPCList_t *pl )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_OTHERSERVER);
MSG_WriteByte(&netMessage, PCLIST_DELETE);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_PCList_Reply_Update( entityPCList_t *pl )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_OTHERSERVER);
MSG_WriteByte(&netMessage, PCLIST_UPDATE);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_Reply_OtherServer()
{
int command;
command = MSG_ReadByte();
switch( command )
{
case PCLIST_ADD:
break;
case PCLIST_DELETE:
break;
case PCLIST_FRIENDS_LIST:
GTH_ProcessMessage_Reply_Friends_List ();
break;
case PCLIST_FRIENDS_UPDATE:
GTH_ProcessMessage_Reply_Friends_Update ();
break;
}
}
void GTH_ProcessMessage_Guild_Request_From_MemberServer()
{
int command;
command = MSG_ReadByte();
switch( command )
{
case GUILD_SYNC:
gcpGuildCtrl->BetweenMsGs_ManageServerDecoder();
break;
case GUILD_ORGANIZE :
GTH_ProcessMessage_Guild_Organize_Request_From_MemberServer();
break;
case GUILD_DISORGANIZE :
GTH_ProcessMessage_Guild_Disorganize_Request_From_MemberServer();
break;
case GUILD_INVITE_REQUEST :
GTH_ProcessMessage_Guild_Add_Request_From_MemberServer();
break;
case GUILD_SECEDE :
GTH_ProcessMessage_Guild_Remove_Request_From_MemberServer();
break;
case GUILD_BANISH:
GTH_ProcessMessage_Guild_Banish_Request_From_MemberServer();
break;
case GUILD_UPDATE:
GTH_ProcessMessage_Guild_Update_Request_From_MemberServer();
break;
case GUILD_CONNECT:
GTH_ProcessMessage_Guild_Connect_Request_From_MemberServer();
break;
case GUILD_CHATMESSAGE:
GTH_ProcessMessage_Guild_ChatMessage_Request_From_MemberServer();
break;
case GUILD_CHANGEMASTER:
GTH_ProcessMessage_Guild_Change_Master_Request_From_MemberServer();
break;
case GUILD_ADDSUBMASTER:
GTH_ProcessMessage_Guild_Add_SubMaster_Request_From_MemberServer();
break;
case GUILD_REMOVESUBMASTER:
GTH_ProcessMessage_Guild_Remove_SubMaster_Request_From_MemberServer();
break;
case GUILD_ADDFACTIONMASTER:
GTH_ProcessMessage_Guild_Add_FactionMaster_Request_From_MemberServer();
break;
case GUILD_REMOVEFACTIONMASTER:
GTH_ProcessMessage_Guild_Remove_FactionMaster_Request_From_MemberServer();
break;
case GUILD_SCHEDULE:
GTH_ProcessMessage_Guild_Schedule_Request_From_MemberServer();
break;
case GUILD_GUILDMARK:
GTH_ProcessMessage_Guild_GuildMark_Request_From_MemberServer();
break;
case GUILD_SUBSCRIBE:
GTH_ProcessMessage_Guild_Subscribe_Request_From_MemberServer();
break;
}
}
void GTH_ProcessMessage_Guild_Organize_Request_From_MemberServer()
{
if( !g_config.isManager )
return;
int error = -1;
char reqName[NAMESTRING];
char guildName[GUILDNAMESTRING];
char guildMark[GUILDMARKSIZE];
memset( guildMark, 0, GUILDMARKSIZE );
sstrncpy( reqName, MSG_ReadString(), NAMESTRING - 1 );
sstrncpy( guildName, MSG_ReadString(), GUILDNAMESTRING - 1 );
for( int i=0; i<GUILDMARKSIZE; i++ )
guildMark[i] = MSG_ReadByte();
entityPCList_t reqPl;
if( g_entityListMng.FindPCList( reqName, &reqPl ) == -1 )
return;
short guildIdx = GTH_GuildOrganize( reqName, guildName, guildMark, reqPl.serverGroupID, error );
if(guildIdx >= 0){
gcpGuildCtrl->ManagerServerProc_Organize(guildIdx,guildName,(const unsigned char*)guildMark);
g_DBGameServer->UpdateGuildIdx(
reqPl.userID,
reqPl.serverGroupID,
reqPl.characterID,
guildIdx);
}
GTH_SendMessage_Guild_Organize_Reply_To_MemberServer( reqPl.serverIdx, reqPl.idxOnServer, guildIdx, error );
}
void GTH_ProcessMessage_Guild_Disorganize_Request_From_MemberServer()
{
if( !g_config.isManager )
return;
int error = -1;
char reqName[NAMESTRING];
sstrncpy( reqName, MSG_ReadString(), NAMESTRING - 1 );
short guildIdx = MSG_ReadShort();
int result = GTH_GuildDisorganize( guildIdx, reqName, error );
entityPCList_t reqPl;
if( g_entityListMng.FindPCList( reqName, &reqPl ) == -1 )
return;
if(-1 != result){
gcpGuildCtrl->ManagerServerProc_DisOrganize(guildIdx);
g_DBGameServer->UpdateGuildIdx(
reqPl.userID,
reqPl.serverGroupID,
reqPl.characterID,
-1);
}
GTH_SendMessage_Guild_Disorganize_Reply_To_MemberServer( reqPl.serverIdx, reqPl.idxOnServer, result, error );
}
void GTH_ProcessMessage_Guild_Add_Request_From_MemberServer()
{
char reqName[NAMESTRING];
char accName[NAMESTRING];
int error = -1;
int accJob, accRank;
if( !g_config.isManager )
return;
short guildIdx = MSG_ReadShort();
sstrncpy( reqName, MSG_ReadString(), NAMESTRING - 1 );
sstrncpy( accName, MSG_ReadString(), NAMESTRING - 1 );
accJob = MSG_ReadLong();
accRank = MSG_ReadLong();
if( guildIdx < 0 )
return;
entityPCList_t reqPl, accPl;
if( g_entityListMng.FindPCList( reqName, &reqPl ) == -1 )
return;
if( g_entityListMng.FindPCList( accName, &accPl ) == -1 )
return;
if( reqPl.serverIdx != accPl.serverIdx )
return;
int rankIdxInGuild = -1;
int result = GTH_GuildAddUser( guildIdx, accName, accJob, rankIdxInGuild, error );
if(-1 != result){
g_DBGameServer->UpdateGuildIdx(
accPl.userID,
accPl.serverGroupID,
accPl.characterID,
guildIdx);
}
GTH_SendMessage_Guild_Add_Reply_To_MemberServer( accPl.serverIdx, reqPl.idxOnServer, accPl.idxOnServer, guildIdx, accRank, rankIdxInGuild, result, error );
}
void GTH_ProcessMessage_Guild_Remove_Request_From_MemberServer()
{
char name[NAMESTRING];
int error = -1;
if( !g_config.isManager )
return;
short guildIdx = MSG_ReadShort();
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
int rank = MSG_ReadLong();
if( guildIdx < 0 )
return;
entityPCList_t pl;
if( g_entityListMng.FindPCList( name, &pl ) == -1 )
return;
if( stricmp( g_guild[guildIdx].masterName, name ) == 0 )
{
error = GUILD_ERROR_SECEDE_3;
GTH_SendMessage_Guild_Remove_Reply_To_MemberServer( pl.serverIdx, pl.idxOnServer, rank, -1, error );
return;
}
int result = GTH_GuildRemoveUser( guildIdx, name, error );
if(-1 != result){
g_DBGameServer->UpdateGuildIdx(
pl.userID,
pl.serverGroupID,
pl.characterID,
-1);
}
GTH_SendMessage_Guild_Remove_Reply_To_MemberServer( pl.serverIdx, pl.idxOnServer, rank, result, error );
}
void GTH_ProcessMessage_Guild_Banish_Request_From_MemberServer()
{
char reqName[NAMESTRING];
char accName[NAMESTRING];
int error = -1;
if( !g_config.isManager )
return;
short guildIdx = MSG_ReadShort();
memset( reqName, 0, NAMESTRING );
memset( accName, 0, NAMESTRING );
strcpy( reqName, MSG_ReadString() );
strcpy( accName, MSG_ReadString() );
int rank = MSG_ReadLong();
if( guildIdx < 0 )
return;
entityPCList_t reqPl, accPl;
if( g_entityListMng.FindPCList( reqName, &reqPl ) == -1 )
return;
if( stricmp( g_guild[guildIdx].masterName, reqName ) != 0 )
{
int i;
for( i=0; i<MAX_GUILD_SUBMASTERS; i++ )
{
if( stricmp( g_guild[guildIdx].subMasterName[i], reqName ) == 0 )
break;
}
if( i == MAX_GUILD_SUBMASTERS )
{
error = GUILD_ERROR_BANISH_5;
GTH_SendMessage_Guild_Banish_Reply_To_MemberServer( reqPl.serverIdx, reqPl.idxOnServer, rank, -1, error, 0, accName );
return;
}
}
int result = GTH_GuildRemoveUser( guildIdx, accName, error );
if( result != -1 )
{
if( g_entityListMng.FindPCList( accName, &accPl ) == -1 )
{
error = 0;
GTH_SendMessage_Guild_Banish_Reply_To_MemberServer( reqPl.serverIdx, reqPl.idxOnServer, rank, result, error, 0, accName );
return;
}else{
g_DBGameServer->UpdateGuildIdx(
accPl.userID,
accPl.serverGroupID,
accPl.characterID,
-1);
}
GTH_SendMessage_Guild_Banish_Reply_To_MemberServer( accPl.serverIdx, accPl.idxOnServer, rank, result, error, 1, g_guild[guildIdx].name );
}
GTH_SendMessage_Guild_Banish_Reply_To_MemberServer( reqPl.serverIdx, reqPl.idxOnServer, rank, result, error, 0, accName );
}
void GTH_ProcessMessage_Guild_Update_Request_From_MemberServer()
{
char name[NAMESTRING];
short guildIdx = MSG_ReadShort();
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
int rank = MSG_ReadLong();
int rankIdx = MSG_ReadLong();
int type = MSG_ReadLong();
int value = MSG_ReadLong();
if( guildIdx < 0 )
return;
entityPCList_t pl;
if( g_entityListMng.FindPCList( name, &pl ) == -1 )
return;
if( rank == -1 && rankIdx == -1 )
GTH_GuildSetUserInfo( guildIdx, name, rank, rankIdx );
GTH_GuildUpdateUser( guildIdx, name, rank, rankIdx, type, value );
}
void GTH_ProcessMessage_Guild_Connect_Request_From_MemberServer()
{
char name[NAMESTRING];
short guildIdx = MSG_ReadShort();
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
if( guildIdx < 0 )
return;
entityPCList_t pl;
if( g_entityListMng.FindPCList( name, &pl ) == -1 )
{
return;
}
int rankInGuild;
int rankIdxInGuild;
GTH_GuildSetUserInfo( guildIdx, name, rankInGuild, rankIdxInGuild );
if( rankInGuild != -1 )
{
GTH_GuildUpdate( guildIdx, GUILD_UPDATE_ALL, GUILD_ALLRANK, -1, rankInGuild, rankIdxInGuild );
GTH_GuildUpdate( guildIdx, GUILD_UPDATE_USER, rankInGuild, rankIdxInGuild, GUILD_ALLRANK, -1 );
GTH_SendMessage_Guild_Connect_Reply_To_MemberServer( pl.serverIdx, pl.idxOnServer, rankInGuild, rankIdxInGuild, g_guild[guildIdx].name );
}
else
{
GTH_SendMessage_Guild_Connect_Reply_To_MemberServer( pl.serverIdx, pl.idxOnServer, rankInGuild, rankIdxInGuild, g_guild[guildIdx].name );
}
}
void GTH_ProcessMessage_Guild_ChatMessage_Request_From_MemberServer()
{
short guildIdx;
char name[NAMESTRING];
char chatMessage[CHATSTRING];
guildIdx = MSG_ReadShort();
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
sstrncpy( chatMessage, MSG_ReadString(), CHATSTRING );
GTH_GuildChatMessage( guildIdx, name, chatMessage );
}
void GTH_ProcessMessage_Guild_Change_Master_Request_From_MemberServer()
{
short guildIdx;
char reqName[NAMESTRING];
char accName[NAMESTRING];
int accJob;
int error = -1;
guildIdx = MSG_ReadShort();
sstrncpy( reqName, MSG_ReadString(), NAMESTRING - 1 );
sstrncpy( accName, MSG_ReadString(), NAMESTRING - 1 );
accJob = MSG_ReadLong();
if( guildIdx < 0 )
return;
entityPCList_t reqPl, accPl;
if( g_entityListMng.FindPCList( reqName, &reqPl ) == -1 )
return;
if( g_entityListMng.FindPCList( accName, &accPl ) == -1 )
return;
if( reqPl.serverIdx != accPl.serverIdx )
return;
int rankIdxInGuild = -1;
int result = GTH_GuildChangeMaster( guildIdx, reqName, accName, accJob, rankIdxInGuild, error );
GTH_SendMessage_Guild_Change_Master_Reply_To_MemberServer( reqPl.serverIdx, reqPl.idxOnServer, accPl.idxOnServer, result, error, rankIdxInGuild );
}
void GTH_ProcessMessage_Guild_Add_SubMaster_Request_From_MemberServer()
{
short guildIdx;
char reqName[NAMESTRING];
char accName[NAMESTRING];
int accJob;
int error = -1;
guildIdx = MSG_ReadShort();
sstrncpy( reqName, MSG_ReadString(), NAMESTRING - 1 );
sstrncpy( accName, MSG_ReadString(), NAMESTRING - 1 );
accJob = MSG_ReadLong();
if( guildIdx < 0 )
return;
entityPCList_t reqPl, accPl;
if( g_entityListMng.FindPCList( reqName, &reqPl ) == -1 )
return;
if( g_entityListMng.FindPCList( accName, &accPl ) == -1 )
return;
if( reqPl.serverIdx != accPl.serverIdx )
return;
int rankIdxInGuild = -1;
int result = GTH_GuildAddSubMaster( guildIdx, accName, accJob, rankIdxInGuild, error );
GTH_SendMessage_Guild_Add_SubMaster_Reply_To_MemberServer( reqPl.serverIdx, reqPl.idxOnServer, accPl.idxOnServer, result, error, rankIdxInGuild );
}
void GTH_ProcessMessage_Guild_Remove_SubMaster_Request_From_MemberServer()
{
short guildIdx;
char reqName[NAMESTRING];
char accName[NAMESTRING];
int accJob;
int error = -1;
int rankIdxInGuild;
int result;
guildIdx = MSG_ReadShort();
sstrncpy( reqName, MSG_ReadString(), NAMESTRING - 1 );
sstrncpy( accName, MSG_ReadString(), NAMESTRING - 1 );
accJob = MSG_ReadLong();
if( guildIdx < 0 )
return;
entityPCList_t reqPl, accPl;
if( g_entityListMng.FindPCList( reqName, &reqPl ) == -1 )
return;
if( g_entityListMng.FindPCList( accName, &accPl ) == -1 )
{
rankIdxInGuild = -1;
result = GTH_GuildRemoveSubMaster( guildIdx, accName, error );
GTH_SendMessage_Guild_Remove_SubMaster_Reply_To_MemberServer( reqPl.serverIdx, reqPl.idxOnServer, -1, accName, result, error );
return;
}
if( reqPl.serverIdx != accPl.serverIdx )
return;
if( stricmp( g_guild[guildIdx].masterName, reqName ) != 0 )
{
error = GUILD_ERROR_AUTHORITY;
GTH_SendMessage_Guild_Remove_SubMaster_Reply_To_MemberServer( reqPl.serverIdx, reqPl.idxOnServer, accPl.idxOnServer, accName, -1, error );
return;
}
rankIdxInGuild = -1;
result = GTH_GuildRemoveSubMaster( guildIdx, accName, error );
GTH_SendMessage_Guild_Remove_SubMaster_Reply_To_MemberServer( reqPl.serverIdx, reqPl.idxOnServer, accPl.idxOnServer, accName, result, error );
}
void GTH_ProcessMessage_Guild_Add_FactionMaster_Request_From_MemberServer()
{
short guildIdx;
char reqName[NAMESTRING];
char accName[NAMESTRING];
int accJob;
int error = -1;
guildIdx = MSG_ReadShort();
sstrncpy( reqName, MSG_ReadString(), NAMESTRING - 1 );
sstrncpy( accName, MSG_ReadString(), NAMESTRING - 1 );
accJob = MSG_ReadLong();
if( guildIdx < 0 )
return;
entityPCList_t reqPl, accPl;
if( g_entityListMng.FindPCList( reqName, &reqPl ) == -1 )
return;
if( g_entityListMng.FindPCList( accName, &accPl ) == -1 )
return;
if( reqPl.serverIdx != accPl.serverIdx )
return;
int rankIdxInGuild = -1;
int result = GTH_GuildAddFactionMaster( guildIdx, accName, accJob, rankIdxInGuild, error );
GTH_SendMessage_Guild_Add_FactionMaster_Reply_To_MemberServer( reqPl.serverIdx, reqPl.idxOnServer, accPl.idxOnServer, result, error, rankIdxInGuild );
}
void GTH_ProcessMessage_Guild_Remove_FactionMaster_Request_From_MemberServer()
{
short guildIdx;
char reqName[NAMESTRING];
char accName[NAMESTRING];
int accJob;
int error = -1;
int rankIdxInGuild;
int result;
guildIdx = MSG_ReadShort();
sstrncpy( reqName, MSG_ReadString(), NAMESTRING - 1 );
sstrncpy( accName, MSG_ReadString(), NAMESTRING - 1 );
accJob = MSG_ReadLong();
if( guildIdx < 0 )
return;
entityPCList_t reqPl, accPl;
if( g_entityListMng.FindPCList( reqName, &reqPl ) == -1 )
return;
if( g_entityListMng.FindPCList( accName, &accPl ) == -1 )
{
rankIdxInGuild = -1;
result = GTH_GuildRemoveFactionMaster( guildIdx, accName, error );
GTH_SendMessage_Guild_Remove_FactionMaster_Reply_To_MemberServer( reqPl.serverIdx, reqPl.idxOnServer, -1, accName, result, error );
return;
}
if( reqPl.serverIdx != accPl.serverIdx )
return;
char authority = 0;
if( stricmp( g_guild[guildIdx].masterName, reqName ) == 0 )
authority = 1;
for( int i=0; i<MAX_GUILD_SUBMASTERS; i++ )
{
if( stricmp( g_guild[guildIdx].subMasterName[i], reqName ) == 0 )
{
authority = 1;
break;
}
}
if( authority == 0 )
{
error = GUILD_ERROR_AUTHORITY;
GTH_SendMessage_Guild_Remove_FactionMaster_Reply_To_MemberServer( reqPl.serverIdx, reqPl.idxOnServer, accPl.idxOnServer, accName, -1, error );
return;
}
rankIdxInGuild = -1;
result = GTH_GuildRemoveFactionMaster( guildIdx, accName, error );
GTH_SendMessage_Guild_Remove_FactionMaster_Reply_To_MemberServer( reqPl.serverIdx, reqPl.idxOnServer, accPl.idxOnServer, accName, result, error );
}
void GTH_ProcessMessage_Guild_Schedule_Request_From_MemberServer()
{
short guildIdx;
char name[NAMESTRING];
char notice[100];
bool flag = false;
int i;
guildIdx = MSG_ReadShort();
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
sstrncpy( notice, MSG_ReadString(), sizeof( notice ) );
if( !stricmp( g_guild[guildIdx].masterName, name ) )
{
flag = true;
}
else
{
for( i=0; i<MAX_GUILD_SUBMASTERS; i++)
{
if( g_guild[guildIdx].subMasterName[i][0] == 0 ) continue;
if( !stricmp( g_guild[guildIdx].subMasterName[i], name ) )
{
flag = true;
break;
}
}
for( i=0; i<MAX_GUILD_FACTIONMASTERS; i++ )
{
if( g_guild[guildIdx].factionMasterName[i][0] == 0 ) continue;
if( !stricmp( g_guild[guildIdx].factionMasterName[i], name ) )
{
flag = true;
break;
}
}
}
if( flag )
{
strcpy( g_guild[guildIdx].notice, notice );
int update = GUILD_NOTICE;
GTH_GuildUpdate( guildIdx, update, -1, -1, GUILD_ALLRANK, -1 );
}
}
void GTH_ProcessMessage_Guild_GuildMark_Request_From_MemberServer()
{
short guildIdx;
char name[NAMESTRING];
char guildMark[GUILDMARKSIZE];
unsigned int updateTime;
guildIdx = MSG_ReadShort();
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
entityPCList_t pl;
if( g_entityListMng.FindPCList( name, &pl ) == -1 )
return;
int i;
for( i=0; i<MAX_GUILDS; i++ )
{
if( guildIdx == g_guild[i].idx )
{
updateTime = g_guild[i].idx;
memcpy( guildMark, g_guild[guildIdx].mark, GUILDMARKSIZE );
break;
}
}
if (i<MAX_GUILDS)
GTH_SendMessage_Guild_GuildMark_Reply_To_MemberServer( pl.serverIdx, pl.idxOnServer, guildIdx, updateTime, guildMark );
}
void GTH_ProcessMessage_Guild_Subscribe_Request_From_MemberServer()
{
int guildIdx;
int error;
int fromMemberIdx;
char fromName[NAMESTRING], guildName[GUILDNAMESTRING];
sstrncpy( fromName, MSG_ReadString(), NAMESTRING - 1 );
sstrncpy( guildName, MSG_ReadString(), GUILDNAMESTRING - 1 );
fromMemberIdx = MSG_ReadByte();
entityPCList_t pl;
if( g_entityListMng.FindPCList( fromName, &pl ) == -1 )
return;
for( int i=0; i<MAX_GUILDS; i++ )
{
if( !stricmp( g_guild[i].name, guildName ) )
{
guildIdx = i;
break;
}
}
if( i == MAX_GUILDS )
{
error = GUILD_ERROR_NOGUILD;
GTH_SendMessage_Guild_Subscribe_Reply_To_MemberServer( pl.serverIdx, pl.idxOnServer, -1, error );
return;
}
int bSended = 0;
if( g_guild[guildIdx].userLocation[0] != -1 )
{
GTH_Send_Subscribe_Request_Message_To_Server( g_guild[guildIdx].masterName, fromName, fromMemberIdx );
bSended = 1;
GTH_SendMessage_Guild_Subscribe_Reply_To_MemberServer( pl.serverIdx, pl.idxOnServer, 0, 0, guildName );
}
else
{
int temp = MAX_GUILD_MASTERS;
for( int i=0; i<MAX_GUILD_SUBMASTERS; i++ )
{
if( g_guild[guildIdx].userLocation[i+temp] != -1 )
{
GTH_Send_Subscribe_Request_Message_To_Server( g_guild[guildIdx].subMasterName[i], fromName, fromMemberIdx );
bSended = 1;
GTH_SendMessage_Guild_Subscribe_Reply_To_MemberServer( pl.serverIdx, pl.idxOnServer, 0, i+temp, guildName );
}
}
}
if( bSended == 0 )
{
error = GUILD_ERROR_NOMASTER;
GTH_SendMessage_Guild_Subscribe_Reply_To_MemberServer( pl.serverIdx, pl.idxOnServer, -1, error );
return;
}
}
void GTH_ProcessMessage_Guild_Subscribe_Request_From_ManagerServer()
{
int idx;
char toName[NAMESTRING], fromName[NAMESTRING];
sstrncpy(toName, MSG_ReadString(), NAMESTRING - 1 );
sstrncpy(fromName, MSG_ReadString(), NAMESTRING - 1 );
idx = GTH_FindPCByName( toName );
if (idx >= 0)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_SUBSCRIBE_REQUEST);
MSG_WriteString(&netMessage, fromName);
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
}
void GTH_SendMessage_Guild_Organize_Reply_To_MemberServer( int serverIdx, int idxOnServer, short guildIdx, int error )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_ORGANIZE);
MSG_WriteLong(&netMessage, idxOnServer);
MSG_WriteShort(&netMessage, guildIdx);
if( guildIdx != -1 )
{
MSG_WriteLong(&netMessage, g_guild[guildIdx].markUpdateTime);
MSG_WriteString(&netMessage, g_guild[guildIdx].name);
for( int i=0; i<GUILDMARKSIZE; i++ )
MSG_WriteByte(&netMessage, g_guild[guildIdx].mark[i]);
}
else
{
MSG_WriteShort(&netMessage, error);
}
NET_SendUnreliableMessage(&g_memberServer[serverIdx].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Disorganize_Reply_To_MemberServer( int serverIdx, int idxOnServer, int result, int error )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_DISORGANIZE);
MSG_WriteLong(&netMessage, idxOnServer);
MSG_WriteShort(&netMessage, result);
MSG_WriteShort(&netMessage, error);
NET_SendUnreliableMessage(&g_memberServer[serverIdx].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Add_Reply_To_MemberServer( int serverIdx, int reqIdx, int accIdx, short guildIdx, int rank, int rankIdx, int result, int error )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_INVITE_REPLY);
MSG_WriteLong(&netMessage, reqIdx);
MSG_WriteLong(&netMessage, accIdx);
MSG_WriteShort(&netMessage, guildIdx);
MSG_WriteLong(&netMessage, rank);
MSG_WriteLong(&netMessage, rankIdx);
MSG_WriteShort(&netMessage, result);
MSG_WriteShort(&netMessage, error);
NET_SendUnreliableMessage(&g_memberServer[serverIdx].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Remove_Reply_To_MemberServer( int serverIdx, int idxOnServer, int rank, int result, int error )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_SECEDE);
MSG_WriteLong(&netMessage, idxOnServer);
MSG_WriteLong(&netMessage, rank);
MSG_WriteShort(&netMessage, result);
MSG_WriteShort(&netMessage, error);
NET_SendUnreliableMessage(&g_memberServer[serverIdx].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Banish_Reply_To_MemberServer( int serverIdx, int idxOnServer, int rank, int result, int error, int who, char *name )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_BANISH);
MSG_WriteLong(&netMessage, idxOnServer);
MSG_WriteLong(&netMessage, rank);
MSG_WriteShort(&netMessage, result);
MSG_WriteShort(&netMessage, error);
MSG_WriteShort(&netMessage, who);
MSG_WriteString(&netMessage, name);
NET_SendUnreliableMessage(&g_memberServer[serverIdx].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Subscribe_Reply_To_MemberServer( int serverIdx, int idxOnServer, int result, int error, char *guildName )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_SUBSCRIBE);
MSG_WriteLong(&netMessage, idxOnServer);
MSG_WriteShort(&netMessage, result);
MSG_WriteShort(&netMessage, error);
if( result != -1 )
MSG_WriteString(&netMessage, guildName);
NET_SendUnreliableMessage(&g_memberServer[serverIdx].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Update_To_MemberServer( int serverIdx, int idxOnServer, guild_t *guild, int update, int rank, int rankIdx )
{
int i;
if( idxOnServer < 0 || idxOnServer >= MAX_PCS ) return;
if( guild->idx < 0 || guild->idx > MAX_GUILDS ) return;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_UPDATE);
MSG_WriteLong(&netMessage, idxOnServer);
MSG_WriteShort(&netMessage, guild->idx);
MSG_WriteLong(&netMessage, update);
MSG_WriteLong(&netMessage, rank);
MSG_WriteLong(&netMessage, rankIdx);
int addRankIdx = 0;
if( rank == GUILD_SUBMASTER )
addRankIdx = MAX_GUILD_MASTERS;
else if( rank == GUILD_FACTIONMASTER )
addRankIdx = MAX_GUILD_MASTERS+MAX_GUILD_SUBMASTERS;
else if( rank == GUILD_MATE )
addRankIdx = MAX_GUILD_MASTERS+MAX_GUILD_SUBMASTERS+MAX_GUILD_FACTIONMASTERS;
else
addRankIdx = 0;
if( ( update & GUILD_IDX ) != 0 )
{
MSG_WriteShort(&netMessage, guild->idx);
}
if( ( update & GUILD_SERVERGROUPID ) != 0 )
{
MSG_WriteShort(&netMessage, guild->serverGroupID);
}
if( ( update & GUILD_NAME ) != 0 )
{
MSG_WriteString(&netMessage, guild->name);
}
if( ( update & GUILD_MARK ) != 0 )
{
}
if( ( update & GUILD_MARKUPDATETIME ) != 0 )
{
MSG_WriteLong(&netMessage, guild->markUpdateTime);
}
if( ( update & GUILD_NOTICE ) != 0 )
{
MSG_WriteString(&netMessage, guild->notice);
}
if( ( update & GUILD_FAMEPOINT ) != 0 )
{
MSG_WriteLong(&netMessage, guild->famePoint);
}
if( ( update & GUILD_EXPPOINT ) != 0 )
{
MSG_WriteLong(&netMessage, guild->expPoint);
}
if( ( update & GUILD_RAIDPOINT ) != 0 )
{
MSG_WriteLong(&netMessage, guild->raidPoint);
}
if( ( update & GUILD_PVPPOINT ) != 0 )
{
MSG_WriteLong(&netMessage, guild->pvpPoint);
}
if( ( update & GUILD_HUNTERPOINT ) != 0 )
{
MSG_WriteLong(&netMessage, guild->hunterPoint);
}
if( ( update & GUILD_LEVEL ) != 0 )
{
MSG_WriteShort(&netMessage, guild->level);
}
if( ( update & GUILD_MASTERNAME ) != 0 )
{
MSG_WriteString(&netMessage, guild->masterName);
}
if( ( update & GUILD_SUBMASTERNAME ) != 0 )
{
if( rankIdx == -1 )
{
for( i=0; i<MAX_GUILD_SUBMASTERS; i++ )
MSG_WriteString(&netMessage, guild->subMasterName[i]);
}
else
MSG_WriteString(&netMessage, guild->subMasterName[rankIdx]);
}
if( ( update & GUILD_FACTIONMASTERNAME ) != 0 )
{
if( rankIdx == -1 )
{
for( i=0; i<MAX_GUILD_FACTIONMASTERS; i++ )
MSG_WriteString(&netMessage, guild->factionMasterName[i]);
}
else
MSG_WriteString(&netMessage, guild->factionMasterName[rankIdx]);
}
if( ( update & GUILD_MATENAME ) != 0 )
{
if( rankIdx == -1 )
{
for( i=0; i<MAX_GUILD_MATES; i++ )
MSG_WriteString(&netMessage, guild->mateName[i]);
}
else
MSG_WriteString(&netMessage, guild->mateName[rankIdx]);
}
if( ( update & GUILD_MATEAUTHORITY ) != 0 )
{
if( rankIdx == -1 )
{
for( i=0; i<MAX_GUILD_MATES; i++ )
MSG_WriteByte(&netMessage, guild->mateAuthority[i]);
}
else
MSG_WriteByte(&netMessage, guild->mateAuthority[rankIdx]);
}
if( ( update & GUILD_MATELASTCONNECTTIME ) != 0 )
{
if( rankIdx == -1 )
{
for( i=0; i<MAX_GUILD_MATES; i++ )
MSG_WriteLong(&netMessage, guild->mateLastConnectTime[i]);
}
else
MSG_WriteLong(&netMessage, guild->mateLastConnectTime[rankIdx]);
}
if( ( update & GUILD_MASTERNOTE ) != 0 )
{
if( rankIdx == -1 )
{
}
else
MSG_WriteString(&netMessage, guild->masterNote[rankIdx]);
}
if( ( update & GUILD_USERLEVEL ) != 0 )
{
if( rankIdx == -1 )
{
int max = MAX_GUILD_MASTERS+MAX_GUILD_SUBMASTERS+MAX_GUILD_FACTIONMASTERS+MAX_GUILD_MATES;
for( i=0; i<max; i++ )
MSG_WriteLong(&netMessage, guild->userLevel[i]);
}
else
MSG_WriteLong(&netMessage, guild->userLevel[rankIdx+addRankIdx]);
}
if( ( update & GUILD_USERJOB ) != 0 )
{
if( rankIdx == -1 )
{
int max = MAX_GUILD_MASTERS+MAX_GUILD_SUBMASTERS+MAX_GUILD_FACTIONMASTERS+MAX_GUILD_MATES;
for( i=0; i<max; i++ )
MSG_WriteLong(&netMessage, guild->userJob[i]);
}
else
MSG_WriteLong(&netMessage, guild->userJob[rankIdx+addRankIdx]);
}
if( ( update & GUILD_USERLOCATION ) != 0 )
{
if( rankIdx == -1 )
{
int max = MAX_GUILD_MASTERS+MAX_GUILD_SUBMASTERS+MAX_GUILD_FACTIONMASTERS+MAX_GUILD_MATES;
for( i=0; i<max; i++ )
MSG_WriteLong(&netMessage, guild->userLocation[i]);
}
else
MSG_WriteLong(&netMessage, guild->userLocation[rankIdx+addRankIdx]);
}
NET_SendUnreliableMessage(&g_memberServer[serverIdx].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Connect_Reply_To_MemberServer( int serverIndex, int idxOnServer, int rankInGuild, int rankIdxInGuild, char *guildName )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_CONNECT);
MSG_WriteLong(&netMessage, idxOnServer);
MSG_WriteLong(&netMessage, rankInGuild);
MSG_WriteLong(&netMessage, rankIdxInGuild);
MSG_WriteString(&netMessage, guildName);
NET_SendUnreliableMessage(&g_memberServer[serverIndex].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_ChatMessage_Reply_To_MemberServer( int serverIndex, int idxOnServer, char *name, char *chatMessage )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_CHATMESSAGE);
MSG_WriteLong(&netMessage, idxOnServer);
MSG_WriteString(&netMessage, name);
MSG_WriteString(&netMessage, chatMessage);
NET_SendUnreliableMessage(&g_memberServer[serverIndex].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Change_Master_Reply_To_MemberServer( int serverIdx, int reqIdx, int accIdx, int result, int error, int rankIdxInGuild )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_CHANGEMASTER);
MSG_WriteLong(&netMessage, reqIdx);
MSG_WriteLong(&netMessage, accIdx);
MSG_WriteShort(&netMessage, result);
MSG_WriteShort(&netMessage, error);
MSG_WriteShort(&netMessage, rankIdxInGuild);
NET_SendUnreliableMessage(&g_memberServer[serverIdx].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Add_SubMaster_Reply_To_MemberServer( int serverIdx, int reqIdx, int accIdx, int result, int error, int rankIdxInGuild )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_ADDSUBMASTER);
MSG_WriteLong(&netMessage, reqIdx);
MSG_WriteLong(&netMessage, accIdx);
MSG_WriteShort(&netMessage, result);
MSG_WriteShort(&netMessage, error);
MSG_WriteShort(&netMessage, rankIdxInGuild);
NET_SendUnreliableMessage(&g_memberServer[serverIdx].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Remove_SubMaster_Reply_To_MemberServer( int serverIdx, int reqIdx, int accIdx, char *accName, int result, int error )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_REMOVESUBMASTER);
MSG_WriteLong(&netMessage, reqIdx);
MSG_WriteLong(&netMessage, accIdx);
MSG_WriteShort(&netMessage, result);
MSG_WriteShort(&netMessage, error);
MSG_WriteString(&netMessage, accName);
NET_SendUnreliableMessage(&g_memberServer[serverIdx].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Add_FactionMaster_Reply_To_MemberServer( int serverIdx, int reqIdx, int accIdx, int result, int error, int rankIdxInGuild )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_ADDFACTIONMASTER);
MSG_WriteLong(&netMessage, reqIdx);
MSG_WriteLong(&netMessage, accIdx);
MSG_WriteShort(&netMessage, result);
MSG_WriteShort(&netMessage, error);
MSG_WriteShort(&netMessage, rankIdxInGuild);
NET_SendUnreliableMessage(&g_memberServer[serverIdx].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Remove_FactionMaster_Reply_To_MemberServer( int serverIdx, int reqIdx, int accIdx, char *accName, int result, int error )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_REMOVEFACTIONMASTER);
MSG_WriteLong(&netMessage, reqIdx);
MSG_WriteLong(&netMessage, accIdx);
MSG_WriteShort(&netMessage, result);
MSG_WriteShort(&netMessage, error);
MSG_WriteString(&netMessage, accName);
NET_SendUnreliableMessage(&g_memberServer[serverIdx].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_GuildMark_Reply_To_MemberServer( int serverIdx, int idxOnServer, short guildIdx, unsigned int updateTime, char *guildMark )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_GUILDMARK);
MSG_WriteLong(&netMessage, idxOnServer);
MSG_WriteShort(&netMessage, guildIdx);
MSG_WriteLong(&netMessage, updateTime);
for( int i=0; i<GUILDMARKSIZE; i++ )
MSG_WriteByte(&netMessage, guildMark[i]);
NET_SendUnreliableMessage(&g_memberServer[serverIdx].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_Guild_Reply_From_ManagerServer()
{
int command;
int i, idx, guildIdx, reqIdx, accIdx, rank, rankIdx;
int result, who, error = -1;
char name[NAMESTRING];
char guildName[GUILDNAMESTRING];
char chatMessage[CHATSTRING];
command = MSG_ReadByte();
switch( command )
{
case GUILD_SYNC:
gcpGuildCtrl->BetweenMsGs_GameServerDecoder();
break;
case GUILD_ORGANIZE :
idx = MSG_ReadLong();
guildIdx = MSG_ReadShort();
if( guildIdx != -1 )
{
g_guild[guildIdx].markUpdateTime = MSG_ReadLong();
sstrncpy( g_guild[guildIdx].name, MSG_ReadString(), GUILDNAMESTRING - 1 );
for( i=0; i<GUILDMARKSIZE; i++ )
g_guild[guildIdx].mark[i] = MSG_ReadByte();
}
else
{
error = MSG_ReadShort();
}
if( idx < 0 || idx >= MAX_PCS ) break;
g_pc[idx].guildIdx = guildIdx;
if( g_pc[idx].guildIdx != -1 )
{
g_pc[idx].curChargeSE -= GUILD_ORGANIZABLE_NAK;
g_pc[idx].rankPoint -= GUILD_ORGANIZABLE_RANKPOINT;
if( 0 > g_pc[idx].rankPoint) g_pc[idx].rankPoint = 0;
strcpy( g_pc[idx].guildName, g_guild[guildIdx].name );
GTH_SendMessage_Guild_Organize_Reply_To_Client( &g_pc[idx], 0, error );
}
else
{
GTH_SendMessage_Guild_Organize_Reply_To_Client( &g_pc[idx], -1, error );
}
break;
case GUILD_DISORGANIZE :
{
idx = MSG_ReadLong();
result = MSG_ReadShort();
error = MSG_ReadShort();
if( idx < 0 || idx >= MAX_PCS ) break;
if( result != -1 )
g_pc[idx].guildIdx = -1;
if( result == 1 )
{
}
if( result == 0 )
g_pc[idx].rankPoint -= 50;
time_t NowTime = time(NULL) + DELAY_DAN_CREATE_SEC;
g_pc[idx].GuildDeconstructionTime = NowTime;
NowTime = time(NULL) + DELAY_DAN_REJOIN_SEC_FOR_GENERAL_REMOVE;
g_pc[idx].GuildsecedeTime = NowTime;
if( 0 > g_pc[idx].rankPoint) g_pc[idx].rankPoint = 0;
GTH_SendMessage_Guild_Disorganize_Reply_To_Client( &g_pc[idx], result, error );
}
break;
case GUILD_UPDATE :
GTH_ProcessMessage_Guild_Update_From_ManagerServer();
break;
case GUILD_INVITE_REPLY:
reqIdx = MSG_ReadLong();
accIdx = MSG_ReadLong();
guildIdx = MSG_ReadShort();
rank = MSG_ReadLong();
rankIdx = MSG_ReadLong();
result = MSG_ReadShort();
error = MSG_ReadShort();
if( reqIdx < 0 || reqIdx >= MAX_PCS ) break;
if( accIdx < 0 || accIdx >= MAX_PCS ) break;
if( result != -1 )
{
g_pc[accIdx].guildIdx = guildIdx;
g_pc[accIdx].rankInGuild = rank;
g_pc[accIdx].rankIdxInGuild = rankIdx;
strcpy( g_pc[accIdx].guildName, g_guild[guildIdx].name );
}
else
{
error = GUILD_ERROR_CANNOTFIND;
}
GTH_SendMessage_Guild_Invite_Reply_To_Client( &g_pc[reqIdx], result, error, 0, g_pc[accIdx].name );
GTH_SendMessage_Guild_Invite_Reply_To_Client( &g_pc[accIdx], result, error, 1, g_pc[reqIdx].guildName );
GTH_DeleteNoticePC( &g_pc[reqIdx] );
GTH_DeleteNoticePC( &g_pc[accIdx] );
break;
case GUILD_SECEDE:
idx = MSG_ReadLong();
rank = MSG_ReadLong();
result = MSG_ReadShort();
error = MSG_ReadShort();
if( idx < 0 || idx >= MAX_PCS ) break;
if( result != -1 )
{
g_pc[idx].guildIdx = -1;
g_pc[idx].rankPoint -= 10;
if( 0 > g_pc[idx].rankPoint) g_pc[idx].rankPoint = 0;
time_t NowTime = time(NULL) + DELAY_DAN_REJOIN_SEC_FOR_GENERAL_REMOVE;
g_pc[idx].GuildsecedeTime = NowTime;
}
GTH_SendMessage_Guild_Secede_Reply_To_Client( &g_pc[idx], result, error );
break;
case GUILD_BANISH:
idx = MSG_ReadLong();
rank = MSG_ReadLong();
result = MSG_ReadShort();
error = MSG_ReadShort();
who = MSG_ReadShort();
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
if( idx < 0 || idx >= MAX_PCS ) break;
if( result != -1 )
{
if( who == 0 )
{
if( error == 0 )
{
g_DBGameServer->BanishMemberGuild(name,10);
}
}
else
{
g_pc[idx].guildIdx = -1;
g_pc[idx].rankPoint -= 10;
if( 0 > g_pc[idx].rankPoint) g_pc[idx].rankPoint = 0;
time_t NowTime = time(NULL) + DELAY_DAN_REJOIN_SEC_FOR_POWER_REMOVE;
g_pc[idx].GuildsecedeTime = NowTime;
}
}
GTH_SendMessage_Guild_Banish_Reply_To_Client( &g_pc[idx], result, error, who, name );
break;
case GUILD_CONNECT:
idx = MSG_ReadLong();
rank = MSG_ReadLong();
rankIdx = MSG_ReadLong();
sstrncpy( guildName, MSG_ReadString(), GUILDNAMESTRING - 1 );
if( idx < 0 || idx >= MAX_PCS ) break;
g_pc[idx].rankInGuild = rank;
g_pc[idx].rankIdxInGuild = rankIdx;
if( g_pc[idx].rankInGuild == -1 )
{
g_pc[idx].rankInGuild = -1;
g_pc[idx].rankIdxInGuild = -1;
memset( g_pc[idx].guildName, 0, GUILDNAMESTRING );
g_pc[idx].guildIdx = -1;
}
break;
case GUILD_CHATMESSAGE:
idx = MSG_ReadLong();
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
sstrncpy( chatMessage, MSG_ReadString(), CHATSTRING );
if( idx < 0 || idx >= MAX_PCS ) break;
GTH_SendMessage_Guild_ChatMessage_Reply_To_Client( &g_pc[idx], name, chatMessage );
break;
case GUILD_CHANGEMASTER:
reqIdx = MSG_ReadLong();
accIdx = MSG_ReadLong();
result = MSG_ReadShort();
error = MSG_ReadShort();
rankIdx = MSG_ReadShort();
if( reqIdx < 0 || reqIdx >= MAX_PCS ) break;
if( accIdx < 0 || accIdx >= MAX_PCS ) break;
if( result != -1 )
{
g_pc[accIdx].rankInGuild = GUILD_MASTER;
g_pc[accIdx].rankIdxInGuild = 0;
}
GTH_SendMessage_Guild_Add_SubMaster_Reply_To_Client( &g_pc[reqIdx], result, error, 0, g_pc[accIdx].name );
GTH_SendMessage_Guild_Add_SubMaster_Reply_To_Client( &g_pc[accIdx], result, error, 1, g_pc[accIdx].name );
break;
case GUILD_ADDSUBMASTER:
reqIdx = MSG_ReadLong();
accIdx = MSG_ReadLong();
result = MSG_ReadShort();
error = MSG_ReadShort();
rankIdx = MSG_ReadShort();
if( reqIdx < 0 || reqIdx >= MAX_PCS ) break;
if( accIdx < 0 || accIdx >= MAX_PCS ) break;
if( result != -1 )
{
g_pc[accIdx].rankInGuild = GUILD_SUBMASTER;
g_pc[accIdx].rankIdxInGuild = rankIdx;
}
GTH_SendMessage_Guild_Add_SubMaster_Reply_To_Client( &g_pc[reqIdx], result, error, 0, g_pc[accIdx].name );
GTH_SendMessage_Guild_Add_SubMaster_Reply_To_Client( &g_pc[accIdx], result, error, 1, g_pc[accIdx].name );
break;
case GUILD_REMOVESUBMASTER:
reqIdx = MSG_ReadLong();
accIdx = MSG_ReadLong();
result = MSG_ReadShort();
error = MSG_ReadShort();
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
if( reqIdx < 0 || reqIdx >= MAX_PCS ) break;
if( !g_pc[reqIdx].active || !g_pc[reqIdx].ready )
{
error = GUILD_ERROR_OFFLINE;
GTH_SendMessage_Guild_Remove_SubMaster_Reply_To_Client( &g_pc[reqIdx], -1, error, 0, name );
break;
}
GTH_SendMessage_Guild_Remove_SubMaster_Reply_To_Client( &g_pc[reqIdx], result, error, 0, name );
if( accIdx != -1 )
{
if( !g_pc[accIdx].active || !g_pc[accIdx].ready ) break;
GTH_SendMessage_Guild_Remove_SubMaster_Reply_To_Client( &g_pc[accIdx], result, error, 1, g_pc[accIdx].name );
}
break;
case GUILD_ADDFACTIONMASTER:
reqIdx = MSG_ReadLong();
accIdx = MSG_ReadLong();
result = MSG_ReadShort();
error = MSG_ReadShort();
rankIdx = MSG_ReadShort();
if( reqIdx < 0 || reqIdx >= MAX_PCS ) break;
if( accIdx < 0 || accIdx >= MAX_PCS ) break;
if( result != -1 )
{
g_pc[accIdx].rankInGuild = GUILD_FACTIONMASTER;
g_pc[accIdx].rankIdxInGuild = rankIdx;
}
GTH_SendMessage_Guild_Add_FactionMaster_Reply_To_Client( &g_pc[accIdx], result, error, 1, g_pc[accIdx].name );
GTH_SendMessage_Guild_Add_FactionMaster_Reply_To_Client( &g_pc[reqIdx], result, error, 0, g_pc[accIdx].name );
break;
case GUILD_REMOVEFACTIONMASTER:
reqIdx = MSG_ReadLong();
accIdx = MSG_ReadLong();
result = MSG_ReadShort();
error = MSG_ReadShort();
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
if( reqIdx < 0 || reqIdx >= MAX_PCS ) break;
if( !g_pc[reqIdx].active || !g_pc[reqIdx].ready )
{
error = GUILD_ERROR_OFFLINE;
GTH_SendMessage_Guild_Remove_FactionMaster_Reply_To_Client( &g_pc[reqIdx], -1, error, 0, name );
break;
}
GTH_SendMessage_Guild_Remove_FactionMaster_Reply_To_Client( &g_pc[reqIdx], result, error, 0, g_pc[accIdx].name );
if( accIdx != -1 )
{
if( !g_pc[accIdx].active || !g_pc[accIdx].ready ) break;
GTH_SendMessage_Guild_Remove_FactionMaster_Reply_To_Client( &g_pc[accIdx], result, error, 1, g_pc[accIdx].name );
}
break;
case GUILD_GUILDMARK:
break;
case GUILD_SUBSCRIBE:
idx = MSG_ReadLong();
result = MSG_ReadShort();
error = MSG_ReadShort();
if( result != -1 )
{
sstrncpy( guildName, MSG_ReadString(), GUILDNAMESTRING - 1 );
GTH_SendMessage_Guild_Subscribe_Reply_To_Client( &g_pc[idx], result, error, guildName );
}
else
{
GTH_SendMessage_Guild_Subscribe_Reply_To_Client( &g_pc[idx], result, error );
}
break;
case GUILD_SUBSCRIBE_REQUEST:
GTH_ProcessMessage_Guild_Subscribe_Request_From_ManagerServer();
break;
}
}
void GTH_ProcessMessage_Guild_Update_From_ManagerServer()
{
int i, idx;
short guildIdx;
int update;
int rank, rankIdx;
char name[NAMESTRING];
char guildName[GUILDNAMESTRING];
idx = MSG_ReadLong();
guildIdx = MSG_ReadShort();
update = MSG_ReadLong();
rank = MSG_ReadLong();
rankIdx = MSG_ReadLong();
if( idx < 0 || idx >= MAX_PCS ) return;
if( guildIdx < 0 || guildIdx >= MAX_GUILDS ) return;
int addRankIdx = 0;
if( rank == GUILD_SUBMASTER )
addRankIdx = MAX_GUILD_MASTERS;
else if( rank == GUILD_FACTIONMASTER )
addRankIdx = MAX_GUILD_MASTERS + MAX_GUILD_SUBMASTERS;
else if( rank == GUILD_MATE )
addRankIdx = MAX_GUILD_MASTERS + MAX_GUILD_SUBMASTERS + MAX_GUILD_FACTIONMASTERS;
else
addRankIdx = 0;
if( ( update & GUILD_IDX ) != 0 )
{
g_guild[guildIdx].idx = MSG_ReadShort();
}
if( ( update & GUILD_SERVERGROUPID ) != 0 )
{
g_guild[guildIdx].serverGroupID = MSG_ReadShort();
}
if( ( update & GUILD_NAME ) != 0 )
{
sstrncpy( guildName, MSG_ReadString(), GUILDNAMESTRING - 1 );
strcpy( g_guild[guildIdx].name, guildName );
strcpy( g_pc[idx].guildName, guildName );
}
if( ( update & GUILD_MARK ) != 0 )
{
}
if( ( update & GUILD_MARKUPDATETIME ) != 0 )
{
g_guild[guildIdx].markUpdateTime = MSG_ReadLong();
}
if( ( update & GUILD_NOTICE ) != 0 )
{
sstrncpy( g_guild[guildIdx].notice, MSG_ReadString(), sizeof( g_guild[guildIdx].notice ) );
}
if( ( update & GUILD_FAMEPOINT ) != 0 )
{
g_guild[guildIdx].famePoint = MSG_ReadLong();
}
if( ( update & GUILD_EXPPOINT ) != 0 )
{
g_guild[guildIdx].expPoint = MSG_ReadLong();
}
if( ( update & GUILD_RAIDPOINT ) != 0 )
{
g_guild[guildIdx].raidPoint = MSG_ReadLong();
}
if( ( update & GUILD_PVPPOINT ) != 0 )
{
g_guild[guildIdx].pvpPoint = MSG_ReadLong();
}
if( ( update & GUILD_HUNTERPOINT ) != 0 )
{
g_guild[guildIdx].hunterPoint = MSG_ReadLong();
}
if( ( update & GUILD_LEVEL ) != 0 )
{
g_guild[guildIdx].level = MSG_ReadShort();
}
if( ( update & GUILD_MASTERNAME ) != 0 )
{
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
strcpy( g_guild[guildIdx].masterName, name );
}
if( ( update & GUILD_SUBMASTERNAME ) != 0 )
{
if( rankIdx == -1 )
{
for( i=0; i<MAX_GUILD_SUBMASTERS; i++)
{
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
strcpy( g_guild[guildIdx].subMasterName[i], name );
}
}
else
{
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
strcpy( g_guild[guildIdx].subMasterName[rankIdx], name );
}
}
if( ( update & GUILD_FACTIONMASTERNAME ) != 0 )
{
if( rankIdx == -1 )
{
for( i=0; i<MAX_GUILD_FACTIONMASTERS; i++)
{
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
strcpy( g_guild[guildIdx].factionMasterName[i], name );
}
}
else
{
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
strcpy( g_guild[guildIdx].factionMasterName[rankIdx], name );
}
}
if( ( update & GUILD_MATENAME ) != 0 )
{
if( rankIdx == -1 )
{
for( i=0; i<MAX_GUILD_MATES; i++)
{
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
strcpy( g_guild[guildIdx].mateName[i], name );
}
}
else
{
sstrncpy( name, MSG_ReadString(), NAMESTRING - 1 );
strcpy( g_guild[guildIdx].mateName[rankIdx], name );
}
}
if( ( update & GUILD_MATEAUTHORITY ) != 0 )
{
if( rankIdx == -1 )
{
for( i=0; i<MAX_GUILD_MATES; i++)
g_guild[guildIdx].mateAuthority[i] = MSG_ReadByte();
}
else
g_guild[guildIdx].mateAuthority[rankIdx] = MSG_ReadByte();
}
if( ( update & GUILD_MATELASTCONNECTTIME ) != 0 )
{
if( rankIdx == -1 )
{
for( i=0; i<MAX_GUILD_MATES; i++)
g_guild[guildIdx].mateLastConnectTime[i] = MSG_ReadLong();
}
else
g_guild[guildIdx].mateLastConnectTime[rankIdx] = MSG_ReadLong();
}
if( ( update & GUILD_MASTERNOTE ) != 0 )
{
if( rankIdx == -1 )
{
}
else
strcpy( g_guild[guildIdx].masterNote[rankIdx], MSG_ReadString() );
}
if( ( update & GUILD_USERLEVEL ) != 0 )
{
if( rankIdx == -1 )
{
int max = MAX_GUILD_MASTERS + MAX_GUILD_SUBMASTERS + MAX_GUILD_FACTIONMASTERS + MAX_GUILD_MATES;
for( i=0; i<max; i++ )
g_guild[guildIdx].userLevel[i] = MSG_ReadLong();
}
else
g_guild[guildIdx].userLevel[rankIdx+addRankIdx] = MSG_ReadLong();
}
if( ( update & GUILD_USERJOB ) != 0 )
{
if( rankIdx == -1 )
{
int max = MAX_GUILD_MASTERS + MAX_GUILD_SUBMASTERS + MAX_GUILD_FACTIONMASTERS + MAX_GUILD_MATES;
for( i=0; i<max; i++ )
g_guild[guildIdx].userJob[i] = MSG_ReadLong();
}
else
g_guild[guildIdx].userJob[rankIdx+addRankIdx] = MSG_ReadLong();
}
if( ( update & GUILD_USERLOCATION ) != 0 )
{
if( rankIdx == -1 )
{
int max = MAX_GUILD_MASTERS + MAX_GUILD_SUBMASTERS + MAX_GUILD_FACTIONMASTERS + MAX_GUILD_MATES;
for( i=0; i<max; i++ )
g_guild[guildIdx].userLocation[i] = MSG_ReadLong();
}
else
g_guild[guildIdx].userLocation[rankIdx+addRankIdx] = MSG_ReadLong();
}
if( !g_pc[idx].active || !g_pc[idx].ready ) return;
GTH_SendMessage_Guild_Update_To_Client( &g_pc[idx], &g_guild[guildIdx], update, rank, rankIdx );
}
void GTH_SendMessage_Guild_Organize_Request_To_ManagerServer( playerCharacter_t *pc, char* guildName, char* guildMark )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REQUEST);
MSG_WriteByte(&netMessage, GUILD_ORGANIZE);
MSG_WriteString(&netMessage, pc->name);
MSG_WriteString(&netMessage, guildName);
for( int i=0; i<GUILDMARKSIZE; i++ )
MSG_WriteByte(&netMessage, guildMark[i]);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Disorganize_Request_To_ManagerServer( playerCharacter_t* pc )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REQUEST);
MSG_WriteByte(&netMessage, GUILD_DISORGANIZE);
MSG_WriteString(&netMessage, pc->name);
MSG_WriteShort(&netMessage, pc->guildIdx);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Add_Request_To_ManagerServer( playerCharacter_t *reqPC, playerCharacter_t *accPC, int rank )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REQUEST);
MSG_WriteByte(&netMessage, GUILD_INVITE_REQUEST);
MSG_WriteShort(&netMessage, reqPC->guildIdx);
MSG_WriteString(&netMessage, reqPC->name);
MSG_WriteString(&netMessage, accPC->name);
MSG_WriteLong(&netMessage, accPC->pcJob);
MSG_WriteLong(&netMessage, rank);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Remove_Request_To_ManagerServer( playerCharacter_t *pc, int rank )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REQUEST);
MSG_WriteByte(&netMessage, GUILD_SECEDE);
MSG_WriteShort(&netMessage, pc->guildIdx);
MSG_WriteString(&netMessage, pc->name);
MSG_WriteLong(&netMessage, rank);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Banish_Request_To_ManagerServer( short guildIdx, char *reqName, char *accName, int rank )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REQUEST);
MSG_WriteByte(&netMessage, GUILD_BANISH);
MSG_WriteShort(&netMessage, guildIdx);
MSG_WriteString(&netMessage, reqName);
MSG_WriteString(&netMessage, accName);
MSG_WriteLong(&netMessage, rank);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Update_Request_To_ManagerServer( short guildIdx, char *name, int rank, int rankIdx, int type, int value )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REQUEST);
MSG_WriteByte(&netMessage, GUILD_UPDATE);
MSG_WriteShort(&netMessage, guildIdx);
MSG_WriteString(&netMessage, name);
MSG_WriteLong(&netMessage, rank);
MSG_WriteLong(&netMessage, rankIdx);
MSG_WriteLong(&netMessage, type);
MSG_WriteLong(&netMessage, value);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Connect_Reqeust_To_ManagerServer( short guildIdx, char *name )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REQUEST);
MSG_WriteByte(&netMessage, GUILD_CONNECT);
MSG_WriteShort(&netMessage, guildIdx);
MSG_WriteString(&netMessage, name);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_ChatMessage_Request_To_ManagerServer( short guildIdx, char *name, char *chatMessage )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REQUEST);
MSG_WriteByte(&netMessage, GUILD_CHATMESSAGE);
MSG_WriteShort(&netMessage, guildIdx);
MSG_WriteString(&netMessage, name);
MSG_WriteString(&netMessage, chatMessage);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Change_Master_Request_To_ManagerServer( short guildIdx, playerCharacter_t *reqPC, playerCharacter_t *accPC )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REQUEST);
MSG_WriteByte(&netMessage, GUILD_CHANGEMASTER);
MSG_WriteShort(&netMessage, guildIdx);
MSG_WriteString(&netMessage, reqPC->name);
MSG_WriteString(&netMessage, accPC->name);
MSG_WriteLong(&netMessage, accPC->pcJob);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Add_SubMaster_Request_To_ManagerServer( short guildIdx, playerCharacter_t *reqPC, playerCharacter_t *accPC )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REQUEST);
MSG_WriteByte(&netMessage, GUILD_ADDSUBMASTER);
MSG_WriteShort(&netMessage, guildIdx);
MSG_WriteString(&netMessage, reqPC->name);
MSG_WriteString(&netMessage, accPC->name);
MSG_WriteLong(&netMessage, accPC->pcJob);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Remove_SubMaster_Request_To_ManagerServer( playerCharacter_t *reqPC, char *accName, int accPCJob )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REQUEST);
MSG_WriteByte(&netMessage, GUILD_REMOVESUBMASTER);
MSG_WriteShort(&netMessage, reqPC->guildIdx);
MSG_WriteString(&netMessage, reqPC->name);
MSG_WriteString(&netMessage, accName);
MSG_WriteLong(&netMessage, accPCJob);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Add_FactionMaster_Request_To_ManagerServer( short guildIdx, playerCharacter_t *reqPC, playerCharacter_t *accPC )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REQUEST);
MSG_WriteByte(&netMessage, GUILD_ADDFACTIONMASTER);
MSG_WriteShort(&netMessage, guildIdx);
MSG_WriteString(&netMessage, reqPC->name);
MSG_WriteString(&netMessage, accPC->name);
MSG_WriteLong(&netMessage, accPC->pcJob);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Remove_FactionMaster_Request_To_ManagerServer( playerCharacter_t *reqPC, char *accName, int accPCJob )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REQUEST);
MSG_WriteByte(&netMessage, GUILD_REMOVEFACTIONMASTER);
MSG_WriteShort(&netMessage, reqPC->guildIdx);
MSG_WriteString(&netMessage, reqPC->name);
MSG_WriteString(&netMessage, accName);
MSG_WriteLong(&netMessage, accPCJob);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Schedule_Request_To_ManagerServer( short guildIdx, playerCharacter_t *pc, char *notice )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REQUEST);
MSG_WriteByte(&netMessage, GUILD_SCHEDULE);
MSG_WriteShort(&netMessage, guildIdx);
MSG_WriteString(&netMessage, pc->name);
MSG_WriteString(&netMessage, notice);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_GuildMark_Request_To_ManagerServer( playerCharacter_t *pc, short guildIdx )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REQUEST);
MSG_WriteByte(&netMessage, GUILD_GUILDMARK);
MSG_WriteShort(&netMessage, guildIdx);
MSG_WriteString(&netMessage, pc->name);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Subscribe_Request_To_ManagerServer( playerCharacter_t *pc, char *guildName )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REQUEST);
MSG_WriteByte(&netMessage, GUILD_SUBSCRIBE);
MSG_WriteString(&netMessage, pc->name);
MSG_WriteString(&netMessage, guildName);
MSG_WriteByte(&netMessage, g_config.gameServerNo);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
| C++ |
#include "../global.h"
extern i3sizebuf_t netMessage;
#include "..\GolryunBattle\CGolryunBattle_Observer.h"
extern CGolryunBattle_Observer* gcpGolryunBattle_Observer;
int GTH_SendMonsterEventMessage_Idle( monsterCharacter_t *monster )
{
int i;
int idx;
GTH_GetPCListInValidRange(monster->worldIdx, monster->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_IDLE);
MSG_WriteShort(&netMessage, monster->idx);
MSG_WriteByte(&netMessage, monster->entityType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendMonsterEventMessage_Walk( monsterCharacter_t *monster )
{
int i;
int idx;
GTH_GetPCListInValidRange(monster->worldIdx, monster->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_WALK);
MSG_WriteShort(&netMessage, monster->idx);
MSG_WriteByte(&netMessage, monster->entityType);
MSG_WriteFloat(&netMessage, monster->angles[1]);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(monster);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendMonsterEventMessage_Back( monsterCharacter_t *monster)
{
int i;
int idx;
GTH_GetPCListInValidRange(monster->worldIdx, monster->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_BACK);
MSG_WriteShort(&netMessage, monster->idx);
MSG_WriteByte(&netMessage, monster->entityType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(monster);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendMonsterEventMessage_Run( monsterCharacter_t *monster)
{
int i;
int idx;
GTH_GetPCListInValidRange(monster->worldIdx, monster->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_RUN);
MSG_WriteShort(&netMessage, monster->idx);
MSG_WriteByte(&netMessage, monster->entityType);
MSG_WriteFloat(&netMessage, monster->angles[1]);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(monster);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendMonsterEventMessage_TurnLeft( monsterCharacter_t *monster )
{
int i;
int idx;
GTH_GetPCListInValidRange(monster->worldIdx, monster->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_TURNLEFT);
MSG_WriteShort(&netMessage, monster->idx);
MSG_WriteByte(&netMessage, monster->entityType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(monster);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendMonsterEventMessage_TurnRight( monsterCharacter_t *monster )
{
int i;
int idx;
GTH_GetPCListInValidRange(monster->worldIdx, monster->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_TURNRIGHT);
MSG_WriteShort(&netMessage, monster->idx);
MSG_WriteByte(&netMessage, monster->entityType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(monster);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendMonsterEventMessage_MoveLeft( monsterCharacter_t *monster )
{
int i;
int idx;
GTH_GetPCListInValidRange(monster->worldIdx, monster->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_MOVERIGHT);
MSG_WriteShort(&netMessage, monster->idx);
MSG_WriteByte(&netMessage, monster->entityType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(monster);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendMonsterEventMessage_MoveRight( monsterCharacter_t *monster )
{
int i;
int idx;
GTH_GetPCListInValidRange(monster->worldIdx, monster->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_MOVERIGHT);
MSG_WriteShort(&netMessage, monster->idx);
MSG_WriteByte(&netMessage, monster->entityType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(monster);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendMonsterEventMessage_Attack( monsterCharacter_t *monster )
{
int i;
int idx;
GTH_GetPCListInValidRange(monster->worldIdx, monster->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_ATTACK);
MSG_WriteShort(&netMessage, monster->idx);
MSG_WriteByte(&netMessage, monster->entityType);
MSG_WriteFloat(&netMessage, monster->angles[ YAW ] );
MSG_WriteShort(&netMessage, monster->targetIdx);
MSG_WriteByte(&netMessage, monster->targetType);
MSG_WriteShort(&netMessage, monster->calAttackDelay);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(monster);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendMonsterEventMessage_Damage( monsterCharacter_t *monster, int stunFlag )
{
int i;
int idx;
GTH_GetPCListInValidRange(monster->worldIdx, monster->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_DAMAGE);
MSG_WriteShort(&netMessage, monster->idx);
MSG_WriteByte(&netMessage, monster->entityType);
MSG_WriteLong(&netMessage, (int)monster->curRA);
MSG_WriteShort(&netMessage, (int)monster->curSA);
MSG_WriteLong(&netMessage, monster->curDamage );
MSG_WriteShort(&netMessage, monster->damagedEntityIdx );
MSG_WriteByte(&netMessage, monster->damagedEntityType );
if( monster->damagedEntityType == ENTITY_PC )
{
MSG_WriteLong(&netMessage, (int)g_pc[monster->damagedEntityIdx].curRA);
MSG_WriteShort(&netMessage, (int)g_pc[monster->damagedEntityIdx].curSA);
MSG_WriteLong( &netMessage, g_pc[monster->damagedEntityIdx].curChargeSE );
}
else
{
MSG_WriteLong(&netMessage, (int)g_monster[monster->damagedEntityIdx].curRA);
MSG_WriteShort(&netMessage, (int)g_monster[monster->damagedEntityIdx].curSA);
}
MSG_WriteByte(&netMessage, stunFlag );
MSG_WriteShort(&netMessage, monster->recoveryTime );
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(monster);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendMonsterEventMessage_Die( monsterCharacter_t *monster )
{
int i;
int idx;
GTH_GetPCListInValidRange(monster->worldIdx, monster->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_DIE);
MSG_WriteShort(&netMessage, monster->idx);
MSG_WriteByte(&netMessage, monster->entityType);
MSG_WriteShort(&netMessage, monster->curDamage );
MSG_WriteByte(&netMessage, monster->lastAttackState);
MSG_WriteShort(&netMessage, monster->killerIdx );
MSG_WriteByte(&netMessage, monster->killerType );
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(monster);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendMonsterEventMessage_Skill( monsterCharacter_t *monster )
{
int i;
int idx;
GTH_GetPCListInValidRange(monster->worldIdx, monster->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_ATTACK);
MSG_WriteShort(&netMessage, monster->idx);
MSG_WriteByte(&netMessage, monster->entityType);
MSG_WriteFloat(&netMessage, monster->angles[ YAW ] );
MSG_WriteShort(&netMessage, monster->targetIdx);
MSG_WriteByte(&netMessage, monster->targetType);
MSG_WriteShort(&netMessage, monster->calAttackDelay);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(monster);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendMonsterEventMessage_State( monsterCharacter_t *monster )
{
return true;
}
| C++ |
#include "../Global.h"
#include "Gms_To_Gs.h"
CGms_To_Gs g_GmsToGs;
extern CItem_Scroll_Proc g_Item_Scroll_Proc;
CGms_To_Gs::CGms_To_Gs()
{
}
CGms_To_Gs::~CGms_To_Gs()
{
}
void CGms_To_Gs::Decoder(playerCharacter_t* pPlayer)
{
short PacketID =MSG_ReadShort();
switch(PacketID){
case ITEM_SUMMON_SYSTEM:
g_Item_Scroll_Proc.GSDecoder();
break;
}
}
int CGms_To_Gs::Send_GS(int SystemType,int mainType, int subType,char *FromPlayerName,char *TargetPlayerName,int gameServerNo)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMS_TO_GS_PACKET);
MSG_WriteShort(&netMessage, SystemType);
MSG_WriteShort(&netMessage, mainType);
MSG_WriteShort(&netMessage, subType);
MSG_WriteString(&netMessage, FromPlayerName);
MSG_WriteString(&netMessage, TargetPlayerName);
MSG_WriteShort(&netMessage, gameServerNo);
if(g_config.gameServerNo == gameServerNo)
{
return 0;
}
if(0 > gameServerNo || gameServerNo >= MAX_MEMBER_SERVER)
{
char txt[256];
wsprintf(txt,"Send_GS :: 0 > gameServerNo || gameServerNo >= MAX_MEMBER_SERVER mainType %d, subType %d, %s -> %s ",mainType,subType,FromPlayerName,TargetPlayerName);
TRACE(txt);
return 0;
}
NET_SendUnreliableMessage(&g_memberServer[gameServerNo].sock, &netMessage);
}
MSG_EndWriting(&netMessage);
return 0;
}
| C++ |
#ifndef _NETLIB_H_
#define _NETLIB_H_
#pragma warning( disable : 4786 )
#pragma warning( disable : 4251 )
#define NETLIB_VERSION "03.10.03"
#include <stdio.h>
#include <math.h>
#include <ctime>
#include <map>
#include <stack>
#include <winsock.h>
#define _COMPILE_FOR_SERVER
#ifdef _COMPILE_FOR_SERVER
#define _USE_SENDING_THREAD
#define _USE_RECEIVING_THREAD
#endif
#define NET_MAXMESSAGE 8192
#define MAX_DATAGRAM 1024
#define NET_HEADERSIZE (sizeof(unsigned int) + sizeof(unsigned int) + sizeof(unsigned int) +sizeof(unsigned short) )
#define NET_DATAGRAMSIZE (MAX_DATAGRAM + NET_HEADERSIZE)
#define NET_MAXWAITINGMESSAGE 8
#define NETFLAG_LENGTH_MASK 0x0fff
#define NETFLAG_SOM 1 << 0
#define NETFLAG_RELIABLE 1 << 1
#define NETFLAG_ACK 1 << 2
#define NETFLAG_EOM 1 << 3
#define NETFLAG_ENCRYPT 1 << 0
#define NETFLAG_ENCRYPT_CHECKSUM 0X7FFFFFFF
#define NET_RESENDTIME 800
#define NET_MAXIMUM_PACKETMAP_SIZE 100
#define NET_SENDTIME_UNRELIABLE 0
#define MAX_ERROR_PACKETNUM 20
#define MAXHOSTNAMELEN 256
#define MAX_CHANNELS 20
typedef float vec3_t[3];
typedef struct
{
int allowoverflow;
int overflowed;
byte data[NET_MAXMESSAGE];
int maxsize;
int cursize;
int overwriting;
} i3sizebuf_t;
#pragma pack ( push , 1 )
typedef struct
{
unsigned int sequence;
unsigned int encrypt: 1;
unsigned int checksum : 31;
unsigned int lastSendTime;
unsigned short length;
byte data[MAX_DATAGRAM];
} i3packet_t;
#pragma pack ( pop )
typedef std::map<UINT, i3packet_t*> PacketMap;
typedef PacketMap::iterator PacketMapItor;
typedef PacketMap::value_type PacketMapPair;
enum
{
SocketType_Reliable,
SocketType_Unreliable
};
enum
{
PacketBlock_None,
PacketBlock_Wait,
};
typedef struct i3socket_s
{
i3socket_s()
{
sendPacketMap = NULL;
recvPacketMap = NULL;
socket = INVALID_SOCKET;
socketType = SocketType_Reliable;
}
int socket;
int socketType;
unsigned int connecttime;
unsigned int lastReceiveTime;
unsigned int lastSendTime;
unsigned int latencyTime;
int disconnected;
int canSend;
int sendNext;
unsigned int resendSequence;
unsigned int ackSequence;
unsigned int sendSequence;
unsigned int unreliableSendSequence;
int sendMessageLength;
byte sendMessage [NET_MAXMESSAGE];
unsigned int receiveSequence;
unsigned int unreliableReceiveSequence;
int receiveMessageLength;
byte receiveMessage [NET_MAXMESSAGE];
int packetBlockSequence;
struct sockaddr_in addr;
PacketMap *sendPacketMap;
PacketMap *recvPacketMap;
} i3socket_t;
enum
{
PacketAnalysis_None = 0,
PacketAnalysis_Skip,
PacketAnalysis_Ack,
PacketAnalysis_Start,
};
void SZ_Write (i3sizebuf_t *buf, void *data, int length);
void SZ_Clear (i3sizebuf_t *buf);
void SZ_Alloc (i3sizebuf_t *buf, int startsize);
unsigned char *SZ_GetSpace (i3sizebuf_t *buf, int length);
void SZ_Load (i3sizebuf_t *buf, void *data);
void MSG_BeginWriting(i3sizebuf_t *sb);
void MSG_EndWriting(i3sizebuf_t *sb);
void MSG_Clear( i3sizebuf_t *sb );
void MSG_WriteChar (i3sizebuf_t *sb, int c);
void MSG_WriteByte (i3sizebuf_t *sb, int c);
void MSG_WriteShort (i3sizebuf_t *sb, int c);
void MSG_WriteLong (i3sizebuf_t *sb, int c);
void MSG_Write64Int (i3sizebuf_t *sb, __int64 in_n64Value);
void MSG_WriteFloat (i3sizebuf_t *sb, float f);
void MSG_WriteString (i3sizebuf_t *sb, char *s);
void MSG_WriteAngle (i3sizebuf_t *sb, float f);
void MSG_WriteVector(i3sizebuf_t *sb, vec3_t v);
void MSG_BeginReading (void);
int MSG_ReadChar (void);
int MSG_ReadByte (void);
int MSG_ReadShort (void);
int MSG_ReadLong (void);
__int64 MSG_Read64Int (void);
float MSG_ReadFloat (void);
char *MSG_ReadString (void);
float MSG_ReadAngle (void);
void MSG_ReadVector(vec3_t v);
int NET_AddrCompare (struct sockaddr *addr1, struct sockaddr *addr2);
char *NET_AddrToString (struct sockaddr *addr);
int NET_StringToAddr (char *string, struct sockaddr *addr);
char *NET_GetLocalAddress();
char *NET_GetHostName();
char *NET_AddrToIPString (struct sockaddr *addr);
int NET_SendPacket (i3socket_t *sock, i3sizebuf_t *data, BOOL encrypt = FALSE);
int NET_SendPacket_Unreliable(i3socket_t *sock, i3sizebuf_t *data, BOOL encrypt = FALSE);
int NET_ReadPacket(int *socket, byte *buf, struct sockaddr_in *addr);
int NET_ControlPacket(i3socket_t *sock, i3packet_t *packet);
int NET_ControlRecvBank( i3socket_t *sock );
int NET_ControlSendBank( i3socket_t *sock );
int NET_CheckSockProblem( i3socket_t *sock, int checkTime = -1 );
int NET_PreviewMessage(i3packet_t *p);
int NET_Write (int socket, byte *buf, int len, struct sockaddr_in *addr);
int NET_Read (int socket, byte *buf, int len, struct sockaddr_in *addr);
int NET_ReadFromReceivingQueue (int *socket, byte *buf, struct sockaddr_in *addr);
int NET_WriteToSendingQueue (int socket, byte *buf, int len, struct sockaddr_in *addr);
void NET_InitNetTime();
unsigned int NET_GetNetTime();
int NET_OpenNetwork();
void NET_InitPacketMap( i3socket_t *sock );
int NET_InitSocket(i3socket_t *sock, struct sockaddr_in *addr, int socket, int socketType );
int NET_OpenSocketForServer(i3socket_t *sock, char *serverIP, int port, int socketType = SocketType_Reliable );
int NET_OpenSocketForClient(i3socket_t *sock, char *serverIP, int port, int socketType = SocketType_Reliable );
void NET_CloseSocket(i3socket_t *sock);
void NET_ClearSocket(i3socket_t *sock);
void NET_CloseNetwork();
int NET_CreateSendingThread();
int NET_CreateReceivingThread();
void NET_DestroySendingThread();
void NET_DestroyReceivingThread();
DWORD WINAPI NET_SendingThread(LPVOID param);
DWORD WINAPI NET_ReceivingThread(LPVOID param);
char *NET_ErrorString ();
int NET_AddListenChannel( int socket );
int NET_DeleteListenChannel( int socket );
#define NET_SendMessage NET_SendPacket
#define NET_SendUnreliableMessage NET_SendPacket_Unreliable
void ErrorLog( char *filename, char* str, ... );
extern void TRACE(LPCTSTR lpszFormat, ...);
void Crypt(TCHAR *inp, DWORD inplen, TCHAR* key = "", DWORD keylen = 0);
#endif | C++ |
#include "../global.h"
extern i3sizebuf_t netMessage;
#include "..\GolryunBattle\CGolryunBattle_Observer.h"
extern CGolryunBattle_Observer* gcpGolryunBattle_Observer;
int GTH_SendPCEventMessage_Idle( playerCharacter_t *pc )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_IDLE);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if (pc->idx == idx) continue;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_Walk( playerCharacter_t *pc )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_WALK);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
MSG_WriteFloat(&netMessage, pc->angles[1]);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if (pc->idx == idx) continue;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_WalkLeft( playerCharacter_t *pc )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_WALKLEFT);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if (pc->idx == idx) continue;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_WalkRight( playerCharacter_t *pc )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_WALKRIGHT);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if (pc->idx == idx) continue;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_Back( playerCharacter_t *pc )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_BACK);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if (pc->idx == idx) continue;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_BackLeft( playerCharacter_t *pc )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_BACKLEFT);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if (pc->idx == idx) continue;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_BackRight( playerCharacter_t *pc )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_BACKRIGHT);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if (pc->idx == idx) continue;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_Run( playerCharacter_t *pc )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_RUN);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
MSG_WriteFloat(&netMessage, pc->angles[1]);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if (pc->idx == idx) continue;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_RunLeft( playerCharacter_t *pc )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_RUNLEFT);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if (pc->idx == idx) continue;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_RunRight( playerCharacter_t *pc )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_RUNRIGHT);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if (pc->idx == idx) continue;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_TurnLeft( playerCharacter_t *pc )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_TURNLEFT);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if (pc->idx == idx) continue;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_TurnRight( playerCharacter_t *pc )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_TURNRIGHT);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if (pc->idx == idx) continue;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_MoveLeft( playerCharacter_t *pc )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_MOVELEFT);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if (pc->idx == idx) continue;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_MoveRight( playerCharacter_t *pc )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_MOVERIGHT);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_Attack( playerCharacter_t *pc, int damageAttackFlag, int success, int itemIdx )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_ATTACK);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
MSG_WriteFloat(&netMessage, pc->angles[ YAW ] );
MSG_WriteByte(&netMessage, damageAttackFlag );
MSG_WriteByte(&netMessage, success );
MSG_WriteShort(&netMessage, pc->targetIdx);
MSG_WriteByte(&netMessage, pc->targetType);
MSG_WriteShort(&netMessage, pc->calAttackDelay );
MSG_WriteByte(&netMessage, pc->resultHitRate );
MSG_WriteByte(&netMessage, pc->attackComboType );
MSG_WriteShort(&netMessage, itemIdx );
if( itemIdx >= 0 ) MSG_WriteShort(&netMessage, pc->item[itemIdx].durability );
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_SkillCasting( playerCharacter_t *pc, int castingTime,int skillIdx,int skillTargetType,int UseType )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_SKILLCASTING);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
MSG_WriteShort(&netMessage, (int)pc->curSA);
MSG_WriteLong(&netMessage, castingTime );
MSG_WriteShort(&netMessage, skillIdx);
MSG_WriteShort(&netMessage, skillTargetType);
MSG_WriteLong(&netMessage, pc->generalSpeed);
MSG_WriteByte(&netMessage, UseType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
if( pc->idx == idx ) NET_SendMessage( &g_pc[idx].sock, &netMessage );
else NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_Skill( playerCharacter_t *pc, int skillIdx, int coolTime, int delayTime )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_SKILL);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
MSG_WritePosition(&netMessage, pc->position );
MSG_WriteFloat(&netMessage, pc->angles[ YAW ] );
if( pc->bNotOwnSkill )
{
MSG_WriteShort(&netMessage, skillIdx );
}
else
{
MSG_WriteShort(&netMessage, pc->skill[skillIdx].tableIdx );
}
MSG_WriteByte(&netMessage, 0 );
MSG_WriteLong(&netMessage, (int)pc->curRA);
MSG_WriteShort(&netMessage, (int)pc->curSA);
MSG_WriteShort(&netMessage, pc->targetIdx);
MSG_WriteByte(&netMessage, pc->targetType);
if( pc->bNotOwnSkill ) MSG_WriteChar(&netMessage, -1);
else MSG_WriteChar(&netMessage, skillIdx);
MSG_WriteLong(&netMessage, coolTime);
MSG_WriteLong(&netMessage, delayTime);
MSG_WriteByte(&netMessage, pc->resultValid );
MSG_WriteByte(&netMessage, g_skillMultiTarget.targetNumber );
for( i = 0; i < g_skillMultiTarget.targetNumber; i ++ )
{
MSG_WriteByte( &netMessage, g_skillMultiTarget.targetType[i] );
MSG_WriteShort( &netMessage, g_skillMultiTarget.targetIdx[i] );
}
MSG_WriteByte(&netMessage, pc->resultHitRate);
MSG_WriteShort(&netMessage, pc->recoveryTime);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
if( pc->idx == idx ) NET_SendMessage( &g_pc[idx].sock, &netMessage );
else NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_Die( playerCharacter_t *pc, int dropItemType, int dropItemPosition )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_DIE);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
MSG_WriteShort(&netMessage, pc->curDamage);
MSG_WriteByte(&netMessage, pc->lastAttackState);
MSG_WriteShort(&netMessage, pc->killerIdx);
MSG_WriteByte(&netMessage, pc->killerType);
MSG_Write64Int(&netMessage, pc->exp );
MSG_WriteLong(&netMessage, pc->curChargeSE);
MSG_WriteShort(&netMessage, dropItemType);
MSG_WriteShort(&netMessage, dropItemPosition);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
if( pc->idx == idx ) NET_SendMessage(&g_pc[idx].sock, &netMessage);
else NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_Damage( playerCharacter_t *pc, int itemIdx, int stunFlag )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_DAMAGE);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
MSG_WriteLong(&netMessage, (int)pc->curRA);
MSG_WriteShort(&netMessage, (int)pc->curSA);
MSG_WriteLong(&netMessage, pc->curDamage);
MSG_WriteShort(&netMessage, pc->damagedEntityIdx );
MSG_WriteByte(&netMessage, pc->damagedEntityType );
if( pc->damagedEntityType == ENTITY_PC )
{
MSG_WriteLong(&netMessage, (int)g_pc[pc->damagedEntityIdx].curRA);
MSG_WriteShort(&netMessage, (int)g_pc[pc->damagedEntityIdx].curSA);
}
else
{
MSG_WriteLong(&netMessage, (int)g_monster[pc->damagedEntityIdx].curRA);
MSG_WriteShort(&netMessage, (int)g_monster[pc->damagedEntityIdx].curSA);
}
MSG_WriteByte(&netMessage, stunFlag );
MSG_WriteShort(&netMessage, pc->recoveryTime );
MSG_WriteByte(&netMessage, pc->resultAvoidRate );
MSG_WriteShort(&netMessage, itemIdx );
if( itemIdx >= 0 ) MSG_WriteShort(&netMessage, pc->item[itemIdx].durability );
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_Respawn( playerCharacter_t *pc )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_RESPAWN);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
MSG_WriteByte(&netMessage, pc->worldIdx);
MSG_WritePosition(&netMessage, pc->position);
MSG_WriteFloat(&netMessage, pc->angles[1]);
MSG_WriteLong(&netMessage, (int)pc->curRA);
MSG_WriteShort(&netMessage, (int)pc->curSA);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
if( g_pc[idx].idx == pc->idx )
{
NET_SendMessage(&g_pc[idx].sock, &netMessage);
}
else
{
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_Teleport( playerCharacter_t *pc, vec3_t movePos )
{
int i;
int idx;
int zoneIdx;
float dist;
vec3_t monsterPos;
vec_copy( g_monster[pc->targetIdx].position, monsterPos );
dist = GTH_GetDistance2D( pc->position, monsterPos );
if( dist < 50.0f ) return false;
int localWorldIdx = GTH_GetLocalWorldIdx( g_curPC->worldIdx );
if( FindMonsterNearPlace(localWorldIdx, movePos) != -1 )
{
vec_copy( movePos, pc->position );
}
else
{
}
zoneIdx = GTH_Zone_UpdateCurrentZone(ENTITY_PC, pc->idx, pc->worldIdx, pc->zoneIdx, pc->position);
pc->zoneIdx = zoneIdx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1)
{
return false;
}
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_TELEPORT);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
MSG_WriteByte(&netMessage, pc->worldIdx);
MSG_WritePosition(&netMessage, movePos);
MSG_WriteFloat(&netMessage, pc->angles[1]);
MSG_WriteLong(&netMessage, (int)pc->curRA);
MSG_WriteShort(&netMessage, (int)pc->curSA);
static int sendCount;
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
if( g_pc[idx].idx == pc->idx )
{
NET_SendMessage(&g_pc[idx].sock, &netMessage);
sendCount++;
}
else
{
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_Before_Teleport( playerCharacter_t *pc )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_BEFORE_TELEPORT);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
MSG_WriteByte(&netMessage, pc->worldIdx);
MSG_WriteShort(&netMessage, pc->curSkillIdx);
MSG_WriteShort(&netMessage, pc->pcJob);
MSG_WritePosition(&netMessage, pc->position);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
if( g_pc[idx].idx == pc->idx )
{
NET_SendMessage(&g_pc[idx].sock, &netMessage);
}
else
{
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_MouseWalk( playerCharacter_t *pc )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_MOUSEWALK);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
MSG_WriteFloat(&netMessage, pc->angles[YAW]);
MSG_WritePosition(&netMessage, pc->mousePos);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if (pc->idx == idx) continue;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_MouseRun( playerCharacter_t *pc )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_MOUSERUN);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
MSG_WriteFloat(&netMessage, pc->angles[YAW]);
MSG_WritePosition(&netMessage, pc->mousePos);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if (pc->idx == idx) continue;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_Sit( playerCharacter_t *pc )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_SIT);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_Stand( playerCharacter_t *pc )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_STAND);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_Shout( playerCharacter_t* pc )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_SUB_EVENT_SOCIAL_SHOUT);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCEventMessage_Bow( playerCharacter_t* pc )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_SUB_EVENT_SOCIAL_BOW);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendPCMessage_TransportReply(playerCharacter_t* pToPlayerRecord,const tagGCPacket_TRANSPORTWORLDREP::enumCode code)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_TRANSPORTWORLDREP);
MSG_WriteByte(&netMessage, code);
MSG_WriteByte(&netMessage, pToPlayerRecord->worldIdx);
MSG_WritePosition(&netMessage, pToPlayerRecord->position);
MSG_WriteFloat(&netMessage, pToPlayerRecord->angles[1]);
NET_SendMessage(&(pToPlayerRecord->sock), &netMessage);
}
MSG_EndWriting(&netMessage);
return true;
}
void GTH_SendPCMessage_ChangeServer( playerCharacter_t *pc, memberServer_t *member )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_CHANGESERVER);
MSG_WriteString(&netMessage, member->serviceIP);
MSG_WriteShort(&netMessage, member->servicePort);
NET_SendUnreliableMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendPCMessage_ChangeWorld( playerCharacter_t *pc )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_CHANGEWORLD);
MSG_WriteByte(&netMessage, pc->worldIdx);
MSG_WritePosition(&netMessage, pc->position);
MSG_WriteFloat(&netMessage, pc->angles[1]);
NET_SendUnreliableMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendPCMessage_ReplyWeaponChange( playerCharacter_t* pc )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_WEAPONCHANGE);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendPCMessage_LevelUp( playerCharacter_t* pc, __int64 exp, __int64 genExp, int lootNSE, int genCapability, int skillIdx[], int skillNumber, int sharingType )
{
int i;
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_LEVELUP);
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
MSG_Write64Int(&netMessage, exp);
MSG_Write64Int(&netMessage, genExp);
MSG_WriteLong(&netMessage, lootNSE);
MSG_WriteLong(&netMessage, genCapability);
MSG_WriteShort(&netMessage, pc->level );
MSG_WriteShort(&netMessage, pc->genLevel );
MSG_WriteShort(&netMessage, pc->bonusStatusPoint );
MSG_WriteShort(&netMessage, pc->force );
MSG_WriteShort(&netMessage, pc->soulpower );
MSG_WriteShort(&netMessage, pc->agility );
MSG_WriteShort(&netMessage, pc->vitality );
pc->curRA = pc->calMaxRA;
pc->curSA = pc->calMaxSA;
MSG_WriteLong(&netMessage, (int)pc->curRA );
MSG_WriteShort(&netMessage, (int)pc->curSA );
MSG_WriteByte(&netMessage, pc->bonusSkillPoint );
MSG_WriteByte(&netMessage, sharingType);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
if( pc->idx == idx ) NET_SendMessage(&pc->sock, &netMessage);
else NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
}
void GTH_SendPCMessage_ReplyGenChange( playerCharacter_t* pc)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_GENCHANGE );
MSG_WriteByte(&netMessage, pc->selectedGen );
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendPCMessage_ReplyStatusUp( playerCharacter_t* pc, int reply, int error, int statusType )
{
int point, bonusPoint;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_STATUSUP );
MSG_WriteByte(&netMessage, reply );
if( reply )
{
switch( statusType )
{
case 0 :
point = pc->force;
break;
case 1 :
point = pc->soulpower;
break;
case 2 :
point = pc->agility;
break;
case 3 :
point = pc->vitality;
break;
}
bonusPoint = pc->bonusStatusPoint;
MSG_WriteShort(&netMessage, statusType);
MSG_WriteShort(&netMessage, point);
MSG_WriteShort(&netMessage, bonusPoint);
MSG_WriteLong(&netMessage, (int)pc->curRA);
MSG_WriteShort(&netMessage, (int)pc->curSA);
}
else
{
MSG_WriteByte(&netMessage, error );
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendPCMessage_AutoRecovery( playerCharacter_t* pc )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_AUTORECOVERY );
MSG_WriteLong(&netMessage, (int)pc->curRA );
MSG_WriteShort(&netMessage, (int)pc->curSA );
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendPCMessage_ReplyEpackUse( playerCharacter_t* pc, int type )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_EPACKUSE );
MSG_WriteByte(&netMessage, type );
switch( type )
{
case 0 :
MSG_WriteLong(&netMessage, (int)pc->curRA );
MSG_WriteShort(&netMessage, pc->epackUseRAWaitTime - g_globalTime );
MSG_WriteShort(&netMessage, (int)pc->curChargeRA );
break;
case 1 :
MSG_WriteLong(&netMessage, (int)pc->curSA );
MSG_WriteShort(&netMessage, pc->epackUseSAWaitTime - g_globalTime );
MSG_WriteShort(&netMessage, (int)pc->curChargeSA );
break;
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendPCMessage_Affect( playerCharacter_t *pc )
{
int i, numAffect, affectData[MAX_AFFECT], affectTime[MAX_AFFECT];
int idx;
GTH_GetPCListInValidRange(pc->worldIdx, pc->position);
if (g_zonePCListNumber < 1) return;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_AFFECT );
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
MSG_WritePosition(&netMessage, pc->position);
MSG_WriteFloat(&netMessage, pc->calVelocity );
numAffect = GTH_MakeAffectTableIdx( pc, affectData, ENTITY_PC );
numAffect = GTH_MakeAffectTime( pc, affectTime, ENTITY_PC );
MSG_WriteByte(&netMessage, numAffect);
for( i = 0; i < numAffect; i ++ )
{
MSG_WriteShort(&netMessage, affectData[i] );
MSG_WriteLong(&netMessage, affectTime[i] );
}
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pc);
MSG_EndWriting(&netMessage);
}
void GTH_SendMonsterMessage_Affect( monsterCharacter_t *mon )
{
int i, numAffect, affectData[MAX_AFFECT], affectTime[MAX_AFFECT];
int idx;
GTH_GetPCListInValidRange(mon->worldIdx, mon->position);
if (g_zonePCListNumber < 1) return;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_AFFECT );
MSG_WriteShort(&netMessage, mon->idx);
MSG_WriteByte(&netMessage, mon->entityType);
MSG_WritePosition(&netMessage, mon->position);
MSG_WriteFloat(&netMessage, mon->calVelocity );
numAffect = GTH_MakeAffectTableIdx( mon, affectData, mon->entityType );
numAffect = GTH_MakeAffectTime( mon, affectTime, ENTITY_MONSTER );
MSG_WriteByte(&netMessage, numAffect);
for( i = 0; i < numAffect; i ++ )
{
MSG_WriteShort(&netMessage, affectData[i] );
MSG_WriteLong(&netMessage, affectTime[i] );
}
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(mon);
MSG_EndWriting(&netMessage);
}
int GTH_SendMonsterEventMessage_SkillCasting( monsterCharacter_t *pMonster, int castingTime )
{
int i;
int idx;
GTH_GetPCListInValidRange(pMonster->worldIdx, pMonster->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_MONSTER_SKILLCASTING);
MSG_WriteShort(&netMessage, pMonster->idx);
MSG_WriteByte(&netMessage, pMonster->entityType);
MSG_WriteLong(&netMessage, pMonster->saveSkillIdx);
MSG_WriteShort(&netMessage, (int)pMonster->curSA);
MSG_WriteLong(&netMessage, castingTime );
for(i = 0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(pMonster);
MSG_EndWriting(&netMessage);
return true;
}
int GTH_SendMonsterEventMessage_Skill( monsterCharacter_t *monster, int skillIdx, int coolTime, int delayTime )
{
int i;
int idx;
GTH_GetPCListInValidRange(monster->worldIdx, monster->position);
if (g_zonePCListNumber < 1) return false;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EVENT_MONSTER_SKILL);
MSG_WriteShort(&netMessage, monster->idx);
MSG_WriteByte(&netMessage, monster->entityType);
MSG_WritePosition(&netMessage, monster->position );
MSG_WriteFloat(&netMessage, monster->angles[ YAW ] );
MSG_WriteShort(&netMessage, monster->skill[skillIdx].tableIdx );
MSG_WriteLong(&netMessage, monster->skill[skillIdx].iLevel );
MSG_WriteLong(&netMessage, (int)monster->curRA);
MSG_WriteShort(&netMessage, (int)monster->curSA);
MSG_WriteShort(&netMessage, monster->targetIdx);
MSG_WriteByte(&netMessage, monster->targetType);
MSG_WriteByte(&netMessage, skillIdx);
MSG_WriteLong(&netMessage, coolTime);
MSG_WriteLong(&netMessage, delayTime);
MSG_WriteByte(&netMessage, 1 );
MSG_WriteByte(&netMessage, g_skillMultiTarget.targetNumber );
for( i = 0; i < g_skillMultiTarget.targetNumber; i ++ )
{
MSG_WriteByte( &netMessage, g_skillMultiTarget.targetType[i] );
MSG_WriteShort( &netMessage, g_skillMultiTarget.targetIdx[i] );
}
MSG_WriteByte(&netMessage, 1);
MSG_WriteShort(&netMessage, monster->recoveryTime);
for (i=0; i < g_zonePCListNumber; i++)
{
idx = g_zonePCList[i].idx;
if ( !g_pc[idx].ready ) continue;
if( monster->targetIdx == idx )
{
NET_SendMessage( &g_pc[idx].sock, &netMessage );
}
else
{
NET_SendUnreliableMessage(&g_pc[idx].sock, &netMessage);
}
}
}
gcpGolryunBattle_Observer->NET_SendUnreliableMessage(monster);
MSG_EndWriting(&netMessage);
return true;
}
void GTH_SendMessage_SkillError( playerCharacter_t* pc , int errorIdx)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_EXTEND_EVENT_SKILL_ERROR);
MSG_WriteByte(&netMessage, errorIdx);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
} | C++ |
#include "../Global.h"
#include "Gs_To_Cc.h"
CGs_To_Cc g_GsToCc;
CGs_To_Cc::CGs_To_Cc()
{
}
CGs_To_Cc::~CGs_To_Cc()
{
}
void CGs_To_Cc::Send(playerCharacter_t* pPlayer,int SystemType,int mainType, int subType)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, SystemType);
MSG_WriteShort(&netMessage, mainType);
MSG_WriteShort(&netMessage, subType);
NET_SendMessage(&pPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CGs_To_Cc::Send(playerCharacter_t* pPlayer,int SystemType,int mainType, int subType,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, TargetPlayerName);
NET_SendMessage(&pPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
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 CGs_To_Cc::Send(playerCharacter_t* pPlayer,int SystemType,int mainType, int subType,int val, 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_WriteLong(&netMessage, val);
MSG_WriteString(&netMessage, TargetPlayerName);
NET_SendMessage(&pPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CGs_To_Cc::Send(playerCharacter_t* pPlayer,int SystemType,int mainType, int subType,int val, 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_WriteLong(&netMessage, val);
MSG_WriteString(&netMessage, requestPlayerName);
MSG_WriteString(&netMessage, TargetPlayerName);
NET_SendMessage(&pPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CGs_To_Cc::Send(playerCharacter_t* pPlayer,int SystemType,int mainType, int subType,int worldIdx,vec3_t position,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_WriteByte(&netMessage, worldIdx);
MSG_WritePosition(&netMessage, position);
MSG_WriteString(&netMessage, requestPlayerName);
MSG_WriteString(&netMessage, TargetPlayerName);
NET_SendMessage(&pPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CGs_To_Cc::Send(playerCharacter_t* pPlayer,int SystemType,int mainType, int subType,int val, int worldIdx,vec3_t position,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_WriteLong(&netMessage, val);
MSG_WriteByte(&netMessage, worldIdx);
MSG_WritePosition(&netMessage, position);
MSG_WriteString(&netMessage, requestPlayerName);
MSG_WriteString(&netMessage, TargetPlayerName);
NET_SendMessage(&pPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
} | C++ |
#include "../global.h"
extern i3sizebuf_t netMessage;
extern i3socket_t localSocket;
void GTH_SendMessage_CompleteEffect_To_AllPC( playerCharacter_t *pc, int effectIdx )
{
GTH_GetEntityListInValidRange(pc->worldIdx, pc->position);
if (g_zoneEntityListNumber < 1)
{
g_logSystem->Write("Can Not Found User from Zone.(name: %s, zoneNo: %d, pos(%f, %f, %f))", pc->name, pc->zoneIdx, pc->position[0], pc->position[1], pc->position[2]);
GTH_Zone_UpdateCurrentZone(ENTITY_PC, pc->idx, pc->worldIdx, pc->zoneIdx, pc->position);
return;
}
for ( int i=0; i < g_zonePCListNumber; i++)
{
int idx = g_zonePCList[i].idx;
if( g_pc[idx].entityType != ENTITY_PC || idx == pc->idx )
continue;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte( &netMessage, GSC_EXTEND );
MSG_WriteByte( &netMessage, GSC_SUB_EVENT_COMPLETE_EFFECT );
MSG_WriteShort( &netMessage, pc->idx );
MSG_WriteShort( &netMessage, pc->entityType );
MSG_WriteShort( &netMessage, effectIdx );
NET_SendUnreliableMessage( &g_pc[idx].sock, &netMessage );
}
MSG_EndWriting(&netMessage);
}
}
void GTH_SendMessage_PCTrade_Request( playerCharacter_t* pc, int reply, int error, int targetIdx, int type )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PCTRADE);
MSG_WriteByte(&netMessage, PCTRADE_REQUEST);
MSG_WriteByte(&netMessage, reply);
if( reply > 0 )
{
MSG_WriteShort(&netMessage, targetIdx);
MSG_WriteByte(&netMessage, type);
MSG_WriteString(&netMessage, g_pc[targetIdx].name );
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_PCTrade_Admit( playerCharacter_t* pc, int reply, int error )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PCTRADE);
MSG_WriteByte(&netMessage, PCTRADE_ADMIT);
MSG_WriteByte(&netMessage, reply);
if( reply > 0 )
{
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_PCTrade_Reject( playerCharacter_t* pc, int reply, int error, int type )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PCTRADE);
MSG_WriteByte(&netMessage, PCTRADE_REJECT);
MSG_WriteByte(&netMessage, reply);
if( reply > 0 )
{
MSG_WriteByte(&netMessage, type);
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_PCTrade_Item( playerCharacter_t* pc, int reply, int error, int isOwner, int type, int pos, item_t *item )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PCTRADE);
MSG_WriteByte(&netMessage, PCTRADE_ITEM);
MSG_WriteByte(&netMessage, reply);
if( reply > 0 )
{
MSG_WriteByte(&netMessage, isOwner);
MSG_WriteByte(&netMessage, type);
MSG_WriteByte(&netMessage, pos);
MSG_WriteItem(&netMessage, item);
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_PCTrade_Exit( playerCharacter_t* pc, int reply, int error )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PCTRADE);
MSG_WriteByte(&netMessage, PCTRADE_EXIT);
MSG_WriteByte(&netMessage, reply);
if( reply > 0 )
{
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_PCTrade_Ok( playerCharacter_t* pc, int reply, int error, int type )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PCTRADE);
MSG_WriteByte(&netMessage, PCTRADE_OK);
MSG_WriteByte(&netMessage, reply);
if( reply > 0 )
{
MSG_WriteByte(&netMessage, type);
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_PCTrade_Cancel( playerCharacter_t* pc, int reply, int error, int type )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PCTRADE);
MSG_WriteByte(&netMessage, PCTRADE_CANCEL);
MSG_WriteByte(&netMessage, reply);
if( reply > 0 )
{
MSG_WriteByte(&netMessage, type);
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_PCTrade_Confirm( playerCharacter_t* pc, int reply, int error, int type )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PCTRADE);
MSG_WriteByte(&netMessage, PCTRADE_CONFIRM);
MSG_WriteByte(&netMessage, reply);
if( reply > 0 )
{
MSG_WriteByte(&netMessage, type);
}
else
{
MSG_WriteByte(&netMessage, error);
}
if( reply == 0 )
{
GTH_UndoPCTrade( pc, 1 );
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_PCTrade_SE( playerCharacter_t *pc, int reply, int error, int type, int se )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PCTRADE);
MSG_WriteByte(&netMessage, PCTRADE_SE);
MSG_WriteByte(&netMessage, reply);
if( reply )
{
MSG_WriteByte(&netMessage, type);
MSG_WriteLong(&netMessage, se);
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Party_Error( playerCharacter_t* pc )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PARTY );
MSG_WriteByte(&netMessage, PARTY_ERROR );
MSG_WriteByte(&netMessage, pc->serverPartyErrorFlag );
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Party_Request_Organize( playerCharacter_t* pc, int reply, int error, int idx, int type )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PARTY);
MSG_WriteByte(&netMessage, PARTY_REQUEST_ORGANIZE);
MSG_WriteByte(&netMessage, reply);
if( reply > 0 )
{
MSG_WriteShort(&netMessage, idx);
MSG_WriteByte(&netMessage, type);
MSG_WriteString(&netMessage, g_pc[idx].name );
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Party_Admit_Organize( playerCharacter_t* pc, int reply, int error, int type )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PARTY);
MSG_WriteByte(&netMessage, PARTY_ADMIT_ORGANIZE);
MSG_WriteByte(&netMessage, reply);
if( reply > 0 )
{
MSG_WriteByte(&netMessage, type);
MSG_WriteString(&netMessage, pc->organizerName);
MSG_WriteChar(&netMessage, pc->organizeServer);
MSG_WriteLong(&netMessage, pc->organizeTime);
MSG_WriteByte(&netMessage, pc->memberNumber);
MSG_WriteByte(&netMessage, pc->_partyRandomInfo_t.itemDivideType);
MSG_WriteByte(&netMessage, pc->canJoin);
MSG_WriteShort(&netMessage, pc->partyIndex);
MSG_WriteByte(&netMessage, pc->isLeader);
MSG_WriteMember(&netMessage, &pc->member[0] );
MSG_WriteMember(&netMessage, &pc->member[1] );
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Party_Reject_Organize( playerCharacter_t* pc, int type )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PARTY);
MSG_WriteByte(&netMessage, PARTY_REJECT_ORGANIZE);
MSG_WriteByte(&netMessage, type);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Party_Request_Join( playerCharacter_t* pc, int reply, int error, int idx, int type )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PARTY);
MSG_WriteByte(&netMessage, PARTY_REQUEST_JOIN);
MSG_WriteByte(&netMessage, reply);
if( reply > 0 )
{
MSG_WriteShort(&netMessage, idx);
MSG_WriteByte(&netMessage, type);
MSG_WriteString(&netMessage, g_pc[idx].name );
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Party_Admit_Join( playerCharacter_t* pc, int reply, int error, int isNewMember )
{
int i;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PARTY);
MSG_WriteByte(&netMessage, PARTY_ADMIT_JOIN);
MSG_WriteByte(&netMessage, reply);
if( reply > 0 )
{
MSG_WriteByte(&netMessage, isNewMember);
MSG_WriteString( &netMessage, pc->organizerName );
MSG_WriteChar( &netMessage, pc->organizeServer );
MSG_WriteLong( &netMessage, pc->organizeTime );
MSG_WriteByte( &netMessage, pc->memberNumber );
MSG_WriteByte( &netMessage, pc->_partyRandomInfo_t.itemDivideType );
MSG_WriteByte( &netMessage, pc->canJoin );
MSG_WriteShort( &netMessage, pc->partyIndex );
MSG_WriteByte( &netMessage, pc->isLeader );
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( pc->member[i].serverIndex == -1 ) continue;
MSG_WriteMember( &netMessage, &pc->member[i] );
}
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Party_Reject_Join( playerCharacter_t* pc, int type )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PARTY);
MSG_WriteByte(&netMessage, PARTY_REJECT_JOIN);
MSG_WriteByte(&netMessage, type);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Party_Out( playerCharacter_t* pc, int reply, int error, int isForced, int outMemberIdx, int newLeaderIdx, int reqFlag )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PARTY);
if( isForced )
MSG_WriteByte(&netMessage, PARTY_FORCEDOUT );
else
MSG_WriteByte(&netMessage, PARTY_OUT );
if( reply > 0 )
{
MSG_WriteByte(&netMessage, reqFlag);
if( !reqFlag )
{
MSG_WriteByte(&netMessage, outMemberIdx);
MSG_WriteByte(&netMessage, newLeaderIdx);
}
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Party_Disorganize( playerCharacter_t *pc )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PARTY);
MSG_WriteByte(&netMessage, PARTY_DISORGANIZE );
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Party_SendAll( playerCharacter_t *pc, int reply )
{
int i;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PARTY);
MSG_WriteByte(&netMessage, PARTY_SENDALL);
MSG_WriteByte(&netMessage, reply);
if( reply )
{
MSG_WriteString( &netMessage, pc->organizerName );
MSG_WriteChar( &netMessage, pc->organizeServer );
MSG_WriteLong( &netMessage, pc->organizeTime );
MSG_WriteByte( &netMessage, pc->memberNumber );
MSG_WriteByte( &netMessage, pc->_partyRandomInfo_t.itemDivideType );
MSG_WriteByte( &netMessage, pc->canJoin );
MSG_WriteShort( &netMessage, pc->partyIndex );
MSG_WriteByte( &netMessage, pc->isLeader );
for( i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( pc->member[i].serverIndex == -1 ) continue;
MSG_WriteMember( &netMessage, &pc->member[i] );
}
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Party_Update( playerCharacter_t *pc, int memberIdx, int newLeaderIdx, int active, int pcIdx, int level, int worldIdx )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PARTY);
MSG_WriteByte(&netMessage, PARTY_UPDATE );
MSG_WriteByte(&netMessage, memberIdx);
MSG_WriteByte(&netMessage, newLeaderIdx);
MSG_WriteByte(&netMessage, active);
MSG_WriteByte(&netMessage, level);
MSG_WriteShort(&netMessage, worldIdx );
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Party_CanJoin( playerCharacter_t *pc, int type )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PARTY);
MSG_WriteByte(&netMessage, PARTY_CANJOIN );
MSG_WriteByte(&netMessage, type);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Party_ItemDivideType( playerCharacter_t *pc, int type )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PARTY);
MSG_WriteByte(&netMessage, PARTY_ITEMDIVIDETYPE );
MSG_WriteByte(&netMessage, type);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Party_ChatMessage( playerCharacter_t *pc, char* fromName, char *message )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PARTY);
MSG_WriteByte(&netMessage, PARTY_CHATMESSAGE );
MSG_WriteString(&netMessage, fromName);
MSG_WriteString(&netMessage, message);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Reply_SkillLevelUp( playerCharacter_t *pc, int reply, int error, int skillIdx, int genType )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_SKILLLEVELUP);
MSG_WriteByte(&netMessage, reply );
if( !reply )
{
MSG_WriteByte(&netMessage, error );
NET_SendMessage(&pc->sock, &netMessage);
}
else
{
MSG_WriteByte(&netMessage, skillIdx );
MSG_WriteLong(&netMessage, pc->skill[skillIdx].iLevel );
MSG_WriteByte(&netMessage, genType );
MSG_WriteLong(&netMessage, pc->genCapability[genType] );
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(pc->skill[skillIdx].tableIdx);
if(pSkillTable!=NULL)
{
g_logSystem->Write( "Skill Level Up : %s(%s),Skill Table Index %d .. Level %d(GenType %d) Level UP",
pc->name, pc->userID,pc->skill[skillIdx].tableIdx, pc->skill[skillIdx].level.gen[genType], genType );
}
else
{
g_logSystem->Write( "Skill Level Up : %s(%s), %s Level %d(GenType %d) Level UP",
pc->name, pc->userID,"Error!pSkillTable==NULL", pc->skill[skillIdx].level.gen[genType], genType );
}
NET_SendMessage(&pc->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Reply_AddSkill( playerCharacter_t *pc, int skillNumber, int skillIdx[] )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ADDSKILL);
MSG_WriteByte(&netMessage, skillNumber );
for( int i = 0; i < skillNumber; i ++ )
{
MSG_WriteByte(&netMessage, skillIdx[i] );
MSG_WriteShort(&netMessage, pc->skill[skillIdx[i]].tableIdx );
MSG_WriteLong(&netMessage, pc->skill[skillIdx[i]].iLevel );
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Reply_Learn_Skill( playerCharacter_t *pc, int reply, int error, int invenPos, int skillIdx )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_LEARN_SKILL);
MSG_WriteByte(&netMessage, reply);
if( !reply )
{
MSG_WriteByte(&netMessage, error);
}
else
{
MSG_WriteByte(&netMessage, invenPos);
MSG_WriteByte(&netMessage, skillIdx);
MSG_WriteShort(&netMessage, pc->skill[skillIdx].tableIdx);
MSG_WriteLong(&netMessage, pc->skill[skillIdx].iLevel);
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Reply_InitSkill( playerCharacter_t* pc )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_CHEATCODE);
MSG_WriteByte(&netMessage, CHEATCODE_INITSKILL);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Reply_PCInfo( playerCharacter_t *pc )
{
if( !pc->ready ) return;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PCINFO );
MSG_WriteLong( &netMessage, (int)pc->calMaxRA );
MSG_WriteShort( &netMessage, (int)pc->calMaxSA );
MSG_WriteLong( &netMessage, (int)pc->curRA );
MSG_WriteShort( &netMessage, (int)pc->curSA );
MSG_WriteShort( &netMessage, GetStausWeight( pc, STATUS_FORCE ) );
MSG_WriteShort( &netMessage, GetStausWeight( pc, STATUS_SOULPOWER ) );
MSG_WriteShort( &netMessage, GetStausWeight( pc, STATUS_AGILITY ) );
MSG_WriteShort( &netMessage, GetStausWeight( pc, STATUS_VITALITY ) );
MSG_WriteShort( &netMessage, pc->calPhyMinDmg );
MSG_WriteShort( &netMessage, pc->calPhyMaxDmg );
MSG_WriteShort( &netMessage, pc->calMagMinDmg );
MSG_WriteShort( &netMessage, pc->calMagMaxDmg );
MSG_WriteFloat( &netMessage, pc->calCriticalRate );
MSG_WriteShort( &netMessage, pc->calDefensePower );
MSG_WriteShort( &netMessage, pc->calPositiveRes );
MSG_WriteShort( &netMessage, pc->calNegativeRes );
MSG_WriteShort( &netMessage, pc->calHitPower );
MSG_WriteShort( &netMessage, pc->calAvoidPower );
MSG_WriteShort( &netMessage, pc->calAttackDelay );
MSG_WriteFloat( &netMessage, pc->calVelocity );
MSG_WriteShort( &netMessage, pc->calAttackLength );
MSG_WriteByte( &netMessage, pc->atkPowerRACost );
MSG_WriteByte( &netMessage, pc->atkPowerSACost );
MSG_WriteByte( &netMessage, pc->atkBowSACost );
MSG_WriteShort( &netMessage, pc->maxChargeRA );
MSG_WriteShort( &netMessage, pc->maxChargeSA );
MSG_WriteShort( &netMessage, pc->onceRecoveryRA );
MSG_WriteShort( &netMessage, pc->onceRecoverySA );
MSG_WriteLong( &netMessage, pc->curChargeSE );
MSG_WriteShort( &netMessage,(int) pc->curChargeRA );
MSG_WriteShort( &netMessage,(int) pc->curChargeSA );
MSG_WriteShort( &netMessage, pc->curItemWeight );
MSG_WriteShort( &netMessage, pc->calItemWeight );
MSG_WriteFloat( &netMessage, pc->optValue[OV_SKILL_LENGTH_RATE] );
MSG_WriteFloat( & netMessage, pc->optValue[OV_DECSA_USE] );
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Reply_Use_Portal( playerCharacter_t *pc, int reply, int error, int invenPos, int isChangeServer )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_USE_PORTAL);
MSG_WriteByte(&netMessage, reply);
if( reply )
{
MSG_WriteShort(&netMessage, pc->idx);
MSG_WriteByte(&netMessage, pc->entityType);
MSG_WriteByte(&netMessage, isChangeServer);
if( !isChangeServer )
{
MSG_WriteByte(&netMessage, pc->worldIdx);
MSG_WritePosition(&netMessage, pc->position);
MSG_WriteFloat(&netMessage, pc->angles[1]);
MSG_WriteLong(&netMessage, (int)pc->curRA);
MSG_WriteShort(&netMessage, (int)pc->curSA);
MSG_WriteByte(&netMessage, invenPos);
}
else
{
MSG_WriteByte(&netMessage, invenPos);
}
NET_SendMessage(&pc->sock, &netMessage);
}
else
{
MSG_WriteByte(&netMessage, error);
NET_SendMessage(&pc->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Reply_Use_Potion(playerCharacter_t* pc, int error, int invenPos)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_USE_POTION);
MSG_WriteByte(&netMessage, invenPos);
MSG_WriteByte(&netMessage, error);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Reply_SavePortalPosition( playerCharacter_t *pc, int reply, int error )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_SAVE_PORTAL_POSITION);
MSG_WriteByte(&netMessage, reply);
if( reply )
{
MSG_WriteShort( &netMessage, pc->skillVariable[0] );
MSG_WriteShort( &netMessage, pc->skillVariable[1] );
MSG_WriteShort( &netMessage, pc->skillVariable[2] );
MSG_WriteShort( &netMessage, pc->skillVariable[3] );
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_DelQuestStatus( playerCharacter_t *pc )
{
int idx = MSG_ReadShort();
GTH_ClearQuestStatus( pc, idx, 0 );
}
void GTH_SendMessage_QuestStatusInfo( playerCharacter_t *pc, int type, int questIdx )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_QUESTSTATUS_INFO );
MSG_WriteByte(&netMessage, type);
MSG_WriteShort(&netMessage, questIdx);
MSG_WriteByte(&netMessage, pc->questNumber );
for( int i = 0; i < MAX_COUNT_QUEST_STATUS; i ++ )
{
MSG_WriteByte( &netMessage, pc->questStatus[i].idx );
MSG_WriteShort( &netMessage,pc->questStatus[i].questIdx );
MSG_WriteLong( &netMessage, pc->questStatus[i].clearTime );
MSG_WriteLong( &netMessage, pc->questStatus[i].limitTime );
MSG_WriteString( &netMessage, pc->questStatus[i].partyOrganizerName );
MSG_WriteChar( &netMessage, pc->questStatus[i].partyOrganizeServer );
MSG_WriteLong( &netMessage, pc->questStatus[i].partyOrganizeTime );
for( int j = 0; j < MAX_COUNT_QUEST_STATUS_DYNAMIC_FIELD; j ++ )
{
MSG_WriteLong( &netMessage, pc->questStatus[i].dField[j] );
}
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_AutoQuestStatusInfo( playerCharacter_t *pc, int type, int questIdx )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_AUTOQUESTSTATUS_INFO );
MSG_WriteByte(&netMessage, type);
MSG_WriteShort(&netMessage,questIdx);
MSG_WriteByte(&netMessage, pc->questNumber );
for( int i = 0; i <MAX_COUNT_QUEST_STATUS; i ++ )
{
MSG_WriteByte( &netMessage, pc->questStatus[i].idx );
MSG_WriteShort( &netMessage,pc->questStatus[i].questIdx );
MSG_WriteLong( &netMessage, pc->questStatus[i].clearTime );
MSG_WriteLong( &netMessage, pc->questStatus[i].limitTime );
for( int j = 0; j < MAX_COUNT_QUEST_STATUS_DYNAMIC_FIELD; j ++ )
{
MSG_WriteLong( &netMessage, pc->questStatus[i].dField[j] );
}
if(pc->questStatus[i].idx !=-1 && pc->questStatus[i].questIdx !=-1)
{
ShowLogInfo("autoqueststatusInfo: userID:%s,questIdx:%d,type:%d",pc->name,pc->questStatus[i].dField[0],type);
}
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_QuestStep(playerCharacter_t *pc, int questIdx, int questStep, int completeFlag )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_QUEST_STEP );
MSG_WriteShort( &netMessage, questIdx );
MSG_WriteShort( &netMessage, questStep );
MSG_WriteByte( &netMessage, completeFlag );
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_QuestItemInfo( playerCharacter_t *pc, int itemTableIdx, int itemNumber )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_QUEST_ITEM_INFO );
MSG_WriteShort( &netMessage, itemTableIdx );
MSG_WriteShort( &netMessage, itemNumber );
for( int i = 0; i < MAX_COUNT_QUEST_INVENTORY; i ++ )
{
MSG_WriteLong(&netMessage, pc->questInventory[i].iItem );
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_DepotOpen( playerCharacter_t *pc )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, DEPOT_OPEN );
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_DepotGetItem( playerCharacter_t *pc, int reply, int error, int depotPos )
{
int itemIdx;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, DEPOT_GETITEM );
if( reply > 0 )
{
MSG_WriteByte(&netMessage, reply);
MSG_WriteByte(&netMessage, depotPos);
if( reply == 5 )
{
MSG_WriteByte(&netMessage, pc->mouseInventory);
itemIdx = pc->depot[depotPos];
MSG_WriteItem( &netMessage, &pc->item[itemIdx] );
MSG_WriteItem( &netMessage, &pc->item[pc->mouseInventory] );
}
}
else
{
MSG_WriteByte(&netMessage, reply);
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_DepotItem( playerCharacter_t *pc, int reply, int error, int depotPos )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, DEPOT_ITEM );
if( reply > 0 )
{
MSG_WriteByte(&netMessage, reply);
MSG_WriteByte(&netMessage, depotPos);
MSG_WriteLong(&netMessage, pc->curChargeSE );
}
else
{
MSG_WriteByte(&netMessage, reply);
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
GTH_PC_Calculate( pc );
}
void GTH_SendMessage_ItemSystem_DepotNak( playerCharacter_t *pc, int reply, int error )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, DEPOT_NAK );
if( reply > 0 )
{
MSG_WriteByte(&netMessage, reply);
MSG_WriteLong(&netMessage, pc->curChargeSE);
MSG_WriteLong(&netMessage, pc->depotSE );
}
else
{
MSG_WriteByte(&netMessage, reply);
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_PrecocityOpen( playerCharacter_t *pc )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, PRECOCITY_OPEN );
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_PrecocityItem( playerCharacter_t *pc, int reply, int error, int pos )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, PRECOCITY_ITEM);
if( reply > 0 )
{
MSG_WriteByte(&netMessage, reply);
MSG_WriteByte(&netMessage, pos);
MSG_WriteShort( &netMessage, pc->mouseInventory );
MSG_WriteShort( &netMessage, pc->precocityInventory[pos] );
MSG_WriteLong( &netMessage, pc->precocityTime[pos] );
}
else
{
MSG_WriteByte(&netMessage, reply);
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_PrecocityComplete( playerCharacter_t *pc, int pos )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, PRECOCITY_COMPLETE);
MSG_WriteByte(&netMessage, pos);
MSG_WriteItem(&netMessage, &pc->item[pc->precocityInventory[pos]]);
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_EventCraftOpen( playerCharacter_t *pc )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, EVENT_CRAFT_OPEN);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_EventCraftClose( playerCharacter_t *pc )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, EVENT_CRAFT_CLOSE);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_EventCraftItem( playerCharacter_t *pc, int reply, int error, int posType, int pos )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, EVENT_CRAFT_ITEM);
if( reply > 0 )
{
MSG_WriteByte(&netMessage, reply);
MSG_WriteChar(&netMessage, posType);
MSG_WriteByte(&netMessage, pos);
MSG_WriteShort( &netMessage, pc->mouseInventory );
MSG_WriteShort( &netMessage, pc->craftSourceInventory[pos] );
}
else
{
MSG_WriteByte(&netMessage, reply);
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_EventCraftPrepare( playerCharacter_t *pc, int reply, int error )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, EVENT_CRAFT_PREPARE);
MSG_WriteByte(&netMessage, reply);
if(! reply )
{
MSG_WriteByte( &netMessage, error );
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_EventCraftComplete( playerCharacter_t *pc, int reply, int error ,int craftIdx)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, EVENT_CRAFT_COMPLETE);
MSG_WriteByte(&netMessage, reply);
MSG_WriteByte(&netMessage, craftIdx);
if( !reply )
{
MSG_WriteByte( &netMessage, error );
}
else
{
MSG_WriteLong(&netMessage, g_curPC->curChargeSE);
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
if( reply )
{
GTH_SendMessage_CompleteEffect_To_AllPC( pc, 35 );
}
}
void GTH_SendMessage_Reply_Load_EventCraftItem( playerCharacter_t *pc, short sEventIdx , int n1PointCnt, int n3PointCnt,int nTotalPoint )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, EVENT_CRAFT_LOADEVENT);
MSG_WriteShort(&netMessage, sEventIdx);
MSG_WriteLong(&netMessage, n1PointCnt);
MSG_WriteLong(&netMessage, n3PointCnt);
MSG_WriteLong(&netMessage, nTotalPoint);
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_CraftOpen( playerCharacter_t *pc )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, CRAFT_OPEN);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_NpcInventoryOpen( playerCharacter_t *pc )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, AUTOQUESTSCROLL_NPCINVENTORYOPEN);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_NpcInventoryClose( playerCharacter_t *pc )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, AUTOQUESTSCROLL_NPCINVENTORYCLOSE);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_CraftClose( playerCharacter_t *pc )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, CRAFT_CLOSE);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_CraftItem( playerCharacter_t *pc, int reply, int error, int posType, int pos )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, CRAFT_ITEM);
if( reply > 0 )
{
MSG_WriteByte(&netMessage, reply);
MSG_WriteChar(&netMessage, posType);
MSG_WriteByte(&netMessage, pos);
MSG_WriteShort( &netMessage, pc->mouseInventory );
if( posType == 0 ) MSG_WriteShort( &netMessage, pc->craftSourceInventory[pos] );
else MSG_WriteShort( &netMessage, pc->craftResultInventory[pos] );
}
else
{
MSG_WriteByte(&netMessage, reply);
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_AutoQuestCraftItem( playerCharacter_t *pc, int reply, int error, int posType, int pos )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, AUTOQUESTSCROLL_NPCINVENTORYITEM);
if( reply > 0 )
{
MSG_WriteByte(&netMessage, reply);
MSG_WriteChar(&netMessage, posType);
MSG_WriteByte(&netMessage, pos);
MSG_WriteShort( &netMessage, pc->mouseInventory );
if( posType == 0 ) MSG_WriteShort( &netMessage, pc->npcAutoSourceInventory[pos] );
else MSG_WriteShort( &netMessage, pc->npcAutoSourceInventory[pos] );
}
else
{
MSG_WriteByte(&netMessage, reply);
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_CraftPrepare( playerCharacter_t *pc, int reply, int error, int resultItemIdx[], int nak, float pro ,int craftIdx )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, CRAFT_PREPARE);
MSG_WriteByte(&netMessage, reply);
if( reply )
{
MSG_WriteShort( &netMessage, resultItemIdx[0] );
MSG_WriteShort( &netMessage, resultItemIdx[1] );
MSG_WriteLong( &netMessage, nak );
MSG_WriteFloat( &netMessage, pro );
MSG_WriteLong( &netMessage,craftIdx);
}
else
{
MSG_WriteByte( &netMessage, error );
MSG_WriteLong( &netMessage, nak );
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_AutoCraftPrepare( playerCharacter_t *pc, int &reply, int &error)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, AUTOQUESTSCROLL_NPCINVENTORYPREPARE);
MSG_WriteByte(&netMessage, reply);
if( !reply )
{
MSG_WriteByte( &netMessage, error );
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_CraftComplete( playerCharacter_t *pc, int reply, int error, int nak )
{
int success = false;
item_t item1, item2;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, CRAFT_COMPLETE);
MSG_WriteByte(&netMessage, reply);
InitItem( &item1 );
InitItem( &item2 );
if( reply )
{
if( pc->craftResultInventory[0] >= 0 )
{
memcpy( &item1, &pc->item[pc->craftResultInventory[0]], sizeof( item_t ) );
success = true;
}
if( pc->craftResultInventory[1] >= 0 )
{
memcpy( &item1, &pc->item[pc->craftResultInventory[1]], sizeof( item_t ) );
success = true;
}
MSG_WriteByte( &netMessage, success );
MSG_WriteLong( &netMessage, pc->curChargeSE );
MSG_WriteItem( &netMessage, &item1 );
MSG_WriteItem( &netMessage, &item2 );
}
else
{
MSG_WriteByte( &netMessage, error );
MSG_WriteLong( &netMessage, nak );
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
if( reply )
{
if( success )
GTH_SendMessage_CompleteEffect_To_AllPC( pc, 35 );
else
GTH_SendMessage_CompleteEffect_To_AllPC( pc, 36 );
}
}
void GTH_SendMessage_ItemSystem_BoothSellOpen( playerCharacter_t *pc, int reply, int error )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, BOOTH_SELL_OPEN );
if( !reply )
{
MSG_WriteByte(&netMessage, error );
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_BoothSellItem( playerCharacter_t *pc, int reply, int pos, int ErrorIdx )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, BOOTH_SELL_ITEM );
MSG_WriteShort(&netMessage, reply);
if ( reply )
{
MSG_WriteShort(&netMessage, pc->mouseInventory);
MSG_WriteShort(&netMessage, pos);
MSG_WriteShort(&netMessage, pc->boothInventory[pos].itemIdx);
MSG_WriteLong(&netMessage, pc->boothInventory[pos].price);
}
else
MSG_WriteLong(&netMessage, ErrorIdx);
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_BoothSellStart( playerCharacter_t *pc )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, BOOTH_SELL_START );
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_BoothSellClose( playerCharacter_t *pc, int type )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, BOOTH_SELL_CLOSE );
MSG_WriteByte(&netMessage, type );
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_BoothBuyOpen( playerCharacter_t *pc, int reply, int error, playerCharacter_t *targetPC, int type )
{
int itemIdx;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, BOOTH_BUY_OPEN );
MSG_WriteByte(&netMessage, reply );
if( !reply )
{
MSG_WriteByte(&netMessage, error );
NET_SendMessage(&pc->sock, &netMessage);
}
else
{
MSG_WriteByte(&netMessage, type );
if( !type )
{
MSG_WriteString(&netMessage, targetPC->name );
MSG_WriteString(&netMessage, targetPC->boothName );
MSG_WriteString(&netMessage, targetPC->boothInfo );
for( int i = 0; i < MAX_BOOTH_INVENTORY_SIZE; i ++ )
{
itemIdx = targetPC->boothInventory[i].itemIdx;
MSG_WriteShort(&netMessage, itemIdx);
if( itemIdx >= 0 )
{
MSG_WriteShort(&netMessage, i);
MSG_WriteItem(&netMessage, &targetPC->item[itemIdx] );
MSG_WriteLong(&netMessage, targetPC->boothInventory[i].price);
}
}
}
else
{
MSG_WriteString(&netMessage, targetPC->name );
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_BoothBuyItem( playerCharacter_t *pc, int reply, int error, int pos, int itemCount, int type )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, BOOTH_BUY_ITEM );
MSG_WriteByte(&netMessage, reply);
if( reply )
{
MSG_WriteByte(&netMessage, type);
MSG_WriteShort(&netMessage, pos);
MSG_WriteShort(&netMessage, itemCount);
MSG_WriteLong(&netMessage, pc->curChargeSE);
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
GTH_PC_Calculate( pc );
}
void GTH_SendMessage_ItemSystem_BoothBuyClose( playerCharacter_t *pc, int reply, int error, int type, char* targetName )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, BOOTH_BUY_CLOSE );
MSG_WriteByte(&netMessage, reply);
if( reply )
{
MSG_WriteByte(&netMessage, type);
if( type )
{
MSG_WriteString( &netMessage, targetName );
}
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_BoothBuyUpdate( playerCharacter_t *pc, playerCharacter_t *seller )
{
int itemIdx;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, BOOTH_BUY_UPDATE );
for( int i = 0; i < MAX_BOOTH_INVENTORY_SIZE; i ++ )
{
itemIdx = seller->boothInventory[i].itemIdx;
MSG_WriteShort(&netMessage, itemIdx);
if( itemIdx >= 0 )
{
MSG_WriteShort(&netMessage, i);
MSG_WriteItem(&netMessage, &seller->item[itemIdx] );
MSG_WriteLong(&netMessage, seller->boothInventory[i].price);
}
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_UpgradeOpen( playerCharacter_t *pc )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, UPGRADE_OPEN);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_UpgradeClose( playerCharacter_t *pc )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, UPGRADE_CLOSE);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_UpgradeItem( playerCharacter_t *pc, int reply, int error, int posType, int pos )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, UPGRADE_ITEM);
if( reply > 0 )
{
MSG_WriteByte(&netMessage, reply);
MSG_WriteChar(&netMessage, posType);
MSG_WriteByte(&netMessage, pos);
MSG_WriteShort( &netMessage, pc->mouseInventory );
if( posType == 0 ) MSG_WriteShort( &netMessage, pc->upgradeSourceInventory[pos] );
else MSG_WriteShort( &netMessage, pc->upgradeResultInventory );
}
else
{
MSG_WriteByte(&netMessage, reply);
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_UpgradePrepare( playerCharacter_t *pc, int reply, int error, int resultItemIdx, int nak, float pro, float vanishPro, float downGradePro, int currentGrade, int nextGrade, int optionIdx )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, UPGRADE_PREPARE);
MSG_WriteByte(&netMessage, reply);
if( reply )
{
MSG_WriteShort( &netMessage, resultItemIdx );
MSG_WriteLong( &netMessage, nak );
MSG_WriteFloat( &netMessage, pro );
MSG_WriteFloat( &netMessage, vanishPro );
MSG_WriteFloat( &netMessage, downGradePro );
MSG_WriteShort( &netMessage, currentGrade );
MSG_WriteShort( &netMessage, nextGrade );
MSG_WriteShort( &netMessage, optionIdx );
}
else
{
MSG_WriteByte( &netMessage, error );
MSG_WriteLong( &netMessage, nak );
MSG_WriteShort( &netMessage, currentGrade );
MSG_WriteShort( &netMessage, nextGrade );
MSG_WriteShort( &netMessage, resultItemIdx );
MSG_WriteShort( &netMessage, optionIdx );
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_UpgradeComplete( playerCharacter_t *pc, int reply, int error, int nak, int success, int resultItemIdx, int optionIdx, int nextGrade )
{
item_t item;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, UPGRADE_COMPLETE);
MSG_WriteByte(&netMessage, reply);
InitItem( &item );
if( reply )
{
MSG_WriteByte( &netMessage, success );
MSG_WriteLong( &netMessage, pc->curChargeSE );
MSG_WriteShort( &netMessage, resultItemIdx );
MSG_WriteShort( &netMessage, optionIdx );
MSG_WriteShort( &netMessage, nextGrade );
MSG_WriteShort( &netMessage, pc->upgradeResultInventory );
if( pc->upgradeResultInventory >= 0 )
{
memcpy( &item, &pc->item[pc->upgradeResultInventory], sizeof( item_t ) );
MSG_WriteItem( &netMessage, &item );
}
}
else
{
MSG_WriteByte( &netMessage, error );
MSG_WriteShort( &netMessage, resultItemIdx );
MSG_WriteShort( &netMessage, optionIdx );
MSG_WriteLong( &netMessage, nak );
}
NET_SendMessage(&pc->sock, &netMessage, TRUE);
}
MSG_EndWriting(&netMessage);
if( reply )
{
if( success )
GTH_SendMessage_CompleteEffect_To_AllPC( pc, 37 );
else
GTH_SendMessage_CompleteEffect_To_AllPC( pc, 38 );
}
}
void GTH_SendMessage_ItemSystem_DeletePrepare( playerCharacter_t *pc, int reply, int error, int optionIdx )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, DELETE_PREPARE);
MSG_WriteByte(&netMessage, reply);
if( reply )
{
MSG_WriteShort( &netMessage, pc->upgradeSourceInventory[0] );
MSG_WriteByte( &netMessage, optionIdx );
}
else
{
MSG_WriteByte( &netMessage, error );
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ItemSystem_DeleteComplete( playerCharacter_t *pc, int reply, int error, int success, int optionIdx )
{
item_t item;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, DELETE_COMPLETE);
MSG_WriteByte(&netMessage, reply);
InitItem( &item );
if( reply )
{
MSG_WriteByte( &netMessage, success );
MSG_WriteLong( &netMessage, pc->curChargeSE );
MSG_WriteByte( &netMessage, optionIdx );
MSG_WriteShort( &netMessage, pc->upgradeResultInventory );
if( pc->upgradeResultInventory >= 0 )
{
memcpy( &item, &pc->item[pc->upgradeResultInventory], sizeof( item_t ) );
MSG_WriteItem( &netMessage, &item );
}
}
else
{
MSG_WriteByte( &netMessage, error );
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Friends_Invite ( playerCharacter_t * pc, int reply, int error, int idx, int type )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_FRIENDS);
MSG_WriteByte(&netMessage, FRIENDS_INVITE);
MSG_WriteByte(&netMessage, reply);
if( reply > 0 )
{
MSG_WriteShort(&netMessage, idx);
MSG_WriteByte(&netMessage, type);
MSG_WriteString(&netMessage, g_pc[idx].name );
}
else
{
MSG_WriteByte(&netMessage, error);
}
if ( pc->ready )
{
NET_SendMessage(&pc->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Friends_Added ( playerCharacter_t *pc, char *name, int level, int job, int worldIdx )
{
MSG_BeginWriting ( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte ( &netMessage, GSC_REPLY_FRIENDS );
MSG_WriteByte ( &netMessage, FRIENDS_ADD );
MSG_WriteByte ( &netMessage, level );
MSG_WriteByte ( &netMessage, job );
MSG_WriteByte ( &netMessage, worldIdx );
MSG_WriteString ( &netMessage, name );
if ( pc->ready )
{
NET_SendMessage ( &pc->sock, &netMessage );
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Friends_Reject ( playerCharacter_t *pc, int idx )
{
MSG_BeginWriting ( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte ( &netMessage, GSC_REPLY_FRIENDS );
MSG_WriteByte ( &netMessage, FRIENDS_REJECT );
MSG_WriteShort ( &netMessage, idx );
if ( pc->ready )
{
NET_SendMessage ( &pc->sock, &netMessage );
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Friends_Remove ( playerCharacter_t *pc, char *name )
{
MSG_BeginWriting ( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte ( &netMessage, GSC_REPLY_FRIENDS );
MSG_WriteByte ( &netMessage, FRIENDS_REMOVE );
MSG_WriteString ( &netMessage, name );
if ( pc->ready )
{
NET_SendMessage ( &pc->sock, &netMessage );
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Organize_Request_To_Client( playerCharacter_t *pc )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte( &netMessage, GSC_GUILD_REQUEST );
MSG_WriteByte( &netMessage, GUILD_ORGANIZE );
if( pc->ready )
{
NET_SendMessage( &pc->sock, &netMessage );
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Organize_Reply_To_Client( playerCharacter_t *pc, int result, int error, int RemainTime )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte( &netMessage, GSC_GUILD_REPLY );
MSG_WriteByte( &netMessage, GUILD_ORGANIZE );
MSG_WriteShort( &netMessage, result );
MSG_WriteShort( &netMessage, error );
MSG_WriteShort( &netMessage, pc->rankPoint );
MSG_WriteLong( &netMessage, pc->curChargeSE );
MSG_WriteString( &netMessage, pc->guildName );
MSG_WriteLong( &netMessage, RemainTime );
if( pc->ready )
{
NET_SendMessage( &pc->sock, &netMessage );
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Disorganize_Reply_To_Client( playerCharacter_t *pc, int result, int error )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte( &netMessage, GSC_GUILD_REPLY );
MSG_WriteByte( &netMessage, GUILD_DISORGANIZE );
MSG_WriteShort( &netMessage, result );
MSG_WriteShort( &netMessage, error );
MSG_WriteShort( &netMessage, pc->rankPoint );
if( pc->ready )
{
NET_SendMessage( &pc->sock, &netMessage );
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Invite_Request_To_Client( playerCharacter_t *pc, int result, int error, int who, int RemainTime )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_INVITE_REQUEST);
MSG_WriteShort(&netMessage, result);
MSG_WriteShort(&netMessage, error);
MSG_WriteShort(&netMessage, who);
MSG_WriteLong(&netMessage, RemainTime);
if( who == 0 )
MSG_WriteString(&netMessage, pc->tempGuildMateName);
else
MSG_WriteString(&netMessage, pc->guildName);
if( pc->ready )
{
NET_SendMessage(&pc->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Invite_Cancel_To_Client( playerCharacter_t *pc, int error, int who, char *name )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_INVITE_CANCEL);
MSG_WriteShort(&netMessage, error);
MSG_WriteShort(&netMessage, who);
MSG_WriteString(&netMessage, name);
if( pc->ready )
{
NET_SendMessage(&pc->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Invite_Reply_To_Client( playerCharacter_t *pc, int result, int error, int who, char *name )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_INVITE_REPLY);
MSG_WriteShort(&netMessage, result);
MSG_WriteShort(&netMessage, error);
MSG_WriteShort(&netMessage, who);
MSG_WriteString(&netMessage, name);
if( pc->ready )
{
NET_SendMessage(&pc->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Secede_Reply_To_Client( playerCharacter_t *pc, int result, int error )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_SECEDE);
MSG_WriteShort(&netMessage, result);
MSG_WriteShort(&netMessage, error);
MSG_WriteShort(&netMessage, pc->rankPoint);
if( pc->ready )
{
NET_SendMessage(&pc->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Banish_Reply_To_Client( playerCharacter_t *pc, int result, int error, int who, char *name )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_BANISH);
MSG_WriteShort(&netMessage, result);
MSG_WriteShort(&netMessage, error);
MSG_WriteShort(&netMessage, who);
MSG_WriteShort(&netMessage, pc->rankPoint);
MSG_WriteString(&netMessage, name);
if( pc->ready )
{
NET_SendMessage(&pc->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Change_Master_Reply_To_Client( playerCharacter_t *pc, int result, int error, int who, char *name )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_CHANGEMASTER);
MSG_WriteShort(&netMessage, result);
MSG_WriteShort(&netMessage, error);
MSG_WriteShort(&netMessage, who);
MSG_WriteString(&netMessage, name);
if( pc->ready )
{
NET_SendMessage(&pc->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Add_SubMaster_Reply_To_Client( playerCharacter_t *pc, int result, int error, int who, char *name )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_ADDSUBMASTER);
MSG_WriteShort(&netMessage, result);
MSG_WriteShort(&netMessage, error);
MSG_WriteShort(&netMessage, who);
MSG_WriteString(&netMessage, name);
if( pc->ready )
{
NET_SendMessage(&pc->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Add_FactionMaster_Reply_To_Client( playerCharacter_t *pc, int result, int error, int who, char *name )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_ADDFACTIONMASTER);
MSG_WriteShort(&netMessage, result);
MSG_WriteShort(&netMessage, error);
MSG_WriteShort(&netMessage, who);
MSG_WriteString(&netMessage, name);
if( pc->ready )
{
NET_SendMessage(&pc->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Delete_Master_Reply_To_Client( playerCharacter_t *pc, int error, char *name )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_DELETE_MASTER);
MSG_WriteShort(&netMessage, error);
MSG_WriteString(&netMessage, name);
if( pc->ready )
{
NET_SendMessage(&pc->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Remove_SubMaster_Reply_To_Client( playerCharacter_t *pc, int result, int error, int who, char *name )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_REMOVESUBMASTER);
MSG_WriteShort(&netMessage, result);
MSG_WriteShort(&netMessage, error);
MSG_WriteShort(&netMessage, who);
MSG_WriteString(&netMessage, name);
if( pc->ready )
{
NET_SendMessage(&pc->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Remove_FactionMaster_Reply_To_Client( playerCharacter_t *pc, int result, int error, int who, char *name )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_REMOVEFACTIONMASTER);
MSG_WriteShort(&netMessage, result);
MSG_WriteShort(&netMessage, error);
MSG_WriteShort(&netMessage, who);
MSG_WriteString(&netMessage, name);
if( pc->ready )
{
NET_SendMessage(&pc->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_GuildMark_Reply_To_Client(
playerCharacter_t* pc,
const int guildIdx,
const int markChnageCnt,
unsigned char* pMarkImage)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_GUILDMARK);
MSG_WriteShort(&netMessage, guildIdx);
MSG_WriteLong(&netMessage, markChnageCnt);
for( int i=0; i<GUILDMARKSIZE; i++ )
MSG_WriteByte(&netMessage, pMarkImage[i]);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Subscribe_Reply_To_Client( playerCharacter_t *pc, int result, int error, char *guildName )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_SUBSCRIBE);
MSG_WriteShort(&netMessage, result);
MSG_WriteShort(&netMessage, error);
if( result != -1 )
MSG_WriteString(&netMessage, guildName);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Update_To_Client( playerCharacter_t *pc, guild_t* guild, int update, int rank, int rankIdx )
{
int i;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REPLY);
MSG_WriteByte(&netMessage, GUILD_UPDATE);
MSG_WriteShort(&netMessage, guild->idx);
MSG_WriteLong(&netMessage, update);
MSG_WriteLong(&netMessage, rank);
MSG_WriteLong(&netMessage, rankIdx);
int addRankIdx = 0;
if( rank == GUILD_SUBMASTER )
addRankIdx = MAX_GUILD_MASTERS;
else if( rank == GUILD_FACTIONMASTER )
addRankIdx = MAX_GUILD_MASTERS+MAX_GUILD_SUBMASTERS;
else if( rank == GUILD_MATE )
addRankIdx = MAX_GUILD_MASTERS+MAX_GUILD_SUBMASTERS+MAX_GUILD_FACTIONMASTERS;
else
addRankIdx = 0;
if( ( update & GUILD_IDX ) != 0 )
{
MSG_WriteShort(&netMessage, guild->idx);
}
if( ( update & GUILD_SERVERGROUPID ) != 0 )
{
MSG_WriteShort(&netMessage, guild->serverGroupID);
}
if( ( update & GUILD_NAME ) != 0 )
{
MSG_WriteString(&netMessage, guild->name);
}
if( ( update & GUILD_MARK ) != 0 )
{
}
if( ( update & GUILD_MARKUPDATETIME ) != 0 )
{
MSG_WriteLong(&netMessage, guild->markUpdateTime);
}
if( ( update & GUILD_NOTICE ) != 0 )
{
MSG_WriteString(&netMessage, guild->notice);
}
if( ( update & GUILD_FAMEPOINT ) != 0 )
{
MSG_WriteLong(&netMessage, guild->famePoint);
}
if( ( update & GUILD_EXPPOINT ) != 0 )
{
MSG_WriteLong(&netMessage, guild->expPoint);
}
if( ( update & GUILD_RAIDPOINT ) != 0 )
{
MSG_WriteLong(&netMessage, guild->raidPoint);
}
if( ( update & GUILD_PVPPOINT ) != 0 )
{
MSG_WriteLong(&netMessage, guild->pvpPoint);
}
if( ( update & GUILD_HUNTERPOINT ) != 0 )
{
MSG_WriteLong(&netMessage, guild->hunterPoint);
}
if( ( update & GUILD_LEVEL ) != 0 )
{
MSG_WriteShort(&netMessage, guild->level);
}
if( ( update & GUILD_MASTERNAME ) != 0 )
{
MSG_WriteString(&netMessage, guild->masterName);
}
if( ( update & GUILD_SUBMASTERNAME ) != 0 )
{
if( rankIdx == -1)
{
for( i=0; i<MAX_GUILD_SUBMASTERS; i++ )
MSG_WriteString(&netMessage, guild->subMasterName[i]);
}
else
MSG_WriteString(&netMessage, guild->subMasterName[rankIdx]);
}
if( ( update & GUILD_FACTIONMASTERNAME ) != 0 )
{
if( rankIdx == -1)
{
for( i=0; i<MAX_GUILD_FACTIONMASTERS; i++ )
MSG_WriteString(&netMessage, guild->factionMasterName[i]);
}
else
MSG_WriteString(&netMessage, guild->factionMasterName[rankIdx]);
}
if( ( update & GUILD_MATENAME ) != 0 )
{
if( rankIdx == -1)
{
for( i=0; i<MAX_GUILD_MATES; i++ )
MSG_WriteString(&netMessage, guild->mateName[i]);
}
else
MSG_WriteString(&netMessage, guild->mateName[rankIdx]);
}
if( ( update & GUILD_MATEAUTHORITY ) != 0 )
{
if( rankIdx == -1)
{
for( i=0; i<MAX_GUILD_MATES; i++ )
MSG_WriteByte(&netMessage, guild->mateAuthority[i]);
}
else
MSG_WriteByte(&netMessage, guild->mateAuthority[rankIdx]);
}
if( ( update & GUILD_MATELASTCONNECTTIME ) != 0 )
{
if( rankIdx == -1)
{
for( i=0; i<MAX_GUILD_MATES; i++ )
MSG_WriteLong(&netMessage, guild->mateLastConnectTime[i]);
}
else
MSG_WriteLong(&netMessage, guild->mateLastConnectTime[rankIdx]);
}
if( ( update & GUILD_MASTERNOTE ) != 0 )
{
if( rankIdx == -1)
{
}
else
MSG_WriteString(&netMessage, guild->masterNote[rankIdx]);
}
if( ( update & GUILD_USERLEVEL ) != 0 )
{
if( rankIdx == -1 )
{
int max = MAX_GUILD_MASTERS+MAX_GUILD_SUBMASTERS+MAX_GUILD_FACTIONMASTERS+MAX_GUILD_MATES;
for( i=0; i<max; i++ )
MSG_WriteLong(&netMessage, guild->userLevel[i]);
}
else
MSG_WriteLong(&netMessage, guild->userLevel[rankIdx+addRankIdx]);
}
if( ( update & GUILD_USERJOB ) != 0 )
{
if( rankIdx == -1 )
{
int max = MAX_GUILD_MASTERS+MAX_GUILD_SUBMASTERS+MAX_GUILD_FACTIONMASTERS+MAX_GUILD_MATES;
for( i=0; i<max; i++ )
MSG_WriteLong(&netMessage, guild->userJob[i]);
}
else
MSG_WriteLong(&netMessage, guild->userJob[rankIdx+addRankIdx]);
}
if( ( update & GUILD_USERLOCATION ) != 0 )
{
if( rankIdx == -1 )
{
int max = MAX_GUILD_MASTERS+MAX_GUILD_SUBMASTERS+MAX_GUILD_FACTIONMASTERS+MAX_GUILD_MATES;
for( i=0; i<max; i++ )
MSG_WriteLong(&netMessage, guild->userLocation[i]);
}
else
MSG_WriteLong(&netMessage, guild->userLocation[rankIdx+addRankIdx]);
}
if( pc->ready )
{
NET_SendMessage(&pc->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Message_To_Client( playerCharacter_t *pc, short guildIndex, char *message )
{
char buffer[64];
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_CHATMESSAGE);
MSG_WriteByte(&netMessage, CHATMSG_TYPE_DAN );
MSG_WriteString(&netMessage, pc->name);
memset( buffer, 0, sizeof(buffer) );
sprintf( buffer, "%s, %d", message, guildIndex );
MSG_WriteString(&netMessage, buffer);
if( pc->ready )
{
NET_SendUnreliableMessage(&pc->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_Organize_Request_From_Client( playerCharacter_t *pc )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_GUILD_REQUEST);
MSG_WriteByte(&netMessage, GUILD_ORGANIZE_REQUEST);
if( pc->ready )
{
NET_SendUnreliableMessage(&pc->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Guild_List_Request_From_Client( playerCharacter_t *pc )
{
char buffer[128];
int i;
for( i = 0; i < MAX_GUILDS; i++ )
{
if( g_guild[i].name[0] != 0 && g_guild[i].idx != -1 )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_CHATMESSAGE);
MSG_WriteByte(&netMessage, CHATMSG_TYPE_DAN);
MSG_WriteString(&netMessage, pc->name);
memset( buffer, 0, sizeof(buffer) );
sprintf( buffer, "%s, %d", g_guild[i].name, g_guild[i].idx );
MSG_WriteString(&netMessage, buffer);
if( pc->ready )
{
NET_SendUnreliableMessage(&pc->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
}
}
void GTH_SendMessage_Guild_ChatMessage_Reply_To_Client( playerCharacter_t *pc, char *name, char *chatMessage )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_CHATMESSAGE);
MSG_WriteByte(&netMessage, CHATMSG_TYPE_DAN);
MSG_WriteString(&netMessage, name);
MSG_WriteString(&netMessage, chatMessage);
if( pc->ready )
{
NET_SendUnreliableMessage(&pc->sock, &netMessage);
}
}
MSG_EndWriting(&netMessage);
}
bool CheckLevel( int level, int *dptList, int otherClass )
{
bool ret = false;
for( int i=0; i<g_questscrollTableNumber; i++ )
{
if ( g_questscrollTable[i].data.level == level )
{
for (int j=0; j<3; j++)
{
if ( j == otherClass )
continue;
ret = true;
if ( g_questscrollTable[i].data.scrollType == j )
{
dptList[j] = 1;
}
}
}
}
return ret;
}
void GTH_SendMessage_QuestScroll_ObtainOpen( playerCharacter_t *pc, int openFlag )
{
int lvlList[3] = {0, 0, 0};
int dptList[3] = {0, 0, 0};
if ( openFlag > 0 )
{
int otherClass = 0;
switch ( pc->pcClass )
{
case GEN_MENTALITY :
case GEN_WIND :
otherClass = 2;
break;
case GEN_WATER :
case GEN_EARTH :
otherClass = 1;
break;
}
int level;
level = pc->level;
for( int i=0; i<3; i++ )
{
if ( level<11 )
break;
CheckLevel( level, dptList, otherClass );
level--;
}
for( i=0; i<3; i++ )
{
if ( dptList[i] != 0 )
{
int lvl = pc->level;
for( int j=0; j<3; j++ )
{
if ( lvl<11 )
break;
for ( int k=0; k<g_questscrollTableNumber; k++ )
{
if ( g_questscrollTable[k].data.level == lvl && g_questscrollTable[k].data.scrollType == i )
{
lvlList[j] = lvl;
}
}
lvl--;
}
break;
}
}
if ( i == 3 )
openFlag = 2;
}
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, QUESTSCROLL_OBTAINOPEN);
MSG_WriteByte(&netMessage, openFlag);
MSG_WriteByte(&netMessage, lvlList[0]);
MSG_WriteByte(&netMessage, lvlList[1]);
MSG_WriteByte(&netMessage, lvlList[2]);
MSG_WriteByte(&netMessage, dptList[0]);
MSG_WriteByte(&netMessage, dptList[1]);
MSG_WriteByte(&netMessage, dptList[2]);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_QuestScroll_ObtainPrepare( playerCharacter_t *pc, int reply, int error, int reqNak, int tableIdx )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, QUESTSCROLL_OBTAINPREPARE);
MSG_WriteByte(&netMessage, reply);
if( reply )
{
MSG_WriteShort( &netMessage, tableIdx );
MSG_WriteLong( &netMessage, reqNak );
}
else
{
MSG_WriteByte( &netMessage, error );
MSG_WriteShort( &netMessage, tableIdx );
MSG_WriteLong( &netMessage, reqNak );
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_QuestScroll_ObtainComplete( playerCharacter_t *pc, int reply, int error,int reqNak, int tableIdx )
{
int success = false;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, QUESTSCROLL_OBTAINCOMPLETE);
MSG_WriteByte(&netMessage, reply);
if( reply )
{
MSG_WriteShort( &netMessage, tableIdx );
MSG_WriteLong( &netMessage, pc->curChargeSE );
}
else
{
MSG_WriteByte( &netMessage, error );
MSG_WriteShort( &netMessage, tableIdx );
MSG_WriteLong( &netMessage, reqNak );
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_QuestScroll_ObtainClose( playerCharacter_t *pc )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, QUESTSCROLL_OBTAINCLOSE);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_QuestScrollComplete( playerCharacter_t *pc, int type, int reward, int itemNumber, int rankPoint, int nextScroll )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte( &netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte( &netMessage, QUESTSCROLL_COMPLETE );
MSG_WriteByte(&netMessage, type );
MSG_WriteLong(&netMessage, reward);
MSG_WriteShort(&netMessage, itemNumber);
MSG_WriteShort(&netMessage, rankPoint);
if( nextScroll < 0 )
MSG_WriteByte( &netMessage, 0 );
else
MSG_WriteByte( &netMessage, 1 );
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
GTH_SendMessage_CompleteEffect_To_AllPC( pc, 133 );
}
void GTH_SendMessage_AutoQuestScrollComplete( playerCharacter_t *pc, int questindex)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte( &netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte( &netMessage, AUTOQUESTSCROLL_COMPLETE );
MSG_WriteByte(&netMessage, questindex );
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_QuestScroll_ComboListChange( playerCharacter_t *pc, int depart )
{
int lvlList[3] = {0,0,0};
int level = pc->level;
for( int i=0; i<3; i++ )
{
if ( level<11 )
break;
for ( int j=0; j<g_questscrollTableNumber; j++ )
{
if ( g_questscrollTable[j].data.level == level && g_questscrollTable[j].data.scrollType == depart )
{
lvlList[i] = level;
}
}
level--;
}
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, QUESTSCROLL_COMBOLISTCHANGE);
MSG_WriteByte(&netMessage, lvlList[0]);
MSG_WriteByte(&netMessage, lvlList[1]);
MSG_WriteByte(&netMessage, lvlList[2]);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Reply_SendMail( playerCharacter_t *pc, int errorCode, char *toName )
{
int reply = 1, error = 0;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte( &netMessage, GSC_EXTEND );
MSG_WriteByte( &netMessage, GSC_MAILSYSTEM );
MSG_WriteByte( &netMessage, MAIL_SEND );
MSG_WriteString( &netMessage, toName );
if( errorCode == 0 )
{
MSG_WriteByte( &netMessage, reply );
}
else
{
reply = 0;
error = errorCode;
MSG_WriteByte( &netMessage, reply );
MSG_WriteByte( &netMessage, error );
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
if( reply )
{
if( g_config.isManager )
{
GTH_MailSystem_Find_Receiver( toName, pc->name );
}
else
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte( &netMessage, GSC_EXTEND );
MSG_WriteByte( &netMessage, GSC_MAIL_REQUEST );
MSG_WriteByte( &netMessage, MAIL_ARRIVE );
MSG_WriteString( &netMessage, toName );
MSG_WriteString( &netMessage, pc->name );
NET_SendUnreliableMessage( &localSocket, &netMessage );
}
MSG_EndWriting(&netMessage);
}
}
}
void GTH_SendMessage_Reply_RecvMail( playerCharacter_t *pc, int mailCount, MailEntry *mail )
{
int i;
MailEntry *pMail;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte( &netMessage, GSC_EXTEND );
MSG_WriteByte( &netMessage, GSC_MAILSYSTEM );
MSG_WriteByte( &netMessage, MAIL_RECEIVE );
MSG_WriteByte( &netMessage, mailCount );
pMail = &mail[0];
for( i = 0; i < mailCount; i ++, pMail ++ )
{
MSG_WriteByte( &netMessage, pMail->mailIdx );
MSG_WriteString( &netMessage, pMail->fromName );
MSG_WriteString( &netMessage, pMail->mailTitle );
MSG_WriteString( &netMessage, pMail->mailTime );
MSG_WriteByte( &netMessage, pMail->mailState );
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Reply_GetMailState( playerCharacter_t *pc, int notReadNumber, int readNumber, int s_notReadNumber, int s_readNumber )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte( &netMessage, GSC_EXTEND );
MSG_WriteByte( &netMessage, GSC_MAILSYSTEM );
MSG_WriteByte( &netMessage, MAIL_STATE );
MSG_WriteByte( &netMessage, notReadNumber );
MSG_WriteByte( &netMessage, readNumber );
MSG_WriteByte( &netMessage, s_notReadNumber );
MSG_WriteByte( &netMessage, s_readNumber );
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Reply_ViewMail( playerCharacter_t *pc, MailEntry *mail )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte( &netMessage, GSC_EXTEND );
MSG_WriteByte( &netMessage, GSC_MAILSYSTEM );
MSG_WriteByte( &netMessage, MAIL_VIEW );
MSG_WriteByte( &netMessage, mail->mailIdx );
MSG_WriteString( &netMessage, mail->fromName );
MSG_WriteString( &netMessage, mail->mailTitle );
MSG_WriteString( &netMessage, mail->mailTime );
MSG_WriteString( &netMessage, mail->mailStr );
MSG_WriteByte( &netMessage, mail->mailState );
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_AutoQuestScroll_ObtainOpen( playerCharacter_t* pPlayer, const int& autoquestindex)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, AUTOQUESTSCROLL_OBTAINOPEN);
MSG_WriteByte(&netMessage, autoquestindex);
NET_SendMessage(&pPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_AutoQuest_Error(playerCharacter_t* pPlayer,const int& error)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_ITEMSYSTEM );
MSG_WriteByte(&netMessage, AUTOQUESTSCROL_ERROR);
MSG_WriteByte( &netMessage, error );
NET_SendMessage(&pPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_AutoQuestScroll_effectisvalid( playerCharacter_t *pc,int &reply,int type)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_ANSWER_AUTOEFFECT );
MSG_WriteByte(&netMessage, type);
MSG_WriteByte(&netMessage, reply);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ChatBanFlagAnswer(playerCharacter_t *pc)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_ANSWER_CHATBAN_FLAG);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessag_ChaosValue()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_ANSWER_CHAOVALUE);
NET_SendMessage(&g_curPC->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_AddChaosInfo(playerCharacter_t *pc,int chaosvalue,bool sendclass,bool sendspeed)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_SEND_ADDCHAOSINFO);
MSG_WriteLong(&netMessage,chaosvalue);
MSG_WriteLong(&netMessage,pc->chaosPoint);
MSG_WriteShort(&netMessage,sendclass);
MSG_WriteShort(&netMessage,sendspeed);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_DecChaosInfo(playerCharacter_t *pc,int classtype)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_SEND_DECCHAOSINFO);
MSG_WriteShort(&netMessage,classtype);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_Reply_Use_Masic_Book(playerCharacter_t *pc, int reply, int error, int invenPos)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_EXTEND_SEND_USE_MASIC_BOOK);
MSG_WriteByte(&netMessage,reply);
MSG_WriteByte(&netMessage,error);
MSG_WriteByte(&netMessage,invenPos);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ReplayEpack_ChargSoul(playerCharacter_t *pc, int reply, int error, int invenpos,int EpkRemainCount)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_REPLY_USE_EPACK_CHARG_SOUL);
MSG_WriteLong(&netMessage, reply);
if ( reply == 1)
{
MSG_WriteByte(&netMessage, invenpos);
MSG_WriteLong(&netMessage, (int)pc->curChargeRA);
MSG_WriteLong(&netMessage, (int)pc->curChargeSA);
MSG_WriteShort(&netMessage,EpkRemainCount);
}
else
MSG_WriteLong(&netMessage, error);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
| C++ |
#if !defined(AFX_GS_TO_GMS_H__0F18DB24_883B_40D2_9130_7A1951B44389__INCLUDED_)
#define AFX_GS_TO_GMS_H__0F18DB24_883B_40D2_9130_7A1951B44389__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CGs_To_Gms
{
public:
enum enumPacketID
{
};
enum enumCheckType
{
CHECK_PLAYER1=0,
CHECK_PLAYER2
};
public:
CGs_To_Gms();
virtual ~CGs_To_Gms();
void Decoder(playerCharacter_t* pPlayer);
int Send_GMS(int SystemType,int mainType, int subType,char *FromPlayerName,char *TargetPlayerName,int gameServerNo,int CheckTarget);
int Send_GMS(int SystemType,int mainType, int subType,long value,char *FromPlayerName,char *TargetPlayerName,int gameServerNo,int CheckTarget);
int Send_GMS(int SystemType,int mainType, int subType, int worldIdx, vec3_t position, char *FromPlayerName,char *TargetPlayerName,int gameServerNo,int CheckTarget);
int Send_GMS(int SystemType,int mainType, int subType, int val, int worldIdx, vec3_t position, char *FromPlayerName,char *TargetPlayerName,int gameServerNo,int CheckTarget);
};
#endif
| C++ |
#if !defined(AFX_GS_TO_CC_H__F97E17C5_0C44_445A_8F88_BAAF75AE7649__INCLUDED_)
#define AFX_GS_TO_CC_H__F97E17C5_0C44_445A_8F88_BAAF75AE7649__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CGs_To_Cc
{
public:
CGs_To_Cc();
virtual ~CGs_To_Cc();
void Send(playerCharacter_t* pPlayer,int SystemType,int mainType, int subType);
void Send(playerCharacter_t* pPlayer,int SystemType,int mainType, int subType,char *TargetPlayerName);
void Send(playerCharacter_t* pPlayer,int SystemType,int mainType, int subType,char *requestPlayerName,char *TargetPlayerName);
void Send(playerCharacter_t* pPlayer,int SystemType,int mainType, int subType,int lval, char *TargetPlayerName);
void Send(playerCharacter_t* pPlayer,int SystemType,int mainType, int subType,int val, char *requestPlayerName,char *TargetPlayerName);
void Send(playerCharacter_t* pPlayer,int SystemType,int mainType, int subType,int worldIdx,vec3_t position,char *requestPlayerName,char *TargetPlayerName);
void Send(playerCharacter_t* pPlayer,int SystemType,int mainType, int subType,int val, int worldIdx,vec3_t position,char *requestPlayerName,char *TargetPlayerName);
};
#endif
| C++ |
#if !defined(AFX_GMS_TO_GS_H__A5283DC2_E609_4CB2_8AB4_82108DE3EF36__INCLUDED_)
#define AFX_GMS_TO_GS_H__A5283DC2_E609_4CB2_8AB4_82108DE3EF36__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CGms_To_Gs
{
public:
public:
CGms_To_Gs();
virtual ~CGms_To_Gs();
void Decoder(playerCharacter_t* pPlayer);
int Send_GS(int SystemType,int mainType, int subType,char *FromPlayerName,char *TargetPlayerName,int gameServerNo);
};
#endif
| C++ |
#define SENDING_QUEUE_SIZE 3000
#define RECEIVING_QUEUE_SIZE 3000
typedef struct
{
int socket;
int len;
i3packet_t packet;
sockaddr_in addr;
} i3packetqueue_t;
class CSendingQueue
{
private:
int m_first;
int m_last;
int m_size;
int m_overflow;
i3packetqueue_t m_queue[SENDING_QUEUE_SIZE];
public:
int m_count;
int m_maxCount;
CSendingQueue();
~CSendingQueue();
int Push (int socket, byte *buf, int len, struct sockaddr_in *addr);
int Pop (int *socket, byte *buf, int *len, struct sockaddr_in *addr);
void Clear ();
};
class CReceivingQueue
{
private:
int m_first;
int m_last;
int m_size;
int m_overflow;
i3packetqueue_t m_queue[RECEIVING_QUEUE_SIZE];
public:
int m_count;
int m_maxCount;
CReceivingQueue();
~CReceivingQueue();
int Push (int socket, byte *buf, int len, struct sockaddr_in *addr);
int Pop (int *socket, byte *buf, int *len, struct sockaddr_in *addr);
void Clear ();
};
| C++ |
#include "../Global.h"
#include "Gs_To_Gms.h"
#include "Gms_To_Gs.h"
CGs_To_Gms g_GsToGms;
extern CItem_Scroll_Proc g_Item_Scroll_Proc;
CGs_To_Gms::CGs_To_Gms()
{
}
CGs_To_Gms::~CGs_To_Gms()
{
}
void CGs_To_Gms::Decoder(playerCharacter_t* pPlayer)
{
short PacketID =MSG_ReadShort();
switch(PacketID){
case ITEM_SUMMON_SYSTEM:
g_Item_Scroll_Proc.GSDecoder();
break;
}
}
int CGs_To_Gms::Send_GMS(int SystemType,int mainType, int subType,char *FromPlayerName,char *TargetPlayerName,int gameServerNo,int CheckTarget)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GS_TO_GMS_PACKET);
MSG_WriteShort(&netMessage, SystemType);
MSG_WriteShort(&netMessage, mainType);
MSG_WriteShort(&netMessage, subType);
MSG_WriteString(&netMessage, FromPlayerName);
MSG_WriteString(&netMessage, TargetPlayerName);
if ( TRUE == g_config.isManager)
{
entityPCList_t entityPC;
if(enumCheckType::CHECK_PLAYER1 == CheckTarget)
{
int FindIdx = g_entityListMng.FindPCList( FromPlayerName, &entityPC );
if(-1 == FindIdx) return -1;
}
else if(enumCheckType::CHECK_PLAYER2 == CheckTarget)
{
int FindIdx = g_entityListMng.FindPCList( TargetPlayerName, &entityPC );
if(-1 == FindIdx) return -1;
}
else
{
return -1;
}
if(g_config.gameServerNo == entityPC.serverIdx)
{
return 0;
}
if(0 > entityPC.serverIdx || entityPC.serverIdx >= MAX_MEMBER_SERVER)
{
char txt[256];
wsprintf(txt,"Send_GMS :: 0 > entityPC.serverIdx || entityPC.serverIdx >= MAX_MEMBER_SERVER mainType %d, subType %d, %s -> %s ",mainType,subType,FromPlayerName,TargetPlayerName);
TRACE(txt);
return 0;
}
NET_SendUnreliableMessage(&g_memberServer[entityPC.serverIdx].sock, &netMessage);
}
else
{
MSG_WriteShort(&netMessage, gameServerNo);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
}
MSG_EndWriting(&netMessage);
return 0;
}
int CGs_To_Gms::Send_GMS(int SystemType,int mainType, int subType,long value,char *FromPlayerName,char *TargetPlayerName,int gameServerNo,int CheckTarget)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GS_TO_GMS_PACKET);
MSG_WriteShort(&netMessage, SystemType);
MSG_WriteShort(&netMessage, mainType);
MSG_WriteShort(&netMessage, subType);
MSG_WriteLong(&netMessage, value);
MSG_WriteString(&netMessage, FromPlayerName);
MSG_WriteString(&netMessage, TargetPlayerName);
if ( TRUE == g_config.isManager)
{
entityPCList_t entityPC;
if(enumCheckType::CHECK_PLAYER1 == CheckTarget)
{
int FindIdx = g_entityListMng.FindPCList( FromPlayerName, &entityPC );
if(-1 == FindIdx) return -1;
}
else if(enumCheckType::CHECK_PLAYER2 == CheckTarget)
{
int FindIdx = g_entityListMng.FindPCList( TargetPlayerName, &entityPC );
if(-1 == FindIdx) return -1;
}
else
{
return -1;
}
if(g_config.gameServerNo == entityPC.serverIdx)
{
return 0;
}
if(0 > entityPC.serverIdx || entityPC.serverIdx >= MAX_MEMBER_SERVER)
{
char txt[256];
wsprintf(txt,"Send_GMS :: 0 > entityPC.serverIdx || entityPC.serverIdx >= MAX_MEMBER_SERVER mainType %d, subType %d, %s -> %s ",mainType,subType,FromPlayerName,TargetPlayerName);
TRACE(txt);
return 0;
}
NET_SendUnreliableMessage(&g_memberServer[entityPC.serverIdx].sock, &netMessage);
}
else
{
MSG_WriteShort(&netMessage, gameServerNo);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
}
MSG_EndWriting(&netMessage);
return 0;
}
int CGs_To_Gms::Send_GMS(int SystemType,int mainType, int subType, int worldIdx, vec3_t position, char *FromPlayerName,char *TargetPlayerName,int gameServerNo,int CheckTarget)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GS_TO_GMS_PACKET);
MSG_WriteShort(&netMessage, SystemType);
MSG_WriteShort(&netMessage, mainType);
MSG_WriteShort(&netMessage, subType);
MSG_WriteByte(&netMessage, worldIdx);
MSG_WritePosition(&netMessage, position);
MSG_WriteString(&netMessage, FromPlayerName);
MSG_WriteString(&netMessage, TargetPlayerName);
if ( TRUE == g_config.isManager)
{
entityPCList_t entityPC;
if(enumCheckType::CHECK_PLAYER1 == CheckTarget)
{
int FindIdx = g_entityListMng.FindPCList( FromPlayerName, &entityPC );
if(-1 == FindIdx) return -1;
}
else if(enumCheckType::CHECK_PLAYER2 == CheckTarget)
{
int FindIdx = g_entityListMng.FindPCList( TargetPlayerName, &entityPC );
if(-1 == FindIdx) return -1;
}
else
{
return -1;
}
if(g_config.gameServerNo == entityPC.serverIdx)
{
return 0;
}
if(0 > entityPC.serverIdx || entityPC.serverIdx >= MAX_MEMBER_SERVER)
{
char txt[256];
wsprintf(txt,"Send_GMS :: 0 > entityPC.serverIdx || entityPC.serverIdx >= MAX_MEMBER_SERVER mainType %d, subType %d, %s -> %s ",mainType,subType,FromPlayerName,TargetPlayerName);
TRACE(txt);
return 0;
}
NET_SendUnreliableMessage(&g_memberServer[entityPC.serverIdx].sock, &netMessage);
}
else
{
MSG_WriteShort(&netMessage, gameServerNo);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
}
MSG_EndWriting(&netMessage);
return 0;
}
int CGs_To_Gms::Send_GMS(int SystemType,int mainType, int subType, int val, int worldIdx, vec3_t position, char *FromPlayerName,char *TargetPlayerName,int gameServerNo,int CheckTarget)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GS_TO_GMS_PACKET);
MSG_WriteShort(&netMessage, SystemType);
MSG_WriteShort(&netMessage, mainType);
MSG_WriteShort(&netMessage, subType);
MSG_WriteLong(&netMessage, val);
MSG_WriteByte(&netMessage, worldIdx);
MSG_WritePosition(&netMessage, position);
MSG_WriteString(&netMessage, FromPlayerName);
MSG_WriteString(&netMessage, TargetPlayerName);
if ( TRUE == g_config.isManager)
{
entityPCList_t entityPC;
if(enumCheckType::CHECK_PLAYER1 == CheckTarget)
{
int FindIdx = g_entityListMng.FindPCList( FromPlayerName, &entityPC );
if(-1 == FindIdx) return -1;
}
else if(enumCheckType::CHECK_PLAYER2 == CheckTarget)
{
int FindIdx = g_entityListMng.FindPCList( TargetPlayerName, &entityPC );
if(-1 == FindIdx) return -1;
}
else
{
return -1;
}
if(g_config.gameServerNo == entityPC.serverIdx)
{
return 0;
}
if(0 > entityPC.serverIdx || entityPC.serverIdx >= MAX_MEMBER_SERVER)
{
char txt[256];
wsprintf(txt,"Send_GMS :: 0 > entityPC.serverIdx || entityPC.serverIdx >= MAX_MEMBER_SERVER mainType %d, subType %d, %s -> %s ",mainType,subType,FromPlayerName,TargetPlayerName);
TRACE(txt);
return 0;
}
NET_SendUnreliableMessage(&g_memberServer[entityPC.serverIdx].sock, &netMessage);
}
else
{
MSG_WriteShort(&netMessage, gameServerNo);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
}
MSG_EndWriting(&netMessage);
return 0;
}
| C++ |
#include "../global.h"
extern i3sizebuf_t 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;
}
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 GTH_SendMessage_AddItemObject(itemObject_t *itemObject)
{
int i;
int idx;
GTH_GetPCListInValidRange(itemObject->worldIdx, itemObject->position);
if (g_zonePCListNumber < 1) return;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_ADDITEMOBJECT);
MSG_WriteShort(&netMessage, itemObject->idx);
MSG_WritePosition(&netMessage, itemObject->position);
MSG_WriteByte(&netMessage, itemObject->objectType);
if( itemObject->objectType == OBJECT_TYPE_ITEM )
{
MSG_WriteShort(&netMessage, itemObject->item.itemTableIdx);
} else if( itemObject->objectType == OBJECT_TYPE_PORTAL )
{
MSG_WriteShort(&netMessage, itemObject->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 GTH_SendMessage_DeleteItemObject(itemObject_t *itemObject)
{
int i;
int idx;
GTH_GetPCListInValidRange(itemObject->worldIdx, itemObject->position);
if (g_zonePCListNumber < 1) return;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_DELETEITEMOBJECT);
MSG_WriteShort(&netMessage, itemObject->idx);
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 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 GTH_SendMessage_ReplyPickUpItem(playerCharacter_t *pc, int reply, int error, item_t *item )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_PICKUPITEM);
MSG_WriteByte(&netMessage, reply);
if (reply > 0)
{
MSG_WriteItem(&netMessage, item);
MSG_WriteShort(&netMessage, pc->curItemWeight);
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_ReplyGetInventoryItem(playerCharacter_t *pc, int reply, int error, int inventoryPos, int equipPos )
{
int itemIdx;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_GETINVENTORYITEM);
if( reply > 0 )
{
MSG_WriteByte(&netMessage, reply);
MSG_WriteByte(&netMessage, inventoryPos);
MSG_WriteByte(&netMessage, equipPos);
if( reply == 5 )
{
MSG_WriteByte(&netMessage, pc->mouseInventory);
itemIdx = pc->inventory[inventoryPos];
MSG_WriteItem( &netMessage, &pc->item[itemIdx] );
MSG_WriteItem( &netMessage, &pc->item[pc->mouseInventory] );
}
}
else
{
MSG_WriteByte(&netMessage, reply);
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
GTH_PC_Calculate( pc, PCINFO_BASIC );
}
void GTH_SendMessage_ReplyGetEquipItem(playerCharacter_t *pc, int reply, int error, int inventoryPos, int equipPos)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_GETEQUIPITEM);
if( reply > 0 )
{
MSG_WriteByte(&netMessage, reply);
MSG_WriteByte(&netMessage, inventoryPos);
MSG_WriteByte(&netMessage, equipPos);
}
else
{
MSG_WriteByte(&netMessage, reply);
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
GTH_PC_Calculate( pc, PCINFO_BASIC );
}
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_DestroyItem( playerCharacter_t *pc, int reply, int error, int itemIdx )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_DESTROY_ITEM );
MSG_WriteByte(&netMessage, reply );
if( reply > 0 )
{
MSG_WriteShort(&netMessage, (int)pc->curChargeRA );
MSG_WriteShort(&netMessage, (int)pc->curChargeSA );
MSG_WriteShort(&netMessage, itemIdx );
MSG_WriteShort(&netMessage, pc->curItemWeight );
MSG_WriteShort(&netMessage, error);
}
else
{
MSG_WriteByte(&netMessage, error );
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_AddInvItem( playerCharacter_t *pc, int reply, int error, item_t *item )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_ADDITEMINV);
MSG_WriteByte(&netMessage, reply);
if( reply )
{
MSG_WriteItem(&netMessage, item);
MSG_WriteByte(&netMessage, error);
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&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);
}
| C++ |
#include "../global.h"
extern i3sizebuf_t netMessage;
int GTH_SendMessage_ReplyNpcChat( playerCharacter_t* pc, int reply, int error )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_NPCCHAT);
MSG_WriteByte(&netMessage, reply );
NET_SendMessage(&pc->sock, &netMessage );
}
MSG_EndWriting(&netMessage);
return 1;
}
int GTH_SendMessage_ReplyQuitNpcChat( playerCharacter_t* pc, int reply, int error )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_QUITNPCCHAT);
NET_SendMessage(&pc->sock, &netMessage );
}
MSG_EndWriting(&netMessage);
return 1;
}
int GTH_SendMessage_NpcMessage( playerCharacter_t* pc )
{
int dialogIdx, buttonNumber, buttonIdx;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_NPCMESSAGE);
dialogIdx = pc->npcAi.sendMsgIdx;
MSG_WriteShort(&netMessage, dialogIdx);
buttonNumber = pc->npcAi.replyMsgIdxNumber;
MSG_WriteByte(&netMessage, buttonNumber);
for( int i = 0; i < buttonNumber; i ++ )
{
MSG_WriteByte(&netMessage, i);
buttonIdx = pc->npcAi.replyMsgIdx[i];
MSG_WriteShort(&netMessage, buttonIdx);
}
NET_SendMessage(&pc->sock, &netMessage );
}
MSG_EndWriting(&netMessage);
return 1;
}
int GTH_SendMessage_ReplyStore( playerCharacter_t* pc, storeStruct_t *store, int type )
{
int chaoclass=GetChaosClass(pc);
float chargeRACost=0.0f;
float chargeSACost=0.0f;
unsigned int storevalue=1;
switch(chaoclass) {
case CHAOS_DISORDER:
storevalue=storevalue*3;
break;
case CHAOS_MONSTER:
storevalue=storevalue*5;
break;
default:
storevalue=1;
break;
}
int i;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_STORE );
if( store != NULL )
{
MSG_WriteByte(&netMessage, type);
MSG_WriteShort(&netMessage, store->itemNumber );
for( i = 0; i < store->itemNumber; i ++ )
{
MSG_WriteByte(&netMessage, store->item[i].page );
MSG_WriteShort(&netMessage, store->item[i].curNumber );
MSG_WriteLong(&netMessage, store->item[i].price*storevalue);
MSG_WriteShort(&netMessage, i );
MSG_WriteItem(&netMessage, &store->item[i].item );
}
MSG_WriteFloat(&netMessage, store->chargeRACost );
MSG_WriteFloat(&netMessage, store->chargeSACost );
}
else
{
MSG_WriteByte(&netMessage, 1);
MSG_WriteShort(&netMessage, type );
}
NET_SendMessage(&pc->sock, &netMessage );
}
MSG_EndWriting(&netMessage);
return 1;
}
int GTH_SendMessage_ReplyBuyItem(playerCharacter_t *pc, int reply, int error, item_t *item, int storeItemIdx, int curNumber )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_BUYITEM);
MSG_WriteByte(&netMessage, reply);
if (reply > 0)
{
MSG_WriteShort(&netMessage, storeItemIdx );
MSG_WriteShort(&netMessage, curNumber);
MSG_WriteItem(&netMessage, item);
MSG_WriteLong(&netMessage, pc->curChargeSE);
MSG_WriteShort(&netMessage, pc->curItemWeight);
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
return 1;
}
int GTH_SendMessage_ReplySellItem(playerCharacter_t *pc, int reply, int error, int itemIdx)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_SELLITEM);
MSG_WriteByte(&netMessage, reply);
if (reply > 0)
{
MSG_WriteByte(&netMessage, itemIdx);
MSG_WriteLong(&netMessage, pc->curChargeSE);
MSG_WriteShort(&netMessage, pc->curItemWeight);
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
return 1;
}
int GTH_SendMessage_ReplyBinding( playerCharacter_t* pc, int reply, int error, int type, int bindingIdx, int bindingCost )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_BINDING);
MSG_WriteByte(&netMessage, reply);
if (reply > 0)
{
MSG_WriteByte(&netMessage, type);
MSG_WriteByte(&netMessage, bindingIdx);
MSG_WriteLong(&netMessage, bindingCost );
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
return 1;
}
int GTH_SendMessage_ReplyEpackStore( playerCharacter_t* pc, int reply, int error,int EpkRemainCount)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_EPACKSTORE);
MSG_WriteByte(&netMessage, reply);
if (reply > 0)
{
MSG_WriteLong(&netMessage, pc->curChargeSE );
MSG_WriteLong(&netMessage, (int) pc->curChargeRA );
MSG_WriteLong(&netMessage, (int) pc->curChargeSA );
MSG_WriteShort(&netMessage, EpkRemainCount);
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
return 1;
}
int GTH_SendMessage_ReplyRepairItem( playerCharacter_t* pc, int reply, int error, int type, int repairItemIdx[], int repairItemDur[], int numOfRepairItem )
{
int i;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_REPAIR );
MSG_WriteByte(&netMessage, reply);
if( reply > 0 )
{
MSG_WriteLong(&netMessage, pc->curChargeSE );
MSG_WriteByte(&netMessage, type );
switch( type )
{
case 0 : case 1 :
MSG_WriteShort(&netMessage, repairItemIdx[0] );
MSG_WriteShort(&netMessage, repairItemDur[0] );
break;
case 2 :
MSG_WriteByte(&netMessage, numOfRepairItem );
for( i = 0; i < numOfRepairItem; i ++ )
{
MSG_WriteShort(&netMessage, repairItemIdx[i] );
MSG_WriteShort(&netMessage, repairItemDur[i] );
}
break;
}
}
else
{
MSG_WriteByte(&netMessage, error );
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
return 1;
}
int GTH_SendMessage_ReplyBuySkill( playerCharacter_t *pc, int reply, int error, int inventoryPos, int buySphereCost, int skillIdx )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_REPLY_BUY_SKILL);
MSG_WriteByte(&netMessage, reply);
if( reply )
{
MSG_WriteByte(&netMessage, inventoryPos);
MSG_WriteByte(&netMessage, buySphereCost);
MSG_WriteByte(&netMessage, skillIdx);
MSG_WriteShort(&netMessage, pc->skill[skillIdx].tableIdx);
MSG_WriteLong(&netMessage, pc->skill[skillIdx].iLevel);
}
else
{
MSG_WriteByte( &netMessage, error );
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
return 1;
}
int GTH_SendMessage_QuestLogic_ChatMsg( playerCharacter_t *pc, int idx ,int type)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_QUESTLOGIC );
MSG_WriteByte(&netMessage, QUESTLOGIC_CHATMSG);
MSG_WriteShort(&netMessage, type);
MSG_WriteShort(&netMessage, idx);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
return 1;
}
int GTH_SendMessage_QuestLogic_Awaken( playerCharacter_t *pc )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_QUESTLOGIC );
MSG_WriteByte(&netMessage, QUESTLOGIC_AWAKEN);
MSG_WriteShort(&netMessage, pc->pcJob);
for( int i = 0 ; i < GEN_NUMBER; i ++ )
MSG_WriteLong(&netMessage, pc->genCapability[i]);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
return 1;
}
int GTH_SendMessage_QuestLogic_InitStatus( playerCharacter_t *pc, int reply, int error, int type, int nak )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_QUESTLOGIC );
MSG_WriteByte(&netMessage, QUESTLOGIC_INITSTATUS );
MSG_WriteByte(&netMessage, reply);
if( reply )
{
MSG_WriteByte(&netMessage, type);
if( !type )
{
MSG_WriteLong(&netMessage, nak);
}
else
{
MSG_WriteShort(&netMessage, pc->bonusStatusPoint);
}
}
else
{
MSG_WriteByte(&netMessage, error);
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
return 1;
}
int GTH_SendMessage_NPCInfo( playerCharacter_t * pc )
{
int npcNumber;
monsterCharacter_t *pNpc;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_NPCINFO );
LIST_NONPLAYER_STRUCT::iterator itor;
npcNumber = 0;
for( itor = g_sNpcList.begin(); itor != g_sNpcList.end(); itor ++ )
{
pNpc = ( *itor );
if( pNpc->worldIdx == pc->worldIdx ) npcNumber ++;
}
MSG_WriteByte( &netMessage, npcNumber );
for( itor = g_sNpcList.begin(); itor != g_sNpcList.end(); itor ++ )
{
pNpc = ( *itor );
if( pNpc->worldIdx != pc->worldIdx ) continue;
MSG_WritePosition( &netMessage, pNpc->position );
MSG_WriteShort( &netMessage, pNpc->tableIdx );
}
MSG_WriteByte( &netMessage, pc->worldIdx );
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
return 1;
}
int GTH_SendMessage_Reply_MasicBook_RepairItem( playerCharacter_t* pc, int reply, int error, int repairItemIdx[], int repairItemDur[], int numOfRepairItem ,int InvenPos )
{
int i;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_EXTEND_REPLY_USE_MASIC_BOOK);
MSG_WriteByte(&netMessage, reply);
if( reply > 0 )
{
MSG_WriteByte(&netMessage, numOfRepairItem );
for( i = 0; i < numOfRepairItem; i ++ )
{
MSG_WriteShort(&netMessage, repairItemIdx[i] );
MSG_WriteShort(&netMessage, repairItemDur[i] );
}
MSG_WriteShort(&netMessage, InvenPos );
}
else
{
MSG_WriteByte(&netMessage, error );
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
return 1;
}
void GTH_SendMessage_Reply_RepairItemConfirm
(playerCharacter_t* pc, int reply, int erroridx, enumRepairType repairtype, int cost, int repairCount, int itemtableidx)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, ITEM_REPAIR);
MSG_WriteShort(&netMessage, GSC_ITEM_REPAIR);
MSG_WriteByte(&netMessage, reply);
if ( reply == 0)
MSG_WriteByte(&netMessage, erroridx);
else
{
MSG_WriteLong(&netMessage, repairtype);
MSG_WriteLong(&netMessage, cost);
MSG_WriteByte(&netMessage, repairCount);
MSG_WriteLong(&netMessage, itemtableidx);
}
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
} | C++ |
#include "Global.h"
HINSTANCE g_hInst;
TCHAR* g_strAppTitle = TEXT( "GTH GameServer Ver.06-04-13" );
TCHAR* g_strWindowClass = TEXT( "MS" );
TCHAR* g_systemStatusMessage = TEXT( "Starting Game Server..." );
HWND g_hWnd;
unsigned int g_globalTime;
i3gameServerConfig_t g_config;
gthGameLogicCofing_t g_logic;
i3zone_t g_zone[MAX_LOCALSERVICEWORLDS][ZONE_DIV * ZONE_DIV];
i3zoneScanList_t g_zoneEntityList[MAX_SCAN_ENTITYLIST];
int g_zoneEntityListNumber;
i3zoneScanList_t g_zonePCList[MAX_SCAN_PCLIST];
int g_zonePCListNumber;
i3zoneScanList_t g_zoneMonsterList[MAX_SCAN_MONSTERLIST];
int g_zoneMonsterListNumber;
i3zoneScanList_t g_zoneNPCList[MAX_SCAN_NPCLIST];
int g_zoneNPCListNumber;
i3zoneScanList_t g_zoneObjectList[MAX_SCAN_OBJECTLIST];
int g_zoneObjectListNumber;
int g_pcNumber;
playerCharacter_t g_pc[MAX_PCS];
playerCharacter_t *g_curPC;
int g_maxPCNumber;
int g_monsterNumber;
monsterCharacter_t g_monster[MAX_MONSTERS];
LIST_NONPLAYER_STRUCT g_sNpcList;
int g_objectNumber;
itemObject_t g_object[MAX_OBJECTS];
itemObject_t *g_curobject;
CTimer *g_timer;
CDBAccount *g_DBAccountServer;
CDBGame *g_DBGameServer;
CLogSystem *g_logSystem;
int g_fixedScreenSize;
unsigned long g_dwMaxTextureHeight;
unsigned long g_dwMaxTextureWidth;
worldTable_t g_worldTable[MAX_WORLDS];
int g_worldTableNumber;
monsterBasicTable_t g_monsterTable[MAX_NUMBER_OF_MONSTER_TABLE];
int g_monsterTableNumber;
itemTable_t g_itemTable[MAX_NUMBER_OF_ITEM_TABLE];
int g_itemTableNumber;
itemClassTable_t g_itemClassTable[MAX_NUMBER_OF_ITEM_CLASS_TABLE];
int g_itemClassTableNumber;
GambleItem_t g_GambleItem[MAX_COUNT_OPTION_AVAILABLE_TYPE];
int g_GambleItemTalbleNumber;
optionTable_t g_optionTable[MAX_COUNT_OPTION_TABLE];
optionGroupTable_t g_optionGroupTable[MAX_COUNT_OPTION_GROUP_TABLE];
itemGenerateTable_t g_itemGenerateTable[MAX_NUMBER_OF_ITEM_GENERATE_TABLE];
int g_itemGenerateTableNumber;
questItemGenerate_t g_qigTable[MAX_NUMBER_OF_MONSTER_TABLE];
int g_qigTableNumber;
itemCraftTable_t g_itemCraftTable[MAX_NUMBER_OF_ITEM_CRAFT_TABLE];
int g_itemCraftTableNumber;
questscrollTable_t g_questscrollTable[MAX_NUMBER_OF_QUESTSCROLL_TABLE];
int g_questscrollTableNumber;
autoQuestScrollTable_t g_autoQuestscrollTable[MAX_NUMBER_OF_AUTO_QUESTSCROLL_TABLE];
int g_autoQuestscrollTableNumber;
bool g_AutoQuestScrolltype2 = false;
bool g_AutoQuestScrolltype4 = false;
SummonMonster_t g_summonMonstertable[MAX_NUMBER_OF_SUMMON_MONSTER_TABLE];
int g_summonMonstertableNumber;
Consideration_t g_ConsiderationTable[MAX_NUMBER_OF_CONSIDERATION_TABLE];
int g_ConsiderationTableNumber;
int g_skillTableNumber;
skillGradeClass_t g_skillGradeClassTable[100];
genCapabilityTable_t g_genCapabilityTable;
expTable_t g_expTable[MAX_NUMBER_OF_LEVEL];
MaxDefense_t g_MaxDefneseTable[MAX_NUMBER_OF_LEVEL];
int g_storeNumber;
storeStruct_t g_store[MAX_STORES];
int g_bindingNumber;
bindingStruct_t g_binding[MAX_BINDINGS];
scriptInfoStruct_t g_scriptInfo;
collisionMap_t g_cmap[MAX_LOCALSERVICEWORLDS];
tcpSocket *g_pBillingSocket ;
int g_memberServerNumber;
memberServer_t g_memberServer[MAX_MEMBER_SERVER];
memberServer_t *g_curMemberServer;
CEntityListMng g_entityListMng;
serverPartyInfo_t g_partyInfo[MAX_PARTY_NUMBER];
FriendsList g_friendsList[MAX_FRIENDS_LIST];
serverShutdownTimer_t g_serverShutdownTimer;
noticeInfo_t g_noticeInfo;
golryunManagerTable_t g_golryunManagerTable[MAX_NUMBER_OF_GOLRYUN_MANAGER_TABLE];
golryunProgressTable_t g_golryunProgressTable[MAX_NUMBER_OF_GOLRYUN_MANAGER_TABLE];
golryunRewardManagerTable_t g_golryunRewardManagerTable[MAX_NUMBER_OF_GOLRYUN_MANAGER_TABLE];
golryunItemGroupTable_t g_golryunItemGroupTable[MAX_NUMBER_OF_GOLRYUN_ITEM_GROUP_TABLE];
char g_hostName[HOSTNAMESTRING];
LPDAN_BATTLE_MANAGER g_pDanBattleManager = NULL;
LPDAN_BATTLE_SYS g_pDanBattleSys = NULL;
CDanBattleFunc g_DanBattleFunc;
CChristMasEvent g_ChristMasEvent;
CPostFunc g_PostFunc;
CHelperManager g_HelperManager;
CWeatherSystem g_WeatherSystem;
CExpEventMng g_ExpEventMng;
CGambleSystem g_GambleSystem;
NewDanBattleSystem g_NewDanBattleSystem;
guild_t g_guild[MAX_GUILDS];
void GTH_InitGlobalVariable()
{
g_pcNumber = 0;
if ( g_timer ) { delete g_timer; g_timer = NULL; }
g_timer = new CTimer;
if ( g_DBAccountServer ) { delete g_DBAccountServer; g_DBAccountServer = NULL; }
g_DBAccountServer = new CDBAccount;
if ( g_DBGameServer ) { delete g_DBGameServer; g_DBGameServer = NULL; }
g_DBGameServer = new CDBGame;
if ( g_logSystem ) { delete g_logSystem; g_logSystem = NULL; }
g_logSystem = new CLogSystem;
GTH_Init_ServerShutdownTimer();
GTH_Init_ServerNoticeInfo();
GTH_InitPartyInfo();
GTH_InitGuildList();
}
void GTH_DestroyVariables()
{
if ( g_timer ) { delete g_timer; g_timer = NULL; }
if ( g_DBAccountServer ) { delete g_DBAccountServer; g_DBAccountServer = NULL; }
if ( g_DBGameServer ) { delete g_DBGameServer; g_DBGameServer = NULL; }
if ( g_logSystem ) { delete g_logSystem; g_logSystem = NULL; }
CloseBilling();
}
monsterSpawnOptionTable_t g_monsterSpawnOption[100] =
{
{ 0, 1, 1, (float)0.8, 10, 400 },
{ 1, 1, 6, (float)1.2, 10, 600 },
{ 2, 1, 1, (float)0.8, 10, 50 },
{ 3, 1, 3, (float)0.8, 10, 50 },
{ 4, 1, 3, (float)0.8, 10, 70 },
{ 5, 1, 1, (float)0.8, 10, 30 },
{ 6, 1, 1, (float)0.8, 10, 50 },
{ 7, 1, 1, (float)0.8, 10, 400 },
{ 8, 1, 3, (float)0.8, 10, 400 },
{ 9, 1, 3, (float)0.8, 10, 400 },
{ 10, 1, 3, (float)0.8, 10, 400 },
{ 11, 1, 5, (float)0.8, 10, 400 },
{ 12, 1, 5, (float)0.8, 10, 400 },
{ 13, 1, 5, (float)0.8, 10, 400 },
{ 14, 1, 5, (float)0.8, 10, 400 },
{ 15, 1, 5, (float)0.8, 10, 400 },
{ 16, 1, 1, (float)0.8, 10, 400 },
{ 17, 1, 1, (float)0.8, 10, 400 },
{ 18, 1, 7, (float)0.8, 10, 400 },
{ 19, 1, 7, (float)0.8, 10, 400 },
{ 20, 0, 1, (float)0.8, 10, 500 },
{ 21, 0, 1, (float)1.5, 10, 500 },
{ 22, 0, 1, (float)1.5, 10, 500 },
{ 23, 0, 1, (float)1.2, 10, 500 },
{ 24, 0, 5, (float)0.08, 10, 1000},
}; | C++ |
#include "../global.h"
int AI_InterpretMessage( monsterCharacter_t* monster, message_t* message )
{
playerCharacter_t *pToPC = NULL;
monsterCharacter_t *pToMon = NULL;
if( message->fromType == ENTITY_PC ) pToPC = &g_pc[message->fromIdx];
else pToMon = &g_monster[message->fromIdx];
switch( message->type )
{
case MSG_DAMEGED :
if( monster->aliveState == MON_ALIVE_STATE_NORMAL )
{
if( message->fromType == ENTITY_PC )
{
if( pToPC->event != GTH_EV_CHAR_STUN && pToPC->event != GTH_EV_CHAR_DIE ) GTH_Monster_Damage(monster, message);
}
else
{
if( pToMon->event != GTH_EV_CHAR_STUN && pToMon->event != GTH_EV_CHAR_DIE && pToMon->event != GTH_EV_CHAR_FREEZE)
GTH_Monster_Damage(monster, message);
}
}
break;
case MSG_AFFECT :
{
GTH_Affect( monster, message, monster->entityType );
}
break;
case MSG_ETC :
if( !AI_InterpretMessage_Etc( monster, message ) ) return( false );
break;
}
if( message->repeatNum > 0 )
{
message->repeatNum --;
message->receiveTime = g_globalTime + message->repeatDelayTime;
}
return( true );
}
int AI_InterpretMessage_Etc( monsterCharacter_t* monster, message_t *message )
{
switch( message->data[0] )
{
case MSG_ETC_RESURRECTION :
return( false );
break;
case MSG_ETC_FORCED_CHANGE_TARGET :
AI_RemoveTarget( monster );
monster->forcedEntityType = message->data[1];
monster->forcedEntityIdx = message->data[2];
break;
}
return( true );
}
int AI_InterpretMessage( playerCharacter_t* pc, message_t* message )
{
playerCharacter_t *pToPC;
monsterCharacter_t *pToMon;
if( message->fromType == ENTITY_PC ) pToPC = &g_pc[message->fromIdx];
else pToMon = &g_monster[message->fromIdx];
switch( message->type )
{
case MSG_DAMEGED :
if( pc->alive )
{
if( message->fromType == ENTITY_PC )
{
if( pToPC->event != GTH_EV_CHAR_STUN && pToPC->event != GTH_EV_CHAR_DIE ) GTH_PC_Damage(pc, message);
}
else
{
if( pToMon->event != GTH_EV_CHAR_STUN &&
pToMon->event != GTH_EV_CHAR_DIE &&
pToMon->event != GTH_EV_CHAR_FREEZE )
GTH_PC_Damage(pc, message);
}
}
break;
case MSG_AFFECT :
{
GTH_Affect( pc, message );
}
break;
case MSG_ETC :
if( !AI_InterpretMessage_Etc( pc, message ) ) return( false );
break;
}
if( message->repeatNum > 0 )
{
message->repeatNum --;
message->receiveTime = g_globalTime + message->repeatDelayTime;
}
return( true );
}
int AI_InterpretMessage_Etc( playerCharacter_t* pc, message_t *message )
{
switch( g_SkillDataGlobal.GetMessageType(SKILL_MES_TYPE_ETC_TYPE,message) )
{
case MSG_ETC_RESURRECTION :
{
float curRA, curSA;
int recoveryExp;
curRA = (float)g_SkillDataGlobal.GetMessageType(SKILL_MES_TYPE_RA,message);
curSA = (float)g_SkillDataGlobal.GetMessageType(SKILL_MES_TYPE_SA,message);
if(curRA > pc->calMaxRA) curRA = pc->calMaxRA;
if(curSA > pc->calMaxSA) curSA = pc->calMaxSA;
recoveryExp = (int)( (float)g_SkillDataGlobal.GetMessageType(SKILL_MES_TYPE_EXP,message) / g_logic.expRate );
GTH_PC_Respawn( pc, (int)curRA, (int)curSA, recoveryExp, true );
g_logSystem->WriteToLog( pc, LOG_CLASS_SKILL,"%d;;;;;;operator=%s recoveryExp=%d",
LOG_CLASS_SKILL_RESURRECTION,
message->fromNameV2,
recoveryExp);
}
return( false );
break;
case MSG_ETC_FORCED_CHANGE_TARGET :
break;
}
return( true );
}
| C++ |
#include "../global.h"
#define HIT_RATE_ADD_PROB 10
#define HIT_CRIRATE_ADD_PROB 20
#define HIT_CRIDMG_ADD_PROB 5.0f
void AI_MakeMessage( playerCharacter_t* pc, message_t* message, int type, messageInfo_t *msginfo )
{
memset( message, 0, sizeof( message_t ) );
switch( type )
{
case MESSAGE_NORMAL_ATTACK :
AI_MakeAttackMessage( pc, message );
break;
case MESSAGE_USEINFO :
if( msginfo->infoType == MSGINFO_TYPE_ATTACK ) AI_MakeMsgInfoAttack( pc, message, msginfo );
else if( msginfo->infoType == MSGINFO_TYPE_AFFECT ) AI_MakeMsgInfoAffect( pc, message, msginfo );
break;
}
}
void AI_MakeAttackMessage( playerCharacter_t* pc, message_t* message )
{
int d, attackType = 0, criticalRate = 0;
message->type = MSG_DAMEGED;
message->fromIdx = pc->idx;
message->fromType = ENTITY_PC;
strncpy( message->fromNameV2, pc->name,NAMESTRING);
message->fromNameV2[NAMESTRING]=NULL;
message->toType = pc->targetType;
message->toIdx = pc->targetIdx;
message->worldIdx = pc->worldIdx;
message->sendTime = g_globalTime;
pc->curSA -= (float)pc->atkBowSACost;
pc->curRA -= pc->optValue[OV_ATK_RACOST];
pc->curSA -= pc->optValue[OV_ATK_SACOST];
if( (int)pc->curRA < 0 ) pc->curRA = 1.0f;
if( (int)pc->curSA < 0 ) pc->curSA = 0.0f;
PC_GetAttackComboType( pc );
message->receiveTime = g_globalTime + (int)( (float)pc->sock.latencyTime );
message->repeatNum = 0;
message->data[MSG_ATKDATA_ATTACK_TYPE] = MSGINFO_ATK_TYPE_NORMAL;
d = pc->calPhyMaxDmg - pc->calPhyMinDmg + 1;
message->data[MSG_ATKDATA_PHYSIC_DMG] = GTH_Randomize( d ) + pc->calPhyMinDmg;
d = pc->calPosMaxDmg - pc->calPosMinDmg + 1;
message->data[MSG_ATKDATA_POSITIVE_DMG] = GTH_Randomize( d ) + pc->calPosMinDmg;
d = pc->calNegMaxDmg - pc->calNegMinDmg + 1;
message->data[MSG_ATKDATA_NEGATIVE_DMG] = GTH_Randomize( d ) + pc->calNegMinDmg;
message->data[MSG_ATKDATA_WEAPON_TYPE] = 0;
message->data[MSG_ATKDATA_HITRATE] = 0;
message->data[MSG_ATKDATA_CRITICAL_RATE] = 0;
message->data[MSG_ATKDATA_CRITICAL_DAMAGE] = 0;
message->data[MSG_ATKDATA_STUN_FLAG] = 0;
}
void AI_MakeMsgInfoAttack( playerCharacter_t *pc, message_t* message, messageInfo_t* msginfo )
{
MSGINFO_ATTACK* atkinfo = &msginfo->attack;
int d, attackType = 0, criticalRate = -1;
message->type = MSG_DAMEGED;
message->fromIdx = pc->idx;
message->fromType = ENTITY_PC;
strncpy( message->fromNameV2, pc->name,NAMESTRING );
message->fromNameV2[NAMESTRING]=NULL;
message->toType = msginfo->targetType;
message->toIdx = msginfo->targetIdx;
message->sendTime = g_globalTime;
if( msginfo->attack.etcInfo == MSGINFO_ATK_ETC_MULTIDAMAGE_DELAY )
{
message->receiveTime = g_globalTime + msginfo->attack.etcData0;
}
else
{
message->receiveTime = g_globalTime + msginfo->attack.delayTime;
}
message->worldIdx = pc->worldIdx;
message->repeatNum = atkinfo->repeatNum;
message->repeatDelayTime = atkinfo->repeatDelayTime;
d = atkinfo->phyMaxDmg - atkinfo->phyMinDmg + 1;
message->data[MSG_ATKDATA_PHYSIC_DMG] = GTH_Randomize( d ) + atkinfo->phyMinDmg;
d = atkinfo->posMaxDmg - atkinfo->posMinDmg + 1;
message->data[MSG_ATKDATA_POSITIVE_DMG] = GTH_Randomize( d ) + atkinfo->posMinDmg;
message->data[MSG_ATKDATA_POSITIVE_DMG] += (int)( (float)message->data[MSG_ATKDATA_POSITIVE_DMG] * pc->optValue[OV_SKILL_DMG_RATE] * 0.01f );
d = atkinfo->negMaxDmg - atkinfo->negMinDmg + 1;
message->data[MSG_ATKDATA_NEGATIVE_DMG] = GTH_Randomize( d ) + atkinfo->negMinDmg;
message->data[MSG_ATKDATA_NEGATIVE_DMG] += (int)( (float)message->data[MSG_ATKDATA_NEGATIVE_DMG] * pc->optValue[OV_SKILL_DMG_RATE] * 0.01f );
message->data[MSG_ATKDATA_WEAPON_TYPE] = 0;
message->data[MSG_ATKDATA_ATTACK_TYPE] = atkinfo->atkType;
message->data[MSG_ATKDATA_HITPOWER] = atkinfo->hitPower;
message->data[MSG_ATKDATA_HITRATE] = atkinfo->hitRate;
if( atkinfo->atkType == MSGINFO_ATK_TYPE_NORMAL )
{
message->data[MSG_ATKDATA_CRITICAL_RATE] = atkinfo->criticalRate;
message->data[MSG_ATKDATA_CRITICAL_DAMAGE] = atkinfo->criticalDamage;
}
else
{
message->data[MSG_ATKDATA_CRITICAL_RATE] = 0;
message->data[MSG_ATKDATA_CRITICAL_DAMAGE] = 0;
}
message->data[MSG_ATKDATA_STUN_FLAG] = 0;
message->data[MSG_ATKDATA_ETC_INFO] = atkinfo->etcInfo;
message->data[MSG_ATKDATA_ETC_DATA_0] = atkinfo->etcData0;
message->data[MSG_ATKDATA_ETC_DATA_1] = atkinfo->etcData1;
}
void AI_MakeMsgInfoAffect( playerCharacter_t *pc, message_t* message, messageInfo_t* msginfo )
{
MSGINFO_AFFECT* affinfo = &msginfo->affect;
int attackType = 0;
message->type = MSG_AFFECT;
message->fromIdx = pc->idx;
message->fromType = ENTITY_PC;
strncpy( message->fromNameV2, pc->name,NAMESTRING);
message->fromNameV2[NAMESTRING]=NULL;
message->toType = msginfo->targetType;
message->toIdx = msginfo->targetIdx;
message->sendTime = g_globalTime;
message->receiveTime = affinfo->startTime;
message->worldIdx = pc->worldIdx;
message->repeatNum = 0;
pc->curSA += pc->optValue[OV_DECSA_USE];
pc->curRA += pc->optValue[OV_DECRA_USE];
message->data[MSG_AFFDATA_AFFECT_TYPE] = affinfo->type;
message->data[MSG_AFFDATA_AFFECT_HITTYPE] = affinfo->affectType;
message->data[MSG_AFFDATA_LEVEL] = affinfo->level;
message->data[MSG_AFFDATA_KEEPTIME] = affinfo->keepTime;
message->data[MSG_AFFDATA_SKILLTABLEIDX] = affinfo->skillTableIdx;
message->data[MSG_AFFDATA_HITRATE] = affinfo->hitRate;
if( affinfo->affectType == MSGINFO_AFF_TYPE_NORMAL )
message->data[MSG_AFFDATA_HITRATE] = 100;
if( affinfo->type == AFFECT_TOGGLE )
{
message->data[MSG_AFFDATA_RACOST_PER_SEC] = affinfo->raCostPerSec;
message->data[MSG_AFFDATA_SACOST_PER_SEC] = affinfo->saCostPerSec;
message->data[MSG_AFFDATA_DELAY_TIME] = affinfo->delayTime;
}
for( int i = 0; i < MAX_COUNT_AFFECT_DATA; i ++ )
{
message->data[i + CONVERT_MSG_TO_AFFECT_SIZE] = affinfo->data[i];
}
}
void AI_MakeMessage( monsterCharacter_t* monster, message_t* message, int type, messageInfo_t* msginfo )
{
switch( type )
{
case MESSAGE_NORMAL_ATTACK :
AI_MakeAttackMessage( monster, message );
break;
case MESSAGE_USEINFO :
if ( msginfo->infoType == MSGINFO_TYPE_ATTACK ) AI_Make_Monster_MsgInfoAttack( monster, message, msginfo );
else if( msginfo->infoType == MSGINFO_TYPE_AFFECT ) AI_Make_Monster_MsgInfoAffect( monster, message, msginfo );
break;
}
}
void AI_MakeAttackMessage( monsterCharacter_t* monster, message_t* message )
{
int trainMonsterAddDmg[8] = { 0, 0, 0, 0, 5, 15, 25, 50 };
int trainMonsterAddHitRate[8] = { 0, 0, 0, 0, 30, 50, 70, 90 };
int d, attackType = 0, criticalRate = -1;
message->type = MSG_DAMEGED;
message->fromIdx = monster->idx;
message->fromType = monster->entityType;
strncpy( message->fromNameV2, monster->basic.name,NAMESTRING);
message->fromNameV2[NAMESTRING]=NULL;
message->toType = monster->targetType;
message->toIdx = monster->targetIdx;
message->worldIdx = monster->worldIdx;
message->sendTime = g_globalTime;
message->receiveTime = g_globalTime + (int)( (float)monster->calAttackDelay * 0.3f );
message->repeatNum = 0;
d = monster->calPhyMaxDmg - monster->calPhyMinDmg + 1;
message->data[MSG_ATKDATA_PHYSIC_DMG] = GTH_Randomize( d ) + monster->calPhyMinDmg;
d = monster->calPosMaxDmg - monster->calPosMinDmg + 1;
message->data[MSG_ATKDATA_POSITIVE_DMG] = GTH_Randomize( d ) + monster->calPosMinDmg;
d = monster->calNegMaxDmg - monster->calNegMinDmg + 1;
message->data[MSG_ATKDATA_NEGATIVE_DMG] = GTH_Randomize( d ) + monster->calNegMinDmg;
message->data[MSG_ATKDATA_WEAPON_TYPE] = 0;
message->data[MSG_ATKDATA_HITRATE] = 0;
message->data[MSG_ATKDATA_ATTACK_TYPE] = MSGINFO_ATK_TYPE_NORMAL;
message->data[MSG_ATKDATA_CRITICAL_RATE] = 0;
message->data[MSG_ATKDATA_HITPOWER ] = 0;
message->data[MSG_ATKDATA_CRITICAL_DAMAGE] = 0;
message->data[MSG_ATKDATA_STUN_FLAG] = 0;
if( message->toType == ENTITY_PC )
{
if( g_pc[message->toIdx].numTrainMonster > 0 && g_pc[message->toIdx].numTrainMonster <= MAX_COUNT_TRAIN_MONSTER )
{
message->data[MSG_ATKDATA_HITRATE] += trainMonsterAddHitRate[g_pc[message->toIdx].numTrainMonster - 1];
message->data[MSG_ATKDATA_PHYSIC_DMG] += trainMonsterAddDmg[g_pc[message->toIdx].numTrainMonster - 1];
}
}
}
void AI_Make_Monster_MsgInfoAttack( monsterCharacter_t *pMonster, message_t* message, messageInfo_t* msginfo )
{
MSGINFO_ATTACK* atkinfo = &msginfo->attack;
int d, attackType = 0, criticalRate = -1;
message->type = MSG_DAMEGED;
message->fromIdx = pMonster->idx;
message->fromType = ENTITY_MONSTER;
message->toType = msginfo->targetType;
message->toIdx = msginfo->targetIdx;
message->sendTime = g_globalTime;
strncpy( message->fromNameV2, pMonster->basic.name,NAMESTRING);
message->fromNameV2[NAMESTRING]=NULL;
message->receiveTime = g_globalTime + atkinfo->delayTime;
message->worldIdx = pMonster->worldIdx;
message->repeatNum = atkinfo->repeatNum;
message->repeatDelayTime = atkinfo->repeatDelayTime;
d = atkinfo->phyMaxDmg - atkinfo->phyMinDmg + 1;
message->data[MSG_ATKDATA_PHYSIC_DMG] = GTH_Randomize( d ) + atkinfo->phyMinDmg;
d = atkinfo->posMaxDmg - atkinfo->posMinDmg + 1;
message->data[MSG_ATKDATA_POSITIVE_DMG] = GTH_Randomize( d ) + atkinfo->posMinDmg;
d = atkinfo->negMaxDmg - atkinfo->negMinDmg + 1;
message->data[MSG_ATKDATA_NEGATIVE_DMG] = GTH_Randomize( d ) + atkinfo->negMinDmg;
message->data[MSG_ATKDATA_WEAPON_TYPE] = 0;
message->data[MSG_ATKDATA_ATTACK_TYPE] = atkinfo->atkType;
message->data[MSG_ATKDATA_HITPOWER] = atkinfo->hitPower;
message->data[MSG_ATKDATA_HITRATE] = atkinfo->hitRate;
message->data[MSG_ATKDATA_HITRATE] = atkinfo->hitPower;
if( atkinfo->atkType == MSGINFO_ATK_TYPE_NORMAL )
{
message->data[MSG_ATKDATA_CRITICAL_RATE] = atkinfo->criticalRate;
message->data[MSG_ATKDATA_CRITICAL_DAMAGE] = atkinfo->criticalDamage;
}
else
{
message->data[MSG_ATKDATA_CRITICAL_RATE] = 0;
message->data[MSG_ATKDATA_CRITICAL_DAMAGE] = 0;
}
message->data[MSG_ATKDATA_STUN_FLAG] = 0;
message->data[MSG_ATKDATA_ETC_INFO] = atkinfo->etcInfo;
message->data[MSG_ATKDATA_ETC_DATA_0] = atkinfo->etcData0;
message->data[MSG_ATKDATA_ETC_DATA_1] = atkinfo->etcData1;
message->data[MSG_ATKDATA_ETC_DATA_2] = msginfo->infoType;
}
void AI_Make_Monster_MsgInfoAffect( monsterCharacter_t *pMonster, message_t* message, messageInfo_t* msginfo )
{
MSGINFO_AFFECT* affinfo = &msginfo->affect;
int attackType = 0;
message->type = MSG_AFFECT;
message->fromIdx = pMonster->idx;
message->fromType = ENTITY_MONSTER;
strncpy( message->fromNameV2, pMonster->basic.name,NAMESTRING);
message->fromNameV2[NAMESTRING]=NULL;
message->toType = msginfo->targetType;
message->toIdx = msginfo->targetIdx;
message->sendTime = g_globalTime;
message->receiveTime = g_globalTime;
message->worldIdx = pMonster->worldIdx;
message->repeatNum = 0;
message->data[MSG_AFFDATA_AFFECT_TYPE] = affinfo->type;
message->data[MSG_AFFDATA_AFFECT_HITTYPE] = affinfo->affectType;
message->data[MSG_AFFDATA_LEVEL] = affinfo->level;
message->data[MSG_AFFDATA_KEEPTIME] = affinfo->keepTime;
message->data[MSG_AFFDATA_SKILLTABLEIDX] = affinfo->skillTableIdx;
message->data[MSG_AFFDATA_HITRATE] = affinfo->hitRate;
if( affinfo->affectType == MSGINFO_AFF_TYPE_NORMAL )
message->data[MSG_AFFDATA_HITRATE] = 100;
for( int i = 0; i < MAX_COUNT_AFFECT_DATA; i ++ )
{
message->data[i + CONVERT_MSG_TO_AFFECT_SIZE] = affinfo->data[i];
}
}
| C++ |
#pragma warning(disable:4786)
#include "../global.h"
#define MAX_RANGE_ATTACK_TARGET 5
int AI_SendMessageToPC( playerCharacter_t* pc, message_t* message )
{
if( pc->messageNumber >= MAX_NUMBER_OF_MESSAGE ) return 0;
if( pc->messageNumber < 0 ) pc->messageNumber = 0;
if( pc->worldIdx != message->worldIdx ) return 0;
if( message->fromType == ENTITY_PC && message->type == MSG_DAMEGED )
{
if( !( g_pc[message->fromIdx].pvpMode && pc->pvpMode ) )
{
if( !InTargetList( &g_pc[message->fromIdx], pc->name ) ) return 0;
}
if( !PC_IsValidAttack( &g_pc[message->fromIdx], pc->entityType, pc->idx ) )
{
g_pc[message->fromIdx].resultValid = false;
return 0;
}
}
int n = pc->messageNumber;
memcpy( &pc->message[n], message, sizeof( message_t ) );
pc->message[n].toType = ENTITY_PC;
pc->message[n].toIdx = pc->idx;
strncpy(pc->message[n].toNameV2,pc->name,NAMESTRING);
pc->message[n].toNameV2[NAMESTRING]=NULL;
pc->messageNumber ++;
return 1;
}
int AI_SendMessageToMONSTER( monsterCharacter_t* monster, message_t* message )
{
if( monster->messageNumber >= MAX_NUMBER_OF_MESSAGE ) return 0;
if( monster->messageNumber < 0 ) monster->messageNumber = 0;
if( monster->worldIdx != message->worldIdx ) return 0;
if( message->fromType == ENTITY_PC && message->type == MSG_DAMEGED )
{
if( monster->aliveState != MON_ALIVE_STATE_NORMAL ) return 0;
if( !PC_IsValidAttack( &g_pc[message->fromIdx], monster->entityType, monster->idx ) )
{
g_pc[message->fromIdx].resultValid = false;
return 0;
}
}
int n = monster->messageNumber;
memcpy( &monster->message[n], message, sizeof( message_t ) );
monster->message[n].toType = ENTITY_MONSTER;
monster->message[n].toIdx = monster->idx;
strncpy( monster->message[n].toNameV2, monster->basic.name,NAMESTRING);
monster->message[n].toNameV2[NAMESTRING]=NULL;
monster->messageNumber ++;
return 1;
}
#define MAX_ATTACK_NUMBER 32
void AI_SendMessage( message_t* message, CAISendMessage *pAIMsg)
{
int i, worldIdx, n = 0;
int idx, idxBuffer[MAX_ATTACK_NUMBER];
int exceptType = -1, exceptIdx = -1;
vec3_t position;
for(int k=0;k<MAX_ATTACK_NUMBER;k++)
{
idxBuffer[k]=-1;
}
CAISendMessage AIMsg;
if(pAIMsg)
{
AIMsg = *pAIMsg;
}
if( message->fromType == ENTITY_PC )
{
if( !g_pc[message->fromIdx].active) return;
if( !g_pc[message->fromIdx].alive )
{
if(!g_SkillItem.IsType_UseSkillID(message->data[MSG_SKILL_TABLE_INDEX],CSkillItem::ITEM_TYPE_ENABLE_DEAD_SELF_ITEM)) return;
}
g_pc[message->fromIdx].resultValid = true;
}
if( AIMsg.range == 0 )
{
switch( message->toType )
{
case ENTITY_PC :
{
if( g_pc[message->toIdx].active && g_pc[message->toIdx].ready )
{
AI_SendMessageToPC( &g_pc[message->toIdx], message );
}
}
break;
case ENTITY_MONSTER : case ENTITY_NPC :
{
if( g_monster[message->toIdx].active )
{
AI_SendMessageToMONSTER( &g_monster[message->toIdx], message );
}
}
break;
}
return;
}
switch( AIMsg.rangeType )
{
case MSG_RANGE_TYPE_TARGET :
case MSG_RANGE_TYPE_EXCEPT_TARGET :
case MSG_RANGE_TYPE_EXCEPT_PARTY:
{
switch( message->toType )
{
case ENTITY_PC :
{
worldIdx = g_pc[message->toIdx].worldIdx;
vec_copy( g_pc[message->toIdx].position, position );
}
break;
case ENTITY_MONSTER : case ENTITY_NPC :
{
worldIdx = g_monster[message->toIdx].worldIdx;
vec_copy( g_monster[message->toIdx].position, position );
}
break;
default :
return;
break;
}
}
break;
case MSG_RANGE_TYPE_MYSELF :
{
switch( message->fromType )
{
case ENTITY_PC :
{
worldIdx = g_pc[message->fromIdx].worldIdx;
vec_copy( g_pc[message->fromIdx].position, position );
}
break;
case ENTITY_MONSTER : case ENTITY_NPC :
{
worldIdx = g_monster[message->fromIdx].worldIdx;
vec_copy( g_monster[message->fromIdx].position, position );
}
break;
default :
return;
break;
}
}
break;
}
if( AIMsg.basePosition != NULL &&
AIMsg.rangeType != MSG_RANGE_TYPE_MYSELF &&
AIMsg.rangeType != MSG_RANGE_TYPE_TARGET &&
message->data[MSG_ATKDATA_ETC_INFO] != MSGINFO_ATK_ETC_DEC_DAMAGE_AS_TARGET_NUMBER &&
message->data[MSG_ATKDATA_ETC_INFO] != MSGINFO_ATK_ETC_DEC_DAMAGE_AS_TARGET_100_ELSE_LITE_DAMAGE)
{
vec_copy( AIMsg.basePosition, position );
}
if( AIMsg.rangeType == MSG_RANGE_TYPE_EXCEPT_TARGET )
{
exceptType = message->toType;
exceptIdx = message->toIdx;
}
switch( message->toType )
{
case ENTITY_PC :
{
GTH_GetPCListInValidRange( worldIdx, position );
if (g_zonePCListNumber < 1) return;
for( i = 0; i < g_zonePCListNumber; i ++ )
{
if ( (int)g_zonePCList[i].distance < AIMsg.range || AIMsg.range == SENDALL_RANGE )
{
idx = g_zonePCList[i].idx;
if( exceptType == ENTITY_PC && exceptIdx == idx ) continue;
if( message->fromType == ENTITY_PC && message->type == MSG_DAMEGED)
{
if(idx ==message->fromIdx) continue;
if(message->fromType == MSG_RANGE_TYPE_EXCEPT_PARTY)
{
if(g_SkillPartyProc.IfPartyMember(message->fromIdx, idx))
{
continue;
}
}
}
if ( g_pc[idx].alive && g_pc[idx].ready )
{
if( message->data[MSG_ATKDATA_ETC_INFO] == MSGINFO_ATK_ETC_DEC_DAMAGE_AS_TARGET_NUMBER )
{
idxBuffer[n] = idx;
n ++;
if( n >= MAX_ATTACK_NUMBER ) break;
}
else
{
if( AI_SendMessageToPC( &g_pc[idx], message ) ) n ++;
}
}
}
if( n > AIMsg.maxMsgNumber && AIMsg.maxMsgNumber > 0 ) break;
}
if( message->data[MSG_ATKDATA_ETC_INFO] == MSGINFO_ATK_ETC_DEC_DAMAGE_AS_TARGET_NUMBER && n > 0 )
{
message->data[MSG_ATKDATA_PHYSIC_DMG] /= n;
for( i = 0; i < n; i ++ )
{
AI_SendMessageToPC( &g_pc[idxBuffer[i]], message );
}
}
}
break;
case ENTITY_MONSTER :
{
GTH_GetMonsterListInValidRange( worldIdx, position);
if (g_zoneMonsterListNumber < 1) return;
for( i = 0; i < g_zoneMonsterListNumber; i ++ )
{
if ( (int)g_zoneMonsterList[i].distance < AIMsg.range || AIMsg.range == SENDALL_RANGE )
{
idx = g_zoneMonsterList[i].idx;
if( exceptType == ENTITY_MONSTER && exceptIdx == idx ) continue;
if( message->fromType == ENTITY_MONSTER && idx == message->fromIdx )
{
if( message->type == MSG_DAMEGED ) continue;
}
if( g_monster[idx].active && g_monster[idx].aliveState == MON_ALIVE_STATE_NORMAL)
{
if( message->data[MSG_ATKDATA_ETC_INFO] == MSGINFO_ATK_ETC_DEC_DAMAGE_AS_TARGET_NUMBER ||
message->data[MSG_ATKDATA_ETC_INFO] == MSGINFO_ATK_ETC_DEC_DAMAGE_AS_TARGET_100_ELSE_LITE_DAMAGE)
{
idxBuffer[n] = idx;
n ++;
if( n >= MAX_ATTACK_NUMBER ) break;
}
else
{
if( AI_SendMessageToMONSTER( &g_monster[idx], message ) ) n ++;
}
}
if( n > AIMsg.maxMsgNumber && AIMsg.maxMsgNumber > 0 ) break;
}
}
if( message->data[MSG_ATKDATA_ETC_INFO] == MSGINFO_ATK_ETC_DEC_DAMAGE_AS_TARGET_NUMBER && n > 0 )
{
message->data[MSG_ATKDATA_PHYSIC_DMG] /= n;
for( i = 0; i < n; i ++ )
{
AI_SendMessageToMONSTER( &g_monster[idxBuffer[i]], message );
}
}
else if(message->data[MSG_ATKDATA_ETC_INFO] == MSGINFO_ATK_ETC_DEC_DAMAGE_AS_TARGET_100_ELSE_LITE_DAMAGE && n > 0 )
{
float fDamageRatio =1.0f;
CStr_Skill_Msg *msg = AIMsg.m_pSkillMsg;
if(msg != NULL)
{
fDamageRatio = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_DAMAGE_TARGET_100_ELSE_LITE_DAMAGE,msg);
}
for( i = 0; i < n; i ++ )
{
if(message->toIdx == idxBuffer[i])
{
if(SAFE_MONSTER(idxBuffer[i]))
AI_SendMessageToMONSTER( &g_monster[idxBuffer[i]], message );
}
else
{
message->data[MSG_ATKDATA_PHYSIC_DMG] *= fDamageRatio;
if(SAFE_MONSTER(idxBuffer[i]))
AI_SendMessageToMONSTER( &g_monster[idxBuffer[i]], message );
}
}
}
}
break;
case ENTITY_NPC :
{
GTH_GetNPCListInValidRange( worldIdx, position);
if (g_zoneNPCListNumber < 1) return;
for( i = 0; i < g_zoneNPCListNumber; i ++ )
{
if ( (int)g_zoneNPCList[i].distance < AIMsg.range || AIMsg.range == SENDALL_RANGE )
{
idx = g_zoneNPCList[i].idx;
if( exceptType == ENTITY_NPC && exceptIdx == idx ) continue;
if( message->fromType == ENTITY_NPC && idx == message->fromIdx )
{
if( message->type == MSG_DAMEGED ) continue;
}
if( g_monster[idx].active )
{
if( message->data[MSG_ATKDATA_ETC_INFO] == MSGINFO_ATK_ETC_DEC_DAMAGE_AS_TARGET_NUMBER )
{
idxBuffer[n] = idx;
n ++;
if( n >= MAX_ATTACK_NUMBER ) break;
}
else
{
if( AI_SendMessageToMONSTER( &g_monster[idx], message ) ) n ++;
}
}
if( n > AIMsg.maxMsgNumber && AIMsg.maxMsgNumber > 0 ) break;
}
}
if( message->data[MSG_ATKDATA_ETC_INFO] == MSGINFO_ATK_ETC_DEC_DAMAGE_AS_TARGET_NUMBER && n > 0 )
{
message->data[MSG_ATKDATA_PHYSIC_DMG] /= n;
for( i = 0; i < n; i ++ )
{
AI_SendMessageToMONSTER( &g_monster[idxBuffer[i]], message );
}
}
}
break;
}
return;
}
void AI_ReceiveMessage( monsterCharacter_t* monster )
{
int i = 0, n;
n = monster->messageNumber;
while( i < n )
{
if( monster->message[i].receiveTime <= g_globalTime )
{
if( monster->message[i].worldIdx == monster->worldIdx)
{
if( !AI_InterpretMessage( monster, &monster->message[i] ) )
{
AI_InitMessage( monster );
return;
}
}
if( monster->message[i].repeatNum <= 0 )
{
if( i < n - 1 )
{
memcpy( &monster->message[i], &monster->message[n - 1], sizeof( message_t ) );
}
n --;
monster->messageNumber --;
}
}
else i ++;
}
}
void AI_ReceiveMessage( playerCharacter_t* pc )
{
int i = 0, n;
n = pc->messageNumber;
while( i < n )
{
if( pc->message[i].receiveTime <= g_globalTime )
{
if( pc->message[i].worldIdx == pc->worldIdx && !stricmp( pc->name, pc->message[i].toNameV2 ) )
{
if( !AI_InterpretMessage( pc, &pc->message[i] ) )
{
AI_InitMessage( pc );
return;
}
}
if( pc->message[i].repeatNum <= 0 )
{
if( i < n - 1 )
{
memcpy( &pc->message[i], &pc->message[n - 1], sizeof( message_t ) );
}
n --;
pc->messageNumber --;
}
}
else i ++;
}
}
void AI_InitMessage( playerCharacter_t* pc )
{
int i;
for( i = 0; i < MAX_NUMBER_OF_MESSAGE; i ++ )
memset( &pc->message[i], 0, sizeof( message_t ) );
pc->messageNumber = 0;
if ( pc->worldIdx != DAN_BATTLEMAP_NO )
GTH_DeleteAffectAll( pc, ENTITY_PC );
else
{
if ( g_pDanBattleManager != NULL)
{
if ( g_pDanBattleManager->GetStatus() == DBTL_STATUS_EVENT )
{
GTH_DeleteAffectAll( pc, ENTITY_PC );
}
}
}
for( i = 0; i < MAX_COUNT_TRAIN_MONSTER; i ++ )
{
pc->trainMonsterIdx[i] = -1;
pc->trainMonsterTime[i] = 0;
}
pc->numTrainMonster = 0;
}
void AI_InitMessage( monsterCharacter_t* monster )
{
int i;
for( i = 0; i < MAX_NUMBER_OF_MESSAGE; i ++ )
memset( &monster->message[i], 0, sizeof( message_t ) );
monster->messageNumber = 0;
for ( i = 0; i < MAX_AFFECT; i++ )
{
memset( &monster->affect[i], 0, sizeof( affect_t ) );
monster->affect[i].type = AFFECT_NONE;
}
monster->affectNumber = 0;
}
| C++ |
#include <VECTOR>
#include <algorithm>
#include "global.h"
CEntityListMng::CEntityListMng()
{
ZeroMemory ( m_entityPCList, sizeof ( m_entityPCList ) );
for( int i = 0; i < MAX_NUMBER_OF_ENTITY_PCLIST; ++i )
{
m_entityPCList[i].idx = -1;
}
m_vEntityPCList.reserve (MAX_NUMBER_OF_ENTITY_PCLIST) ;
}
CEntityListMng::~CEntityListMng()
{
m_vEntityPCList.clear ();
}
void CEntityListMng::MakePCList( playerCharacter_t *pc, entityPCList_t *pl )
{
ZeroMemory ( pl, sizeof ( entityPCList_t ) );
pl->idx = 0;
pl->serverIdx = g_config.gameServerNo;
pl->idxOnServer = pc->idx;
pl->serverGroupID = pc->serverGroupID;
pl->characterID = pc->characterID;
strncpy( pl->userID, pc->userID, NAMESTRING );
strncpy( pl->name, pc->name, NAMESTRING );
pl->worldIdx = pc->worldIdx;
pl->job = pc->pcJob;
pl->level = pc->level;
}
int CEntityListMng::FindPCList( entityPCList_t *pl )
{
if ( !g_config.isManager || pl->userID[0] == 0 ) return -1;
VECTOR_ENTITYPCLIST_STRUCT::iterator itor;
for( itor = m_vEntityPCList.begin(); itor != m_vEntityPCList.end(); ++itor )
{
if( ( !stricmp( (*itor)->userID, pl->userID ) ) &&
( (*itor)->serverGroupID == pl->serverGroupID ) &&
( (*itor)->characterID == pl->characterID ) ) return (*itor)->idx;
}
return -1;
}
int CEntityListMng::FindPCList ( char *name, entityPCList_t *pl )
{
if ( name[0] == 0 ) return -1 ;
VECTOR_ENTITYPCLIST_STRUCT::iterator itor;
for( itor = m_vEntityPCList.begin(); itor != m_vEntityPCList.end(); ++itor )
{
if ( !stricmp ( name, (*itor)->name ) )
{
ZeroMemory ( pl, sizeof ( entityPCList_t ) );
memcpy ( pl, *itor, sizeof ( entityPCList_t ) );
return (*itor)->idx ;
}
}
return -1 ;
}
void CEntityListMng::AddPCList( entityPCList_t *pl )
{
if( g_config.isManager )
{
int emptyIdx = FindEmptyPCList();
if( FindPCList( pl ) >= 0 )
{
return;
}
if( emptyIdx < 0 )
{
return;
}
pl->idx = emptyIdx;
memcpy( &m_entityPCList[emptyIdx], pl, sizeof( entityPCList_t ) );
m_vEntityPCList.push_back( &m_entityPCList[emptyIdx] );
}
else
{
GTH_SendMessage_PCList_Request_Add( pl );
}
}
void CEntityListMng::DeletePCList( entityPCList_t *pl )
{
if( g_config.isManager )
{
int pcIdx = FindPCList( pl );
if( pcIdx < 0 )
{
return;
}
m_vEntityPCList.erase( std::find( m_vEntityPCList.begin(), m_vEntityPCList.end(), &m_entityPCList[pcIdx] ) );
m_entityPCList[pcIdx].idx = -1;
}
else
{
GTH_SendMessage_PCList_Request_Delete( pl );
}
}
void CEntityListMng::UpdatePCList( entityPCList_t *pl )
{
if( g_config.isManager )
{
int pcIdx = FindPCList( pl );
if( pcIdx < 0 )
{
return;
}
memcpy( &m_entityPCList[pcIdx], pl, sizeof( entityPCList_t ) );
m_entityPCList[pcIdx].idx = pcIdx;
}
else
{
GTH_SendMessage_PCList_Request_Update( pl );
}
}
| C++ |
#if !defined(AFX_CHECKSUM_H__25AE8BA5_981D_4BF5_B9FA_CB7B5259ECE3__INCLUDED_)
#define AFX_CHECKSUM_H__25AE8BA5_981D_4BF5_B9FA_CB7B5259ECE3__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include <windows.h>
class checksum {
public:
checksum() { clear(); }
void clear() { sum = 0; r = 55665; c1 = 52845; c2 = 22719;}
void add(DWORD w);
void add(BOOL w) { add((DWORD)w); }
void add(UINT w) { add((DWORD)w); }
void add(WORD w);
void add(LPBYTE b, UINT length);
void add(BYTE b);
DWORD get() { return sum; }
protected:
WORD r;
WORD c1;
WORD c2;
DWORD sum;
};
#endif
| C++ |
#include "netlib.h"
#include "queue.h"
CSendingQueue::CSendingQueue()
{
m_first = 0;
m_last = -1;
m_count = 0;
m_size = SENDING_QUEUE_SIZE;
m_overflow = false;
m_maxCount = 0;
memset( m_queue , 0 , sizeof(i3packetqueue_t) * SENDING_QUEUE_SIZE );
}
CSendingQueue::~CSendingQueue()
{
}
int CSendingQueue::Push (int socket, byte *buf, int len, struct sockaddr_in *addr)
{
if (m_count >= m_size)
{
m_overflow = true;
return 0;
}
if (m_last < m_size - 1)
m_last ++;
else
m_last = 0;
m_queue[m_last].socket = socket;
m_queue[m_last].len = len;
memcpy( &m_queue[m_last].packet, buf, len );
memcpy( &m_queue[m_last].addr, addr, sizeof(sockaddr_in) );
m_count ++;
if (m_count > m_maxCount)
m_maxCount = m_count;
return 1;
}
int CSendingQueue::Pop (int *socket, byte *buf, int *len, struct sockaddr_in *addr)
{
if (m_count <= 0)
{
return 0;
}
*socket = m_queue[m_first].socket;
*len = m_queue[m_first].len;
memcpy( buf, &m_queue[m_first].packet, m_queue[m_first].len );
memcpy( addr, &m_queue[m_first].addr, sizeof(sockaddr_in) );
if (m_first < m_size - 1)
m_first ++;
else
m_first = 0;
m_count --;
return 1;
}
void CSendingQueue::Clear()
{
CSendingQueue();
}
CReceivingQueue::CReceivingQueue()
{
m_first = 0;
m_last = -1;
m_count = 0;
m_size = RECEIVING_QUEUE_SIZE;
m_overflow = false;
m_maxCount = 0;
memset( m_queue , 0 , sizeof(i3packetqueue_t) * RECEIVING_QUEUE_SIZE );
}
CReceivingQueue::~CReceivingQueue()
{
}
int CReceivingQueue::Push (int socket, byte *buf, int len, struct sockaddr_in *addr)
{
if (m_count >= m_size)
{
m_overflow = true;
return 0;
}
if (m_last < m_size - 1)
m_last ++;
else
m_last = 0;
m_queue[m_last].socket = socket;
m_queue[m_last].len = len;
memcpy( &m_queue[m_last].packet, buf, len );
memcpy( &m_queue[m_last].addr, addr, sizeof(sockaddr_in) );
m_count ++;
if (m_count > m_maxCount)
m_maxCount = m_count;
return 1;
}
int CReceivingQueue::Pop (int *socket, byte *buf, int *len, struct sockaddr_in *addr)
{
if (m_count <= 0)
{
return 0;
}
*socket = m_queue[m_first].socket;
*len = m_queue[m_first].len;
memcpy( buf, &m_queue[m_first].packet, m_queue[m_first].len );
memcpy( addr, &m_queue[m_first].addr, sizeof(sockaddr_in) );
if (m_first < m_size - 1)
m_first ++;
else
m_first = 0;
m_count --;
return 1;
}
void CReceivingQueue::Clear()
{
CReceivingQueue();
}
| C++ |
#include "netlib.h"
#include "queue.h"
#include <time.h>
extern i3sizebuf_t netMessage;
extern i3sizebuf_t recvMessage;
extern int msgReadCount;
extern int msgBadRead;
extern int readSizePerSecond;
extern CRITICAL_SECTION spCrit;
void MSG_BeginWriting(i3sizebuf_t* )
{
EnterCriticalSection( &spCrit );
}
void MSG_EndWriting(i3sizebuf_t* )
{
LeaveCriticalSection( &spCrit );
}
void MSG_Clear( i3sizebuf_t *sb )
{
SZ_Clear( sb );
}
void MSG_WriteChar (i3sizebuf_t *sb, int c)
{
byte *buf;
buf = SZ_GetSpace (sb, 1);
buf[0] = c;
}
void MSG_WriteByte (i3sizebuf_t *sb, int c)
{
byte *buf;
buf = SZ_GetSpace (sb, 1);
buf[0] = c;
}
void MSG_WriteShort (i3sizebuf_t *sb, int c)
{
byte *buf;
buf = SZ_GetSpace (sb, 2);
buf[0] = c&0xff;
buf[1] = c>>8;
}
void MSG_WriteLong (i3sizebuf_t *sb, int c)
{
byte *buf;
buf = SZ_GetSpace (sb, 4);
buf[0] = c&0xff;
buf[1] = (c>>8)&0xff;
buf[2] = (c>>16)&0xff;
buf[3] = c>>24;
}
void MSG_Write64Int (i3sizebuf_t *sb, __int64 in_n64Value)
{
byte *pBuffer;
pBuffer = SZ_GetSpace (sb, 8);
pBuffer[0] = (in_n64Value>>0) & 0xff;
pBuffer[1] = (in_n64Value>>8) & 0xff;
pBuffer[2] = (in_n64Value>>16) & 0xff;
pBuffer[3] = (in_n64Value>>24) & 0xff;
pBuffer[4] = (in_n64Value>>32) & 0xff;
pBuffer[5] = (in_n64Value>>40) & 0xff;
pBuffer[6] = (in_n64Value>>48) & 0xff;
pBuffer[7] = (in_n64Value>>56) & 0xff;
}
void MSG_WriteString (i3sizebuf_t *sb, char *s)
{
if (!s)
SZ_Write (sb, "", 1);
else
SZ_Write (sb, s, strlen(s)+1);
}
void MSG_WriteFloat (i3sizebuf_t *sb, float f)
{
union
{
float f;
int l;
} dat;
dat.f = f;
SZ_Write (sb, &dat.l, 4);
}
void MSG_WriteAngle (i3sizebuf_t *sb, float f)
{
MSG_WriteByte (sb, ((int)f*256/360) & 255);
}
void MSG_WriteVector(i3sizebuf_t *sb, vec3_t v)
{
MSG_WriteFloat(sb, v[0]);
MSG_WriteFloat(sb, v[1]);
MSG_WriteFloat(sb, v[2]);
}
void MSG_ReadVector(vec3_t v)
{
readSizePerSecond += 16;
v[0] = MSG_ReadFloat();
v[1] = MSG_ReadFloat();
v[2] = MSG_ReadFloat();
}
void MSG_BeginReading (void)
{
msgReadCount = 0;
msgBadRead = false;
}
int MSG_ReadChar (void)
{
readSizePerSecond += 1;
int c;
if (msgReadCount+1 > recvMessage.cursize)
{
msgBadRead = true;
return -1;
}
c = (signed char)recvMessage.data[msgReadCount];
msgReadCount++;
return c;
}
int MSG_ReadByte (void)
{
readSizePerSecond += 1;
int c;
if (msgReadCount+1 > recvMessage.cursize)
{
msgBadRead = true;
return -1;
}
c = (unsigned char)recvMessage.data[msgReadCount];
msgReadCount++;
return c;
}
int MSG_ReadShort (void)
{
readSizePerSecond += 2;
int c;
if (msgReadCount+2 > recvMessage.cursize)
{
msgBadRead = true;
return -1;
}
c = (short)(recvMessage.data[msgReadCount]
+ (recvMessage.data[msgReadCount+1]<<8));
msgReadCount += 2;
return c;
}
int MSG_ReadLong (void)
{
readSizePerSecond += 4;
int c;
if (msgReadCount+4 > recvMessage.cursize)
{
msgBadRead = true;
return -1;
}
c = recvMessage.data[msgReadCount]
+ (recvMessage.data[msgReadCount+1]<<8)
+ (recvMessage.data[msgReadCount+2]<<16)
+ (recvMessage.data[msgReadCount+3]<<24);
msgReadCount += 4;
return c;
}
__int64 MSG_Read64Int (void)
{
readSizePerSecond += 8;
__int64 i64Value=0x00;;
if (msgReadCount+8 > recvMessage.cursize)
{
msgBadRead = true;
return -1;
}
i64Value =
((__int64)(recvMessage.data[msgReadCount+0])<<0)
+ ((__int64)(recvMessage.data[msgReadCount+1])<<8)
+ ((__int64)(recvMessage.data[msgReadCount+2])<<16)
+ ((__int64)(recvMessage.data[msgReadCount+3])<<24)
+ ((__int64)(recvMessage.data[msgReadCount+3])<<32)
+ ((__int64)(recvMessage.data[msgReadCount+3])<<40)
+ ((__int64)(recvMessage.data[msgReadCount+3])<<48)
+ ((__int64)(recvMessage.data[msgReadCount+3])<<56);
msgReadCount += 8;
return i64Value;
}
char *MSG_ReadString (void)
{
static char string[2048];
int l,c;
l = 0;
do
{
c = MSG_ReadChar ();
if (c == -1 || c == 0)
break;
string[l] = c;
l++;
} while (l < sizeof(string)-1);
string[l] = 0;
readSizePerSecond += l;
return string;
}
float MSG_ReadFloat (void)
{
readSizePerSecond += 4;
union
{
byte b[4];
float f;
int l;
} dat;
dat.b[0] = recvMessage.data[msgReadCount];
dat.b[1] = recvMessage.data[msgReadCount+1];
dat.b[2] = recvMessage.data[msgReadCount+2];
dat.b[3] = recvMessage.data[msgReadCount+3];
msgReadCount += 4;
return dat.f;
}
float MSG_ReadAngle (void)
{
readSizePerSecond += 1;
return float( MSG_ReadByte() * (360.0/256) );
}
void SZ_Clear (i3sizebuf_t *buf)
{
buf->cursize = 0;
buf->overwriting = 0;
}
unsigned char *SZ_GetSpace (i3sizebuf_t *buf, int length)
{
unsigned char *data;
if (buf->cursize + length > buf->maxsize)
{
buf->overflowed = true;
SZ_Clear (buf);
}
data = buf->data + buf->cursize;
buf->cursize += length;
return data;
}
void SZ_Write (i3sizebuf_t *buf, void *data, int length)
{
memcpy (SZ_GetSpace(buf,length),data,length);
}
void SZ_Alloc (i3sizebuf_t *buf, int startsize)
{
buf->maxsize = startsize;
buf->cursize = 0;
buf->overwriting = 0;
}
void SZ_Free (i3sizebuf_t *buf)
{
buf->cursize = 0;
buf->overwriting = 0;
}
void SZ_Load (i3sizebuf_t *buf, void *data)
{
memcpy (data, buf->data, buf->cursize);
}
| C++ |
#ifndef _NETLIB_H_
#define _NETLIB_H_
#pragma warning( disable : 4786 )
#pragma warning( disable : 4251 )
#define NETLIB_VERSION "03.10.03"
#include <stdio.h>
#include <math.h>
#include <ctime>
#include <map>
#include <stack>
#include <winsock.h>
#define _COMPILE_FOR_SERVER
#ifdef _COMPILE_FOR_SERVER
#define _USE_SENDING_THREAD
#define _USE_RECEIVING_THREAD
#endif
#define NET_MAXMESSAGE 8192
#define MAX_DATAGRAM 1024
#define NET_HEADERSIZE (sizeof(unsigned int) + sizeof(unsigned int) + sizeof(unsigned int) +sizeof(unsigned short) )
#define NET_DATAGRAMSIZE (MAX_DATAGRAM + NET_HEADERSIZE)
#define NET_MAXWAITINGMESSAGE 8
#define NETFLAG_LENGTH_MASK 0x0fff
#define NETFLAG_SOM 1 << 0
#define NETFLAG_RELIABLE 1 << 1
#define NETFLAG_ACK 1 << 2
#define NETFLAG_EOM 1 << 3
#define NETFLAG_ENCRYPT 1 << 0
#define NETFLAG_ENCRYPT_CHECKSUM 0X7FFFFFFF
#define NET_RESENDTIME 800
#define NET_MAXIMUM_PACKETMAP_SIZE 100
#define NET_SENDTIME_UNRELIABLE 0
#define MAX_ERROR_PACKETNUM 20
#define MAXHOSTNAMELEN 256
#define MAX_CHANNELS 20
typedef float vec3_t[3];
typedef struct
{
int allowoverflow;
int overflowed;
byte data[NET_MAXMESSAGE];
int maxsize;
int cursize;
int overwriting;
} i3sizebuf_t;
#pragma pack ( push , 1 )
typedef struct
{
unsigned int sequence;
unsigned int encrypt: 1;
unsigned int checksum : 31;
unsigned int lastSendTime;
unsigned short length;
byte data[MAX_DATAGRAM];
} i3packet_t;
#pragma pack ( pop )
typedef std::map<UINT, i3packet_t*> PacketMap;
typedef PacketMap::iterator PacketMapItor;
typedef PacketMap::value_type PacketMapPair;
enum
{
SocketType_Reliable,
SocketType_Unreliable
};
enum
{
PacketBlock_None,
PacketBlock_Wait,
};
typedef struct i3socket_s
{
i3socket_s()
{
sendPacketMap = NULL;
recvPacketMap = NULL;
socket = INVALID_SOCKET;
socketType = SocketType_Reliable;
}
int socket;
int socketType;
unsigned int connecttime;
unsigned int lastReceiveTime;
unsigned int lastSendTime;
unsigned int latencyTime;
int disconnected;
int canSend;
int sendNext;
unsigned int resendSequence;
unsigned int ackSequence;
unsigned int sendSequence;
unsigned int unreliableSendSequence;
int sendMessageLength;
byte sendMessage [NET_MAXMESSAGE];
unsigned int receiveSequence;
unsigned int unreliableReceiveSequence;
int receiveMessageLength;
byte receiveMessage [NET_MAXMESSAGE];
int packetBlockSequence;
struct sockaddr_in addr;
PacketMap *sendPacketMap;
PacketMap *recvPacketMap;
} i3socket_t;
enum
{
PacketAnalysis_None = 0,
PacketAnalysis_Skip,
PacketAnalysis_Ack,
PacketAnalysis_Start,
};
void SZ_Write (i3sizebuf_t *buf, void *data, int length);
void SZ_Clear (i3sizebuf_t *buf);
void SZ_Alloc (i3sizebuf_t *buf, int startsize);
unsigned char *SZ_GetSpace (i3sizebuf_t *buf, int length);
void SZ_Load (i3sizebuf_t *buf, void *data);
void MSG_BeginWriting(i3sizebuf_t *sb);
void MSG_EndWriting(i3sizebuf_t *sb);
void MSG_Clear( i3sizebuf_t *sb );
void MSG_WriteChar (i3sizebuf_t *sb, int c);
void MSG_WriteByte (i3sizebuf_t *sb, int c);
void MSG_WriteShort (i3sizebuf_t *sb, int c);
void MSG_WriteLong (i3sizebuf_t *sb, int c);
void MSG_Write64Int (i3sizebuf_t *sb, __int64 in_n64Value);
void MSG_WriteFloat (i3sizebuf_t *sb, float f);
void MSG_WriteString (i3sizebuf_t *sb, char *s);
void MSG_WriteAngle (i3sizebuf_t *sb, float f);
void MSG_WriteVector(i3sizebuf_t *sb, vec3_t v);
void MSG_BeginReading (void);
int MSG_ReadChar (void);
int MSG_ReadByte (void);
int MSG_ReadShort (void);
int MSG_ReadLong (void);
__int64 MSG_Read64Int (void);
float MSG_ReadFloat (void);
char *MSG_ReadString (void);
float MSG_ReadAngle (void);
void MSG_ReadVector(vec3_t v);
int NET_AddrCompare (struct sockaddr *addr1, struct sockaddr *addr2);
char *NET_AddrToString (struct sockaddr *addr);
int NET_StringToAddr (char *string, struct sockaddr *addr);
char *NET_GetLocalAddress();
char *NET_GetHostName();
char *NET_AddrToIPString (struct sockaddr *addr);
int NET_SendPacket (i3socket_t *sock, i3sizebuf_t *data, BOOL encrypt = FALSE);
int NET_SendPacket_Unreliable(i3socket_t *sock, i3sizebuf_t *data, BOOL encrypt = FALSE);
int NET_ReadPacket(int *socket, byte *buf, struct sockaddr_in *addr);
int NET_ControlPacket(i3socket_t *sock, i3packet_t *packet);
int NET_ControlRecvBank( i3socket_t *sock );
int NET_ControlSendBank( i3socket_t *sock );
int NET_CheckSockProblem( i3socket_t *sock, int checkTime = -1 );
int NET_PreviewMessage(i3packet_t *p);
int NET_Write (int socket, byte *buf, int len, struct sockaddr_in *addr);
int NET_Read (int socket, byte *buf, int len, struct sockaddr_in *addr);
int NET_ReadFromReceivingQueue (int *socket, byte *buf, struct sockaddr_in *addr);
int NET_WriteToSendingQueue (int socket, byte *buf, int len, struct sockaddr_in *addr);
void NET_InitNetTime();
unsigned int NET_GetNetTime();
int NET_OpenNetwork();
void NET_InitPacketMap( i3socket_t *sock );
int NET_InitSocket(i3socket_t *sock, struct sockaddr_in *addr, int socket, int socketType );
int NET_OpenSocketForServer(i3socket_t *sock, char *serverIP, int port, int socketType = SocketType_Reliable );
int NET_OpenSocketForClient(i3socket_t *sock, char *serverIP, int port, int socketType = SocketType_Reliable );
void NET_CloseSocket(i3socket_t *sock);
void NET_ClearSocket(i3socket_t *sock);
void NET_CloseNetwork();
int NET_CreateSendingThread();
int NET_CreateReceivingThread();
void NET_DestroySendingThread();
void NET_DestroyReceivingThread();
DWORD WINAPI NET_SendingThread(LPVOID param);
DWORD WINAPI NET_ReceivingThread(LPVOID param);
char *NET_ErrorString ();
int NET_AddListenChannel( int socket );
int NET_DeleteListenChannel( int socket );
#define NET_SendMessage NET_SendPacket
#define NET_SendUnreliableMessage NET_SendPacket_Unreliable
void ErrorLog( char *filename, char* str, ... );
extern void TRACE(LPCTSTR lpszFormat, ...);
void Crypt(TCHAR *inp, DWORD inplen, TCHAR* key = "", DWORD keylen = 0);
#endif | C++ |
#include "netlib.h"
#include "queue.h"
#include <time.h>
extern i3sizebuf_t netMessage;
extern i3sizebuf_t recvMessage;
extern i3packet_t packetBuffer;
extern int totalPacketsSend;
extern int totalPacketsReceived;
extern int packetsSent;
extern int packetsReceived;
extern int packetsReSent;
extern int packetsDropCount;
extern int packetsDupCount;
extern int packetsAckSent;
extern int packetsAckReceived;
extern int un_packetsSent;
extern int un_packetsReceived;
extern int un_packetsDropCount;
extern unsigned int g_netTime;
extern unsigned int prevTime;
extern unsigned int curTime;
extern unsigned int g_globalTime;
extern int channel[ MAX_CHANNELS ];
extern int channelNumber;
extern HANDLE hThread;
extern DWORD SendingThreadID, ReceivingThreadID;
extern int runSendingThread, runReceivingThread;
extern CSendingQueue *sendingQueue;
extern CReceivingQueue *receivingQueue;
extern HANDLE hSQMutex, hRQMutex;
extern FILE *packetErrorLog;
extern int lastRecvSequence;
extern int myRecvSequence;
extern CRITICAL_SECTION spCrit;
using namespace std;
#include <string>
#include <vector>
#include "../CheckSum.h"
FILE *g_logFile;
vector<string> g_logFilename;
#include "../DebugInfo/vutil.h"
extern void ShowLogInfo(char *pszFmtMsg, ...);
int sendFirstWrite = true;
int recvFirstWrite = true;
int g_lastWriteSequence = -1;
void WriteCompletePacket( int idx, int type )
{
return;
int *firstwrite;
char filename[256];
char msg[128];
if( type == 0 )
{
strcpy( filename, "send.txt" );
firstwrite = &sendFirstWrite;
strcpy( msg, "-" );
}
else if( type == 1 )
{
strcpy( filename, "recv.txt" );
firstwrite = &recvFirstWrite;
strcpy( msg, "-" );
if( g_lastWriteSequence < 0 ) g_lastWriteSequence = idx;
else if( g_lastWriteSequence != idx )
{
int checkSequence = 1;
}
else g_lastWriteSequence = idx;
}
else if( type == 2 )
{
strcpy( filename, "recv.txt" );
firstwrite = &recvFirstWrite;
sprintf( msg, "dup : %d<%d", myRecvSequence, lastRecvSequence );
}
else if( type == 3 )
{
strcpy( filename, "recv.txt" );
firstwrite = &recvFirstWrite;
sprintf( msg, "drop : %d>%d", myRecvSequence, lastRecvSequence );
}
FILE *fp;
if( (*firstwrite) )
{
fp = fopen( filename, "wt" );
(*firstwrite) = false;
}
else
{
fp = fopen( filename, "at" );
}
fprintf( fp, "%s[%d]packet complete\n", msg, idx );
fclose( fp );
}
void NET_WriteErrorLog( char* str, struct sockaddr_in *addr )
{
return;
char cTime[32];
time_t logtime;
time( &logtime );
strcpy( cTime, ctime( &logtime ) );
cTime[24] = '\0';
#ifdef _COMPILE_FOR_SERVER
packetErrorLog = fopen( "net_error.txt", "at" );
#else
packetErrorLog = fopen( "../net_error.txt", "at" );
#endif
fprintf( packetErrorLog, "%s : %s(%s)\n", cTime, str, inet_ntoa( addr->sin_addr ) );
fclose( packetErrorLog );
}
int NET_AddrCompare (struct sockaddr *addr1, struct sockaddr *addr2)
{
if (addr1->sa_family != addr2->sa_family)
return -1;
if (((struct sockaddr_in *)addr1)->sin_addr.s_addr != ((struct sockaddr_in *)addr2)->sin_addr.s_addr)
return -1;
if (((struct sockaddr_in *)addr1)->sin_port != ((struct sockaddr_in *)addr2)->sin_port)
return 1;
return 0;
}
char *NET_AddrToString (struct sockaddr *addr)
{
static char buffer[22];
int haddr;
haddr = ntohl(((struct sockaddr_in *)addr)->sin_addr.s_addr);
sprintf(buffer, "%d.%d.%d.%d:%d", (haddr >> 24) & 0xff, (haddr >> 16) & 0xff, (haddr >> 8) & 0xff, haddr & 0xff, ntohs(((struct sockaddr_in *)addr)->sin_port));
return buffer;
}
int NET_StringToAddr (char *string, struct sockaddr *addr)
{
int ha1, ha2, ha3, ha4, hp;
int ipaddr;
sscanf(string, "%d.%d.%d.%d:%d", &ha1, &ha2, &ha3, &ha4, &hp);
ipaddr = (ha1 << 24) | (ha2 << 16) | (ha3 << 8) | ha4;
addr->sa_family = AF_INET;
((struct sockaddr_in *)addr)->sin_addr.s_addr = htonl(ipaddr);
((struct sockaddr_in *)addr)->sin_port = htons((unsigned short)hp);
return 0;
}
char *NET_GetLocalAddress()
{
struct hostent *hostEntry;
int haddr;
static char buffer[16];
char hostName[MAXHOSTNAMELEN];
if ( gethostname(hostName, MAXHOSTNAMELEN) == SOCKET_ERROR ) return NULL;
hostEntry = gethostbyname( hostName );
if (hostEntry == NULL) return NULL;
haddr = ntohl( *(int *)hostEntry->h_addr );
sprintf(buffer, "%d.%d.%d.%d", (haddr >> 24) & 0xff, (haddr >> 16) & 0xff, (haddr >> 8) & 0xff, haddr & 0xff);
return buffer;
}
char *NET_AddrToIPString (struct sockaddr *addr)
{
static char buffer[16];
int haddr;
haddr = ntohl(((struct sockaddr_in *)addr)->sin_addr.s_addr);
sprintf(buffer, "%d.%d.%d.%d", (haddr >> 24) & 0xff, (haddr >> 16) & 0xff, (haddr >> 8) & 0xff, haddr & 0xff);
return buffer;
}
char *NET_GetHostName()
{
static char hostNameString[MAXHOSTNAMELEN];
if ( gethostname(hostNameString, MAXHOSTNAMELEN) == SOCKET_ERROR ) return NULL;
return hostNameString;
}
void NET_ClearBank( PacketMap *pm )
{
for( PacketMapItor itor = pm->begin(); itor != pm->end(); ++itor )
{
if( ((*itor).second) == NULL ) continue;
delete ((*itor).second);
}
pm->clear();
}
int NET_InsertPacketBank( PacketMap *pm, i3packet_t *packet )
{
PacketMapItor itor = pm->find( packet->sequence );
i3packet_t *pk;
if( itor != pm->end() ) return false;
pk = new i3packet_t;
memcpy( pk, packet, sizeof( i3packet_t ) );
pm->insert( PacketMapPair( packet->sequence, pk ) );
return true;
}
int NET_DeletePacketBank( PacketMap *pm, UINT sequence )
{
PacketMapItor itor = pm->find( sequence );
if( itor == pm->end() ) return false;
delete (*itor).second;
pm->erase( itor );
return true;
}
int NET_SendPacket (i3socket_t *sock, i3sizebuf_t *data, BOOL bEncrypt)
{
unsigned int packetLen;
unsigned int dataLen;
byte som;
byte eom;
unsigned int encrypt = 0;
if (data->cursize == 0)
{
packetsDropCount++;
return 0;
}
if (data->cursize > NET_MAXMESSAGE)
{
packetsDropCount++;
return 0;
}
memcpy(sock->sendMessage, data->data, data->cursize);
sock->sendMessageLength = data->cursize;
som = 0xff;
while( 1 )
{
if (sock->sendMessageLength <= MAX_DATAGRAM)
{
dataLen = sock->sendMessageLength;
eom = NETFLAG_EOM;
som = 0;
}
else
{
dataLen = MAX_DATAGRAM;
eom = 0;
if( som == 0xff ) som = NETFLAG_SOM;
else som = 0;
}
packetLen = NET_HEADERSIZE + dataLen;
if( sock->socketType == SocketType_Reliable)
packetBuffer.length = ((NETFLAG_RELIABLE | eom) << 12) | packetLen;
else
packetBuffer.length = ((NETFLAG_RELIABLE | eom | som) << 12) | packetLen;
packetBuffer.sequence = sock->sendSequence++;
packetBuffer.lastSendTime = g_netTime;
packetBuffer.encrypt = bEncrypt;
memcpy( packetBuffer.data, sock->sendMessage, dataLen );
if (bEncrypt == TRUE)
{
Crypt((TCHAR*)packetBuffer.data, dataLen);
checksum packetsum;
packetsum.clear();
packetsum.add((BYTE*)packetBuffer.data, dataLen);
packetBuffer.checksum = packetsum.get();
}
if( sock->sendPacketMap != NULL )
{
if( sock->socketType == SocketType_Reliable ) NET_InsertPacketBank( sock->sendPacketMap, &packetBuffer );
}
#ifndef _USE_SENDING_THREAD
if (NET_Write(sock->socket, (byte *)&packetBuffer, packetLen, &sock->addr) == -1)
#else
if (NET_WriteToSendingQueue(sock->socket, (byte *)&packetBuffer, packetLen, &sock->addr) == -1)
#endif
return -1;
sock->lastSendTime = NET_GetNetTime();
totalPacketsSend ++;
packetsSent ++;
if( eom != 0 ) break;
sock->sendMessageLength -= MAX_DATAGRAM;
memcpy( sock->sendMessage, sock->sendMessage+MAX_DATAGRAM, sock->sendMessageLength );
}
return 1;
}
int NET_SendPacket_Unreliable(i3socket_t *sock, i3sizebuf_t *data, BOOL bEncrypt)
{
if( sock->socketType == SocketType_Unreliable )
{
return( NET_SendPacket( sock, data ) );
}
unsigned int packetLen;
unsigned int dataLen;
byte eom;
if (data->cursize == 0)
{
un_packetsDropCount++;
return 0;
}
if (data->cursize > MAX_DATAGRAM)
{
un_packetsDropCount++;
return 0;
}
memcpy(sock->sendMessage, data->data, data->cursize);
sock->sendMessageLength = data->cursize;
dataLen = sock->sendMessageLength;
eom = NETFLAG_EOM;
packetLen = NET_HEADERSIZE + dataLen;
packetBuffer.length = ((NETFLAG_RELIABLE | eom) << 12) | packetLen;
packetBuffer.sequence = sock->unreliableSendSequence ++;
packetBuffer.lastSendTime = NET_SENDTIME_UNRELIABLE;
unsigned int CheckSum = 0;
packetBuffer.encrypt = bEncrypt;
memcpy( packetBuffer.data, sock->sendMessage, dataLen );
if (bEncrypt == TRUE)
{
Crypt((TCHAR*)packetBuffer.data, dataLen);
checksum packetsum;
packetsum.clear();
packetsum.add((BYTE*)packetBuffer.data, dataLen);
packetBuffer.checksum = packetsum.get();
}
#ifndef _USE_SENDING_THREAD
if (NET_Write(sock->socket, (byte *)&packetBuffer, packetLen, &sock->addr) == -1)
#else
if (NET_WriteToSendingQueue(sock->socket, (byte *)&packetBuffer, packetLen, &sock->addr) == -1)
#endif
return -1;
sock->lastSendTime = NET_GetNetTime();
totalPacketsSend ++;
un_packetsSent ++;
return 1;
}
int NET_ControlSendBank( i3socket_t *sock )
{
int packetLen;
if( sock->sendPacketMap == NULL ) return 0;
if( sock->sendPacketMap->empty() ) return 0;
int sendSize = sock->sendPacketMap->size();
i3packet_t *packet;
for( PacketMapItor itor = sock->sendPacketMap->begin(); itor != sock->sendPacketMap->end(); ++itor )
{
if( g_netTime - ((*itor).second)->lastSendTime < NET_RESENDTIME ) continue;
packet = (*itor).second;
packet->lastSendTime = g_netTime;
packetLen = ( packet->length & NETFLAG_LENGTH_MASK );
packetsReSent ++;
totalPacketsSend ++;
#ifndef _USE_SENDING_THREAD
if (NET_Write(sock->socket, (byte *)packet, packetLen, &sock->addr) == -1)
#else
if (NET_WriteToSendingQueue(sock->socket, (byte *)packet, packetLen, &sock->addr) == -1)
#endif
return -1;
}
return 1;
}
int NET_ControlRecvBank( i3socket_t *sock )
{
if( sock->recvPacketMap == NULL ) return false;
if( sock->recvPacketMap->empty() ) return false;
i3packet_t packet;
unsigned int length;
unsigned int flags;
unsigned int sequence;
int recvSize = sock->recvPacketMap->size();
while( 1 )
{
for( PacketMapItor itor = sock->recvPacketMap->begin(); itor != sock->recvPacketMap->end(); ++itor )
{
if( ((*itor).second)->sequence != sock->receiveSequence ) continue;
break;
}
if( itor == sock->recvPacketMap->end() || sock->recvPacketMap->size() == 0 ) return false;
memcpy( &packet, (*itor).second, sizeof( i3packet_t ) );
NET_DeletePacketBank( sock->recvPacketMap, packet.sequence );
length = packet.length & NETFLAG_LENGTH_MASK;
flags = packet.length >> 12;
sequence = packet.sequence;
length -= NET_HEADERSIZE;
sock->receiveSequence++;
memcpy(sock->receiveMessage + sock->receiveMessageLength, packet.data, length);
sock->receiveMessageLength += length;
if (flags & NETFLAG_EOM)
{
SZ_Clear(&recvMessage);
SZ_Write(&recvMessage, sock->receiveMessage, sock->receiveMessageLength);
sock->receiveMessageLength = 0;
return true;
}
}
return false;
}
int NET_ControlPacket_ReliableSocket( i3socket_t *sock, i3packet_t *packet )
{
unsigned int length;
unsigned int flags;
unsigned int sequence;
i3packet_t ackPacket;
int ret = PacketAnalysis_Skip;
int count;
sock->lastReceiveTime = g_netTime;
length = packet->length & NETFLAG_LENGTH_MASK;
flags = packet->length >> 12;
sequence = packet->sequence;
memset( &ackPacket, 0, sizeof( i3packet_t ) );
totalPacketsReceived ++;
if( flags & NETFLAG_ACK )
{
packetsAckReceived ++;
if( sock->sendPacketMap != NULL ) NET_DeletePacketBank( sock->sendPacketMap, sequence );
sock->latencyTime = sock->lastReceiveTime - sock->lastSendTime;
return ret = PacketAnalysis_Ack;
}
UINT DataSize = length - NET_HEADERSIZE;
if ( packet->encrypt )
{
checksum packetsum;
packetsum.clear();
packetsum.add((BYTE*)packetBuffer.data, DataSize);
if ( packetBuffer.checksum != packetsum.get() )
{
packetsDupCount++;
ret = PacketAnalysis_Skip;
return ret;
}
Crypt((TCHAR*)packet->data, DataSize);
}
if (flags & NETFLAG_RELIABLE)
{
if( packet->lastSendTime != NET_SENDTIME_UNRELIABLE )
{
packetsReceived ++;
ackPacket.length = (NETFLAG_ACK << 12) | NET_HEADERSIZE;
ackPacket.sequence = sequence;
ackPacket.lastSendTime = g_netTime;
#ifndef _USE_SENDING_THREAD
NET_Write(sock->socket, (byte *)&ackPacket, NET_HEADERSIZE, &sock->addr);
#else
NET_WriteToSendingQueue(sock->socket, (byte *)&ackPacket, NET_HEADERSIZE, &sock->addr);
#endif
packetsAckSent ++;
lastRecvSequence = sequence;
myRecvSequence = sock->receiveSequence;
if( sequence == sock->receiveSequence )
{
if ( ( sock->receiveMessageLength + length ) >= NET_MAXMESSAGE )
{
ret = PacketAnalysis_Skip;
}
else
{
sock->receiveSequence++;
length -= NET_HEADERSIZE;
memcpy(sock->receiveMessage + sock->receiveMessageLength, packet->data, length);
sock->receiveMessageLength += length;
if (flags & NETFLAG_EOM)
{
SZ_Clear(&recvMessage);
SZ_Write(&recvMessage, sock->receiveMessage, sock->receiveMessageLength);
sock->receiveMessageLength = 0;
ret = PacketAnalysis_Start;
}
else
{
ret = PacketAnalysis_Skip;
}
}
}
else if( sequence < sock->receiveSequence )
{
packetsDupCount++;
ret = PacketAnalysis_Skip;
}
else if( sequence > sock->receiveSequence )
{
packetsDropCount ++;
if( sock->recvPacketMap != NULL ) NET_InsertPacketBank( sock->recvPacketMap, packet );
ret = PacketAnalysis_Skip;
}
}
else
{
un_packetsReceived ++;
length -= NET_HEADERSIZE;
if (sequence != sock->unreliableReceiveSequence)
{
count = sequence - sock->unreliableReceiveSequence;
un_packetsDropCount += count;
}
if ( sequence < sock->unreliableReceiveSequence )
{
packetsDupCount++;
ret = PacketAnalysis_Skip;
return ret;
}
sock->unreliableReceiveSequence = sequence + 1;
SZ_Clear (&recvMessage);
SZ_Write (&recvMessage, packet->data, length);
ret = PacketAnalysis_Start;
}
}
if( ret != PacketAnalysis_Start )
{
if( NET_ControlRecvBank( sock ) ) ret = PacketAnalysis_Start;
}
return ret;
}
int NET_ControlPacket_UnreliableSocket(i3socket_t *sock, i3packet_t *packet)
{
unsigned int length;
unsigned int flags;
unsigned int sequence;
i3packet_t ackPacket;
int ret = PacketAnalysis_None;
if( packet->length == 0 ) return PacketAnalysis_None;
sock->lastReceiveTime = g_netTime;
length = packet->length & NETFLAG_LENGTH_MASK;
flags = packet->length >> 12;
sequence = packet->sequence;
memset( &ackPacket, 0, sizeof( i3packet_t ) );
totalPacketsReceived ++;
if( flags & NETFLAG_ACK )
{
return ret = PacketAnalysis_Ack;
}
UINT DataSize = length - NET_HEADERSIZE;
if (packet->encrypt)
{
checksum packetsum;
packetsum.clear();
packetsum.add((BYTE*)packetBuffer.data, DataSize);
if ( packetBuffer.checksum != packetsum.get() )
{
packetsDupCount++;
ret = PacketAnalysis_Skip;
return ret;
}
Crypt((TCHAR*)packet->data, DataSize);
}
if (flags & NETFLAG_RELIABLE)
{
packetsReceived ++;
lastRecvSequence = sequence;
myRecvSequence = sock->receiveSequence;
sock->receiveSequence++;
length -= NET_HEADERSIZE;
if( sock->packetBlockSequence >= 0 )
{
if( sequence != sock->packetBlockSequence + 1 )
{
packetsDropCount++;
ret = PacketAnalysis_Skip;
if( flags & NETFLAG_EOM )
{
sock->receiveMessageLength = 0;
sock->packetBlockSequence = -1;
}
}
else
{
sock->packetBlockSequence ++;
memcpy(sock->receiveMessage + sock->receiveMessageLength, packet->data, length);
sock->receiveMessageLength += length;
if( flags & NETFLAG_EOM )
{
sock->packetBlockSequence = -1;
SZ_Clear(&recvMessage);
SZ_Write(&recvMessage, sock->receiveMessage, sock->receiveMessageLength);
sock->receiveMessageLength = 0;
ret = PacketAnalysis_Start;
}
else
{
ret = PacketAnalysis_Skip;
}
}
}
else if(flags & NETFLAG_SOM)
{
sock->packetBlockSequence = sequence;
memcpy(sock->receiveMessage + sock->receiveMessageLength, packet->data, length);
sock->receiveMessageLength += length;
ret = PacketAnalysis_Skip;
}
else if (flags & NETFLAG_EOM)
{
memcpy(sock->receiveMessage + sock->receiveMessageLength, packet->data, length);
sock->receiveMessageLength += length;
SZ_Clear(&recvMessage);
SZ_Write(&recvMessage, sock->receiveMessage, sock->receiveMessageLength);
sock->receiveMessageLength = 0;
ret = PacketAnalysis_Start;
}
else
{
ret = PacketAnalysis_Skip;
}
}
return ret;
}
int NET_ControlPacket(i3socket_t *sock, i3packet_t *packet)
{
if( sock->socketType == SocketType_Reliable )
return( NET_ControlPacket_ReliableSocket( sock, packet ) );
else
return( NET_ControlPacket_UnreliableSocket( sock, packet ) );
}
int NET_CheckSockProblem( i3socket_t *sock, int checkTime )
{
if( sock->sendPacketMap == NULL || sock->recvPacketMap == NULL ) return false;
if( sock->socketType == SocketType_Unreliable ) return true;
if( sock->sendPacketMap->size() > NET_MAXIMUM_PACKETMAP_SIZE || sock->recvPacketMap->size() > NET_MAXIMUM_PACKETMAP_SIZE )
{
return false;
}
if( checkTime < 0 ) return true;
if( g_netTime - sock->lastReceiveTime > checkTime )
{
return false;
}
return true;
}
int NET_Write (int socket, byte *buf, int len, struct sockaddr_in *addr)
{
int ret;
ret = sendto (socket, (char *)buf, len, 0, (struct sockaddr *)addr, sizeof(struct sockaddr_in));
if (ret == -1)
{
if (WSAGetLastError() == WSAEWOULDBLOCK)
{
return 0;
}
return 0;
}
return ret;
}
int NET_Read (int socket, byte *buf, int len, struct sockaddr_in *addr)
{
int addrlen = sizeof (struct sockaddr_in);
int ret;
ret = recvfrom (socket, (char *)buf, len, 0, (struct sockaddr *)addr, &addrlen);
if (ret == -1){
int errno;
errno = WSAGetLastError();
if(errno == WSAEWOULDBLOCK || errno == WSAECONNREFUSED){
return 0;
}else{
return 0;
}
}
return ret;
}
void NET_InitNetTime()
{
prevTime = curTime = timeGetTime();
g_netTime = 0;
}
unsigned int NET_GetNetTime()
{
unsigned int tempTime;
curTime = timeGetTime();
if (curTime >= prevTime)
{
g_netTime = g_netTime + (curTime - prevTime);
}
else
{
tempTime = (unsigned int)pow(2, 32) - prevTime;
g_netTime = g_netTime + tempTime + curTime;
}
prevTime = curTime;
return g_netTime;
}
void NET_InitPacketMap( i3socket_t *sock )
{
if( sock->sendPacketMap != NULL )
{
NET_ClearBank( sock->sendPacketMap );
delete sock->sendPacketMap;
sock->sendPacketMap = NULL;
}
if( sock->recvPacketMap != NULL )
{
NET_ClearBank( sock->recvPacketMap );
delete sock->recvPacketMap;
sock->recvPacketMap = NULL;
}
}
int NET_InitSocket(i3socket_t *sock, struct sockaddr_in *addr, int socket, int socketType)
{
NET_InitPacketMap( sock );
sock->socket = socket;
sock->socketType = socketType;
sock->connecttime = g_netTime;
sock->lastReceiveTime = g_netTime;
sock->lastSendTime = g_netTime;
sock->latencyTime = 0;
sock->disconnected = false;
sock->canSend = true;
sock->sendNext = false;
sock->resendSequence = 0;
sock->ackSequence = 0;
sock->sendSequence = 0;
sock->unreliableSendSequence = 0;
sock->sendMessageLength = 0;
sock->receiveSequence = 0;
sock->unreliableReceiveSequence = 0;
sock->receiveMessageLength = 0;
sock->packetBlockSequence = -1;
memcpy(&sock->addr, addr, sizeof(sockaddr_in));
sock->sendPacketMap = new PacketMap;
sock->recvPacketMap = new PacketMap;
sock->sendPacketMap->clear();
sock->recvPacketMap->clear();
return 1;
}
int NET_OpenNetwork()
{
WORD wVersionRequested;
WSADATA wsaData;
int i;
wVersionRequested = MAKEWORD( 2, 2 );
if (WSAStartup( wVersionRequested, &wsaData ) != 0 )
{
return false;
}
NET_InitNetTime();
SZ_Alloc(&netMessage, NET_MAXMESSAGE);
SZ_Alloc(&recvMessage, NET_MAXMESSAGE);
channelNumber = 0;
for (i=0; i<MAX_CHANNELS; i++)
channel[i] = -1;
runSendingThread = 0;
runReceivingThread = 0;
totalPacketsSend = 0;
totalPacketsReceived = 0;
packetsSent = 0;
packetsReceived = 0;
packetsReSent = 0;
packetsDropCount = 0;
packetsDupCount = 0;
packetsAckSent = 0;
packetsAckReceived = 0;
un_packetsSent = 0;
un_packetsReceived = 0;
un_packetsDropCount = 0;
InitializeCriticalSection( &spCrit );
return true;
}
int NET_OpenSocketForServer(i3socket_t *sock, char *serverIP, int port, int socketType )
{
SOCKET hSocket;
struct sockaddr_in addr;
unsigned long _true = 1;
hSocket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (hSocket == INVALID_SOCKET)
{
return 0;
}
if (ioctlsocket (hSocket, FIONBIO, &_true) == -1)
{
return 0;
}
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
if ( serverIP )
addr.sin_addr.s_addr = inet_addr(serverIP);
else
addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr.sin_port = htons( port );
if ( bind(hSocket, (LPSOCKADDR) &addr, sizeof(addr)) != 0 )
{
return 0;
}
NET_InitSocket(sock, &addr, hSocket, socketType);
if ( NET_AddListenChannel( sock->socket ) == 0 )
{
return 0;
}
sock->socketType = socketType;
return 1;
}
int NET_OpenSocketForClient(i3socket_t *sock, char *serverIP, int port, int socketType )
{
SOCKET hSocket;
struct sockaddr_in addr;
unsigned long _true = 1;
hSocket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (hSocket == INVALID_SOCKET)
{
return 0;
}
if (ioctlsocket (hSocket, FIONBIO, &_true) == -1)
{
return 0;
}
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = inet_addr(serverIP);
addr.sin_port = htons( port );
NET_InitSocket(sock, &addr, hSocket, socketType);
if ( NET_AddListenChannel( sock->socket ) == 0 )
{
return 0;
}
sock->socketType = socketType;
return 1;
}
void NET_CloseSocket(i3socket_t *sock)
{
NET_DeleteListenChannel ( sock->socket );
closesocket(sock->socket);
sock->socket = INVALID_SOCKET;
}
void NET_ClearSocket(i3socket_t *sock)
{
if (sock->socket != INVALID_SOCKET)
{
closesocket(sock->socket);
sock->socket = INVALID_SOCKET;
}
}
void NET_CloseNetwork()
{
WSACleanup();
DeleteCriticalSection( &spCrit );
}
int NET_CreateSendingThread()
{
hSQMutex = CreateMutex(NULL, FALSE, NULL);
hThread = CreateThread(NULL, 0, NET_SendingThread, NULL, 0, &SendingThreadID);
if ( !hThread )
{
return 0;
}
CloseHandle(hThread);
return 1;
}
int NET_CreateReceivingThread()
{
hRQMutex = CreateMutex(NULL, FALSE, NULL);
hThread = CreateThread(NULL, 0, NET_ReceivingThread, NULL, 0, &ReceivingThreadID);
if ( !hThread )
{
return 0;
}
CloseHandle(hThread);
return 1;
}
//lucky CPU Function rewrite for not handle an infinite Queue.
int nSendQueueRemain = 0;
DWORD WINAPI NET_SendingThread(LPVOID param)
{
int socket, len;
struct sockaddr_in addr;
i3packet_t buf;
bool bHasPacket;
FD_SET SendSet;
if ( sendingQueue ) { delete sendingQueue; sendingQueue = NULL; }
sendingQueue = new CSendingQueue;
runSendingThread = 1;
while ( runSendingThread )
{
bHasPacket = false;
WaitForSingleObject(hSQMutex, INFINITE);
if (sendingQueue->m_count > 0)
{
sendingQueue->Pop(&socket, (byte *)&buf, &len, &addr);
bHasPacket = true;
}
ReleaseMutex(hSQMutex);
if( bHasPacket )
{
SendSet.fd_count = 1;
SendSet.fd_array[0] = socket;
select( 1 , NULL, &SendSet, NULL, NULL);
NET_Write(socket, (byte *)&buf, len, &addr);
}
else
{
Sleep(1);
}
}
CloseHandle(hSQMutex);
nSendQueueRemain = sendingQueue->m_count;
// free a sending queue
if ( sendingQueue ) { delete sendingQueue; sendingQueue = NULL; }
return 0;
}
//lucky CPU , Function rewrite full
DWORD WINAPI NET_ReceivingThread(LPVOID param)
{
int socket, len;
int addrlen = sizeof (struct sockaddr_in);
struct sockaddr_in addr;
i3packet_t buf;
int i;
FD_SET RecvSet;
if ( receivingQueue ) { delete receivingQueue; receivingQueue = NULL; }
receivingQueue = new CReceivingQueue;
runReceivingThread = 1;
while ( runReceivingThread )
{
for (i=0; i<channelNumber; i++)
{
socket = channel[i];
len = NET_Read(socket, (byte *)&buf, NET_DATAGRAMSIZE, &addr);
if (len > 0)
{
WaitForSingleObject(hRQMutex, INFINITE);
receivingQueue->Push(socket, (byte *)&buf, len, &addr);
ReleaseMutex(hRQMutex);
}
}
RecvSet.fd_count = channelNumber;
memcpy( RecvSet.fd_array, channel, sizeof(int) * channelNumber );
select( channelNumber , &RecvSet, NULL, NULL, NULL );
}
CloseHandle(hRQMutex);
// free a receiving queue
if ( receivingQueue ) { delete receivingQueue; receivingQueue = NULL; }
return 0;
}
int NET_ReadFromReceivingQueue (int *socket, byte *buf, struct sockaddr_in *addr)
{
int len;
if ( !runReceivingThread ) return 0;
WaitForSingleObject(hRQMutex, INFINITE);
if (receivingQueue->m_count > 0)
{
receivingQueue->Pop(socket, buf, &len, addr);
}
else
len = 0;
ReleaseMutex(hRQMutex);
return len;
}
int NET_WriteToSendingQueue (int socket, byte *buf, int len, struct sockaddr_in *addr)
{
int ret;
if ( !runSendingThread ) return -1;
WaitForSingleObject(hSQMutex, INFINITE);
ret = sendingQueue->Push(socket, buf, len, addr);
ReleaseMutex(hSQMutex);
return ret;
}
void NET_DestroySendingThread()
{
runSendingThread = 0;
}
void NET_DestroyReceivingThread()
{
runReceivingThread = 0;
}
char *NET_ErrorString ()
{
int code;
code = WSAGetLastError ();
switch (code)
{
case WSAEINTR: return "WSAEINTR";
case WSAEBADF: return "WSAEBADF";
case WSAEACCES: return "WSAEACCES";
case WSAEDISCON: return "WSAEDISCON";
case WSAEFAULT: return "WSAEFAULT";
case WSAEINVAL: return "WSAEINVAL";
case WSAEMFILE: return "WSAEMFILE";
case WSAEWOULDBLOCK: return "WSAEWOULDBLOCK";
case WSAEINPROGRESS: return "WSAEINPROGRESS";
case WSAEALREADY: return "WSAEALREADY";
case WSAENOTSOCK: return "WSAENOTSOCK";
case WSAEDESTADDRREQ: return "WSAEDESTADDRREQ";
case WSAEMSGSIZE: return "WSAEMSGSIZE";
case WSAEPROTOTYPE: return "WSAEPROTOTYPE";
case WSAENOPROTOOPT: return "WSAENOPROTOOPT";
case WSAEPROTONOSUPPORT: return "WSAEPROTONOSUPPORT";
case WSAESOCKTNOSUPPORT: return "WSAESOCKTNOSUPPORT";
case WSAEOPNOTSUPP: return "WSAEOPNOTSUPP";
case WSAEPFNOSUPPORT: return "WSAEPFNOSUPPORT";
case WSAEAFNOSUPPORT: return "WSAEAFNOSUPPORT";
case WSAEADDRINUSE: return "WSAEADDRINUSE";
case WSAEADDRNOTAVAIL: return "WSAEADDRNOTAVAIL";
case WSAENETDOWN: return "WSAENETDOWN";
case WSAENETUNREACH: return "WSAENETUNREACH";
case WSAENETRESET: return "WSAENETRESET";
case WSAECONNABORTED: return "WSWSAECONNABORTEDAEINTR";
case WSAECONNRESET: return "WSAECONNRESET";
case WSAENOBUFS: return "WSAENOBUFS";
case WSAEISCONN: return "WSAEISCONN";
case WSAENOTCONN: return "WSAENOTCONN";
case WSAESHUTDOWN: return "WSAESHUTDOWN";
case WSAETOOMANYREFS: return "WSAETOOMANYREFS";
case WSAETIMEDOUT: return "WSAETIMEDOUT";
case WSAECONNREFUSED: return "WSAECONNREFUSED";
case WSAELOOP: return "WSAELOOP";
case WSAENAMETOOLONG: return "WSAENAMETOOLONG";
case WSAEHOSTDOWN: return "WSAEHOSTDOWN";
case WSASYSNOTREADY: return "WSASYSNOTREADY";
case WSAVERNOTSUPPORTED: return "WSAVERNOTSUPPORTED";
case WSANOTINITIALISED: return "WSANOTINITIALISED";
case WSAHOST_NOT_FOUND: return "WSAHOST_NOT_FOUND";
case WSATRY_AGAIN: return "WSATRY_AGAIN";
case WSANO_RECOVERY: return "WSANO_RECOVERY";
case WSANO_DATA: return "WSANO_DATA";
default: return "NO ERROR";
}
}
int NET_AddListenChannel( int socket )
{
if ( channelNumber < MAX_CHANNELS )
{
channel[channelNumber] = socket;
channelNumber ++;
}
else
{
return 0;
}
return 1;
}
int NET_DeleteListenChannel( int socket )
{
int i;
for (i=0; i<channelNumber; i++)
{
if ( channel[i] == socket )
{
if (i == channelNumber - 1)
channel[i] = -1;
else
channel[i] = channel[channelNumber];
channelNumber --;
return 1;
}
}
return 0;
}
int NET_ReadPacket(int *socket, byte *buf, struct sockaddr_in *addr)
{
int length;
#ifndef _USE_RECEIVING_THREAD
length = NET_Read(*socket, buf, NET_DATAGRAMSIZE, addr);
#else
length = NET_ReadFromReceivingQueue (socket, buf, addr);
#endif
return length;
}
int NET_PreviewMessage(i3packet_t *p)
{
int length;
length = p->length & NETFLAG_LENGTH_MASK;
length -= NET_HEADERSIZE;
if (length < 1) return false;
SZ_Clear (&recvMessage);
SZ_Write (&recvMessage, p->data, length);
return true;
}
void NET_SetMessageOption_EnableOverwriting(i3sizebuf_t *data, int identity)
{
data->overwriting = identity;
}
void TRACE(LPCTSTR lpszFormat, ...)
{
#ifdef _DEBUG
va_list argList;
va_start(argList, lpszFormat);
char szOutputMessage[1024];
vsprintf(szOutputMessage, lpszFormat, argList);
va_end(argList);
OutputDebugString ( szOutputMessage );
#endif
}
#include <tchar.h>
void Crypt(TCHAR *inp, DWORD inplen, TCHAR* key, DWORD keylen)
{
TCHAR Sbox[129], Sbox2[129];
unsigned long i, j, t, x;
static const TCHAR OurUnSecuredKey[] = "gth99comAAA" ;
static const int OurKeyLen = _tcslen(OurUnSecuredKey);
TCHAR temp , k;
i = j = k = t = x = 0;
temp = 0;
ZeroMemory(Sbox, sizeof(Sbox));
ZeroMemory(Sbox2, sizeof(Sbox2));
for(i = 0; i < 128U; i++)
{
Sbox[i] = (TCHAR)i;
}
j = 0;
if(keylen)
{
for(i = 0; i < 128U ; i++)
{
if(j == keylen)
{
j = 0;
}
Sbox2[i] = key[j++];
}
}
else
{
for(i = 0; i < 128U ; i++)
{
if(j == OurKeyLen)
{
j = 0;
}
Sbox2[i] = OurUnSecuredKey[j++];
}
}
j = 0 ;
for(i = 0; i < 128; i++)
{
j = (j + (unsigned long) Sbox[i] + (unsigned long) Sbox2[i]) % 128U ;
temp = Sbox[i];
Sbox[i] = Sbox[j];
Sbox[j] = temp;
}
i = j = 0;
for(x = 0; x < inplen; x++)
{
i = (i + 1U) % 128U;
j = (j + (unsigned long) Sbox[i]) % 128U;
temp = Sbox[i];
Sbox[i] = Sbox[j] ;
Sbox[j] = temp;
t = ((unsigned long) Sbox[i] + (unsigned long) Sbox[j]) % 128U ;
k = Sbox[t];
inp[x] = (inp[x] ^ k);
}
} | C++ |
#define SENDING_QUEUE_SIZE 3000
#define RECEIVING_QUEUE_SIZE 3000
typedef struct
{
int socket;
int len;
i3packet_t packet;
sockaddr_in addr;
} i3packetqueue_t;
class CSendingQueue
{
private:
int m_first;
int m_last;
int m_size;
int m_overflow;
i3packetqueue_t m_queue[SENDING_QUEUE_SIZE];
public:
int m_count;
int m_maxCount;
CSendingQueue();
~CSendingQueue();
int Push (int socket, byte *buf, int len, struct sockaddr_in *addr);
int Pop (int *socket, byte *buf, int *len, struct sockaddr_in *addr);
void Clear ();
};
class CReceivingQueue
{
private:
int m_first;
int m_last;
int m_size;
int m_overflow;
i3packetqueue_t m_queue[RECEIVING_QUEUE_SIZE];
public:
int m_count;
int m_maxCount;
CReceivingQueue();
~CReceivingQueue();
int Push (int socket, byte *buf, int len, struct sockaddr_in *addr);
int Pop (int *socket, byte *buf, int *len, struct sockaddr_in *addr);
void Clear ();
};
| C++ |
#include "netlib.h"
#include "queue.h"
#include <time.h>
i3sizebuf_t netMessage;
i3sizebuf_t recvMessage;
i3packet_t packetBuffer;
int msgReadCount;
int msgBadRead;
int totalPacketsSend;
int totalPacketsReceived;
int packetsSent;
int packetsReceived;
int packetsReSent;
int packetsDropCount;
int packetsDupCount;
int packetsAckSent;
int packetsAckReceived;
int un_packetsSent;
int un_packetsReceived;
int un_packetsDropCount;
unsigned int g_netTime;
unsigned int prevTime, curTime;
int channel[ MAX_CHANNELS ];
int channelNumber;
HANDLE hThread;
DWORD SendingThreadID, ReceivingThreadID;
int runSendingThread, runReceivingThread;
CSendingQueue *sendingQueue;
CReceivingQueue *receivingQueue;
HANDLE hSQMutex, hRQMutex;
FILE *packetErrorLog;
int readSizePerSecond;
int lastRecvSequence;
int myRecvSequence;
CRITICAL_SECTION spCrit;
| C++ |
#if !defined(AFX_GAMETARGET_H__AE7EED36_1E63_482B_BAC9_FC0857A068ED__INCLUDED_)
#define AFX_GAMETARGET_H__AE7EED36_1E63_482B_BAC9_FC0857A068ED__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CGameTarget
{
public:
CGameTarget();
virtual ~CGameTarget();
};
#endif
| C++ |
#include "global.h"
#include <Resapi.h>
#include "LogEvent.h"
CLogEvent gLogEvent;
CLogEvent::CLogEvent()
{
Init();
}
CLogEvent::~CLogEvent()
{
if(NULL != m_hEventSource)
{
::DeregisterEventSource(m_hEventSource);
}
}
void CLogEvent::Init()
{
m_hEventSource = NULL;
AddEventSource("GTH LOG","GTHGameserver",NULL,1);
m_hEventSource = ::RegisterEventSource(NULL,"GTH LOG");
}
BOOL CLogEvent::AddEventSource(
LPTSTR pszLogName,
LPTSTR pszSrcName,
LPTSTR pszMsgDLL,
DWORD dwNum)
{
HKEY hk;
DWORD dwDisp;
TCHAR szBuf[MAX_PATH];
wsprintf(szBuf,
"SYSTEM\\CurrentControlSet\\Services\\EventLog\\%s\\%s",
pszLogName, pszSrcName);
if (RegCreateKeyEx(HKEY_LOCAL_MACHINE, szBuf,
0, NULL, REG_OPTION_NON_VOLATILE,
KEY_WRITE, NULL, &hk, &dwDisp))
{
printf("Could not create the registry key.");
return FALSE;
}
RegCloseKey(hk);
return TRUE;
}
void CLogEvent::WriteLog(WORD wType,const char* szMessage)
{
::ReportEvent(m_hEventSource,
wType,
1,
0,
NULL,
1,
0,
&szMessage,
NULL);
return;
}
void CLogEvent::LogEvent(WORD wType,LPCTSTR lpszFormat, ...)
{
#ifdef _DEBUG
va_list argList;
va_start(argList, lpszFormat);
char szOutputMessage[1024];
vsprintf(szOutputMessage,lpszFormat, argList);
va_end(argList);
WriteLog(wType,szOutputMessage);
#endif
}
void CLogEvent::ReStartLog()
{
::ClearEventLog(m_hEventSource,"gthlog.log");
} | C++ |
#if !defined(AFX_CLOGFILECTRL_H__509985E6_F7C3_4BA8_9399_5E5D4617A358__INCLUDED_)
#define AFX_CLOGFILECTRL_H__509985E6_F7C3_4BA8_9399_5E5D4617A358__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include <WINDOWS.H>
#include <STDIO.H>
#include <sqltypes.h>
class CLogFileCtrl
{
protected:
typedef struct
{
SQLSMALLINT year;
SQLUSMALLINT month;
SQLUSMALLINT day;
SQLUSMALLINT hour;
SQLUSMALLINT minute;
SQLUSMALLINT second;
SQLUINTEGER fraction;
} timeStamp_t;
protected:
FILE* m_fp;
BOOL m_bActive;
CRITICAL_SECTION m_critcalsection;
public:
BOOL Open(const char* in_strfileName);
BOOL Close(void);
enum
{
MAX_MESSAGE_BUFFER = 4096,
MAX_USERINFO_BUFFER = 4096,
MAX_LOG_BUFFER = MAX_MESSAGE_BUFFER + MAX_USERINFO_BUFFER,
};
public:
void SetActive(const BOOL in_bActive);
BOOL IsActive(void);
void GetTimeStamp(timeStamp_t* out_pTimeStamp);
public:
void WriteLog(const char* in_strMessage, const char* in_strUserInfo = NULL);
public:
CLogFileCtrl();
~CLogFileCtrl();
};
#endif
| C++ |
#include "CLogFileCtrl.h"
#include <TIME.H>
CLogFileCtrl::CLogFileCtrl()
{
m_fp = NULL;
m_bActive = FALSE;
InitializeCriticalSection(&m_critcalsection);
}
CLogFileCtrl::~CLogFileCtrl()
{
DeleteCriticalSection(&m_critcalsection);
if( NULL != m_fp)
{
fclose(m_fp);
m_fp = NULL;
}
}
void CLogFileCtrl::SetActive(const BOOL in_bActive)
{
m_bActive = in_bActive;
}
BOOL CLogFileCtrl::IsActive(void)
{
return m_bActive;
}
BOOL CLogFileCtrl::Open(const char* in_strfileName)
{
EnterCriticalSection(&m_critcalsection);
if ( FALSE == m_bActive)
{
LeaveCriticalSection(&m_critcalsection);
return FALSE;
}
if(NULL != m_fp)
{
fclose(m_fp);
m_fp=NULL;
}
m_fp = fopen( in_strfileName, "a+" );
if(NULL == m_fp )
{
LeaveCriticalSection(&m_critcalsection);
return FALSE;
}
LeaveCriticalSection(&m_critcalsection);
return TRUE;
}
BOOL CLogFileCtrl::Close(void)
{
EnterCriticalSection(&m_critcalsection);
if(NULL != m_fp)
{
fclose(m_fp);
m_fp=NULL;
}
LeaveCriticalSection(&m_critcalsection);
return TRUE;
}
void CLogFileCtrl::WriteLog(const char* in_strMessage, const char* in_strUserInfo)
{
EnterCriticalSection(&m_critcalsection);
if(FALSE == m_bActive)
{
LeaveCriticalSection(&m_critcalsection);
return;
}
if(NULL == m_fp)
{
LeaveCriticalSection(&m_critcalsection);
return;
}
char strTimeStamp[30]="";
timeStamp_t timeStamp;
GetTimeStamp( &timeStamp );
sprintf(strTimeStamp, "%4d-%02d-%02d %02d:%02d:%02d",
timeStamp.year, timeStamp.month, timeStamp.day, timeStamp.hour, timeStamp.minute, timeStamp.second);
strTimeStamp[29] = NULL;
char MessageBUffer[MAX_MESSAGE_BUFFER];
char LogBuffer[MAX_LOG_BUFFER];
char UserBuffer[MAX_USERINFO_BUFFER];
memset(MessageBUffer, 0x00, MAX_MESSAGE_BUFFER);
memset(LogBuffer, 0x00, MAX_LOG_BUFFER);
memset(UserBuffer, 0x00, MAX_USERINFO_BUFFER);
if ( NULL != in_strMessage)
{
_snprintf(MessageBUffer, MAX_MESSAGE_BUFFER, in_strMessage);
MessageBUffer[MAX_MESSAGE_BUFFER-1] = NULL;
}
if ( NULL != in_strUserInfo)
{
_snprintf(UserBuffer, MAX_MESSAGE_BUFFER, in_strUserInfo);
UserBuffer[MAX_USERINFO_BUFFER-1] = NULL;
}
int size = strlen(UserBuffer);
if ( strlen(UserBuffer) <= 0)
_snprintf(LogBuffer, MAX_LOG_BUFFER, "[%s] %s\n", strTimeStamp, MessageBUffer);
else
_snprintf(LogBuffer, MAX_LOG_BUFFER, "%s;%s%s\n", strTimeStamp, UserBuffer, MessageBUffer);
LogBuffer[MAX_LOG_BUFFER-1] = NULL;
if ( m_fp != NULL)
fprintf(m_fp, LogBuffer);
LeaveCriticalSection(&m_critcalsection);
return;
}
void CLogFileCtrl::GetTimeStamp(timeStamp_t* out_pTimeStamp)
{
time_t curTime;
struct tm* date_tm=NULL;
time( &curTime );
date_tm = localtime( &curTime );
out_pTimeStamp->year = date_tm->tm_year += 1900;
out_pTimeStamp->month = date_tm->tm_mon += 1;
out_pTimeStamp->day = date_tm->tm_mday;
out_pTimeStamp->hour = date_tm->tm_hour;
out_pTimeStamp->minute = date_tm->tm_min;
out_pTimeStamp->second = date_tm->tm_sec;
out_pTimeStamp->fraction = 0;
}
| C++ |
#if !defined(AFX_GAMETARGET_H__AE7EED36_1E63_482B_BAC9_FC0857A068ED__INCLUDED_)
#define AFX_GAMETARGET_H__AE7EED36_1E63_482B_BAC9_FC0857A068ED__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CGameTarget
{
public:
CGameTarget();
virtual ~CGameTarget();
};
int GTH_GetTargetPosition( monsterCharacter_t *pMonster, vec3_t pos );
int GTH_GetTargetPosition( playerCharacter_t *pc, vec3_t pos );
float GTH_GetDistanceFromTarget( playerCharacter_t *pc );
float GTH_GetDistanceFromTarget( vec3_t pos, int targetIdx, int targetType );
char* GTH_GetTargetName( int entityType, int entityIdx );
void AddTargetList( playerCharacter_t *pc, char *name );
int InTargetList( playerCharacter_t *pc, char* name );
#endif
| C++ |
#if !defined(AFX_ATTACK_H__8C3E9498_9475_42CC_AAA1_436CF7B70C7B__INCLUDED_)
#define AFX_ATTACK_H__8C3E9498_9475_42CC_AAA1_436CF7B70C7B__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CAttack
{
public:
CAttack();
virtual ~CAttack();
};
void GTH_PC_Attack(playerCharacter_t *pc);
void GTH_ProcessEventMessage_Attack();
#endif
| C++ |
#include "../global.h"
CGameTarget::CGameTarget()
{
}
CGameTarget::~CGameTarget()
{
}
int GTH_GetTargetPosition( playerCharacter_t *pc, vec3_t pos )
{
playerCharacter_t *pTargetPC;
monsterCharacter_t *pTargetMon;
if( pc->targetIdx < 0 ) return( false );
if( pc->targetType < 0 ) return( false );
switch( pc->targetType )
{
case ENTITY_PC :
pTargetPC = &g_pc[pc->targetIdx];
vec_copy( pTargetPC->position, pos );
break;
case ENTITY_MONSTER : case ENTITY_NPC :
pTargetMon = &g_monster[pc->targetIdx];
vec_copy( pTargetMon->position, pos );
break;
}
return( true );
}
int GTH_GetTargetPosition( monsterCharacter_t *pMonster, vec3_t pos )
{
playerCharacter_t *pTargetPC;
monsterCharacter_t *pTargetMon;
if( pMonster->targetIdx < 0 ) return( false );
if( pMonster->targetType < 0 ) return( false );
switch( pMonster->targetType )
{
case ENTITY_PC :
pTargetPC = &g_pc[pMonster->targetIdx];
vec_copy( pTargetPC->position, pos );
break;
case ENTITY_MONSTER : case ENTITY_NPC :
pTargetMon = &g_monster[pMonster->targetIdx];
vec_copy( pTargetMon->position, pos );
break;
}
return( true );
}
float GTH_GetDistanceFromTarget( playerCharacter_t *pc )
{
float dist = -1.0f;
playerCharacter_t *pTargetPC;
monsterCharacter_t *pTargetMon;
if( pc->targetIdx < 0 ) return( -1.0f );
if( pc->targetType < 0 ) return( -1.0f );
switch( pc->targetType )
{
case ENTITY_PC :
pTargetPC = &g_pc[pc->targetIdx];
dist = GTH_GetDistance2D( pc->position, pTargetPC->position );
break;
case ENTITY_MONSTER : case ENTITY_NPC :
pTargetMon = &g_monster[pc->targetIdx];
dist = GTH_GetDistance2D( pc->position, pTargetMon->position );
break;
}
if(dist < 0.0000f)
{
}
return( dist );
}
float GTH_GetDistanceFromTarget( vec3_t pos, int targetIdx, int targetType )
{
float dist = -1.0f;
playerCharacter_t *pTargetPC;
monsterCharacter_t *pTargetMon;
if( targetIdx < 0 ) return( -1.0f );
if( targetType < 0 ) return( -1.0f );
switch( targetType )
{
case ENTITY_PC :
pTargetPC = &g_pc[targetIdx];
dist = GTH_GetDistance2D( pos, pTargetPC->position );
break;
case ENTITY_MONSTER : case ENTITY_NPC :
pTargetMon = &g_monster[targetIdx];
dist = GTH_GetDistance2D( pos, pTargetMon->position );
break;
}
if(dist < 0.0000f)
{
}
return( dist );
}
char* GTH_GetTargetName( int entityType, int entityIdx )
{
if( entityIdx < 0 || entityType < 0 ) return NULL;
switch( entityType )
{
case ENTITY_PC :
if( entityIdx >= MAX_PCS ) return NULL;
if( !g_pc[entityIdx].active || !g_pc[entityIdx].ready ) return NULL;
return( g_pc[entityIdx].name );
break;
case ENTITY_MONSTER : case ENTITY_NPC :
if( entityIdx >= MAX_MONSTERS ) return NULL;
if( !g_monster[entityIdx].active ) return NULL;
return( g_monster[entityIdx].basic.name );
break;
}
return NULL;
}
void AddTargetList( playerCharacter_t *pc, char *name )
{
for( int i = 0; i < MAX_TARGET_PCLIST; i ++ )
{
if( !stricmp( name, pc->targetPCList[i] ) ) break;
}
if( i == MAX_TARGET_PCLIST )
{
for( i = 0; i < MAX_TARGET_PCLIST; i ++ )
{
if( pc->targetPCList[i][0] == 0 )
{
strcpy( pc->targetPCList[i], name );
pc->targetPCListTime[i] = g_globalTime;
break;
}
else if( g_globalTime - pc->targetPCListTime[i] > 6000 )
{
strcpy( pc->targetPCList[i], name );
pc->targetPCListTime[i] = g_globalTime;
break;
}
}
}
else
{
pc->targetPCListTime[i] = g_globalTime;
}
}
int InTargetList( playerCharacter_t *pc, char* name )
{
switch( pc->targetingType )
{
case TARGETING_ONLY_MONSTER :
return false;
break;
case TARGETING_NORMAL : case TARGETING_SAFE :
{
for( int i = 0; i < MAX_TARGET_PCLIST; i ++ )
{
if( !stricmp( name, pc->targetPCList[i] ) )
{
if( g_globalTime - pc->targetPCListTime[i] < 60000 ) break;
}
}
if( i == MAX_TARGET_PCLIST ) return false;
return true;
}
break;
case TARGETING_EXCEPT_PARTY :
{
if( pc->organizeServer < 0 ) return true;
for( int i = 0; i < MAX_NUMBER_OF_PARTY_MEMBER; i ++ )
{
if( pc->member[i].serverIndex < 0 ) continue;
if( !stricmp( name, pc->member[i].memberName ) ) return false;
}
return true;
}
break;
case TARGETING_EXCEPT_GUILD :
{
return true;
}
break;
case TARGETING_EVERY :
{
return true;
}
break;
}
return false;
} | C++ |
#if !defined(AFX_ATTACK_H__8C3E9498_9475_42CC_AAA1_436CF7B70C7B__INCLUDED_)
#define AFX_ATTACK_H__8C3E9498_9475_42CC_AAA1_436CF7B70C7B__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CAttack
{
public:
CAttack();
virtual ~CAttack();
};
#endif
| C++ |
#if !defined(AFX_LOGEVENT_H__A3DE815F_0CAF_408A_9BE7_5D60F70E33D0__INCLUDED_)
#define AFX_LOGEVENT_H__A3DE815F_0CAF_408A_9BE7_5D60F70E33D0__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CLogEvent
{
public:
enum
{
GTH_EVENTLOG_SUCCESS=0,
GTH_EVENTLOG_ERROR_TYPE,
GTH_EVENTLOG_WARNING_TYPE,
GTH_EVENTLOG_INFORMATION_TYPE,
GTH_EVENTLOG_AUDIT_SUCCESS,
GTH_EVENTLOG_AUDIT_FAILURE,
};
CLogEvent();
virtual ~CLogEvent();
void Init();
void LogEvent(WORD wType,LPCTSTR lpszFormat, ...);
void WriteLog(WORD wType,const char* szMessage);
BOOL AddEventSource(
LPTSTR pszLogName,
LPTSTR pszSrcName,
LPTSTR pszMsgDLL,
DWORD dwNum);
void ReStartLog();
public:
HANDLE m_hEventSource;
};
#endif
| C++ |
#define NUM_OF_MONSTER_AI_TYPE 14
#define NUM_OF_NPC_AI_TYPE 19
struct node_t
{
grid_t pos;
struct node_t *parent;
int cost;
int total;
bool onOpen;
bool onClosed;
};
struct nodeHash_t
{
node_t *node;
};
struct queue_t
{
std::vector<node_t*> heap;
};
struct path_t
{
grid_t goal;
queue_t open;
};
#define MAX_NUMBER_OF_SCRIPT_VARIABLE 100
#define MAX_NUMBER_OF_SCRIPT_PROCEDURE 100
#define PATH_FINDING_SIZE 30
#define MAX_PATH_BUFFER_SIZE PATH_FINDING_SIZE * PATH_FINDING_SIZE
#define MAX_NUMBER_OF_NODE PATH_FINDING_SIZE * PATH_FINDING_SIZE
#define MAX_MAP_BUFFER_SIZE PATH_FINDING_SIZE * PATH_FINDING_SIZE * 3
#define MAX_NUMBER_OF_RANDOM_POSITION 20
#define MAX_NUMBER_OF_WAYPOINT 20
enum monsterAIEvent_t
{
AI_IDLE,
AI_MOVE,
AI_TRACE,
AI_ATTACK,
AI_RUNAWAY,
AI_RECOVERY,
AI_LOOK,
AI_LOST,
AI_ATTACH,
AI_DIE,
AI_STUN,
AI_SKILL,
};
typedef struct
{
int aiType;
monsterAIEvent_t aiEvent;
monsterAIEvent_t OldAiEvent;
unsigned int saveTime;
int thinkTime;
char *aiData;
int aiAddr;
int aiVariable[MAX_NUMBER_OF_SCRIPT_VARIABLE];
int aiProcedureAddr[MAX_NUMBER_OF_SCRIPT_PROCEDURE];
int callProcedureAddr;
bool isCall;
int pathFindSize;
grid_t startPos;
grid_t curPos;
grid_t *path;
int pathNumber;
grid_t pastPos;
node_t *nodeBank;
node_t** nodeHashTable;
int nodeBankNumber;
int searchNumber;
int heruristic;
int totalSearch;
bool isGoal;
grid_t goalPos;
path_t pathQueue;
vec3_t wayPoint[MAX_NUMBER_OF_WAYPOINT];
int wayPointNumber;
grid_t *wayPath;
int wayPathNumber;
int curWayPath;
int directWayPath;
int attachFlag;
int returnFlag;
int moveType;
int oldMoveType;
int lostPathCount;
} ai_t;
#define AI_DEF_VERYSLOW_TIMER 4000
#define AI_DEF_SLOW_TIMER 2000
#define AI_DEF_NORMAL_TIMER 2000
#define AI_DEF_FAST_TIMER 1000
#define AI_DEF_VERYFAST_TIMER 500
#define AI_DEF_DAMAGED_ENTITY 0
#define AI_DEF_NEAR_ENTITY 1
#define AI_DEF_LESS_RA_ENTITY 2
#define AI_DEF_MORE_POINT_ENTITY 3
#define AI_DEF_RANDOM 0
#define AI_DEF_NEAR_FELLOW 0
#define AI_DEF_MY_RA 0
#define AI_DEF_MY_SA 1
#define AI_DEF_ENABLE_WALK 0
#define AI_DEF_DISABLE_MOVE 1
#define AI_DEF_DISABLE_WALK 2
#define AI_DEF_ENTITY_PC 0
#define AI_DEF_ENTITY_MONSTER 1
#define AI_DEF_ENTITY_NPC 2
#define AI_BUFFER_SIZE 8000
enum npcAIEvent_t
{
AI_NPC_WAIT,
AI_NPC_RUN
};
typedef struct
{
int aiType;
char aiData[AI_BUFFER_SIZE];
npcAIEvent_t aiEvent;
unsigned int saveTime;
int thinkTime;
int aiAddr;
int aiVariable[MAX_NUMBER_OF_SCRIPT_VARIABLE];
int aiProcedureAddr[MAX_NUMBER_OF_SCRIPT_PROCEDURE];
int callProcedureAddr;
bool isCall;
} npcAi_t;
typedef struct
{
int aiType;
char aiData[AI_BUFFER_SIZE];
npcAIEvent_t aiEvent;
unsigned int saveTime;
int thinkTime;
int aiAddr;
int aiVariable[MAX_NUMBER_OF_SCRIPT_VARIABLE];
int aiProcedureAddr[MAX_NUMBER_OF_SCRIPT_PROCEDURE];
int callProcedureAddr;
bool isCall;
int msgWaiting;
int pcReplyIdx;
int msgFlag;
int sendMsgIdx;
int replyMsgIdxNumber;
int replyMsgIdx[5];
int globalData[5];
} npcAiInPc_t;
| C++ |
#include "..\HelperSystem\tagHelper.h"
#include "../AhnLab/AntiCpSvrFunc.h"
#include "../AhnLab/AntiCpCnt.h"
#define MAX_AFFECT 8
#define MAX_NUMBER_OF_SKILL 100
#define MAX_NUMBER_OF_SKILL_VARIABLE 20
#define MAX_NUMBER_OF_OWNITEM 125
#define MAX_INVENTORY_SIZE 48
#define MAX_DEPOT_SIZE 42
#define MAX_EQUIPMENT 14
#define MAX_TRADE_SIZE 12
#define MAX_NUMBER_OF_HOTKEY 32
#define MAX_PRECOCITY_SIZE 6
#define MASK_HOTKEY_ACTION 1000
#define MASK_HOTKEY_ITEM 2000
#define MAX_NUMBER_OF_PARTY_MEMBER 8
#define MAX_COUNT_QUEST_VARIABLE 200
#define MAX_COUNT_QUEST_INVENTORY 24
#define MAX_COUNT_QUEST_STATUS 5
#define MAX_COUNT_QUEST_STATUS_DYNAMIC_FIELD 10
#define DEFAULT_SKINPART_NUMBER 4
#define PC_GAMEDATA_SAVETIME 600000
#define PARTY_INFO_REQUESTTIME 300000
#define MAX_CRAFT_SOURCE_ITEM_SIZE 12
#define MAX_CRAFT_RESULT_ITEM_SIZE 2
#define MAX_BOOTH_INVENTORY_SIZE 18
#define MAX_COUNT_BOOTH_BUYER 50
#define MAX_UPGRADE_SOURCE_ITEM_SIZE 3
#define MAX_AUTO_TRADEITEMFILD 6
#define MAX_COUNT_TRAIN_MONSTER 8
#define MAX_COUNT_AGGRESSIVE_TRAIN_MONSTER 4
#define TRAIN_MONSTER_LIMIT_TIME 30000
#define MAX_FRIENDS 20
#define MAX_TARGET_PCLIST 8
#define MAX_GUILDS 500
#define MAX_NUMBER_OF_STORE_ITEM ( 36 * 3 )
#define CHAOVALUE 300
#define CHAOSTIME 60000
#define CHAOSDECVALUE 100
#define CHAOSDECSPEEDRATE 30.f
#define CHAOSPURE 0
#define CHAOSGENERATE 10
#define CHAOSDISORDER 10000
#define CHAOSMONSTER 29500
#define CHAOSMAX 30000
#define CHAOSADDRATE 1.2f
#define CHAOSVALUEFALTE 100.0f
#define PARTYITEMGENERATE 0
#define PARTYITEMRANDOM 1
#define PARTYITEMORDER 2
#define SKILL_MAX_BASIC_JOB_TYPE 4
enum
{
MONEY_FREE_USER=0,
MONEY_PAY_USER,
MONEY_PRIMIUM_USER
};
enum
{
PC_MENU_PARTY = 1 << 0,
PC_MENU_GUILD = 1 << 1,
PC_MENU_TRADE = 1 << 2,
PC_MENU_VS = 1 << 3,
PC_MENU_EXIT = 1 << 4,
};
enum
{
PC_MENU_TYPE_NONE = -1,
PC_MENU_TYPE_NORMAL = 0,
};
enum
{
BUSY_STATE_NONE = 0,
BUSY_STATE_NPC,
BUSY_STATE_TRADE,
BUSY_STATE_CRAFT,
BUSY_STATE_UPGRADE,
BUSY_STATE_BOOTH_SELL_PREPARE,
BUSY_STATE_BOOTH_SELL,
BUSY_STATE_BOOTH_BUY,
BUSY_STATE_REQUEST,
BUSY_STATE_QUESTSCROLL,
BUSY_STATE_NPC_INVENTORY,
BUSY_STATE_BATTLEPRACTICE,
BUSY_STATE_DAN_BATTLE,
BUSY_STATE_WORLDCHAGNE,
};
enum
{
MOUSEINVEN_TYPE_NONE = -1,
MOUSEINVEN_TYPE_INVENTORY = 0,
MOUSEINVEN_TYPE_EQUIP = 1,
MOUSEINVEN_TYPE_DEPOT = 2,
};
typedef struct
{
char summoner[NAMESTRING];
int worldIdx;
vec3_t position;
int forcedYn;
} summons_t;
typedef struct
{
int idx;
char memberName[NAMESTRING];
int isActive;
int isLeader;
int level;
int gen;
int serverIndex;
int idxOnServer;
int isSharingExp;
int worldIdx;
bool m_bischange;
int m_iorderindex;
} partyMember_t;
#define MAX_COUNT_QUEST_COMPLETE 100
struct QUESTVARIABLE
{
char isComplete;
char step;
byte completeCount;
byte dummy;
};
typedef struct
{
union
{
DWORD iVar;
QUESTVARIABLE var;
};
} questVariable_t;
struct QUESTINVENTORY
{
short itemIdx;
byte itemCount;
byte questIdx;
};
typedef struct
{
union
{
int iItem;
QUESTINVENTORY item;
};
} questInventory_t;
typedef struct
{
int idx;
int questIdx;
int dField[MAX_COUNT_QUEST_STATUS_DYNAMIC_FIELD];
char partyOrganizerName[NAMESTRING];
int partyOrganizeServer;
int partyOrganizeTime;
int clearTime;
int limitTime;
} questStatus_t;
typedef struct
{
int itemIdx;
int price;
} boothItem_t;
typedef char FriendName[NAMESTRING] ;
struct FriendsList
{
int count ;
FriendName names[MAX_FRIENDS] ;
} ;
enum
{
BILL_SEND_NONE,
BILL_SEND_START,
BILL_SEND_END,
};
typedef struct
{
unsigned int normalLastAttackTime;
int idx;
int active;
int ready;
int sendReplyConnect;
int alive;
char userID[IDSTRING+1];
int characterID;
int serverGroupID;
i3characterEvent_t event;
i3characterEvent_t oldEvent;
message_t message[MAX_NUMBER_OF_MESSAGE];
int messageNumber;
entityType_t entityType;
int pcClass;
int pcJob;
int skinPart[DEFAULT_SKINPART_NUMBER];
char name[NAMESTRING+1];
int age;
char rank[NAMESTRING+1];
int rankPoint;
float recoveryTime;
int moveType;
int worldIdx;
int zoneIdx;
vec3_t position;
vec3_t reliablePosition;
int reliableWorldIdx;
vec3_t angles;
int generalSpeed;
int level;
__int64 exp;
int nextExp;
int reduceExp;
int reduceNark;
int increaseExpRate;
int selectedGen;
int genLevel;
__int64 genExp;
int nextGenExp;
int increaseGenExpRate;
int genCapability[GEN_NUMBER];
int genCrossStep;
int force;
int soulpower;
int agility;
int vitality;
int calForce;
int calSoulpower;
int calAgility;
int calVitality;
int bonusStatusPoint;
float curRA;
float curSA;
float baseMaxRA;
float baseMaxSA;
float calMaxRA;
float calMaxSA;
int curChargeNSE;
int curChargeSE;
float curChargeRA;
float curChargeSA;
int maxChargeRA;
int maxChargeSA;
int onceRecoveryRA;
int onceRecoverySA;
int epackUseRAWaitTime;
int epackUseSAWaitTime;
int curWeapon;
int chaosPoint;
int chaosTime;
int targetingType;
char targetPCList[MAX_TARGET_PCLIST][20];
int targetPCListTime[MAX_TARGET_PCLIST];
int targetType;
int targetIdx;
int basePhyMinDmg;
int basePhyMaxDmg;
int baseMagMinDmg;
int baseMagMaxDmg;
int baseCriticalDmg;
float baseCriticalRate;
int baseHitPower;
int baseItemPhyMinDmg;
int baseItemPhyMaxDmg;
int baseItemMagMinDmg;
int baseItemMagMaxDmg;
int baseItemCriticalDmg;
float baseItemCriticalRate;
int baseItemHitPower;
int baseAttackSpeed;
int baseAttackLength;
int baseAttackRange;
int atkWeaponType;
int calPhyMinDmg;
int calPhyMaxDmg;
int calMagMinDmg;
int calMagMaxDmg;
int calCriticalDmg;
float calCriticalRate;
int calHitPower;
int calItemHitPower;
int calAttackDelay;
int calHitRate;
int calAttackLength;
int calPosMinDmg;
int calPosMaxDmg;
int calNegMinDmg;
int calNegMaxDmg;
int attackSpeedRate;
int atkPowerRACost;
int atkPowerSACost;
int atkBowSACost;
int resultHitRate;
int resultAvoidRate;
int resultValid;
int attackComboType;
int forceAtkDelay;
int baseDefensePower;
int baseAvoidPower;
float baseVelocity;
int baseStunTime;
int basePositiveRes;
int baseNegativeRes;
int baseItemDefensePower;
int baseItemPositiveRes;
int baseItemNegativeRes;
int baseItemAvoidPower;
int calDefensePower;
int calAvoidPower;
float calVelocity;
int calStunTime;
int calPositiveRes;
int calNegativeRes;
int curItemWeight;
int baseItemWeight;
int calItemWeight;
affect_t affect[MAX_AFFECT];
int affectNumber;
int skillNumber;
skill_t skill[MAX_NUMBER_OF_SKILL];
float skillCooltime[MAX_NUMBER_OF_SKILL];
float skillCastingtime;
int skillCastingState;
int saveSkillIdx;
int curSkillIdx;
int bNotOwnSkill;
int saveSkillLevel;
vec3_t saveSkillTargetPos;
int bonusSkillPoint;
int skillVariable[MAX_NUMBER_OF_SKILL_VARIABLE];
item_t item[MAX_NUMBER_OF_OWNITEM];
int itemNumber;
int inventory[MAX_INVENTORY_SIZE];
int depot[MAX_DEPOT_SIZE];
int depotSE;
int equipment[MAX_EQUIPMENT];
int mouseInventory;
int mouseInventoryType;
int precocityTime[MAX_PRECOCITY_SIZE];
int precocityInventory[MAX_PRECOCITY_SIZE];
int craftSourceInventory[MAX_CRAFT_SOURCE_ITEM_SIZE];
int craftResultInventory[MAX_CRAFT_RESULT_ITEM_SIZE];
int npcAutoSourceInventory[MAX_AUTO_TRADEITEMFILD];
int upgradeSourceInventory[MAX_UPGRADE_SOURCE_ITEM_SIZE];
int upgradeResultInventory;
boothItem_t boothInventory[MAX_BOOTH_INVENTORY_SIZE];
char boothName[128];
char boothInfo[128];
int boothBuyerIdx[MAX_COUNT_BOOTH_BUYER];
int myTrade[MAX_TRADE_SIZE];
int otherTrade[MAX_TRADE_SIZE];
item_t tradeItem[MAX_TRADE_SIZE];
int tradeSE;
int otherTradeSE;
int tradeOkSignal;
int tradeAdmitSignal;
int flagChangeServer;
i3socket_t sock;
unsigned int syncTime;
unsigned int nextSaveTime;
vec3_t mousePos;
int isSetServerShutdown;
int gameMaster;
summons_t summonsInfo;
int changeServerWorldIdx;
int normalNetwork;
int gmBusy;
int gmHide;
int serverAckMsgNeedFlag;
int serverAckMsgWaitTimer;
int flagDBLoading;
int penaltyTime;
int levelUpTime;
int genLevelUpTime;
npcAiInPc_t npcAi;
int npcIdx;
int storeIdx;
int bindingIdx;
int killerIdx;
int killerType;
int curDamage;
int lastAttackState;
int busyState;
int friendlyEntityType;
int friendlyEntityIdx;
int friendlyEntityWorldIdx;
char friendlyEntityName[NAMESTRING+1];
int damagedEntityType;
int damagedEntityIdx;
int pvpMode;
int trainMonsterIdx[MAX_COUNT_TRAIN_MONSTER];
int trainMonsterTime[MAX_COUNT_TRAIN_MONSTER];
int numTrainMonster;
float autoRecoveryRATime;
float autoRecoverySATime;
float optValue[NUM_OPTION_VALUE];
int isTransform;
int transformType;
int transformEntityIdx;
char organizerName[NAMESTRING+1];
int organizeServer;
int organizeTime;
int memberNumber;
int canJoin;
partyMember_t member[MAX_NUMBER_OF_PARTY_MEMBER];
int partyIndex;
int isLeader;
int isSharingParty;
int partyExp;
int partyGenExp;
int serverAckMsgPartyFlag;
int serverAckMsgPartyWaitTimer;
int serverPartyErrorFlag;
float partyInfoRequestTime;
struct PartyRandom{
bool m_bischange;
int itemDivideType;
int m_iorderindex;
}_partyRandomInfo_t;
questVariable_t questVar[MAX_COUNT_QUEST_VARIABLE];
questInventory_t questInventory[MAX_COUNT_QUEST_INVENTORY];
questStatus_t questStatus[MAX_COUNT_QUEST_STATUS];
int questNumber;
int questPoint;
bool bautoeffectisvalid;
int hotkeyType[MAX_NUMBER_OF_HOTKEY];
int hotkeyIdx[MAX_NUMBER_OF_HOTKEY];
bool friendsBusy ;
FriendsList friends ;
int raCostPerSec;
int saCostPerSec;
short guildIdx;
int rankInGuild;
int rankIdxInGuild;
char guildName[GUILDNAMESTRING+1];
char tempGuildMateName[NAMESTRING+1];
struct tagGuild{
public:
struct tagFromInvite{
char Name[NAMESTRING+1];
};
public:
struct tagFromInvite FromInvite;
}Guild;
int skillDamage;
int RegGambleItems[MAX_NUMBER_OF_STORE_ITEM];
int RegGamblePrice[MAX_NUMBER_OF_STORE_ITEM];
struct tagGonryunBattle{
public:
enum{
NAK_per_ONEGOLD = 1000000,
};
struct tagTowGyun{
int iTournamentGUID;
int BuyNum;
};
struct tagShareWin{
public:
enum{
MAX_INVENTORY_NUMBER = 18,
};
public:
__int64 i64TotalNak;
int iFortuneStone;
int Inventory[MAX_INVENTORY_NUMBER];
};
struct tagObserver{
BOOL bActive;
};
public:
struct tagTowGyun TwoGyun;
struct tagShareWin ShareWin;
int m_iJoinNum;
BOOL m_bWaitingRoom;
struct tagObserver Observer;
}GonryunBattle;
struct tagGonryunBattlePractice{
public:
enum enumMemberShip{
MEMBERSHIP_NONE=0,
MEMBERSHIP_LEADER,
MEMBERSHIP_OPENENT,
MEMBERSHIP_WAITER,
};
enum {
MAX_GBP_INVENTORY_SIZE = 12,
};
struct tagRecord{
int iwin;
int idraw;
int idefeat;
};
public:
enum enumMemberShip MemberShip;
enum enumState PC_State;
int Inventory[MAX_GBP_INVENTORY_SIZE];
int iBattingSE;
BOOL bBattingOkSignal;
BOOL bBattingAdmitSignal;
struct tagRecord Record;
BOOL bisWaitrespond;
};
int BillSendType;
struct tagAddBill{
public:
enum enumStep{
step_none=0,
step_wait_game_start_packet,
step_billing,
step_end,
};
public:
int step;
char User_Status[3];
int time_trGameStartPacket;
}AddBill;
public:
struct tagPremiumInfo{
public:
enum{
maxmap_number=30,
max_charactor_slot_num=3,
};
enum enumMeberShipType{
Free=0,
Pay,
Max,
};
struct tagMap{
struct tagAttr
{
BOOL bAllow;
int iRemainSecond;
BOOL bDecreseRemainSecond;
BOOL bDecreseAllRemainSecond;
float fAddExpRatio;
float fAddGenExpRatio;
float fAddGenCapabilityRatio;
float fAddItemDropRatio;
float fAddNarkRatio;
};
struct tagAttr Default;
struct tagAttr Cur;
};
struct tagGamble{
public:
enum{
maxnum_apperance_item_group=16,
};
struct tagItemGroup{
BOOL bApperance;
};
public:
float fAddPriceRatio;
struct tagItemGroup ItemGroupArray[maxnum_apperance_item_group];
};
struct tagDie{
float fExpRatio;
float fNakRatio;
};
struct tagItemOptionUpgrade{
int iMaxlevel;
float fAddPriceRatio;
};
struct tagStatus{
int iDefaultInitCount;
int iInitCount;
};
struct tagGonyounPracticeBattle{
long lDateV2;
int iMaxCount;
int iDecreseCount;
};
struct tagWorldChatting{
long lDate;
int iMaxCount;
int iDecreaseCount;
};
struct tagItemDurability{
float fRepareCostRate;
int iPrepareRequirdurability;
};
public:
BOOL bLoad;
enum enumMeberShipType iMemberShipType;
int iRemainSecond;
struct tagMap Map[maxmap_number];
struct tagGamble Gamble;
struct tagItemOptionUpgrade ItemOptionUpgrade;
struct tagDie Die;
BOOL bCreatePremiumBooth;
int iMaxLevelItemCraft;
float fItemPrecocityTimeRatio;
BOOL bItemRecycle;
struct tagGonyounPracticeBattle GonyounPracticeBattle;
struct tagWorldChatting WorldChatting;
struct tagStatus Status;
struct tagItemDurability ItemDurability;
};
enum enumNameColor{
normal=0,
week=1,
month=2,
ramification=3,
year=4,
};
struct tagGiftCard{
public:
enum{
maxbytes_serial_num=20,
maxbytes_password=20,
step_none=0,
step_request,
};
public:
int step;
char serial[maxbytes_serial_num+1];
char password[maxbytes_password+1];
};
struct tagLogin{
public:
struct tagLoading{
BOOL bPremiumInfo;
BOOL bCharactor;
BOOL bQuest;
BOOL bQuestStatus;
BOOL bSkill;
BOOL bFriends;
BOOL bHelpList;
BOOL bItem;
};
public:
BOOL bComplete;
struct tagLoading Loading;
};
struct tagHelperAdd{
public:
struct tagReqPlayer{
int pcIdx;
char Name[NAMESTRING+1];
};
public:
struct tagReqPlayer RequestPlayer;
};
public:
enum enumNameColor enumNameColor;
struct tagPremiumInfo PremiumInfo;
CPostManager m_PostMng;
int m_ItemsInPost[CPostManager::MAX_POSTPACKAGE_COUNT];
struct tagPremiumInfo::tagMap *GetCurMap()
{
if(worldIdx < 0 || worldIdx >= tagPremiumInfo::maxmap_number) return NULL;
return &PremiumInfo.Map[worldIdx];
};
struct WorldChangeSystem m_WorldChangeSystem;
struct tagHelper tHelper;
struct tagHelperAdd HelperAdd;
struct tagGonryunBattlePractice GonryunBattlePractice;
struct tagGiftCard GiftCard;
BOOL m_bHide;
struct tagLogin Login;
public:
struct tagGM{
public:
struct tagChat{
public:
enum{
max_ban_time=60 * 60 * 24 * 30,
};
public:
int RemainBanTimePerSecond;
};
public:
struct tagChat Chat;
};
struct tagGM GM;
struct CashMallItem_OptionStone m_CashMall_OptionStone;
struct sPlayerItemExtendItemInfo m_ItemExtendInfo;
public:
struct sUserHackAckMsg{
BYTE byReqInfo[ANTICPSVRREQLEN];
BYTE byReqMsg[ANTICPSVRREQLEN];
BYTE byAckMsg[ANTICPCNTACKLEN];
float SendTime;
float ReciveTime;
BOOL MessageSend;
BYTE SendCount;
};
struct sUserHackAckMsg m_AhnLabMsg;
NewDanBattleSystem::DanBattleInfo DanBattleInfo;
int nAccumulationBattleKillPoint;
int GuildDeconstructionTime;
int GuildsecedeTime;
float fWorldChangeStartTime;
int iChangeWorldIdx;
int NetlastReceiveTime;
} playerCharacter_t;
typedef playerCharacter_t::tagPremiumInfo::tagMap PremiumMap;
typedef playerCharacter_t::tagPremiumInfo::enumMeberShipType PREMIUM_MEMBERSHIP_TYPE;
#define SAFE_PCS(p) (p < 0 || p >= MAX_PCS) ? 0 : 1
typedef enum
{
EQUIP_WEAPON_1,
EQUIP_WEAPON_2,
EQUIP_UPPER,
EQUIP_LOWER,
EQUIP_AIR_PROTECTOR,
EQUIP_BODY_PROTECTOR,
EQUIP_GLOVES,
EQUIP_BOOTS,
EQUIP_RING,
EQUIP_NECKLACE,
EQUIP_BRACELET,
EQUIP_EARRING,
EQUIP_TRANSFER,
EQUIP_EPACK,
NUM_EQUIP_POSITION
} characterEquipPosition_t;
enum
{
STATUS_FORCE = 0,
STATUS_SOULPOWER,
STATUS_AGILITY,
STATUS_VITALITY,
};
enum
{
TARGETING_ONLY_MONSTER = 0,
TARGETING_NORMAL,
TARGETING_SAFE,
TARGETING_EVERY,
TARGETING_EXCEPT_PARTY,
TARGETING_EXCEPT_GUILD,
};
enum
{
CHAOS_PURE = 0,
CHAOS_GENERAL,
CHAOS_DISORDER,
CHAOS_MONSTER,
CHAOS_ATROCITY,
NUM_CHAOS_TYPE,
};
typedef std::vector<playerCharacter_t *> LIST_PLAYER_STRUCT;
struct FriendEntry
{
byte level ;
byte job ;
byte worldIdx ;
char name[NAMESTRING];
};
#define MAX_MAIL_COUNT 50
#define MAIL_TITLESIZE 60
#define MAIL_STRSIZE 2000
struct MailEntry
{
byte mailIdx;
char fromName[NAMESTRING];
char mailTitle[MAIL_TITLESIZE];
char mailTime[32];
char mailStr[MAIL_STRSIZE];
byte mailState;
};
enum enumInvenType
{
INVENTYPE_INVENTORY = 0,
INVENTYPE_EQUIP,
};
enum enumRepairType
{
REPAIR_ITEM_SUB0=0,
REPAIR_ITEM_SUB1,
REPAIR_ITEM_ALL,
};
enum enumAwakenQuest
{
KNIGHT_QUEST_IDX = 5,
WIND_QUEST_IDX = 4,
WATER_QUEST_IDX = 6,
EARTH_QUEST_IDX = 8
};
| C++ |
enum
{
MON_ALIVE_STATE_SPAWN = 0,
MON_ALIVE_STATE_NORMAL,
MON_ALIVE_STATE_CORPSE,
MON_ALIVE_STATE_DISAPPEAR,
MON_ALIVE_STATE_DIE,
MON_ALIVE_STATE_FADE,
};
enum
{
MON_TYPE_CHE = 0,
MON_TYPE_MAMUL,
MON_TYPE_YOGOI,
MON_TYPE_YOGOISUNIN,
MON_TYPE_YAKRYOUNG,
};
enum
{
FIRST_ATTACK_POINT = 0,
FIRST_ATTACK_REVERSE_POINT,
ATTACK_POINT,
MYSTERY_POINT,
RECOVER_POINT,
TOTAL_POINT,
MAX_MONSTER_POINTS_NUM
};
#define MONSTER_SPAWN_ANIMATION_TIME 3000
#define MONSTER_DISAPPEAR_ANIMATION_TIME 3000
#define MONSTER_CORPSE_ANIMATION_TIME 5000
#define MAX_NUMBER_OF_MONSTER_SPAWN_TABLE 1000
#define MAX_NUMBER_OF_MONSTER_SPAWN_ZONE_TABLE 100
#define MAX_NUMBER_OF_SPAWN_ZONE_IDX 20
typedef struct
{
int idx;
vec3_t position;
vec3_t angle;
int range;
} monsterSpawnZoneTable_t;
typedef struct
{
entityType_t entityType;
int aiType;
int npcAiType;
int idx;
int monsterTableIdx;
int worldIdx;
int npcTableIdx;
int spawnZoneNumber;
int spawnZoneIdx[MAX_NUMBER_OF_SPAWN_ZONE_IDX];
int spawnZoneProbability[MAX_NUMBER_OF_SPAWN_ZONE_IDX];
int positionNumber;
vec3_t position[MAX_NUMBER_OF_RANDOM_POSITION];
vec3_t angles[MAX_NUMBER_OF_RANDOM_POSITION];
int wayPointNumber;
vec3_t wayPoint[MAX_NUMBER_OF_WAYPOINT];
int selectedIdx;
int respawnTime;
int smallZoneFlag;
vec3_t smallZonePosition;
} monsterSpawnTable_t;
typedef struct
{
int flag;
int entityIdx;
int entityType;
char entityName[NAMESTRING];
int atkPoint;
int defPoint;
int time;
float ContributionPoints[MAX_MONSTER_POINTS_NUM];
} monsterContribution_t;
#define MAX_NUMBER_OF_MONSTER_CONTRIBUTION 50
#define MAX_NUMBER_OF_JOINT_PC 10
#define MAX_NUMBER_OF_MONSTER_TABLE 500
#define MAX_NUMBER_OF_MONSTER_SKILL 5
typedef struct
{
enum ENUM_MONSTER_INFO
{
MAX_SUMMON_OPTION_VALUE=6,
};
int idx;
int active;
int aliveState;
float recoveryTime;
i3characterEvent_t event;
i3characterEvent_t oldEvent;
monsterBasicTable_t basic;
int tableIdx;
int spawnWorldIdx;
int spawnTableIdx;
int wayPointNumber;
vec3_t wayPoint[MAX_NUMBER_OF_WAYPOINT];
int respawnTime;
int deathTime;
BOOL bIgnoreRespawnTime;
entityType_t entityType;
int worldIdx;
int zoneIdx;
vec3_t position;
vec3_t Spawnposition;
vec3_t angles;
int generalSpeed;
float nextAngle;
ai_t ai;
message_t message[MAX_NUMBER_OF_MESSAGE];
int messageNumber;
float curRA;
float curSA;
float calMaxRA;
float calMaxSA;
int recoveryRARate;
int recoverySARate;
int calPhyMinDmg;
int calPhyMaxDmg;
int calMagMinDmg;
int calMagMaxDmg;
int calPosMinDmg;
int calPosMaxDmg;
int calNegMinDmg;
int calNegMaxDmg;
int calHitPower;
int calAttackDelay;
int attackSpeedRate;
int calAttackLength;
int calAttackRange;
float calCriticalRate;
int calCriticalDmg;
int calHitRate;
int calDefensePower;
int calPositiveRes;
int calNegativeRes;
float calVelocity;
int calStunTime;
int calAvoidPower;
affect_t affect[MAX_AFFECT];
int affectNumber;
monsterContribution_t conInfo[MAX_NUMBER_OF_MONSTER_CONTRIBUTION];
int maxAtkContributionPoint;
int conInfoNumber;
int mostConEntityType;
int mostConEntityIdx;
char mostConEntityName[NAMESTRING];
int targetType;
int targetIdx;
int damagedEntityType;
int damagedEntityIdx;
int searchEntityType;
int searchEntityIdx;
int forcedEntityType;
int forcedEntityIdx;
int bossEntityType;
int bossEntityIdx;
int npcTableIdx;
int npcAIFlag;
npcAi_t npcAi;
npcStruct_t npc;
int killerIdx;
int killerType;
int curDamage;
int lastAttackState;
int isSummon;
float summonTime;
float summonValidTime;
float autoRecoveryRATime;
float autoRecoverySATime;
int specialMonster;
int skillNumber;
skill_t skill[MAX_NUMBER_OF_MONSTER_SKILL];
float skillCooltime[MAX_NUMBER_OF_MONSTER_SKILL];
float skillCastingtime;
int skillCastingState;
int saveSkillIdx;
vec3_t saveSkillTargetPos;
int bonusSkillPoint;
int skillVariable[MAX_NUMBER_OF_SKILL_VARIABLE];
int selectedSkillIdx;
int skillUsePercent[MAX_NUMBER_OF_MONSTER_SKILL];
int totalOptNum;
int playerOptNum;
int SummonOptIndex[MAX_SUMMON_OPTION_VALUE];
float SummonOptValue[MAX_SUMMON_OPTION_VALUE];
BOOL bUsedSkill[10];
float fSpawnElapsedTime;
float fAiTempValue[5];
float fSkillAnimationTime[MAX_NUMBER_OF_MONSTER_SKILL];
float fSkillAnimationPassTime;
float optValue[NUM_OPTION_VALUE];
} monsterCharacter_t;
#define SAFE_MONSTER_SKILL_INDEX(p) ( p < 0 || p >= MAX_NUMBER_OF_MONSTER_SKILL) ? 0 : 1
typedef std::vector<monsterCharacter_t *> LIST_NONPLAYER_STRUCT;
| C++ |
#if !defined(AFX_CTERRABILLINGCTRL_H__F366D29E_FA42_4018_8DBA_0A9E735D3184__INCLUDED_)
#define AFX_CTERRABILLINGCTRL_H__F366D29E_FA42_4018_8DBA_0A9E735D3184__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CTerraBillingCtrl
{
public:
CTerraBillingCtrl();
virtual ~CTerraBillingCtrl();
};
#endif
| C++ |
#ifndef _TABLE_TOTAL_STRUCTURE_
#define _TABLE_TOTAL_STRUCTURE_
typedef struct
{
float pro;
int optionNumber;
float optionPro[MAX_NUMBER_OF_OPTION_IN_CLASS];
int optionIdx[MAX_NUMBER_OF_OPTION_IN_CLASS];
int optionMinValue[MAX_NUMBER_OF_OPTION_IN_CLASS];
int optionMaxValue[MAX_NUMBER_OF_OPTION_IN_CLASS];
} itemOptionSlot_t;
struct ITEMCOMMONFIELD_SKILLSPHERE
{
int skillTableIndex;
};
struct ITEMCOMMONFIELD_SPHERE
{
int sphereGrade;
};
struct ITEMCOMMONFIELD_PORTAL
{
int bindingIdx;
};
struct ITEMCOMMONFIELD_PRECOCITY
{
int precocityTime;
int outComeItemIndex;
int craftAdditionalPro;
int upgradeAdditionalPro;
};
struct ITEMCOMMONFIELD_OPTIONSPHERE
{
int optionSphereType;
int optionSphereGrade;
};
struct ITEMCOMMONFIELD_MONSTERSPHERE
{
int monsterIndex;
int number;
};
struct ITEMCOMMONFIELD_WORLD_PORTAL
{
BYTE IsActiveWorldPortal[MAX_WORLDS];
};
typedef enum
{
J_MENTALITY = 0,
J_WIND,
J_WATER,
J_EARTH,
J_DEVOTIONAL_KNIGHT,
J_ROMING_KNIGHT,
J_PIECING_EYES,
J_WINDY_ROMER,
J_DESTROYER,
J_GUARDIAN,
J_PROPHECIER,
J_TRANSFORMER,
J_DEFENDER,
J_STRANGER,
NUM_JOB_TYPE,
} SERVER_JOB_TYPE_t;
typedef struct
{
enum
{
EPK_TYPE_NORMAL=0,
EPK_TYPE_MUCH_CAPACITY,
};
enum
{
EPK_TYPE_UNCHARGE=0,
EPK_TYPE_CHARGE,
};
enum
{
EPK_CHARGE_TYPE_NPC=0,
EPK_CHARGE_TYPE_ITEM,
EPK_CHARGE_TYPE_BOTH,
};
enum
{
EPK_RECYCLE_TYPE_ENABLE=0,
EPK_RECYCLE_TYPE_DISABLE,
};
}TypeItemTable_t;
typedef struct
{
public:
enum{
MAXBYTES_NAME=31,
MAXBYTES_DOCUMENT=242,
};
enum
{
MAX_ITEM_TABLE_FLOAT_DATA=10,
MAX_ITEM_TABLE_INT_UNRESERVED = 110,
};
int idx;
int NameIdx;
int DocumentIdx;
char name[MAXBYTES_NAME+1];
char document[MAXBYTES_DOCUMENT+1];
int level;
int type;
int classIdx;
int rarity;
int wearPosition;
int size;
int weight;
int supplyRA;
int supplySA;
DWORD reqBeforeAT;
DWORD req1stAT;
DWORD req2ndAT;
DWORD req3rdAT;
int reqForce;
int reqAgility;
int reqSoulpower;
int reqVitality;
int reqNumber;
int sellYn;
int sellCost;
int gambleCost;
int durYn;
int durability;
int repairYn;
int onceRepairDecDur;
int skinningYn;
int skinningPosition;
int tagID;
int skinModelID[NUM_TABLE_GEN_TYPE];
int tagModelID[MAX_NUMBER_OF_ITEM_PART];
int tagMoveID[MAX_NUMBER_OF_ITEM_PART];
int mdlItemType;
int mdlItemID;
int iconItemID;
int attackAni[NUM_TABLE_GEN_TYPE];
int atkHanded;
int atkEffect;
int atkPhyMinDmg;
int atkPhyMaxDmg;
int atkMagMinDmg;
int atkMagMaxDmg;
int atkDelay;
int atkHitPower;
int atkLength;
int atkRange;
float atkCriticalRate;
int atkCriticalDmg;
int atkBowSACost;
int defPower;
int defAvoidPower;
int defPositiveRes;
int defNegativeRes;
int epkMaxChargeRA;
int epkMaxChargeSA;
int epkRecoveryRA;
int epkRecoverySA;
BYTE epkChargeMethod;
BYTE epkChargeType;
BYTE epkPackType;
int epkChargeCount;
BYTE epkRecycleType;
int upgBasicEfficiency;
int upgNumber;
int upgReqExp[6];
int etcItemType;
union
{
int commonField[16];
ITEMCOMMONFIELD_SKILLSPHERE skillSphere;
ITEMCOMMONFIELD_SPHERE sphere;
ITEMCOMMONFIELD_PORTAL portal;
ITEMCOMMONFIELD_PRECOCITY precocity;
ITEMCOMMONFIELD_OPTIONSPHERE optionSphere;
ITEMCOMMONFIELD_MONSTERSPHERE monsterSphere;
ITEMCOMMONFIELD_WORLD_PORTAL WorldPortal;
};
itemOptionSlot_t slotOpt[MAX_NUMBER_OF_ITEM_OPTION];
int stackFlag;
int useFlag;
int skinModelID_job[NUM_JOB_TYPE];
float defVelocity;
int defHitPower;
BYTE AuthorityType;
int iUnReserved[MAX_ITEM_TABLE_INT_UNRESERVED];
int iFluxDataIndex[MAX_ITEM_TABLE_FLOAT_DATA];
float fFluxData[MAX_ITEM_TABLE_FLOAT_DATA];
} itemTable_t;
typedef struct
{
int idx;
char name[128];
char printing[128];
float minValue;
float maxValue;
int group;
int grade;
DWORD availableOn;
int optionSphereType;
int dropOptionYn;
int unreserved[31];
} itemOptionTable_t;
#define MAX_COUNT_OPTION_TABLE 1000
#define MAX_COUNT_OPTION_GROUP_TABLE 1100
#define MAX_OPTION_GRADE 10
#define MAX_OPTIONSTONE_GRADE 5
#define MAX_OPTION_ITEM_TYPE 20
struct OPTIONVALUE
{
char valueName[64];
float value[MAX_OPTION_GRADE];
};
typedef struct
{
DWORD availableOn;
OPTIONVALUE value_item[MAX_OPTION_ITEM_TYPE];
} optionValue_t;
typedef struct
{
int idx;
char name[64];
char printing[64];
int dropYN;
int fixationPro;
int optionType;
int itemType[MAX_OPTION_ITEM_TYPE];
DWORD availableOn;
optionValue_t optValue[MAX_OPTIONSTONE_GRADE];
} optionTable_t;
typedef struct
{
int idx;
char name[64];
int optionIdx[MAX_NUMBER_OF_ITEM_OPTION];
int optionGrade[MAX_NUMBER_OF_ITEM_OPTION];
} optionGroupTable_t;
typedef struct
{
int index;
char type;
int optionGrade;
float point;
int minValue;
int maxValue;
} monsterSpawnOptionTable_t;
typedef struct
{
int idx;
int ClassNameIdx;
int wearPosition;
int weaponType;
int attackAtt;
int defenseAtt;
int packAtt;
int upgradeAtt;
int etcAtt;
int optionIdx[MAX_NUMBER_OF_OPTION_IN_CLASS];
int optionNumber;
int unreserved[ITEM_CLASS_TABLE_UNRESERVED_TOTAL_SIZE - ITEM_CLASS_TABLE_UNRESERVED_USED_SIZE];
} itemClassTable_t;
typedef struct
{
int idx;
char name[20];
char document[255];
int classIdx;
int itemIdx[MAX_NUMBER_OF_ITEM_IN_CLASS];
int itemNumber;
float itemPro[MAX_NUMBER_OF_ITEM_IN_CLASS];
int optionPro[MAX_NUMBER_OF_ITEM_OPTION + 1];
int optionNumber;
int balanceOptionLevel[MAX_NUMBER_OF_OPTION_IN_CLASS];
int graphType;
float graphXpos[MAX_NUMBER_OF_ITEM_IN_CLASS];
float abc[3];
int unreserved[ITEM_CLASS_GENERATE_UNRESERVED_TOTAL_SIZE - ITEM_CLASS_GENERATE_UNRESERVED_USED_SIZE];
} itemGenerateTable_t;
typedef struct
{
enum
{
ITEM_T_CHARGE_VALUE =0,
MAX_SIZE_OF_ITEM_SPAWN_DATA = 20,
};
char name[32];
int itemTableIdx;
int optionNumber;
int optionIdx[MAX_NUMBER_OF_ITEM_OPTION];
int optionValue[MAX_NUMBER_OF_ITEM_OPTION];
int durability;
int reqLevel;
int experience;
int timer;
struct sItemExtendInfo
{
enum enumItemUseFlag
{
ITEM_USE_FLAG_UN_CHECK = 1 << 0,
ITEM_USE_FLAG_ALLOW_DESTROY = 1 << 1,
ITEM_USE_FLAG_ALLOW_REPAIR = 1 << 2,
ITEM_USE_FLAG_PRIMIUM = 1 << 3,
ITEM_USE_FLAG_USE_TIME = 1 << 4,
ITEM_USE_FLAG_USE_DATE = 1 << 5,
};
struct sItemSpawnInfoMation
{
enum enumItemSpawnType
{
ITEM_SPAWN_TYPE_UNKNOW = 0,
ITEM_SPAWN_TYPE_OLDVER = 1,
ITEM_SPAWN_TYPE_STORE = 2,
ITEM_SPAWN_TYPE_MONSTER = 3,
ITEM_SPAWN_TYPE_GAMBLE = 4,
ITEM_SPAWN_TYPE_PRECOCITY = 5,
ITEM_SPAWN_TYPE_WEB_POST = 6,
ITEM_SPAWN_TYPE_CRAFT = 7,
ITEM_SPAWN_TYPE_QUEST = 8,
};
enum enumItemSpawnType ItemSpawnType;
char data[MAX_SIZE_OF_ITEM_SPAWN_DATA];
};
__int64 Serial;
sItemSpawnInfoMation ItemSpawnInfomation;
int UseFlag;
union
{
int AllowUseTime;
int AllowUseDate;
};
int CalclateUseDateToSec;
};
sItemExtendInfo ItemExtendInfo;
} item_t;
typedef item_t::sItemExtendInfo::sItemSpawnInfoMation ITEM_SPAWN_INFO;
typedef item_t::sItemExtendInfo::enumItemUseFlag ENUM_ITEM_USE_FLAG;
typedef struct
{
int maxLootNumber;
int generateIdx[MAX_NUMBER_OF_ITEM_LOOT];
int generateIdxNumber;
float generateProbaility[MAX_NUMBER_OF_ITEM_LOOT];
float lootingProbability;
int unreserved[MAX_NUMBER_OF_LOOT_ITEM_UNRESERVED_TOTAL_SIZE - MAX_NUMBER_OF_LOOT_ITEM_UNRESERVED_USED_SIZE];
} lootItem_t;
typedef struct
{
public:
enum{
MAXBYTES_NAME=31,
MAXBYTES_DOCUMENT=242,
};
public:
int idx;
int modelID;
int aniSetType;
int tagModelID[MAX_NUMBER_OF_ITEM_PART];
int tagMoveID[MAX_NUMBER_OF_ITEM_PART];
int level;
char name[MAXBYTES_NAME+1];
char document[MAXBYTES_DOCUMENT+1];
float phySize;
int size;
int type;
int gen;
int maxRA;
int maxSA;
int recoveryRARate;
int recoverySARate;
int attackAni;
int atkPhyMinDmg;
int atkPhyMaxDmg;
int atkMagMinDmg;
int atkMagMaxDmg;
int atkHitPower;
int atkDelay;
int atkLength;
int atkRange;
float atkCriticalPro;
int atkCriticalDmg;
int defPower;
int defAvoidPower;
int defPositiveRes;
int defNegativeRes;
float velocity;
int stunTime;
int skillIdx[MAX_NUMBER_OF_MONSTER_SKILL];
int skillLevel[MAX_NUMBER_OF_MONSTER_SKILL];
int skillAni[MAX_NUMBER_OF_MONSTER_SKILL];
int skillNumber;
int exp;
int genExp;
int lootSE;
lootItem_t lootItem;
int pathFindingSize;
int optionGrade;
int rareItemGrade;
int mapIconType;
int defDamageReduce;
int atkDefAffectedDegree;
int mapDensityWeight;
int respawnTime;
int AIScriptIdx;
int npcAIScriptIdx;
float physicalSize;
int traceSize;
int recognizeSize;
int unreserved[116];
} monsterBasicTable_t;
typedef struct
{
int classType;
int effectID;
int effectLevel[MAX_COUNT_EFFECT_LEVEL];
float fraction;
int zpos;
int target;
int activity;
int isSubEffect;
int subEffectID;
int notDefined[10];
} skillEffect_t;
typedef struct
{
int id;
char name[64];
int iconID;
int skillClass;
char desc[128];
int usageType;
int jobType;
int autoObtainFlag;
skillEffect_t effect;
int animID;
int reqGenLevel;
int reqBaseLevel;
int reqSkillID[NUM_OF_REQUIRE_SKILL];
int reqItemType;
int reqItem;
int reqLength;
int reqPartyGen[8];
int attackSkillFlag;
int attackAfterFlag;
int targetType;
char valueName[NUM_OF_SKILL_VALUE][128];
float valueInitial[NUM_OF_SKILL_VALUE];
float valueLevelUp[NUM_OF_SKILL_VALUE];
int valueMaxLevel[NUM_OF_SKILL_VALUE];
int valueGenGradeType[NUM_OF_SKILL_VALUE];
int valueGenGradeClass[NUM_OF_SKILL_VALUE];
int numValue;
int sphereCost;
int unreserved[127];
} skillTable_t;
typedef struct
{
enum SKILL_DAMAGE_TYPE
{
NONE_TYPE=0,
SKILL_DMG_PHYDMG,
SKILL_DMG_MYSTERY_POS_DMG,
SKILL_DMG_MYSTERY_NEG_DMG,
SKILL_DMG_DEFENCE,
};
} Skill_Enum_Data_Type;
#define MAX_NUMBER_OF_QUEST_ITEM_GENERATE 8
typedef struct
{
int monsterTableIdx;
int questIdx;
int step;
int itemNumber;
int itemTableIdx[MAX_NUMBER_OF_QUEST_ITEM_GENERATE];
float generateProbaility[MAX_NUMBER_OF_QUEST_ITEM_GENERATE];
int maxItemCount[MAX_NUMBER_OF_QUEST_ITEM_GENERATE];
} oldQuestItemGenerate_t;
typedef struct
{
int monsterTableIdx;
int itemNumber;
int questIdx[MAX_NUMBER_OF_QUEST_ITEM_GENERATE];
int step[MAX_NUMBER_OF_QUEST_ITEM_GENERATE];
int itemTableIdx[MAX_NUMBER_OF_QUEST_ITEM_GENERATE];
float generateProbaility[MAX_NUMBER_OF_QUEST_ITEM_GENERATE];
int maxItemCount[MAX_NUMBER_OF_QUEST_ITEM_GENERATE];
} questItemGenerate_t;
struct REWARDFIELD
{
int exp;
int genExp;
int genCap;
int nak;
int itemIndex;
int itemNo;
int optionGroup;
};
struct QSDATAFIELD
{
int monsterIndex;
int monsterNo;
int scrollType;
union
{
int rewardField[7];
REWARDFIELD reward;
};
int price;
int fame;
int level;
int nextScroll;
};
typedef struct
{
int Index;
char name[32];
char description[512];
union
{
int dataField[14];
QSDATAFIELD data;
};
} questscrollTable_t;
struct SummonMonster_t
{
int idx;
char name[32];
char doc[512];
float SummonTime;
UINT SummonWorldIdx;
};
struct GambleItem_t
{
enum AVAILABLE
{
OPTION_AVAILABLE_ON_DAGGER = 1,
OPTION_AVAILABLE_ON_1HSWORD,
OPTION_AVAILABLE_ON_2HSWORD,
OPTION_AVAILABLE_ON_BOW,
OPTION_AVAILABLE_ON_STAFF,
OPTION_AVAILABLE_ON_SPIRITOR,
OPTION_AVAILABLE_ON_CLAW,
OPTION_AVAILABLE_ON_ARMORS,
OPTION_AVAILABLE_ON_UPPER,
OPTION_AVAILABLE_ON_LOWER,
OPTION_AVAILABLE_ON_AIRPROTECTOR,
OPTION_AVAILABLE_ON_BODYPROTECTOR,
OPTION_AVAILABLE_ON_GLOVES,
OPTION_AVAILABLE_ON_BOOTS,
OPTION_AVAILABLE_ON_RING,
OPTION_AVAILABLE_ON_NECKLACE,
OPTION_AVAILABLE_ON_BRACELET,
OPTION_AVAILABLE_ON_EARRING,
OPTION_AVAILABLE_ON_EPACK,
OPTION_AVAILABLE_ON_ETC,
};
int type;
std::vector<int> vItem;
std::vector<int> vOption;
std::vector<float> vGambleRate;
float TotalGamebleRate;
~GambleItem_t()
{
vItem.clear();
vOption.clear();
vGambleRate.clear();
};
};
struct AUTOREWARDFIELD
{
int exp;
int genExp;
int genCap;
int nak;
int skillIdx;
int itemIdx;
int itemNo;
int optionGroup;
int fame;
int nextScroll;
int chaoPoin;
int rewardchaoPoint;
int regClass;
int regItemIndex0;
int regItemNo0;
int regItemOption0;
int regItemIndex1;
int regItemNo1;
int regItemOption1;
int regItemIndex2;
int regItemNo2;
int regItemOption2;
int regItemIndex3;
int regItemNo3;
int regItemOption3;
int questexcute;
int questitemindex;
};
struct AUTOQSDATAFIELD
{
int monsterIdx;
int monsterNo;
int npcIdx;
int missionItemIdx;
int missionTime;
int type;
int level;
int startexp;
int startLpack;
int endLpack;
union
{
int rewardField[27];
AUTOREWARDFIELD reward;
};
};
typedef struct
{
int Index;
char name[32];
union
{
int dataField[35];
AUTOQSDATAFIELD data;
};
} autoQuestScrollTable_t;
struct Consideration_t
{
int Idx;
char Name[32];
int Quantity;
int Exp;
int GenExp;
float SelectRate;
};
typedef struct
{
int index;
BOOL bcontrol;
BOOL bgamble;
int levelMin;
int levelMax;
int joinNum;
BOOL bdeposit;
int deposit;
int progressIdx;
} golryunManagerTable_t;
typedef struct
{
int index;
int rewardIdx;
unsigned int statusTime[7];
} golryunProgressTable_t;
typedef struct
{
int chooseRate;
int expRate;
int rewardExp;
int rewardItem;
int provisionNum;
bool setOption;
} golryunRewardField;
typedef struct
{
int id;
int groupIdx;
golryunRewardField rewardField[3];
} golryunItemGroupTable_t;
typedef struct
{
int index;
int rewardType;
BOOL bsetWaiting;
int waitingExp;
BOOL bsetDefeat;
int defeatExp;
int setReward;
int rewardItemRate;
int rewardGroupIdx[3];
} golryunRewardManagerTable_t;
#endif | C++ |
#if !defined(AFX_SKILLDATACHECKPROC_H__58F15E15_DEF2_4990_A861_7B332E6E2B0A__INCLUDED_)
#define AFX_SKILLDATACHECKPROC_H__58F15E15_DEF2_4990_A861_7B332E6E2B0A__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CSkillDataCheckProc
{
public:
CSkillDataCheckProc();
virtual ~CSkillDataCheckProc();
bool CheckSkillProc(void *pPc,CStr_Skill_Msg *msg);
};
extern CSkillDataCheckProc g_SkillDataCheckProc;
#endif
| C++ |
#include "../global.h"
#ifdef _OLD_SKILL_VER
void SKILL_WaterFreezer( void *pPc, float *pValue )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float dmg, slowPro, slowRate, magbonus;
int slowTime;
messageInfo_t msginfo;
message_t message;
dmg = pValue[SKILL_VALUE_0];
slowPro = pValue[SKILL_VALUE_1];
slowTime = (int)pValue[SKILL_VALUE_2] * 1000;
slowRate = pValue[SKILL_VALUE_3];
magbonus = pValue[SKILL_VALUE_4];
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_ATTACK;
msginfo.attack.atkType = MSGINFO_ATK_TYPE_MAGIC;
msginfo.attack.hitRate = 100;
msginfo.attack.phyMinDmg = (int)( (float)pc->calMagMinDmg * ( 1.0f + dmg * 0.01f ) + pc->calPhyMinDmg + magbonus);
msginfo.attack.phyMaxDmg = (int)( (float)pc->calMagMaxDmg * ( 1.0f + dmg * 0.01f ) + pc->calPhyMaxDmg + magbonus);
msginfo.attack.criticalRate = 0;
msginfo.attack.criticalDamage = 0;
msginfo.attack.delayTime = pc->calAttackDelay;
msginfo.attack.repeatNum = 0;
msginfo.targetType = pc->targetType;
msginfo.targetIdx = pc->targetIdx;
msginfo.attack.etcInfo = MSGINFO_ATK_ETC_MULTIDAMAGE_DELAY;
msginfo.attack.etcData0 = 2000;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = 10;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_CURSE;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_POSITIVE;
msginfo.affect.startTime = g_globalTime + 1000;
msginfo.affect.keepTime = msginfo.affect.startTime + slowTime;
msginfo.affect.hitRate = (int)slowPro;
msginfo.targetType = pc->targetType;
msginfo.targetIdx = pc->targetIdx;
msginfo.affect.common.type[0] = AFFDATA_TYPE_VELOCITY_RATE;
msginfo.affect.common.data[0] = -(int)slowRate;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_RARecovery(void* pPc, float* pValue)
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float raRecovery = pValue[SKILL_VALUE_0];
switch( pc->targetType )
{
case ENTITY_PC :
g_pc[pc->targetIdx].curRA += raRecovery;
g_pc[pc->targetIdx].curRA += (float)raRecovery * g_pc[pc->targetIdx].optValue[OV_HEAL_EFFICIENCY] * 0.01f;
if( g_pc[pc->targetIdx].curRA > g_pc[pc->targetIdx].calMaxRA )
g_pc[pc->targetIdx].curRA = g_pc[pc->targetIdx].calMaxRA;
break;
}
}
void SKILL_HitandReturn(void* pPc, float* pValue)
{
float dmg, hitPro;
float moveSp, criPro, phybonus;
messageInfo_t msginfo;
message_t message;
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
dmg = pValue[SKILL_VALUE_0];
hitPro = pValue[SKILL_VALUE_1];
moveSp = pValue[SKILL_VALUE_2];
criPro = pValue[SKILL_VALUE_3];
phybonus = pValue[SKILL_VALUE_4];
memset( &msginfo, 0, sizeof(messageInfo_t) );
msginfo.infoType = MSGINFO_TYPE_ATTACK;
msginfo.attack.atkType = MSGINFO_ATK_TYPE_NORMAL;
msginfo.attack.hitPower = (int)((float)pc->calHitPower * hitPro * 0.01f);
msginfo.attack.phyMinDmg = (int)((float)pc->calPhyMinDmg + (float)pc->calPhyMinDmg * hitPro * 0.01 + (float)pc->calMagMinDmg + phybonus);
msginfo.attack.phyMaxDmg = (int)((float)pc->calPhyMaxDmg + (float)pc->calPhyMaxDmg * hitPro * 0.01 + (float)pc->calMagMaxDmg + phybonus);
msginfo.attack.criticalRate = (int)criPro;
msginfo.targetType = pc->targetType;
msginfo.targetIdx = pc->targetIdx;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_BeFrozen(void* pPc, float* pValue)
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float dmg, freezePro, magbonus;
int keepTime;
messageInfo_t msginfo;
message_t message;
dmg = pValue[SKILL_VALUE_0];
freezePro = pValue[SKILL_VALUE_1];
keepTime = (int)pValue[SKILL_VALUE_2] * 1000;
magbonus = pValue[SKILL_VALUE_3];
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_ATTACK;
msginfo.attack.atkType = MSGINFO_ATK_TYPE_MAGIC;
msginfo.attack.hitRate = 100;
msginfo.attack.phyMinDmg = (int)( (float)pc->calMagMinDmg * ( 1.0f + dmg * 0.01f ) + pc->calPhyMinDmg + magbonus);
msginfo.attack.phyMaxDmg = (int)( (float)pc->calMagMaxDmg * ( 1.0f + dmg * 0.01f ) + pc->calPhyMaxDmg + magbonus);
msginfo.attack.criticalRate = 0;
msginfo.attack.criticalDamage = 0;
msginfo.attack.delayTime = pc->calAttackDelay;
msginfo.attack.repeatNum = 0;
msginfo.targetType = pc->targetType;
msginfo.targetIdx = pc->targetIdx;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = 13;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_CURSE;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_POSITIVE;
msginfo.affect.startTime = g_globalTime + 1000;
msginfo.affect.keepTime = msginfo.affect.startTime + (int)keepTime;
msginfo.affect.hitRate = (int)freezePro;
msginfo.targetType = pc->targetType;
msginfo.targetIdx = pc->targetIdx;
msginfo.affect.common.type[0] = AFFDATA_TYPE_PARALYSIS;
msginfo.affect.common.data[0] = 0;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_TrainStaff( void *pPc, float *pValue )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float dmg;
dmg = pValue[SKILL_VALUE_0];
pc->calMagMinDmg += dmg;
pc->calMagMaxDmg += dmg;
}
void SKILL_CoolFrame(void* pPc, float* pValue)
{
float dmg;
float magbonus;
messageInfo_t msginfo;
message_t message;
playerCharacter_t* pc = NULL;
pc = static_cast<playerCharacter_t *>(pPc);
if( pc == NULL ) return;
dmg = pValue[SKILL_VALUE_0];
magbonus = pValue[SKILL_VALUE_1];
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_ATTACK;
msginfo.attack.atkType = MSGINFO_ATK_TYPE_MAGIC;
msginfo.attack.hitRate = 100;
msginfo.attack.phyMinDmg = (int)( (float)pc->calMagMinDmg * ( 1.0f + dmg * 0.01f ) + pc->calPhyMinDmg + magbonus);
msginfo.attack.phyMaxDmg = (int)( (float)pc->calMagMaxDmg * ( 1.0f + dmg * 0.01f ) + pc->calPhyMaxDmg + magbonus);
msginfo.attack.criticalRate = 0;
msginfo.attack.criticalDamage = 0;
msginfo.attack.delayTime = pc->calAttackDelay;
msginfo.attack.repeatNum = 0;
msginfo.targetType = pc->targetType;
msginfo.targetIdx = pc->targetIdx;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_SAUseDecrease( void* pPc, float* pValue)
{
int keepTime;
float DecSa;
messageInfo_t msginfo;
message_t message;
playerCharacter_t* pc = NULL;
pc = static_cast<playerCharacter_t *>(pPc);
if( pc == NULL ) return;
DecSa = pValue[SKILL_VALUE_0];
keepTime = (int)pValue[SKILL_VALUE_1] * 1000;
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = 31;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_ASSIST;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msginfo.affect.startTime = g_globalTime;
msginfo.affect.keepTime = g_globalTime + keepTime;
msginfo.targetType = ENTITY_PC;
msginfo.targetIdx = pc->idx;
msginfo.affect.common.type[0] = AFFDATA_TYPE_DECREASESAUSE;
msginfo.affect.common.data[0] = DecSa;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_Resurrection(void* pPc, float* pValue)
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float raRec = pValue[SKILL_VALUE_0];
float saRec = pValue[SKILL_VALUE_1];
float expRecRate = pValue[SKILL_VALUE_2];
message_t message;
switch(pc->targetType){
case ENTITY_PC :
if( g_pc[pc->targetIdx].alive ) return;
break;
default:
case ENTITY_MONSTER :
case ENTITY_NPC :
return;
break;
}
message.type = MSG_ETC;
message.fromIdx = pc->idx;
message.fromType = ENTITY_PC;
strcpy( message.fromName, pc->name );
message.toType = pc->targetType;
message.toIdx = pc->targetIdx;
message.worldIdx = pc->worldIdx;
message.sendTime = g_globalTime;
message.receiveTime = g_globalTime + 1500;
message.data[0] = MSG_ETC_RESURRECTION;
message.data[1] = (int)raRec;
message.data[2] = (int)saRec;
message.data[3] = (int)expRecRate;
AI_SendMessage( &message );
}
void SKILL_WatSelfHeal(void* pPc, float* pValue)
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float raRecovery = pValue[SKILL_VALUE_0];
switch( pc->entityType )
{
case ENTITY_PC :
g_pc[pc->idx].curRA += raRecovery;
g_pc[pc->idx].curRA += (float)raRecovery * g_pc[pc->idx].optValue[OV_HEAL_EFFICIENCY] * 0.01f;
if( g_pc[pc->idx].curRA > g_pc[pc->idx].calMaxRA )
g_pc[pc->idx].curRA = g_pc[pc->idx].calMaxRA;
break;
}
}
void SKILL_ManaShield( void* pPc, float* pValue )
{
float keepTime;
messageInfo_t msginfo;
message_t message;
playerCharacter_t* pc = NULL;
pc = static_cast<playerCharacter_t *>(pPc);
if( pc == NULL ) return;
keepTime = pValue[SKILL_VALUE_0] * 1000.0f;
memset( &msginfo, 0, sizeof(messageInfo_t) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = 47;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_ASSIST;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msginfo.affect.startTime = g_globalTime;
msginfo.affect.keepTime = g_globalTime + (int)keepTime;
msginfo.targetType = ENTITY_PC;
msginfo.targetIdx = pc->idx;
msginfo.affect.common.type[0] = AFFDATA_TYPE_MANASHIELD;
msginfo.affect.common.data[0] = (int)1;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_SummonJude(void* pPc, float* pValue)
{
float dmg, magBonus, range;
messageInfo_t msginfo;
message_t message;
playerCharacter_t* pc = NULL;
pc = static_cast<playerCharacter_t *>(pPc);
if( pc == NULL ) return;
dmg = pValue[SKILL_VALUE_0];
magBonus = pValue[SKILL_VALUE_1];
range = pValue[SKILL_VALUE_2];
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_ATTACK;
msginfo.attack.atkType = MSGINFO_ATK_TYPE_NORMAL;
msginfo.attack.hitRate = 100;
msginfo.attack.phyMinDmg = (int)( (float)pc->calMagMinDmg * ( 1.0f + dmg * 0.01f ) + pc->calPhyMinDmg + magBonus);
msginfo.attack.phyMaxDmg = (int)( (float)pc->calMagMaxDmg * ( 1.0f + dmg * 0.01f ) + pc->calPhyMaxDmg + magBonus);
msginfo.attack.delayTime = pc->calAttackDelay;
msginfo.targetType = pc->targetType;
msginfo.targetIdx = pc->targetIdx;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message, (int)range, MSG_RANGE_TYPE_TARGET );
}
void SKILL_RARecovery2(void* pPc, float* pValue)
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float raRecovery = pValue[SKILL_VALUE_0];
switch( pc->targetType )
{
case ENTITY_PC :
g_pc[pc->targetIdx].curRA += raRecovery;
g_pc[pc->targetIdx].curRA += (float)raRecovery * g_pc[pc->targetIdx].optValue[OV_HEAL_EFFICIENCY] * 0.01f;
if( g_pc[pc->targetIdx].curRA > g_pc[pc->targetIdx].calMaxRA )
g_pc[pc->targetIdx].curRA = g_pc[pc->targetIdx].calMaxRA;
break;
}
}
void SKILL_ResurrectionUpgrade(void* pPc, float* pValue)
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float raRec = pValue[SKILL_VALUE_0];
float saRec = pValue[SKILL_VALUE_1];
float expRecRate = pValue[SKILL_VALUE_2];
message_t message;
switch( pc->targetType )
{
case ENTITY_PC :
if( g_pc[pc->targetIdx].alive ) return;
break;
case ENTITY_MONSTER : case ENTITY_NPC :
return;
break;
}
message.type = MSG_ETC;
message.fromIdx = pc->idx;
message.fromType = ENTITY_PC;
strcpy( message.fromName, pc->name );
message.toType = pc->targetType;
message.toIdx = pc->targetIdx;
message.worldIdx = pc->worldIdx;
message.sendTime = g_globalTime;
message.receiveTime = g_globalTime + 1500;
message.data[0] = MSG_ETC_RESURRECTION;
message.data[1] = (int)raRec;
message.data[2] = (int)saRec;
message.data[3] = (int)expRecRate;
AI_SendMessage( &message );
}
void SKILL_AttackDmgUp(void* pPc, float* pValue)
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float dmg = pValue[SKILL_VALUE_0];
float keepTime = pValue[SKILL_VALUE_1] * 1000.0f;
messageInfo_t msginfo;
message_t message;
memset( &msginfo, 0, sizeof( messageInfo_t ) );
memset( &message, 0, sizeof( message_t ) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = 52;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_ASSIST;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msginfo.affect.startTime = g_globalTime;
msginfo.affect.keepTime = g_globalTime + (int)keepTime;
msginfo.affect.common.type[0] = AFFDATA_TYPE_PHYDAMAGE;
msginfo.affect.common.data[0] = dmg;
msginfo.targetType = pc->targetType;
msginfo.targetIdx = pc->targetIdx;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_SkillSooho(void* pPc, float* pValue)
{
float dmg;
float magbonus;
messageInfo_t msginfo;
message_t message;
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
dmg = pValue[SKILL_VALUE_0];
magbonus = pValue[SKILL_VALUE_1];
memset( &msginfo, 0, sizeof(messageInfo_t) );
msginfo.infoType = MSGINFO_TYPE_ATTACK;
msginfo.attack.atkType = MSGINFO_ATK_TYPE_MAGIC;
msginfo.attack.hitRate = 100;
msginfo.attack.phyMinDmg = (int)( (float)pc->calMagMinDmg * ( 1.0f + dmg * 0.01f ) + pc->calPhyMinDmg + magbonus);
msginfo.attack.phyMaxDmg = (int)( (float)pc->calMagMaxDmg * ( 1.0f + dmg * 0.01f ) + pc->calPhyMaxDmg + magbonus);
msginfo.attack.criticalRate = 0;
msginfo.attack.criticalDamage = 0;
msginfo.attack.delayTime = pc->calAttackDelay;
msginfo.attack.repeatNum = 0;
msginfo.targetType = pc->targetType;
msginfo.targetIdx = pc->targetIdx;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_IncreaseRa(void* pPc, float* pValue )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float increaseRA = pValue[SKILL_VALUE_0];
float keepTime = pValue[SKILL_VALUE_1] * 1000.0f;
messageInfo_t msginfo;
message_t message;
memset( &msginfo, 0, sizeof( messageInfo_t ) );
memset( &message, 0, sizeof( message_t ) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = 59;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_ASSIST;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msginfo.affect.startTime = g_globalTime;
msginfo.affect.keepTime = g_globalTime + (int)keepTime;
msginfo.affect.common.type[0] = AFFDATA_TYPE_MAXRA;
msginfo.affect.common.data[0] = increaseRA;
msginfo.targetType = pc->targetType;
msginfo.targetIdx = pc->targetIdx;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_RARecovery3(void* pPc, float* pValue)
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float raRecovery = pValue[SKILL_VALUE_0];
switch( pc->targetType )
{
case ENTITY_PC :
g_pc[pc->targetIdx].curRA += raRecovery;
g_pc[pc->targetIdx].curRA += (float)raRecovery * g_pc[pc->targetIdx].optValue[OV_HEAL_EFFICIENCY] * 0.01f;
if( g_pc[pc->targetIdx].curRA > g_pc[pc->targetIdx].calMaxRA )
g_pc[pc->targetIdx].curRA = g_pc[pc->targetIdx].calMaxRA;
break;
}
}
playerCharacter_t* GetPCPointer(const int Idx)
{
if((Idx < 0) || (Idx >= MAX_PCS)) return NULL;
if(FALSE == g_pc[Idx].active) return NULL;
return &g_pc[Idx];
}
void SKILL_Groupheal(void* parampPc, float* pValue)
{
playerCharacter_t* pPc = NULL;
pPc = static_cast<playerCharacter_t *>(parampPc);
if( NULL == pPc) return;
float raRecovery=0.0f;
float range=0.0f;
raRecovery = pValue[SKILL_VALUE_0];
range = pValue[SKILL_VALUE_1];
pPc->curRA += raRecovery;
pPc->curRA += (float)raRecovery * pPc->optValue[OV_HEAL_EFFICIENCY] * 0.01f;
if(pPc->curRA > pPc->calMaxRA) pPc->curRA = pPc->calMaxRA;
playerCharacter_t* pMemberPC=NULL;
partyMember_t* pPartyMemberList=NULL;
int PartyMemberIdx=0;
for(PartyMemberIdx = 0; PartyMemberIdx < MAX_NUMBER_OF_PARTY_MEMBER ; PartyMemberIdx ++){
pPartyMemberList=&(pPc->member[PartyMemberIdx]);
if ( pPartyMemberList == NULL) continue;
if(pPartyMemberList->serverIndex < 0 ) continue;
if( pPartyMemberList->serverIndex != g_config.gameServerNo ) continue;
pMemberPC=GetPCPointer(pPartyMemberList->idxOnServer);
if(NULL == pMemberPC) continue;
if(FALSE == pMemberPC->alive ) continue;
if(pPc == pMemberPC) continue;
if ( pMemberPC->worldIdx != pPc->worldIdx ) continue;
if(0 != stricmp(pMemberPC->name, pPartyMemberList->memberName ) ) continue;
if( GTH_GetDistance2D( pPc->position, pMemberPC->position) > range ) continue;
pMemberPC->curRA += raRecovery;
pMemberPC->curRA += (float)raRecovery * pMemberPC->optValue[OV_HEAL_EFFICIENCY] * 0.01f;
if( pMemberPC->curRA > pMemberPC->calMaxRA ) pMemberPC->curRA = pMemberPC->calMaxRA;
}
}
#endif | C++ |
#include "../global.h"
#include "SkillApp.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
#define CHARACTER_DEFAULT_GEN_LEVEL 1
CSkillCastData g_SkillCastDataList;
CSkillDataGlobal g_SkillDataGlobal;
CSkillDataTableList g_SkillDataTableList;
CSkillDataGlobal::CSkillDataGlobal()
{
}
CSkillDataGlobal::~CSkillDataGlobal()
{
Clear();
}
void CSkillDataGlobal::Clear()
{
g_SkillCastDataList.Clear();
g_SkillDataTableList.Clear();
g_SkillTableDB.ClearDB();
}
float CSkillDataGlobal::GetValue(void *pPc,BYTE _Type,CStr_Skill_Msg *msg,int _nSkillID,int _nMySkillIndex)
{
int nSkillID=_nSkillID;
int nMySkillIndex=_nMySkillIndex;
if(msg)
{
nSkillID = msg->nSkillID;
nMySkillIndex = msg->nMySkillIndex;
}
float fError = 0.0f;
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(nSkillID);
if(pSkillTable==NULL) return fError;
CSkillDataFormat *pDataFormat = pSkillTable->GetDataFormat();
if(pDataFormat == NULL) return fError;
for(int i=0;i<MAX_SKILL_VALUE_LIST;i++)
{
if(pDataFormat->m_ValueList[i].m_Type == _Type)
{
CSkillTableData *pTable = g_SkillDataTableList.Get(_Type,pDataFormat->m_ValueList[i].m_nIndex-1);
if(pTable == NULL)
{
break;
}
int GenLevel = CHARACTER_DEFAULT_GEN_LEVEL;
if(msg != NULL && msg->nSkillLevel > 0)
{
GenLevel = msg->nSkillLevel;
}
else if(msg != NULL && msg->pPartyMeber != NULL)
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPartyMeber);
if(pc !=NULL && (nMySkillIndex >=0 && nMySkillIndex <MAX_NUMBER_OF_SKILL ))
{
GenLevel = pc->skill[nMySkillIndex].level.gen[pTable->m_bGenGrade];
}
}
else if(pTable->m_bGenGrade < NUM_JOB_TYPE)
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(pc !=NULL && (nMySkillIndex >=0 && nMySkillIndex <MAX_NUMBER_OF_SKILL ))
{
GenLevel = pc->skill[nMySkillIndex].level.gen[pTable->m_bGenGrade];
}
}
if(pTable->m_bMaxLv < GenLevel)
{
GenLevel = pTable->m_bMaxLv;
}
if(GenLevel <= 0) GenLevel=CHARACTER_DEFAULT_GEN_LEVEL;
if(GenLevel ==CHARACTER_DEFAULT_GEN_LEVEL)
{
return pTable->m_fValue;
}
else
{
CSkillTableData *pvalue =
g_SkillDataTableList.Get(_Type,pDataFormat->m_ValueList[i].m_nIndex-1+GenLevel-CHARACTER_DEFAULT_GEN_LEVEL);
if(pvalue == NULL)
{
break;
}
return pvalue->m_fValue;
}
}
else if(!pDataFormat->m_ValueList[i].m_Type)
{
break;
}
}
#ifdef SKILL_TEST_VERSION
TRACE("Error!! CSkillProcAttack::GetValue ...Type %d .. SkillID %d \n",_Type,nSkillID);
#endif
return fError;
}
int CSkillDataGlobal::GetGenLevel(void *pPc,int nSkillID,int _nMySkillIdx)
{
return CHARACTER_DEFAULT_GEN_LEVEL;
}
int CSkillDataGlobal::GetGrade(int pcJob)
{
switch(pcJob)
{
case J_MENTALITY:
case J_DEVOTIONAL_KNIGHT:
case J_ROMING_KNIGHT:
return J_MENTALITY;
case J_WIND :
case J_PIECING_EYES:
case J_WINDY_ROMER:
return J_WIND;
case J_WATER:
case J_DESTROYER:
case J_GUARDIAN:
return J_WATER;
case J_EARTH:
case J_TRANSFORMER:
case J_DEFENDER:
return J_EARTH;
}
#ifdef SKILL_TEST_VERSION
TRACE("Error!! GetGrade %d \n,pcJob");
#endif
return -1;
}
CSkillCastValue * CSkillDataGlobal::GetCastValue(void *pPc,void *pMon,int nSkillID,BYTE _Type,int nLevel,int _nMySkillIdx)
{
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(nSkillID);
if(pSkillTable==NULL) return NULL;
CSkillDataFormat *pDataFormat = pSkillTable->GetDataFormat();
if(pDataFormat == NULL) return NULL;
CSkillCastValue *pTable =NULL;
int i;
int GenLevel=CHARACTER_DEFAULT_GEN_LEVEL,MaxGenLevel=CHARACTER_DEFAULT_GEN_LEVEL;
for(i=0;i<MAX_SKILL_VALUE_LIST;i++)
{
if(pDataFormat->m_ValueList[i].m_Type)
{
if(pDataFormat->m_ValueList[i].m_Type == SKILL_CAST_TABLE_INDEX) continue;
if(pPc)
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
int nGrade = GetGrade(pc->pcJob);
if(nGrade <0) continue;
if(_nMySkillIdx > -1 && _nMySkillIdx < MAX_NUMBER_OF_SKILL)
{
if(pc) GenLevel = pc->skill[_nMySkillIdx].level.gen[nGrade];
}
else if(pPc != NULL)
{
if(pc)
{
for(int j=0;j<MAX_NUMBER_OF_SKILL;j++)
{
if(pc->skill[j].tableIdx == nSkillID)
{
GenLevel = pc->skill[j].level.gen[nGrade];
break;
}
}
}
}
else
{
GenLevel=nLevel;
}
}
else
{
GenLevel=CHARACTER_DEFAULT_GEN_LEVEL;
}
if(GenLevel <= 0) GenLevel=CHARACTER_DEFAULT_GEN_LEVEL;
if(MaxGenLevel < GenLevel)
{
MaxGenLevel = GenLevel;
}
}
else if(!pDataFormat->m_ValueList[i].m_Type)
{
break;
}
}
for(i=0;i<MAX_SKILL_VALUE_LIST;i++)
{
if(pDataFormat->m_ValueList[i].m_Type == _Type)
{
pTable = g_SkillCastDataList.Get(pDataFormat->m_ValueList[i].m_nIndex);
if(pTable == NULL)
{
return NULL;
}
CSkillCastValue *pLevelValue =
g_SkillCastDataList.Get(pDataFormat->m_ValueList[i].m_nIndex+(MaxGenLevel-CHARACTER_DEFAULT_GEN_LEVEL));
if(pLevelValue == NULL) return pTable;
return pLevelValue;
}
else if(!pDataFormat->m_ValueList[i].m_Type)
{
break;
}
}
#ifdef SKILL_TEST_VERSION
TRACE("Error! GetCastValue nSkillID %d, _Type %d\n", nSkillID , _Type );
#endif
return NULL;
}
playerCharacter_t* CSkillDataGlobal::GetPCPointer(const int Idx)
{
if((Idx < 0) || (Idx >= MAX_PCS))
{
return NULL;
}
if(FALSE == g_pc[Idx].active)
{
return NULL;
}
return &g_pc[Idx];
}
int CSkillDataGlobal::GetLimitlevel(int skillTableIdx,int nGenType)
{
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(skillTableIdx);
if(pSkillTable==NULL) return NULL;
CSkillDataFormat *pDataFormat = pSkillTable->GetDataFormat();
if(pDataFormat == NULL) return 0;
int nGenLevel=0;
for(int i=0;i<MAX_SKILL_VALUE_LIST;i++)
{
if(pDataFormat->m_ValueList[i].m_Type)
{
CSkillTableData *pTable = g_SkillDataTableList.Get(pDataFormat->m_ValueList[i].m_Type,pDataFormat->m_ValueList[i].m_nIndex-1);
if(pTable == NULL) continue;
if(pTable->m_bMaxLv > nGenLevel)
{
nGenLevel = pTable->m_bMaxLv;
}
}
else if(!pDataFormat->m_ValueList[i].m_Type)
{
break;
}
}
return nGenLevel;
}
int CSkillDataGlobal::GetGradeClass(int skillTableIdx,int nGenType)
{
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(skillTableIdx);
if(pSkillTable==NULL) return NULL;
CSkillDataFormat *pDataFormat = pSkillTable->GetDataFormat();
if(pDataFormat == NULL) return 0;
int nGenCapablity=0;
for(int i=0;i<MAX_SKILL_VALUE_LIST;i++)
{
if(pDataFormat->m_ValueList[i].m_Type)
{
if( pDataFormat->m_ValueList[i].m_Type == SKILL_CAST_TABLE_INDEX) continue;
CSkillTableData *pTable = g_SkillDataTableList.Get(pDataFormat->m_ValueList[i].m_Type,pDataFormat->m_ValueList[i].m_nIndex-1);
if(pTable == NULL) continue;
if(pTable->m_bGenGrade == nGenType && pTable->m_bGenCapablity > nGenCapablity)
{
nGenCapablity = pTable->m_bGenCapablity;
}
}
else if(!pDataFormat->m_ValueList[i].m_Type)
{
break;
}
}
return nGenCapablity;
}
int CSkillDataGlobal::GetMessageType(int Type, message_t *message )
{
for(int i=0;i<MAX_SKILL_MESSAGE_DATA;i++)
{
if(message->Type[i] == Type)
{
return message->data[i];
}
}
return 0;
}
int CSkillDataGlobal::IsDataFormatType(const int skillTableIdx,const int Type)
{
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(skillTableIdx);
if(pSkillTable==NULL) return 0;
CSkillDataFormat *pDataFormat = pSkillTable->GetDataFormat();
if(pDataFormat == NULL) return 0;
for(int i=0;i<CSkillDataFormat::MAX_NUM_OF_DATA;i++)
{
if(0 == pDataFormat->m_Data[i]) return 0;
if(Type == pDataFormat->m_Data[i])
{
return true;
}
}
return 0;
}
| C++ |
#if !defined(AFX_SKILLPROC_H__1D5E71BE_020A_417C_B7ED_E12B3419AC52__INCLUDED_)
#define AFX_SKILLPROC_H__1D5E71BE_020A_417C_B7ED_E12B3419AC52__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#define SKILL_TEST_VERSION 1
class CSkillProc
{
public:
CSkillProc();
virtual ~CSkillProc();
bool Active(void *pPc,CStr_Skill_Msg *msg);
bool BasicActive(void *pPc,CStr_Skill_Msg *msg);
bool AttackActive(void *pPc,CStr_Skill_Msg *msg);
bool AffectActive(void *pPc,CStr_Skill_Msg *msg);
bool AffectCommonActive(void *pPc,CStr_Skill_Msg *msg);
bool AffectSpe(void *pPc,CStr_Skill_Msg *msg);
bool MessageActive(void *pPc,CStr_Skill_Msg *msg);
int Proc(void *pPc,CStr_Skill_Msg *msg);
bool CastActive(void *pPc,CStr_Skill_Msg *msg);
bool SendMessageProc(void *pPc,CStr_Skill_Msg *msg);
bool MakeMessageProc(void *pPc,CStr_Skill_Msg *msg);
void MultiDamageSkill(void *pPc,CStr_Skill_Msg *msg,int Index);
CSkillProcAffectSpe *GetAffectSpe()
{
return &m_AffectSpe;
}
public:
CSkillProcBasic m_BasicDataProc;
CSkillProcAttack m_AttackDataProc;
CSkillProcAffect m_AffectDataProc;
CSkillProcAffectCommon m_AffectCommonDataProc;
CSkillProcAffectSpe m_AffectSpe;
};
extern CSkillProc g_SkillProc;
#endif
| C++ |
#include "../global.h"
#include "SkillApp.h"
CSkillProcAttack::CSkillProcAttack()
{
}
CSkillProcAttack::~CSkillProcAttack()
{
}
int CSkillProcAttack::GetAttackType(BYTE _Type,void *pPc,int nSkillID)
{
switch(_Type) {
case SKILL_ATK_TYPE_NORMAL: return MSGINFO_ATK_TYPE_NORMAL;
case SKILL_ATK_TYPE_MAGIC: return MSGINFO_ATK_TYPE_MAGIC;
case SKILL_ATK_TYPE_EFFECT: return MSGINFO_ATK_TYPE_EFFECT;
case SKILL_ATK_TYPE_NONE: return MSGINFO_ATK_TYPE_NONE;
}
TRACE("Error!! GetAttackType ... %d \n",_Type);
return NO_TYPE;
}
int CSkillProcAttack::GetHitPower(BYTE _Type,CStr_Skill_Msg *msg)
{
switch(_Type) {
case SKILL_HITPOWER_HITPRO:
{
float fHitPro = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_HITPOWER,msg);
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
return (int)((float)pc->calHitPower * fHitPro * 0.01f);
}
}
break;
case SKILL_HITPOWER_NORMAL:
{
switch(msg->pDataFormat->m_ClassType)
{
case SKILL_CLASS_PC:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(NULL == pc) return 0;
float fHitPro = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_HITPOWER,msg);
return (int)((float)pc->calHitPower * (1.0f + fHitPro * 0.01f));
}
break;
case SKILL_CLASS_MON:
{
monsterCharacter_t* pMon = static_cast<monsterCharacter_t*>(msg->pPc);
if(NULL == pMon) return 0;
float fHitPro = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_HITPOWER,msg);
return (int)((float)pMon->calHitPower * (1.0f + fHitPro * 0.01f));
}
break;
}
}
break;
case SKILL_HITPOWER_VALUE:
{
float fHitPro = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_HITPOWER,msg);
return fHitPro;
}
break;
}
TRACE("Error!! GetHitPower ... %d \n",_Type);
return NO_TYPE;
}
int CSkillProcAttack::GetHiteRate(BYTE _Type,CStr_Skill_Msg *msg)
{
switch(_Type) {
case SKILL_HITRATE_VALUE:
{
float fHitRate = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_HITRATE,msg);
return fHitRate;
}
break;
case SKILL_HITRATE_PANELTY:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
float fHitRate = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_HITRATE,msg);
if(pc)
{
if(!SAFE_MONSTER(pc->targetIdx)) return 0;
int level = (pc->level - g_monster[pc->targetIdx].basic.level);
if( level < 0 ) level = 0;
float panelty = 1.0f - 0.03 * (float)level;
return (fHitRate * 0.01 * panelty);
}
break;
}
}
TRACE("Error!! GetHiteRate ... %d \n",_Type);
return NO_TYPE;
}
int CSkillProcAttack::GetPhyMinDmg(BYTE _Type,CStr_Skill_Msg *msg)
{
switch(_Type) {
case SKILL_PHYMINDMG_NORMAL:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fDmg = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_PHYMINDMG,msg);
return (int)( (float)pc->calPhyMinDmg * (1.0f + fDmg * 0.01f) + pc->calMagMinDmg );
}
}
break;
case SKILL_PHYMINDMG_VALUE:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fDmg = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_PHYMINDMG,msg);
return fDmg;
}
}
break;
case SKILL_PHYMINDMG_MON:
{
monsterCharacter_t* pMon = static_cast<monsterCharacter_t*>(msg->pPc);
if(pMon)
{
float fDmg = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_PHYMINDMG,msg);
return fDmg + pMon->calPhyMinDmg;
}
}
break;
case SKILL_PC_PHYMINDMG_ADD_VALUE:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
int nGrade = g_SkillDataGlobal.GetGrade(pc->pcJob);
if(nGrade <0 || nGrade >= SKILL_MAX_BASIC_JOB_TYPE) return 0;
float fDmg = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_PHYBONUS_MENTALITY+nGrade,msg);
pc->calPhyMinDmg += fDmg;
return 0;
}
}
break;
case SKILL_PHYMINDMG_MAGIC:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fDmg = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_POSMINDMG,msg);
return (int)((float)pc->calMagMinDmg * ( 1.0f + fDmg * 0.01f ) + pc->calMagMinDmg );
}
}
break;
case SKILL_PHYMINDMG_NORMAL_PHYBONUS :
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fDmg = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_PHYMINDMG,msg);
float fBonus = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_PHYBONUS,msg);
return (int)( (float)pc->calPhyMinDmg * (1.0f + fDmg * 0.01f ) + pc->calMagMinDmg + fBonus );
}
}
break;
case SKILL_PHYMINDMG_MAGIC_PHYBONUS:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fDmg = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_POSMINDMG,msg);
float fPosBonus = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_POSBONUS,msg);
return (int)((float)pc->calMagMinDmg * ( 1.0f + fDmg * 0.01f ) + pc->calMagMinDmg + fPosBonus);
}
}
break;
}
TRACE("Error!! GetPhyMinDmg ... %d \n",_Type);
return NO_TYPE;
}
int CSkillProcAttack::GetPhyMaxDmg(BYTE _Type,CStr_Skill_Msg *msg)
{
switch(_Type) {
case SKILL_PHYMAXDMG_NORMAL:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fDmg = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_PHYMAXDMG,msg);
return (int)( (float)pc->calPhyMaxDmg * (1.0f + fDmg * 0.01f) + pc->calMagMaxDmg );
}
}
break;
case SKILL_PHYMAXDMG_VALUE:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fDmg = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_PHYMAXDMG,msg);
return fDmg;
}
}
break;
case SKILL_PHYMAXDMG_MON:
{
monsterCharacter_t* pMon = static_cast<monsterCharacter_t*>(msg->pPc);
if(pMon)
{
float fDmg = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_PHYMAXDMG,msg);
return fDmg + pMon->calPhyMaxDmg;
}
}
break;
case SKILL_PC_PHYMAXDMG_ADD_VALUE:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
int nGrade = g_SkillDataGlobal.GetGrade(pc->pcJob);
if(nGrade <0 || nGrade >= SKILL_MAX_BASIC_JOB_TYPE) return 0;
float fDmg = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_PHYBONUS_MENTALITY+nGrade,msg);
pc->calPhyMaxDmg += fDmg;
return 0;
}
}
break;
case SKILL_PHYMAXDMG_MAGIC:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fDmg = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_POSMAXDMG,msg);
return (int)((float)pc->calMagMaxDmg * ( 1.0f + fDmg * 0.01f ) + pc->calMagMaxDmg );
}
}
break;
case SKILL_PHYMAXDMG_NORMAL_PHYBONUS :
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fDmg = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_PHYMAXDMG,msg);
float fBonus = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_PHYBONUS,msg);
return (int)( (float)pc->calPhyMaxDmg * (1.0f + fDmg * 0.01f) + pc->calMagMaxDmg + fBonus );
}
}
break;
case SKILL_PHYMAXDMG_MAGIC_PHYBONUS:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fDmg = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_POSMAXDMG,msg);
float fPosBonus = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_POSBONUS,msg);
return (int)((float)pc->calMagMaxDmg * ( 1.0f + fDmg * 0.01f ) + pc->calMagMaxDmg + fPosBonus);
}
}
break;
}
TRACE("Error!! GetPhyMaxDmg ... %d \n",_Type);
return NO_TYPE;
}
int CSkillProcAttack::GetPosMinDmg(BYTE _Type,CStr_Skill_Msg *msg)
{
switch(_Type) {
case SKILL_POSMINDMG_MON_MAGIC:
{
monsterCharacter_t* pMon = static_cast<monsterCharacter_t*>(msg->pPc);
if(pMon)
{
float fVal = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_POSMINDMG,msg);
return fVal + pMon->calMagMinDmg;
}
}
break;
case SKILL_PC_POSMINDMG_ADD_VALUE:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
int nGrade = g_SkillDataGlobal.GetGrade(pc->pcJob);
if(nGrade <0 || nGrade >= SKILL_MAX_BASIC_JOB_TYPE) return 0;
float fDmg = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_POSBONUS_MENTALITY+nGrade,msg);
pc->calMagMinDmg += fDmg;
return 0;
}
}
break;
case SKILL_POSMINDMG_MAGIC:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fDmg = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_POSMINDMG,msg);
return (int)((float)pc->calMagMinDmg * ( 1.0f + fDmg * 0.01f ) + pc->calMagMinDmg );
}
}
break;
case SKILL_POSMINDMG_MAGIC_PHYBONUS:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fDmg = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_POSMINDMG,msg);
float fPosBonus = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_POSBONUS,msg);
return (int)((float)pc->calMagMinDmg * ( 1.0f + fDmg * 0.01f ) + pc->calMagMinDmg + fPosBonus);
}
}
break;
}
TRACE("Error!! GetPosMinDmg ... %d \n",_Type);
return NO_TYPE;
}
int CSkillProcAttack::GetPosMaxDmg(BYTE _Type,CStr_Skill_Msg *msg)
{
switch(_Type) {
case SKILL_POSMAXDMG_MON_MAGIC:
{
monsterCharacter_t* pMon = static_cast<monsterCharacter_t*>(msg->pPc);
if(pMon)
{
float fVal = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_POSMAXDMG,msg);
return fVal + pMon->calMagMaxDmg;
}
}
break;
case SKILL_PC_POSMAXDMG_ADD_VALUE:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
int nGrade = g_SkillDataGlobal.GetGrade(pc->pcJob);
if(nGrade <0 || nGrade >= SKILL_MAX_BASIC_JOB_TYPE) return 0;
float fDmg = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_POSBONUS_MENTALITY+nGrade,msg);
pc->calMagMaxDmg += fDmg;
return 0;
}
}
break;
case SKILL_POSMAXDMG_MAGIC:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fDmg = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_POSMAXDMG,msg);
return (int)((float)pc->calMagMaxDmg * ( 1.0f + fDmg * 0.01f ) + pc->calMagMaxDmg );
}
}
break;
case SKILL_POSMAXDMG_MAGIC_PHYBONUS:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fDmg = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_POSMAXDMG,msg);
float fPosBonus = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_POSBONUS,msg);
return (int)((float)pc->calMagMaxDmg * ( 1.0f + fDmg * 0.01f ) + pc->calMagMaxDmg + fPosBonus);
}
}
break;
}
TRACE("Error!! GetPosMaxDmg ... %d \n",_Type);
return NO_TYPE;
}
int CSkillProcAttack::GetNegMinDmg(BYTE _Type,CStr_Skill_Msg *msg)
{
switch(_Type) {
case NUM_SKILL_NEGMINDMG:
break;
}
return NO_TYPE;
}
int CSkillProcAttack::GetNegMaxDmg(BYTE _Type,CStr_Skill_Msg *msg)
{
switch(_Type) {
case NUM_SKILL_NEGMAXDMG:
break;
}
return NO_TYPE;
}
int CSkillProcAttack::GetCriticalRate(BYTE _Type,CStr_Skill_Msg *msg)
{
switch(_Type) {
case SKILL_CRITICALRATE_VALUE:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fVal = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_CRITICALRATE,msg);
return fVal;
}
}
break;
case SKILL_CRITICALRATE_CALCRITICALRATE:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fVal = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_CRITICALRATE,msg);
return fVal + pc->calCriticalRate;
}
}
break;
}
TRACE("Error!! GetCriticalRate ... %d \n",_Type);
return NO_TYPE;
}
int CSkillProcAttack::GetCriticalDamage(BYTE _Type,CStr_Skill_Msg *msg)
{
switch(_Type) {
case SKILL_CRITICALDAMAGE_VALUE:
{
return 0;
}
break;
}
TRACE("Error!! GetCriticalDamage ... %d \n",_Type);
return NO_TYPE;
}
int CSkillProcAttack::GetDelayTime(BYTE _Type,CStr_Skill_Msg *msg)
{
switch(_Type) {
case ATTACK_DELAY_PC:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
return pc->calAttackDelay;
}
}
break;
case ATTACK_DELAY_MONSTER:
{
monsterCharacter_t* pMon = static_cast<monsterCharacter_t*>(msg->pPc);
if(pMon)
{
return pMon->calAttackDelay;
}
}
break;
case ATTACK_DELAY_VALUE:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fVal = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_DELAYTIME,msg);
return fVal;
}
}
break;
}
TRACE("Error!! GetDelayTime \n");
return NO_TYPE;
}
int CSkillProcAttack::GetRepeatNum(BYTE _Type,CStr_Skill_Msg *msg)
{
switch(_Type) {
case SKILL_REPEATNUM_VALUE:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fVal = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_REPEATNUM,msg);
return fVal;
}
}
break;
case SKILL_REPEATNUM_CAL:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fKeepTime = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_AFF_KEEPTIME,msg);
float fRepeatTime = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_REPEAT_DELAY_TIME,msg);
int nVal = (int)( fKeepTime / fRepeatTime );
return nVal;
}
}
break;
}
return NO_TYPE;
}
int CSkillProcAttack::GetRepeatDelayTime(BYTE _Type,CStr_Skill_Msg *msg)
{
switch(_Type) {
case SKILL_REPEATDELAYTIME_VALUE:
{
return 0;
}
break;
}
return NO_TYPE;
}
int CSkillProcAttack::GetEtcType(BYTE _Type,CStr_Skill_Msg *msg)
{
switch(_Type)
{
case SKILL_ATK_ETC_INFO_STUNPRO:
case SKILL_ATK_ETC_INFO_STUNTIME:
{
return MSGINFO_ATK_ETC_INFO_STUN;
}
break;
case SKILL_ATK_ETC_INFO_RASTEAL : return MSGINFO_ATK_ETC_INFO_RASTEAL;
break;
case SKILL_ATK_ETC_INFO_STUN: return MSGINFO_ATK_ETC_INFO_STUN;
break;
case SKILL_ATK_ETC_INFO_SHOCK : return MSGINFO_ATK_ETC_INFO_SHOCK;
break;
case SKILL_ATK_ETC_INFO_FREEZE: return MSGINFO_ATK_ETC_INFO_FREEZE;
break;
case SKILL_ATK_ECT_INFO_PUSHED: return MSGINFO_ATK_ECT_INFO_PUSHED;
break;
case SKILL_ATK_ETC_DEC_DAMAGE_AS_TARGET_NUMBER: return MSGINFO_ATK_ETC_DEC_DAMAGE_AS_TARGET_NUMBER;
break;
case SKILL_ATK_ETC_MULTIDAMAGE_DELAY: return MSGINFO_ATK_ETC_MULTIDAMAGE_DELAY;
break;
case SKILL_ATK_ETC_INFO_HIDE: return MSGINFO_ATK_ETC_INFO_HIDE;
break;
case SKILL_ATK_ETC_MULTIDAMAGE_DELAY_WEAPON_TYPE_MAGIC_BOW: return MSGINFO_ATK_ETC_MULTIDAMAGE_DELAY;
break;
case SKILL_ATK_DAMAGE_TARGET_100_ELSE_LITE_DAMAGE: return MSGINFO_ATK_ETC_DEC_DAMAGE_AS_TARGET_100_ELSE_LITE_DAMAGE;
break;
case SKILL_ATK_ETC_RA_RATIO_POS_DAMAGE: return MSGINFO_ATK_ETC_RA_RATIO_DAMAGE;
break;
case SKILL_ATK_ETC_RA_RATIO_PHY_DAMAGE: return MSGINFO_ATK_ETC_RA_RATIO_DAMAGE;
break;
}
return MSGINFO_ATK_ETC_INFO_NONE;
}
int CSkillProcAttack::GetEtcInfo(BYTE _Type,CStr_Skill_Msg *msg)
{
switch(_Type) {
case SKILL_ATK_ETC_INFO_NONE:
{
return 0;
}
break;
case SKILL_ATK_ETC_INFO_RASTEAL:
break;
case SKILL_ATK_ETC_INFO_STUNPRO:
{
if(msg->pDataFormat->m_ClassType == SKILL_CLASS_PC)
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fVal = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_ATK_ETC_INFO_STUN_PRO,msg);
return fVal;
}
}
else if(msg->pDataFormat->m_ClassType == SKILL_CLASS_MON)
{
monsterCharacter_t* pMon = static_cast<monsterCharacter_t*>(msg->pPc);
if(pMon)
{
float fVal = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_ATK_ETC_INFO_STUN_PRO,msg);
return fVal;
}
}
}
break;
case SKILL_ATK_ETC_INFO_STUNTIME:
{
if(msg->pDataFormat->m_ClassType == SKILL_CLASS_PC)
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fVal = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_ATK_ETC_INFO_STUN_TIME,msg);
return fVal;
}
}
else if(msg->pDataFormat->m_ClassType == SKILL_CLASS_MON)
{
monsterCharacter_t* pMon = static_cast<monsterCharacter_t*>(msg->pPc);
if(pMon)
{
float fVal = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_ATK_ETC_INFO_STUN_TIME,msg);
return fVal;
}
}
}
break;
case SKILL_ATK_ETC_INFO_SHOCK:
break;
case SKILL_ATK_ETC_INFO_FREEZE:
break;
case SKILL_ATK_ECT_INFO_PUSHED:
{
return 0;
}
break;
case SKILL_ATK_ETC_DEC_DAMAGE_AS_TARGET_NUMBER:
break;
case SKILL_ATK_ETC_MULTIDAMAGE_DELAY:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fVal = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_ETC_MULTIDAMAGE_DELAY,msg);
return fVal;
}
}
break;
case SKILL_ATK_ETC_MULTIDAMAGE_DELAY_INC:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fVal = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_ETC_MULTIDAMAGE_DELAY_INC,msg);
return fVal;
}
}
break;
case SKILL_ATK_ETC_INFO_HIDE:
break;
case SKILL_ATK_ETC_RA_RATIO_POS_DAMAGE:
{
if(msg->pDataFormat->m_ClassType == SKILL_CLASS_PC)
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fVal = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_ETC_RA_RATIO_POS_DAMAGE,msg);
return fVal;
}
}
else if(msg->pDataFormat->m_ClassType == SKILL_CLASS_MON)
{
monsterCharacter_t* pMon = static_cast<monsterCharacter_t*>(msg->pPc);
if(pMon)
{
float fVal = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_ETC_RA_RATIO_POS_DAMAGE,msg);
return fVal;
}
}
}
break;
case SKILL_ATK_ETC_RA_RATIO_PHY_DAMAGE:
{
if(msg->pDataFormat->m_ClassType == SKILL_CLASS_PC)
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fVal = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_ETC_RA_RATIO_PHY_DAMAGE,msg);
return fVal;
}
}
else if(msg->pDataFormat->m_ClassType == SKILL_CLASS_MON)
{
monsterCharacter_t* pMon = static_cast<monsterCharacter_t*>(msg->pPc);
if(pMon)
{
float fVal = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_ETC_RA_RATIO_PHY_DAMAGE,msg);
return fVal;
}
}
}
break;
}
return NO_TYPE;
}
| C++ |
#if !defined(AFX_SKILLPROCAFFECTSPE_H__C512C7E8_AA20_4FEE_9836_43C1F9C104F5__INCLUDED_)
#define AFX_SKILLPROCAFFECTSPE_H__C512C7E8_AA20_4FEE_9836_43C1F9C104F5__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CSkillProcAffectSpe
{
public:
CSkillProcAffectSpe();
virtual ~CSkillProcAffectSpe();
int GetType(BYTE _Type);
int GetSpecialIdx(BYTE _Type, void *pPc,CStr_Skill_Msg *msg);
float GetSpecialData(BYTE _Type,BYTE _Index, void *pPc,CStr_Skill_Msg *msg);
bool Proc(int nSkillID,void *pPc,AFFECTDATA_SPECIAL *spe);
};
#endif
| C++ |
#include "../global.h"
#include "SkillApp.h"
CSkillProcAffect::CSkillProcAffect()
{
}
CSkillProcAffect::~CSkillProcAffect()
{
}
int CSkillProcAffect::GetAffType(BYTE _Type)
{
switch(_Type) {
case SKILL_AFF_NONE: return AFFECT_NONE;
case SKILL_AFF_ATTACK: return AFFECT_ATTACK;
case SKILL_AFF_DEFENSE: return AFFECT_DEFENSE;
case SKILL_AFF_ASSIST: return AFFECT_ASSIST;
case SKILL_AFF_SPECIAL: return AFFECT_SPECIAL;
case SKILL_AFF_TOGGLE: return AFFECT_TOGGLE;
case SKILL_AFF_CURSE: return AFFECT_CURSE;
}
TRACE("Error!! GetAffType ... %d \n",_Type);
return NO_TYPE;
}
int CSkillProcAffect::GetAffectType(BYTE _Type)
{
switch(_Type) {
case SKILL_AFF_TYPE_NORMAL: return MSGINFO_AFF_TYPE_NORMAL ;
case SKILL_AFF_TYPE_POSITIVE: return MSGINFO_AFF_TYPE_POSITIVE ;
case SKILL_AFF_TYPE_NEGATIVE: return MSGINFO_AFF_TYPE_NEGATIVE ;
case SKILL_AFF_TYPE_NONE: return MSGINFO_AFF_TYPE_NONE ;
}
TRACE("Error!! GetAffectType ... %d \n",_Type);
return NO_TYPE;
}
int CSkillProcAffect::GetStartTime(BYTE _Type,CStr_Skill_Msg *msg)
{
switch(_Type) {
case SKILL_AFF_STARTTIME_GLOBALTIME: return g_globalTime;
break;
case SKILL_AFF_STARTTIME_PLUSVALUE:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fVal = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_AFF_STARTTIME,msg);
return fVal;
}
}
break;
}
TRACE("Error!! GetStartTime ... %d \n",_Type);
return NO_TYPE;
}
int CSkillProcAffect::GetKeepTime(BYTE _Type,CStr_Skill_Msg *msg)
{
switch(_Type) {
case AFFECT_KEEP_TIME_DECDEFENSETIME:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fVal = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_AFF_KEEPTIME,msg) * 1000;
return (fVal + g_globalTime);
}
}
break;
case AFFECT_KEEP_TIME_VALUETIME:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fVal = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_AFF_KEEPTIME,msg) * 1000;
return fVal+ g_globalTime;
}
}
break;
case AFFECT_KEEP_TIME_STARTTIME:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fVal = g_SkillDataGlobal.GetValue(msg->pPc,SKILL_AFF_KEEPTIME,msg) * 1000;
return (fVal + msg->msginfo->affect.startTime);
}
}
break;
}
TRACE("Error!! GetKeepTime ... %d \n",_Type);
return NO_TYPE;
}
int CSkillProcAffect::GetPosMinDmg(BYTE _Type,CStr_Skill_Msg *msg)
{
switch(_Type) {
case SKILL_AFF_POSMINDMG_AFFECTSKILLLEVEL: return g_affectSkillLevel;
case SKILL_AFF_POSMINDMG_VALUE:
{
return 0;
}
break;
}
TRACE("Error!! GetPosMinDmg ... %d \n",_Type);
return NO_TYPE;
}
int CSkillProcAffect::GetHitRate(BYTE _Type,CStr_Skill_Msg *msg)
{
switch(_Type) {
case SKILL_AFF_HITRATE_VALUE:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fVal = (int)g_SkillDataGlobal.GetValue(msg->pPc,SKILL_AFF_HITRATE,msg);
return fVal;
}
}
break;
}
TRACE("Error!! GetHitRate ... %d \n",_Type);
return NO_TYPE;
}
int CSkillProcAffect::GetDelayTime(BYTE _Type,CStr_Skill_Msg *msg)
{
switch(_Type) {
case SKILL_AFF_DELAYTIME_VALUE:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(msg->pPc);
if(pc)
{
float fVal = (int)g_SkillDataGlobal.GetValue(msg->pPc,SKILL_AFF_DELAYTIME,msg);
return fVal;
}
}
break;
}
TRACE("Error!! GetDelayTime ... %d \n",_Type);
return NO_TYPE;
}
| C++ |
#if !defined(AFX_SKILLDATAAFFECT_H__E793C64B_7BFF_4977_A01F_431B4FC63176__INCLUDED_)
#define AFX_SKILLDATAAFFECT_H__E793C64B_7BFF_4977_A01F_431B4FC63176__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CSkillProcAffect
{
public:
CSkillProcAffect();
virtual ~CSkillProcAffect();
int GetAffType(BYTE _Type);
int GetAffectType(BYTE _Type);
int GetStartTime(BYTE _Type,CStr_Skill_Msg *msg);
int GetKeepTime(BYTE _Type,CStr_Skill_Msg *msg);
int GetPosMinDmg(BYTE _Type,CStr_Skill_Msg *msg);
int GetHitRate(BYTE _Type,CStr_Skill_Msg *msg);
int GetDelayTime(BYTE _Type,CStr_Skill_Msg *msg);
};
#endif
| C++ |
#if !defined(AFX_SKILLDATABASIC_H__46296A91_0EEC_44B1_9194_A22020663B4F__INCLUDED_)
#define AFX_SKILLDATABASIC_H__46296A91_0EEC_44B1_9194_A22020663B4F__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CSkillProcBasic
{
public:
CSkillProcBasic();
virtual ~CSkillProcBasic();
int GetInfoType(BYTE _Type);
int GetTargetType(BYTE _Type,void *pPc);
int GetTargetIdx(BYTE _Type,void *pPc,int index=0);
};
#endif
| C++ |
#if !defined(AFX_SKILLPARTYPROC_H__B6C5A52E_CCA6_40DC_B41D_656A584CD081__INCLUDED_)
#define AFX_SKILLPARTYPROC_H__B6C5A52E_CCA6_40DC_B41D_656A584CD081__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CSkillPartyProc
{
public:
CSkillPartyProc();
virtual ~CSkillPartyProc();
bool IfPartyMember(int MyIndex,int PartyMemberIndex);
bool Proc(void *pPc,CStr_Skill_Msg *msg);
bool PartyCheck(void* pPc,int nIndex,CStr_Skill_Msg *msg);
bool Check(void* pPc,int nIndex,CStr_Skill_Msg *msg);
};
extern CSkillPartyProc g_SkillPartyProc;
#endif
| C++ |
#include "../global.h"
#ifdef _OLD_SKILL_VER
void SKILL_Blow( void *pPc, float *pValue )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float dmg, hitPro, decDefensePro, decDefenseRate, decDefenseTime, phybonus;
messageInfo_t msginfo;
message_t message;
dmg = pValue[SKILL_VALUE_0];
hitPro = pValue[SKILL_VALUE_1];
decDefensePro = pValue[SKILL_VALUE_2];
decDefenseRate = pValue[SKILL_VALUE_3];
decDefenseTime = pValue[SKILL_VALUE_4];
phybonus = pValue[SKILL_VALUE_5];
if( pc->atkWeaponType == WEAPON_TYPE_CLAW ) dmg += 30.0f;
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_ATTACK;
msginfo.attack.atkType = MSGINFO_ATK_TYPE_NORMAL;
msginfo.attack.hitPower = (int)( (float)pc->calHitPower * hitPro * 0.01f );
msginfo.attack.phyMinDmg = (int)( (float)pc->calPhyMinDmg * ( 1.0f + dmg * 0.01f ) + pc->calMagMinDmg + phybonus);
msginfo.attack.phyMaxDmg = (int)( (float)pc->calPhyMaxDmg * ( 1.0f + dmg * 0.01f ) + pc->calMagMaxDmg + phybonus);
msginfo.attack.criticalRate = 0;
msginfo.attack.criticalDamage = 0;
msginfo.attack.delayTime = pc->calAttackDelay;
msginfo.attack.repeatNum = 0;
msginfo.targetType = pc->targetType;
msginfo.targetIdx = pc->targetIdx;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
if( pc->atkWeaponType == WEAPON_TYPE_SPIRITOR )
{
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = 15;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_CURSE;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_POSITIVE;
msginfo.affect.startTime = g_globalTime;
msginfo.affect.keepTime = g_globalTime + (int)decDefenseTime * 1000;
msginfo.affect.hitRate = (int)decDefensePro;
msginfo.targetType = pc->targetType;
msginfo.targetIdx = pc->targetIdx;
msginfo.affect.common.type[0] = AFFDATA_TYPE_DEFENSE_RATE;
msginfo.affect.common.data[0] = -(int)decDefenseRate;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
}
void SKILL_AttractAttention(void *pPc, float *pValue)
{
float hitPro, level, panelty;
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if( g_monster[pc->targetIdx].aliveState != MON_ALIVE_STATE_NORMAL ) return;
level = fabs((float)(g_monster[pc->targetIdx].basic.level - pc->level));
if( level > 33.0f ) level = 33.0f;
panelty = 1.0f - level * 0.03f;
hitPro = pValue[SKILL_VALUE_0] * panelty;
if( GTH_Random() < hitPro )
{
g_monster[pc->targetIdx].targetIdx = pc->idx;
g_monster[pc->targetIdx].targetType = ENTITY_PC;
g_monster[pc->targetIdx].ai.callProcedureAddr = g_monster[pc->targetIdx].ai.aiProcedureAddr[1];
g_monster[pc->targetIdx].ai.aiAddr = g_monster[pc->targetIdx].ai.aiProcedureAddr[1];
g_monster[pc->targetIdx].ai.isCall = true;
AI_StopPathFinding( &g_monster[pc->targetIdx] );
AI_InterpretImmediately( &g_monster[pc->targetIdx] );
}
else
{
}
}
void SKILL_MightyBlow(void *pPc, float *pValue)
{
playerCharacter_t* pc = static_cast<playerCharacter_t*>(pPc);
float dmg, pushrate, phybonus;
messageInfo_t msginfo;
message_t message;
dmg = pValue[SKILL_VALUE_0];
pushrate = pValue[SKILL_VALUE_1];
phybonus = pValue[SKILL_VALUE_2];
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_ATTACK;
msginfo.attack.atkType = MSGINFO_ATK_TYPE_NORMAL;
msginfo.attack.phyMinDmg = (int)( (float)pc->calPhyMinDmg * ( 1.0f + dmg * 0.01f ) + pc->calMagMinDmg + phybonus);
msginfo.attack.phyMaxDmg = (int)( (float)pc->calPhyMaxDmg * ( 1.0f + dmg * 0.01f ) + pc->calMagMaxDmg + phybonus);
msginfo.attack.criticalRate = 0;
msginfo.attack.criticalDamage = 0;
msginfo.attack.delayTime = pc->calAttackDelay;
msginfo.attack.repeatNum = 0;
msginfo.targetType = pc->targetType;
msginfo.targetIdx = pc->targetIdx;
msginfo.attack.etcInfo = MSGINFO_ATK_ECT_INFO_PUSHED;
msginfo.attack.etcData0 = 700;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
float level, panelty;
level = (float)(pc->level - g_monster[pc->targetIdx].basic.level);
if( level < 0.0f ) level = 0.0f;
panelty = 1.0f - 0.03 * level;
pushrate = pValue[SKILL_VALUE_1] * 0.01f * panelty;
}
void SKILL_TrainSpiritor( void *pPc, float *pValue )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float dmg;
dmg = pValue[SKILL_VALUE_0];
pc->calPhyMinDmg += dmg;
pc->calPhyMaxDmg += dmg;
}
void SKILL_TrainClaw( void *pPc, float *pValue )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float dmg;
dmg = pValue[SKILL_VALUE_0];
pc->calPhyMinDmg += dmg;
pc->calPhyMaxDmg += dmg;
}
void SKILL_CrossClaw(void *pPc, float *pValue)
{
playerCharacter_t* pc = static_cast<playerCharacter_t*>(pPc);
float dmg, hitPro, dmg1, phybonus;
int count;
messageInfo_t msginfo;
message_t message;
dmg = pValue[SKILL_VALUE_0];
dmg1 = pValue[SKILL_VALUE_2];
count = (int)pValue[SKILL_VALUE_3];
phybonus = pValue[SKILL_VALUE_4];
memset( &msginfo, 0, sizeof( messageInfo_t ) );
int level = (pc->level - g_monster[pc->targetIdx].basic.level);
if( level < 0 ) level = 0;
float panelty = 1.0f - 0.03 * (float)level;
hitPro = pValue[SKILL_VALUE_1] * 0.01 * panelty;
dmg1 = dmg1 * (1.0f - (float)g_monster[pc->targetIdx].basic.defPower * 0.01f) - (float)g_monster[pc->targetIdx].basic.defDamageReduce;
if( dmg1 < 1.0f ) dmg1 = 1.0f;
msginfo.infoType = MSGINFO_TYPE_ATTACK;
msginfo.attack.atkType = MSGINFO_ATK_TYPE_NORMAL;
msginfo.attack.hitRate = (int)hitPro;
msginfo.attack.phyMinDmg = (int)( (float)pc->calPhyMinDmg * ( 1.0f + dmg * 0.01f ) + pc->calMagMinDmg + phybonus);
msginfo.attack.phyMaxDmg = (int)( (float)pc->calPhyMaxDmg * ( 1.0f + dmg * 0.01f ) + pc->calMagMaxDmg + phybonus);
msginfo.attack.criticalRate = 0;
msginfo.attack.criticalDamage = 0;
msginfo.attack.delayTime = pc->calAttackDelay / 2;
msginfo.attack.repeatNum = 0;
msginfo.targetType = pc->targetType;
msginfo.targetIdx = pc->targetIdx;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
dmg1 = pValue[SKILL_VALUE_2];
for(int i = 0; i < count; i++)
{
dmg1 = dmg1 * (1.0f - (float)g_monster[pc->targetIdx].basic.defPower * 0.01f) - (float)g_monster[pc->targetIdx].basic.defDamageReduce;
if( dmg1 < 1.0f ) dmg1 = 1.0f;
msginfo.attack.phyMinDmg = dmg1;
msginfo.attack.phyMaxDmg = dmg1;
msginfo.attack.etcInfo = MSGINFO_ATK_ETC_MULTIDAMAGE_DELAY;
msginfo.attack.etcData0 += 500;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
}
void SKILL_IncreaseAttack1(void* pPc, float* pValue)
{
playerCharacter_t* pc = NULL;
pc = static_cast<playerCharacter_t *>(pPc);
if( pc == NULL ) return;
float dmg, RaUse, RaDec;
message_t message;
messageInfo_t msginfo;
dmg = pValue[SKILL_VALUE_0];
RaUse = pValue[SKILL_VALUE_1];
RaDec = pValue[SKILL_VALUE_2];
memset( &msginfo, 0, sizeof(messageInfo_t) );
memset( &message, 0, sizeof( message_t ) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = 33;
msginfo.affect.level = g_affectSkillLevel;
msginfo.targetType = ENTITY_PC;
msginfo.targetIdx = pc->idx;
msginfo.affect.type = AFFECT_TOGGLE;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msginfo.affect.startTime = g_globalTime;
msginfo.affect.delayTime = 1000;
msginfo.affect.common.type[0] = AFFDATA_TYPE_DECREASERA;
msginfo.affect.common.data[0] = (int)RaUse;
msginfo.affect.common.type[1] = AFFDATA_TYPE_PHYDAMAGE;
msginfo.affect.common.data[1] = (int)dmg;
msginfo.affect.common.type[2] = AFFDATA_TYPE_INCRARECOVERY;
msginfo.affect.common.data[2] = -(int)RaDec;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_EAR_PolymorphMimin( void* pPc, float *pValue )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float addmoveSpeed = pValue[SKILL_VALUE_0];
float RaUse = pValue[SKILL_VALUE_1];
float keepTime = pValue[SKILL_VALUE_2] * 1000.0f;
messageInfo_t msginfo;
message_t message;
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = 34;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_SPECIAL;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msginfo.affect.startTime = g_globalTime;
msginfo.affect.keepTime = g_globalTime + (int)keepTime;
msginfo.affect.spe.specialType = 0;
msginfo.affect.spe.specialIdx = 34;
msginfo.affect.spe.specialData[0] = (int)addmoveSpeed;
msginfo.affect.spe.specialData[1] = RaUse;
msginfo.targetType = ENTITY_PC;
msginfo.targetIdx = pc->idx;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
GTH_DeleteAffect( pc, ENTITY_PC, 43 );
}
void SKILL_MaxRAIncrease(void* pPc, float* pValue)
{
float maxRaInc, keepTime;
messageInfo_t msgInfo;
message_t message;
playerCharacter_t* pc = NULL;
pc = static_cast<playerCharacter_t *>(pPc);
if( pc == NULL ) return;
maxRaInc = pValue[SKILL_VALUE_0];
keepTime = pValue[SKILL_VALUE_1] * 1000.0f;
memset( &msgInfo, 0, sizeof(messageInfo_t) );
msgInfo.infoType = MSGINFO_TYPE_AFFECT;
msgInfo.affect.skillTableIdx = 54;
msgInfo.affect.level = g_affectSkillLevel;
msgInfo.affect.type = AFFECT_ASSIST;
msgInfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msgInfo.affect.startTime = g_globalTime;
msgInfo.affect.keepTime = g_globalTime + (int)keepTime;
msgInfo.targetType = ENTITY_PC;
msgInfo.targetIdx = pc->idx;
msgInfo.affect.common.type[0] = AFFDATA_TYPE_MAXRA;
msgInfo.affect.common.data[0] = (int)maxRaInc;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msgInfo );
AI_SendMessage( &message );
}
void SKILL_StunAttack(void* pPc, float* pValue)
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float dmg, hitPro, phyBonus, stunPro, stunTime, cursePro, curseTime;
int curseType;
messageInfo_t msginfo;
message_t message;
hitPro = pValue[SKILL_VALUE_0];
dmg = pValue[SKILL_VALUE_1];
phyBonus = pValue[SKILL_VALUE_2];
stunPro = pValue[SKILL_VALUE_3];
stunTime = pValue[SKILL_VALUE_4];
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_ATTACK;
msginfo.attack.atkType = MSGINFO_ATK_TYPE_NORMAL;
msginfo.attack.hitPower = (int)( (float)pc->calHitPower * hitPro * 0.01f );
msginfo.attack.phyMinDmg = (int)( (float)pc->calPhyMinDmg * ( 1.0f + dmg * 0.01f ) + phyBonus + pc->calMagMinDmg );
msginfo.attack.phyMaxDmg = (int)( (float)pc->calPhyMinDmg * ( 1.0f + dmg * 0.01f ) + phyBonus + pc->calMagMinDmg );
msginfo.attack.delayTime = pc->calAttackDelay;
msginfo.targetType = pc->targetType;
msginfo.targetIdx = pc->targetIdx;
curseType = MSGINFO_ATK_ETC_INFO_STUN;
cursePro = (int)stunPro;
curseTime = stunTime * 1000.0f;
msginfo.attack.etcInfo = curseType;
msginfo.attack.etcData0 = cursePro;
msginfo.attack.etcData1 = curseTime;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_EAR_PolymorphRifle( void* pPc, float *pValue )
{
float range, addAttInc, phyBonus, raUse, hitPowInc, avoidDec, keepTime;
messageInfo_t msginfo;
message_t message;
playerCharacter_t *pc = NULL;
pc = static_cast<playerCharacter_t*>(pPc);
if( pc == NULL ) return;
range = pValue[SKILL_VALUE_0];
addAttInc = pValue[SKILL_VALUE_1];
phyBonus = pValue[SKILL_VALUE_2];
raUse = pValue[SKILL_VALUE_3];
hitPowInc = pValue[SKILL_VALUE_4];
avoidDec = pValue[SKILL_VALUE_5];
keepTime = pValue[SKILL_VALUE_6] * 1000.0f;
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = 57;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_SPECIAL;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msginfo.affect.startTime = g_globalTime;
msginfo.affect.keepTime = g_globalTime + (int)keepTime;
msginfo.affect.spe.specialType = 0;
msginfo.affect.spe.specialIdx = 57;
msginfo.affect.spe.specialData[0] = addAttInc;
msginfo.affect.spe.specialData[1] = phyBonus;
msginfo.affect.spe.specialData[2] = raUse;
msginfo.affect.spe.specialData[3] = hitPowInc;
msginfo.affect.spe.specialData[4] = avoidDec;
msginfo.targetType = ENTITY_PC;
msginfo.targetIdx = pc->idx;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_EAR_PolymorphFast( void* pPc, float *pValue )
{
float addAttInc, phyBonus, raUse, hitPowInc, avoidInc, keepTime, attSpeed;
messageInfo_t msginfo;
message_t message;
playerCharacter_t *pc = NULL;
pc = static_cast<playerCharacter_t*>(pPc);
if( pc == NULL ) return;
addAttInc = pValue[SKILL_VALUE_0];
phyBonus = pValue[SKILL_VALUE_1];
raUse = pValue[SKILL_VALUE_2];
hitPowInc = pValue[SKILL_VALUE_3];
avoidInc = pValue[SKILL_VALUE_4];
attSpeed = pValue[SKILL_VALUE_5];
keepTime = pValue[SKILL_VALUE_6] * 1000.0f;
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = 58;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_SPECIAL;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msginfo.affect.startTime = g_globalTime;
msginfo.affect.keepTime = g_globalTime + (int)keepTime;
msginfo.affect.spe.specialType = 0;
msginfo.affect.spe.specialIdx = 58;
msginfo.affect.spe.specialData[0] = addAttInc;
msginfo.affect.spe.specialData[1] = phyBonus;
msginfo.affect.spe.specialData[2] = raUse;
msginfo.affect.spe.specialData[3] = hitPowInc;
msginfo.affect.spe.specialData[4] = avoidInc;
msginfo.affect.spe.specialData[5] = attSpeed;
msginfo.targetType = ENTITY_PC;
msginfo.targetIdx = pc->idx;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_Plymoffpower( void* pPc, float *pValue )
{
float addAttInc, hitPowInc, avoidInc, keepTime, IncVelocity;
messageInfo_t msginfo;
message_t message;
playerCharacter_t *pc = NULL;
pc = static_cast<playerCharacter_t*>(pPc);
if( pc == NULL ) return;
addAttInc = pValue[SKILL_VALUE_0];
hitPowInc = pValue[SKILL_VALUE_1];
avoidInc = pValue[SKILL_VALUE_2];
IncVelocity = pValue[SKILL_VALUE_3];
keepTime = pValue[SKILL_VALUE_4] * 1000.0f;
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = 62;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_SPECIAL;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msginfo.affect.startTime = g_globalTime;
msginfo.affect.keepTime = g_globalTime + (int)keepTime;
msginfo.affect.spe.specialType = 0;
msginfo.affect.spe.specialIdx = 62;
msginfo.affect.spe.specialData[0] = addAttInc;
msginfo.affect.spe.specialData[1] = hitPowInc;
msginfo.affect.spe.specialData[2] = avoidInc;
msginfo.affect.spe.specialData[3] = IncVelocity;
msginfo.targetType = ENTITY_PC;
msginfo.targetIdx = pc->idx;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_Defenceup(void* pPc, float* pValue)
{
float decVel, keepTime, incDefenseRate, incDefensvar;
messageInfo_t msginfo;
message_t message;
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
incDefenseRate = pValue[SKILL_VALUE_0];
incDefensvar = pValue[SKILL_VALUE_1];
decVel = -pValue[SKILL_VALUE_2];
keepTime = pValue[SKILL_VALUE_3] * 1000.0f;
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = 56;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_TOGGLE;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msginfo.affect.startTime = g_globalTime;
msginfo.affect.keepTime = g_globalTime + (int)keepTime;
msginfo.affect.delayTime = 1000;
msginfo.targetType = ENTITY_PC;
msginfo.targetIdx = pc->idx;
msginfo.affect.common.type[0] = AFFDATA_TYPE_DEFENSE_RATE;
msginfo.affect.common.data[0] = (int)incDefenseRate;
msginfo.affect.common.type[1] = AFFDATA_TYPE_DEFENSE;
msginfo.affect.common.data[1] = (int)incDefensvar;
msginfo.affect.common.type[2] = AFFDATA_TYPE_VELOCITY_RATE;
msginfo.affect.common.data[2] = (int)decVel;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
#endif | C++ |
#if !defined(AFX_SKILLDATAGLOBAL_H__47B3CAF9_EF63_43F4_B9CE_B43CEAC045A6__INCLUDED_)
#define AFX_SKILLDATAGLOBAL_H__47B3CAF9_EF63_43F4_B9CE_B43CEAC045A6__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include <string>
#include <vector>
#include <algorithm>
#include <math.h>
#include <ctime>
#ifndef _STD_MAP_
#define _STD_MAP_
#include <map>
#endif
#include <stack>
using namespace std;
#include "SkillDataDefine.h"
class CSkillDataValue
{
public:
CSkillDataValue()
{
Init();
}
void Init()
{
m_Type =0;
m_nIndex=0;
}
public:
BYTE m_Type;
int m_nIndex;
};
#define MAX_SKILL_VALUE_LIST 10
class CSkillDataCommon
{
public:
CSkillDataCommon()
{
Init();
}
void Init()
{
int i=0;
for(i=0;i<MAX_COUNT_AFFECT_DATA;i++)
{
m_Data[i].Init();
m_OnceData[i].Init();
}
m_bUse=false;
}
bool Use()
{
return m_bUse;
}
public:
bool m_bUse;
CSkillDataValue m_Data[MAX_COUNT_AFFECT_DATA];
CSkillDataValue m_OnceData[MAX_COUNT_AFFECT_DATA];
};
class CSkillDataFormat_Attack
{
public:
enum
{
MAX_SKILL_ATTACK_ETC_DATA=3,
};
CSkillDataFormat_Attack()
{
Init();
}
void Init()
{
m_AtkType =0;
m_HitPower =0;
m_HitRate =0;
m_PhyMinDmg =0;
m_PhyMaxDmg =0;
m_PosMinDmg =0;
m_PosMaxDmg =0;
m_NegMinDmg =0;
m_NegMaxDmg =0;
m_CriticalRate =0;
m_CriticalDamage=0;
m_DelayTime =0;
m_RepeatNum =0;
m_RepeatDelayTime=0;
m_EtcType=0;
for(int i=0;i<MAX_SKILL_ATTACK_ETC_DATA;i++)
{
m_EtcData[i].Init();
}
m_bUse =false;
}
bool Use()
{
return m_bUse;
}
public:
bool m_bUse;
BYTE m_AtkType;
BYTE m_HitPower;
BYTE m_HitRate;
BYTE m_PhyMinDmg;
BYTE m_PhyMaxDmg;
BYTE m_PosMinDmg;
BYTE m_PosMaxDmg;
BYTE m_NegMinDmg;
BYTE m_NegMaxDmg;
BYTE m_CriticalRate;
BYTE m_CriticalDamage;
BYTE m_DelayTime;
BYTE m_RepeatNum;
BYTE m_RepeatDelayTime;
BYTE m_EtcType;
CSkillDataValue m_EtcData[MAX_SKILL_ATTACK_ETC_DATA];
};
class CSkillDataAffectSpe
{
public:
CSkillDataAffectSpe()
{
Init();
}
void Init()
{
for(int i=0;i<MAX_COUNT_AFFECT_SPE_DATA;i++)
{
m_Data[i].Init();
}
m_bUse=false;
m_SpecialIdx=0;
m_SpecialType=0;
m_IsTransform=0;
m_TransformEntityIndex=0;
m_TransformType=0;
m_bUse=false;
}
bool Use()
{
return m_bUse;
}
public:
bool m_bUse;
BYTE m_SpecialType;
BYTE m_SpecialIdx;
BYTE m_IsTransform;
int m_TransformEntityIndex;
BYTE m_TransformType;
CSkillDataValue m_Data[MAX_COUNT_AFFECT_SPE_DATA];
};
class CSkillDataFormat_Affect
{
public:
CSkillDataFormat_Affect()
{
Init();
}
void Init()
{
m_Type =0;
m_AffectType =0;
m_StartTime =0;
m_KeepTime =0;
m_Level =0;
m_HitRate =0;
m_SkillTableIdx =0;
m_RaCostPerSec =0;
m_SaCostPerSec =0;
m_DelayTime =0;
m_Group =0;
m_GroupLevel =0;
m_bUse =false;
}
CSkillDataCommon *GetCommon()
{
return &m_Common;
}
CSkillDataAffectSpe *GetSpe()
{
return &m_Spe;
}
bool Use()
{
return m_bUse;
}
public:
bool m_bUse;
BYTE m_Type;
BYTE m_AffectType;
BYTE m_StartTime;
BYTE m_KeepTime;
BYTE m_Level;
BYTE m_HitRate;
BYTE m_SkillTableIdx;
BYTE m_RaCostPerSec;
BYTE m_SaCostPerSec;
BYTE m_DelayTime;
BYTE m_Group;
BYTE m_GroupLevel;
CSkillDataCommon m_Common;
CSkillDataAffectSpe m_Spe;
};
class CSkillData_Message
{
public:
CSkillData_Message()
{
Init();
}
~CSkillData_Message()
{
}
void Init()
{
m_Type=0;
m_FromIdx=0;
m_FromType=0;
m_Name=0;
m_ToType=0;
m_ToIdx=0;
m_WorldIdx=0;
m_SendTime=0;
m_ReceiveTime=0;
int i;
for(i=0;i<MAX_SKILL_MESSAGE_DATA;i++) m_Data[i].Init();
}
public:
BYTE m_Type;
BYTE m_FromIdx;
BYTE m_FromType;
BYTE m_Name;
BYTE m_ToType;
BYTE m_ToIdx;
BYTE m_WorldIdx;
BYTE m_SendTime;
BYTE m_ReceiveTime;
CSkillDataValue m_Data[MAX_SKILL_MESSAGE_DATA];
};
class CSkillDataCast
{
public:
CSkillDataCast()
{
Init();
}
~CSkillDataCast()
{
}
void Init()
{
m_Type =0;
}
public:
BYTE m_Type;
};
class CSkillDataSubACtion
{
public:
CSkillDataSubACtion()
{
Init();
}
~CSkillDataSubACtion()
{
}
void Init()
{
m_Type=0;
m_fValue=0.0f;
}
public:
BYTE m_Type;
float m_fValue;
};
class CSkillDataParty
{
public:
CSkillDataParty()
{
Init();
}
~CSkillDataParty()
{
}
void Init()
{
m_Type=0;
for(int i=0;i<MAX_SKILL_PARTY_CHECK;i++)
{
m_Check[i]=0;
}
}
public:
BYTE m_Type;
BYTE m_Check[MAX_SKILL_PARTY_CHECK];
};
class CSkillDataFormat
{
public:
enum
{
MAX_NUM_OF_DATA=3
};
CSkillDataFormat()
{
Init();
}
void Init()
{
m_InfoType =0;
m_TargetType =0;
m_TargetIdx =0;
m_MultiSkill =0;
m_MessageType =0;
m_ClassType =0;
m_Attack.Init();
m_Affect.Init();
m_Message.Init();
int i;
for(i=0;i<MAX_SKILL_CHECK_FLAG;i++) m_CheckFlag[i] = 0;
for(i=0;i<MAX_NUM_OF_DATA;i++) m_Data[i] = 0;
for(i=0;i<MAX_SKILL_SUB_ACTION;i++)
{
m_SubAtion[i].m_Type = 0;
m_SubAtion[i].m_fValue = 0;
}
for(i=0;i<MAX_SKILL_VALUE_LIST;i++)
{
m_ValueList[i].Init();
}
}
CSkillDataFormat_Attack *GetAttack()
{
return &m_Attack;
}
CSkillDataFormat_Affect *GetAffect()
{
return &m_Affect;
}
CSkillData_Message *GetMessage()
{
return &m_Message;
}
CSkillDataCast *GetCast()
{
return &m_Cast;
}
CSkillDataValue *GetValue(int index)
{
if(index <0 || index >= MAX_SKILL_VALUE_LIST ) return NULL;
return &m_ValueList[index];
}
bool DeleteValue(int index)
{
if(index <0 || index >= MAX_SKILL_VALUE_LIST ) return false;
m_ValueList[index].Init();
for(int i=index;i<MAX_SKILL_VALUE_LIST-1;i++)
{
m_ValueList[i] = m_ValueList[i+1];
}
m_ValueList[MAX_SKILL_VALUE_LIST-1].Init();
return true;
}
void ClearValueList()
{
for(int i=0;i<MAX_SKILL_VALUE_LIST;i++)
{
m_ValueList[i].Init();
}
}
bool InsertValue(CSkillDataValue &value)
{
for(int i=0;i<MAX_SKILL_VALUE_LIST;i++)
{
if(!m_ValueList[i].m_Type)
{
m_ValueList[i] = value;
return true;
}
}
return false;
}
CSkillDataParty * GetParty()
{
return &m_Party;
}
public:
BYTE m_InfoType;
BYTE m_TargetType;
BYTE m_TargetIdx;
BYTE m_ClassType;
BYTE m_MessageType;;
BYTE m_MultiSkill;
BYTE m_CheckFlag[MAX_SKILL_CHECK_FLAG];
BYTE m_Data[MAX_NUM_OF_DATA];
CSkillDataValue m_ValueList[MAX_SKILL_VALUE_LIST];
CSkillDataSubACtion m_SubAtion[MAX_SKILL_SUB_ACTION];
CSkillDataFormat_Attack m_Attack;
CSkillDataFormat_Affect m_Affect;
CSkillData_Message m_Message;
CSkillDataCast m_Cast;
CSkillDataParty m_Party;
};
class CSkillCastValue
{
public:
CSkillCastValue()
{
Init();
}
void Init()
{
m_nIndex=0;
m_nSa_Comsumption=0;
m_fCasting_Time=0.0f;
m_fCool_Time=0.0f;
}
public:
int m_nIndex;
int m_nSa_Comsumption;
float m_fCasting_Time;
float m_fCool_Time;
};
class CSkillCastData
{
public:
CSkillCastData()
{
}
~CSkillCastData()
{
Clear();
}
bool Insert(int nID, CSkillCastValue *pTemp)
{
int _Type = nID / 100;
if(_Type < 0 || _Type >= MAX_SKILL_NUMBER) return false;
m_List[_Type].push_back(pTemp);
return true;
}
CSkillCastValue * Get(int nID)
{
int Type = nID / 100;
int index = (nID % 100)-1;
if(Type < 0 || Type >= MAX_SKILL_NUMBER) return NULL;
if(index <0 || index >= m_List[Type].size()) return NULL;
return m_List[Type][index];
}
void Clear()
{
for(int i=0;i<MAX_SKILL_NUMBER;i++)
{
int size = m_List[i].size();
for(int j=0;j<size;j++)
{
CSkillCastValue *temp = m_List[i][j];
SAFE_DELETE(temp);
}
m_List[i].clear();
}
}
public:
vector <CSkillCastValue *> m_List[MAX_SKILL_NUMBER];
};
class CSkillTableData
{
public:
CSkillTableData()
{
m_nLine =0;
m_bType =0;
m_nIndex =0;
m_fValue =0;
m_bGenGrade =0;
m_bGenCapablity=0;
m_bMaxLv =0;
}
public:
int m_nLine;
BYTE m_bType;
int m_nIndex;
float m_fValue;
BYTE m_bGenGrade;
BYTE m_bGenCapablity;
BYTE m_bMaxLv;
};
class CSkillDataTableList
{
public:
CSkillDataTableList()
{
}
bool Insert(int _Type, CSkillTableData *pTemp)
{
if(_Type < 0 || _Type >= NUM_SKILL_TYPE) return false;
m_List[_Type].push_back(pTemp);
return true;
}
CSkillTableData * Get(int Type,int index)
{
if(Type < 0 || Type >= NUM_SKILL_TYPE) return NULL;
if(index <0 || index >= m_List[Type].size()) return NULL;
return m_List[Type][index];
}
void Clear()
{
for(int i=0;i<NUM_SKILL_TYPE;i++)
{
int size = m_List[i].size();
for(int j=0;j<size;j++)
{
CSkillTableData *temp = m_List[i][j];
SAFE_DELETE(temp);
}
m_List[i].clear();
}
}
public:
vector <CSkillTableData *> m_List[NUM_SKILL_TYPE];
};
class CStr_Skill_Msg
{
public:
CStr_Skill_Msg()
{
nSkillID=-1;
msginfo=NULL;
message=NULL;
nMySkillIndex=-1;
nSkillLevel=-1;
pDataFormat=NULL;
pParty=NULL;
pPc=NULL;
pPartyMeber=NULL;
pcIdx = -1;
monsterIdx =-1;
};
void Set(int _SkillID,int _Index,int _Level=0)
{
nSkillID = _SkillID;
nMySkillIndex = _Index;
nSkillLevel = _Level;
}
public:
int pcIdx;
int monsterIdx;
void *pPc;
int nSkillID;
messageInfo_t *msginfo;
message_t *message;
int nMySkillIndex;
int nSkillLevel;
void *pPartyMeber;
CSkillDataFormat *pDataFormat;
CSkillDataParty * pParty;
};
class CAISendMessage
{
public:
CAISendMessage()
{
range = 0;
rangeType = MSG_RANGE_TYPE_TARGET;
maxMsgNumber = 8;
basePosition[0]=0;
basePosition[1]=0;
basePosition[2]=0;
fDamageRatio=1.0f;
m_pSkillMsg=NULL;
}
public:
int range;
int rangeType;
int maxMsgNumber;
float fDamageRatio;
vec3_t basePosition;
CStr_Skill_Msg *m_pSkillMsg;
};
class CSkillDataGlobal
{
public:
CSkillDataGlobal();
virtual ~CSkillDataGlobal();
public:
float GetValue(void *pPc,BYTE _Type,CStr_Skill_Msg *msg,int _nSkillID=0,int _nMySkillIndex=0);
int GetGenLevel(void *pPc,int nSkillID,int AttrGen);
CSkillCastValue * GetCastValue(void *pPc,void *pMon,int nSkillID,BYTE _Type,int nLevel=0,int _nMySkillIdx=-1);
int GetGrade(int pcJob);
playerCharacter_t* GetPCPointer(const int Idx);
int GetLimitlevel(int skillTableIdx,int nGenType);
int GetGradeClass(int skillTableIdx,int nGenType);
void Clear();
int GetMessageType(int Type, message_t *message );
int IsDataFormatType(const int skillTableIdx,const int Type);
};
extern CSkillDataGlobal g_SkillDataGlobal;
extern CSkillCastData g_SkillCastDataList;
extern CSkillDataTableList g_SkillDataTableList;
#endif
| C++ |
#include "../global.h"
#include "SkillApp.h"
CSkillItem g_SkillItem;
CSkillItem::CSkillItem()
{
}
CSkillItem::~CSkillItem()
{
}
bool CSkillItem::IfSkillItem(int itemTableIdx)
{
CMap_SkillItemData::iterator iter;
iter=m_mapSkillItem.find(itemTableIdx);
if(iter==m_mapSkillItem.end()) return false;
return true;
}
int CSkillItem::GetLevel(int itemTableIdx)
{
CMap_SkillItemData::iterator iter;
iter=m_mapSkillItem.find(itemTableIdx);
if(iter==m_mapSkillItem.end()) return -1;
int SkillItemIndex = (iter->second);
CSkillItemSet *pSet= m_SkillItemData.Get(SkillItemIndex);
if(pSet == NULL) return -1;
for(int i=0;i<MAX_SKILLITEM_UNIT;i++)
{
if(pSet->m_ItemList[i].m_nItemTableIdx < 0) break;
if(pSet->m_ItemList[i].m_nItemTableIdx == itemTableIdx)
{
return pSet->m_ItemList[i].m_nLevel;
}
}
return -1;
}
int CSkillItem::GetSkillTableIndex(int itemTableIdx)
{
CMap_SkillItemData::iterator iter;
iter=m_mapSkillItem.find(itemTableIdx);
if(iter==m_mapSkillItem.end()) return -1;
int SkillItemIndex = (iter->second);
CSkillItemSet *pSet= m_SkillItemData.Get(SkillItemIndex);
if(pSet == NULL) return -1;
return pSet->m_nSkillID;
}
void CSkillItem::SetDataList()
{
int size = m_SkillItemData.m_SkillItemList.size();
for(int i=0;i<size;i++)
{
CSkillItemSet *pSet= m_SkillItemData.Get(i);
if(pSet)
{
for(int j=0;j<MAX_SKILLITEM_UNIT;j++)
{
if(pSet->m_ItemList[j].m_nItemTableIdx)
{
m_mapSkillItem.insert(CMap_SkillItemData::value_type(
pSet->m_ItemList[j].m_nItemTableIdx,
i));
}
else
{
break;
}
}
}
}
}
bool CSkillItem::IsType_UseItemID(int itemTableIdx, int Type)
{
CSkillItemSet * pSkillItem= GetSkillItem_UseItemTableIdx(itemTableIdx);
if(NULL == pSkillItem) return false;
for(int i=0;i<MAX_SKILLITEM_UNIT;i++)
{
if(pSkillItem->m_ItemList[i].m_nItemTableIdx < 0) break;
if(pSkillItem->m_ItemList[i].m_nType == Type)
{
return true;
}
}
return false;
}
CSkillItemSet * CSkillItem::GetSkillItem_UseItemTableIdx(int itemTableIdx)
{
CMap_SkillItemData::iterator iter;
iter=m_mapSkillItem.find(itemTableIdx);
if(iter==m_mapSkillItem.end()) return NULL;
int SkillItemIndex = (iter->second);
CSkillItemSet *pSet= m_SkillItemData.Get(SkillItemIndex);
if(pSet == NULL) return NULL;
for(int i=0;i<MAX_SKILLITEM_UNIT;i++)
{
if(pSet->m_ItemList[i].m_nItemTableIdx < 0) break;
if(pSet->m_ItemList[i].m_nItemTableIdx == itemTableIdx)
{
return pSet;
}
}
return NULL;
}
CSkillItemSet * CSkillItem::GetSkillItem_UseSkillTableIdx(int SkillTableIdx)
{
int size = m_SkillItemData.m_SkillItemList.size();
for(int i=0;i<size;i++)
{
CSkillItemSet *pSet= m_SkillItemData.Get(i);
if(pSet)
{
if(pSet->m_nSkillID == SkillTableIdx)
{
return pSet;
}
}
}
return NULL;
}
bool CSkillItem::IsType_UseSkillID(int SkillTableIdx, int Type)
{
CSkillItemSet * pSkillItem= GetSkillItem_UseSkillTableIdx(SkillTableIdx);
if(NULL == pSkillItem) return false;
for(int i=0;i<MAX_SKILLITEM_UNIT;i++)
{
if(pSkillItem->m_ItemList[i].m_nItemTableIdx < 0) break;
if(pSkillItem->m_ItemList[i].m_nType == Type)
{
return true;
}
}
return false;
}
| C++ |
#include "../global.h"
#include "SkillApp.h"
skillObtain_t g_autoObtainSkill;
skillReturnData_t g_skillMultiTarget;
float g_tempCoolTime;
int g_affectSkillLevel;
CSkillLogic g_SkillLogic;
#define MAX_COUNT_SKILL_FUNC 136
void CSkillLogic::SKILL_Empty( void* pPc, float* pValue )
{
}
void CSkillLogic::SKILL_MakeAutoObtain()
{
int i;
AUTO_OBTAIN_SKILL *pObSkill;
memset( &g_autoObtainSkill, 0, sizeof( skillObtain_t ) );
for( i = 0; i < MAX_SKILL_NUMBER; i ++ )
{
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(i);
if(pSkillTable==NULL)
{
TRACE("Error! pSkillTable==NULL \n");
continue;
}
if( pSkillTable->m_nId < 0 ) continue;
if( !pSkillTable->m_nAutoObtainFlag) continue;
pObSkill = &g_autoObtainSkill.autoObtainSkill[pSkillTable->m_nJobType];
pObSkill->status[ pObSkill->count ].tableIdx = pSkillTable->m_nId;
pObSkill->status[ pObSkill->count ].level = pSkillTable->GetSkillRequire()->m_nGenLevel;
pObSkill->count ++;
}
}
int CSkillLogic::SKILL_IsValid( playerCharacter_t* pc, int skillIdx )
{
int i, count = 0;
if( pc->skillNumber <= 0 ) return( false );
for( i = 0; i < MAX_NUMBER_OF_SKILL; i ++ )
{
if( pc->skill[i].tableIdx < 0 ) continue;
if( pc->skill[i].tableIdx == skillIdx ) return( true );
count ++;
if( pc->skillNumber == count ) return( false );
}
return( false );
}
void CSkillLogic::SKILL_GetAutoObtain( playerCharacter_t *pc, int newLevel, int skillIdx[], int &num )
{
}
void CSkillLogic::SKILL_GetInitSkillLevel( int skillTableIdx, SKILL_GEN_LEVEL *level )
{
int gen[4] = { 0, 0, 0, 0 };
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(skillTableIdx);
if(pSkillTable==NULL)
{
TRACE("Error! pSkillTable==NULL \n");
return;
}
switch( pSkillTable->m_nJobType)
{
case J_MENTALITY :
gen[0] = 1;
break;
case J_WIND :
gen[1] = 1;
break;
case J_WATER :
gen[2] = 1;
break;
case J_EARTH :
gen[3] = 1;
break;
case J_DEVOTIONAL_KNIGHT :
gen[0] = 1;
gen[3] = 1;
break;
case J_ROMING_KNIGHT :
gen[0] = 1;
gen[1] = 1;
break;
case J_PIECING_EYES :
gen[1] = 1;
gen[2] = 1;
break;
case J_WINDY_ROMER :
gen[1] = 1;
gen[0] = 1;
break;
case J_DESTROYER :
gen[2] = 1;
gen[0] = 1;
break;
case J_GUARDIAN :
gen[2] = 1;
gen[3] = 1;
break;
case J_PROPHECIER :
gen[2] = 1;
gen[1] = 1;
break;
case J_TRANSFORMER :
gen[3] = 1;
gen[1] = 1;
break;
case J_DEFENDER :
gen[3] = 1;
gen[0] = 1;
break;
case J_STRANGER :
gen[3] = 1;
gen[2] = 1;
break;
}
level->gen[0] = gen[0];
level->gen[1] = gen[1];
level->gen[2] = gen[2];
level->gen[3] = gen[3];
}
int CSkillLogic::SKILL_Add( playerCharacter_t *pc, int skillTableIdx )
{
int i;
if( SKILL_IsValid( pc, skillTableIdx ) ) return( -1 );
if ( skillTableIdx < 0 || skillTableIdx > g_skillTableNumber )
return -1;
for( i = 0; i < MAX_NUMBER_OF_SKILL; i ++ )
{
if( pc->skill[i].tableIdx < 0 ) break;
}
if( i == MAX_NUMBER_OF_SKILL ) return( -1 );
pc->skill[i].idx = i;
pc->skill[i].tableIdx = skillTableIdx;
SKILL_GetInitSkillLevel( skillTableIdx, &pc->skill[i].level );
pc->skillNumber ++;
GTH_PC_Calculate( pc );
return( i );
}
int CSkillLogic::SKILL_LevelUp( playerCharacter_t* pc, int idx, int genType )
{
int skillTableIdx;
int reply = 1, error = 0, skillClass = 0;
int sphereIdx = 0;
if( pc->skill[idx].tableIdx < 0 )
{
reply = 0;
error = ERROR_SKILL_4;
GTH_SendMessage_Reply_SkillLevelUp( pc, reply, error, idx, genType );
return 0;
}
skillTableIdx = pc->skill[idx].tableIdx;
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(skillTableIdx);
if(pSkillTable==NULL)
{
TRACE("Error! pSkillTable==NULL \n");
return false;
}
int curLevel, gradeClass, limitLevel;
int reqGenCapability, reqGenLevel;
limitLevel = 1;
gradeClass = 0;
limitLevel = g_SkillDataGlobal.GetLimitlevel(skillTableIdx,genType);
gradeClass = g_SkillDataGlobal.GetGradeClass(skillTableIdx,genType);
curLevel = pc->skill[idx].level.gen[genType];
if( curLevel >= limitLevel )
{
reply = 0;
error = ERROR_SKILL_5;
GTH_SendMessage_Reply_SkillLevelUp( pc, reply, error, idx, genType );
return 0;
}
reqGenCapability = g_skillGradeClassTable[gradeClass].genCapability[curLevel];
if( pc->genCapability[genType] < reqGenCapability || reqGenCapability <= 0 )
{
reply = 0;
error = ERROR_SKILL_7;
GTH_SendMessage_Reply_SkillLevelUp( pc, reply, error, idx, genType );
return 0;
}
reqGenLevel = g_skillGradeClassTable[gradeClass].limitGenLevel[curLevel];
if( pc->genLevel < reqGenLevel )
{
reply = 0;
error = ERROR_SKILL_6;
GTH_SendMessage_Reply_SkillLevelUp( pc, reply, error, idx, genType );
return 0;
}
pc->genCapability[genType] -= reqGenCapability;
pc->skill[idx].level.gen[genType] ++;
GTH_PC_Calculate( pc );
GTH_SendMessage_Reply_SkillLevelUp( pc, reply, error, idx, genType );
return 1;
}
void CSkillLogic::SKILL_SendMessageMultiTarget( playerCharacter_t *pc, messageInfo_t *msginfo, int targetNumber, int dupflag, int delay )
{
message_t message;
float dist;
int i, n;
i3zoneScanList_t *targetList;
int targetListNumber;
msginfo->targetType = pc->targetType;
msginfo->targetIdx = pc->targetIdx;
g_skillMultiTarget.targetType[0] = pc->targetType;
g_skillMultiTarget.targetIdx[0] = pc->targetIdx;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, msginfo );
AI_SendMessage( &message );
switch( pc->targetType )
{
case ENTITY_MONSTER :
GTH_GetMonsterListInValidRange( pc->worldIdx, pc->position, 1 );
targetList = &g_zoneMonsterList[0];
targetListNumber = g_zoneMonsterListNumber;
break;
}
if( targetListNumber < targetNumber ) targetNumber = targetListNumber;
i = 0;
n = 1;
while( n < targetNumber && i < targetListNumber )
{
if( targetList[i].idx == pc->targetIdx && !dupflag )
{
i ++;
continue;
}
dist = GTH_GetDistanceFromTarget( pc->position, targetList[i].idx, pc->targetType );
if( dist > pc->baseAttackLength )
{
i ++;
continue;
}
msginfo->targetType = pc->targetType;
msginfo->targetIdx = targetList[i].idx;
if( delay ) msginfo->attack.delayTime += pc->calAttackDelay;
g_skillMultiTarget.targetType[n] = pc->targetType;
g_skillMultiTarget.targetIdx[n] = targetList[i].idx;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, msginfo );
AI_SendMessage( &message );
n ++;
i ++;
if( n == MAX_COUNT_SKILL_MULTI_TARGET ) break;
}
g_skillMultiTarget.targetNumber = n;
}
void CSkillLogic::SKILL_GetValue( playerCharacter_t *pc, int skillIdx, float value[] )
{
}
int CSkillLogic::SKILL_CheckPassive( playerCharacter_t* pc, int skillIdx )
{
int skillTableIdx;
int checkItemType, checkItem;
int weaponType, itemIdx, itemTableIdx, classIdx;
if( skillIdx < 0 ) return( false );
skillTableIdx = pc->skill[skillIdx].tableIdx;
if( skillTableIdx < 0 ) return( false );
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(pc->skill[skillIdx].tableIdx);
if(pSkillTable==NULL)
{
TRACE("Error! pSkillTable==NULL \n");
return 0;
}
checkItemType = pSkillTable->GetSkillRequire()->m_nItemType;
checkItem = pSkillTable->GetSkillRequire()->m_nItem;
switch( checkItemType )
{
case -1 :
{
return( true );
}
break;
case 0 :
{
itemIdx = pc->equipment[EQUIP_WEAPON_1 + pc->curWeapon];
if( itemIdx < 0 ) return( false );
itemTableIdx = pc->item[itemIdx].itemTableIdx;
classIdx = g_itemTable[itemTableIdx].classIdx;
weaponType = g_itemClassTable[classIdx].weaponType;
if( weaponType == checkItem ) return( true );
return( false );
}
break;
case 1 :
{
itemIdx = pc->equipment[EQUIP_WEAPON_1 + pc->curWeapon];
if( itemIdx < 0 ) return( false );
itemTableIdx = pc->item[itemIdx].itemTableIdx;
if( itemTableIdx == checkItem ) return( true );
return( false );
}
break;
}
return( false );
}
void CSkillLogic::SKILL_ApplyPassive( playerCharacter_t* pc )
{
int i, n;
int tableIdx;
n = 0;
for( i = 0; i < MAX_NUMBER_OF_SKILL; i ++ )
{
if( pc->skill[i].tableIdx < 0 ) continue;
tableIdx = pc->skill[i].tableIdx;
if( SKILL_CheckPassive( pc, i ) )
{
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(pc->skill[i].tableIdx);
if(pSkillTable==NULL)
{
TRACE("Error! pSkillTable==NULL \n");
continue;
}
if( pSkillTable->m_nUsageType)
{
CStr_Skill_Msg Msg;
Msg.Set(tableIdx,i);
Msg.pcIdx = pc->idx;
g_SkillProc.Active(pc,&Msg);
}
}
n ++;
if( n >= pc->skillNumber ) break;
}
}
int CSkillLogic::SKILL_CheckActive( playerCharacter_t* pc, int skillIdx )
{
int skillTableIdx;
int checkItemType, checkItem;
int weaponType, itemIdx, itemTableIdx, classIdx;
if( skillIdx < 0 ) return( false );
if( !pc->skillCastingState ) return( false );
skillTableIdx = pc->skill[skillIdx].tableIdx;
if( skillTableIdx < 0 ) return( false );
if( pc->skillCooltime[skillIdx] > g_timer->GetAppMilliTime() ) return( false );
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(skillTableIdx);
if(pSkillTable==NULL)
{
TRACE("Error! pSkillTable==NULL \n");
return 0;
}
checkItemType = pSkillTable->GetSkillRequire()->m_nItemType;
checkItem = pSkillTable->GetSkillRequire()->m_nItem;
switch( checkItemType )
{
case -1 :
{
return( true );
}
break;
case 0 :
{
itemIdx = pc->equipment[EQUIP_WEAPON_1 + pc->curWeapon];
if( itemIdx < 0 ) return( false );
itemTableIdx = pc->item[itemIdx].itemTableIdx;
classIdx = g_itemTable[itemTableIdx].classIdx;
weaponType = g_itemClassTable[classIdx].weaponType;
if( weaponType == checkItem ) return( true );
return( false );
}
break;
case 1 :
{
itemIdx = pc->equipment[EQUIP_WEAPON_1 + pc->curWeapon];
if( itemIdx < 0 ) return( false );
itemTableIdx = pc->item[itemIdx].itemTableIdx;
if( itemTableIdx == checkItem ) return( true );
return( false );
}
break;
}
return( false );
}
void CSkillLogic::SKILL_ApplyActive( playerCharacter_t* pc, int skillIdx, int &coolTime )
{
int tableIdx;
int targetType;
vec3_t pos, angles;
g_skillMultiTarget.targetNumber = 0;
tableIdx = pc->skill[skillIdx].tableIdx;
if( tableIdx < 0 || tableIdx >= MAX_NUMBER_OF_SKILL ) return;
g_affectSkillLevel = pc->skill[skillIdx].level.gen[0] + pc->skill[skillIdx].level.gen[1];
g_affectSkillLevel += pc->skill[skillIdx].level.gen[2] + pc->skill[skillIdx].level.gen[3];
if(pc->skillDamage == true )
{
CStr_Skill_Msg Msg;
Msg.Set(tableIdx,skillIdx);
Msg.pcIdx = pc->idx;
g_SkillProc.Active(pc,&Msg);
}
CSkillCastValue *pCast = g_SkillDataGlobal.GetCastValue(pc,NULL,tableIdx,SKILL_CAST_TABLE_INDEX,0,skillIdx);
if(pCast)
{
coolTime = (int)( pCast->m_fCool_Time * 1000.0f );
coolTime += (int)( ( pCast->m_fCool_Time * 1000.0f ) * pc->optValue[OV_DEC_COOLTIME_RATE] * 0.01f );
}
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(tableIdx);
if(pSkillTable==NULL)
{
TRACE("Error! pSkillTable==NULL \n");
return ;
}
targetType = pSkillTable->m_nTargetType;
switch( targetType )
{
case SKILL_TARGET_MONSTER :
case SKILL_TARGET_PLAYER:
if( !GTH_GetTargetPosition( pc, pos ) ) return;
vec_sub( pos, pc->position, pos );
vectoangles( pos, angles );
pc->angles[YAW] = angles[YAW];
break;
}
}
CSkillCastValue * CSkillLogic::SKILL_GetValueNotOwnSkill( int skillTableIdx, int level )
{
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(skillTableIdx);
if(pSkillTable==NULL)
{
TRACE("Error! pSkillTable==NULL \n");
return NULL;
}
CSkillCastValue * pCast = g_SkillDataGlobal.GetCastValue(NULL,NULL,skillTableIdx,SKILL_CAST_TABLE_INDEX,level);
return pCast;
}
void CSkillLogic::SKILL_ApplyActiveNotOwnSkill( playerCharacter_t *pc, int skillTableIdx, int skillLevel )
{
int targetType;
vec3_t pos, angles;
g_skillMultiTarget.targetNumber = 0;
if( skillTableIdx < 0 ) return;
g_affectSkillLevel = skillLevel;
if( pc->skillDamage == true )
{
TRACE("SKILL_ApplyActiveNotOwnSkill \n");
CStr_Skill_Msg Msg;
Msg.Set(skillTableIdx,0,skillLevel);
Msg.pcIdx = pc->idx;
g_SkillProc.Active(pc,&Msg);
}
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(skillTableIdx);
if(pSkillTable==NULL)
{
TRACE("Error! pSkillTable==NULL \n");
return ;
}
targetType = pSkillTable->m_nTargetType;
switch( targetType )
{
case SKILL_TARGET_MONSTER :
if( !GTH_GetTargetPosition( pc, pos ) ) return;
vec_sub( pos, pc->position, pos );
vectoangles( pos, angles );
pc->angles[YAW] = angles[YAW];
break;
}
}
void CSkillLogic::SKILL_Monster_ApplyActive( monsterCharacter_t* pMonster, int skillIdx, int& coolTime )
{
int tableIdx;
int targetType;
vec3_t pos, angles;
pMonster->basic.skillNumber;
pMonster->basic.skillIdx[skillIdx];
pMonster->basic.skillLevel[skillIdx];
g_skillMultiTarget.targetNumber = 1;
tableIdx = pMonster->basic.skillIdx[skillIdx];
if( tableIdx < 0 || tableIdx >= MAX_SKILL_NUMBER ) return;
g_affectSkillLevel = pMonster->skill[skillIdx].level.gen[0] + pMonster->skill[skillIdx].level.gen[1];
g_affectSkillLevel += pMonster->skill[skillIdx].level.gen[2] + pMonster->skill[skillIdx].level.gen[3];
CStr_Skill_Msg Msg;
Msg.Set(tableIdx,skillIdx);
Msg.monsterIdx = pMonster->idx;
g_SkillProc.Active(pMonster,&Msg);
CSkillCastValue * pCast = g_SkillDataGlobal.GetCastValue(NULL,pMonster,tableIdx,SKILL_CAST_TABLE_INDEX);
if(pCast)
{
coolTime = (int)( pCast->m_fCool_Time * 1000.0f );
}
else
{
TRACE("Error!! pCast == NULL \n");
coolTime=0;
}
pMonster->skillCooltime[skillIdx] = g_timer->GetAbsoluteTime() * 1000.0f + coolTime;
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(tableIdx);
if(pSkillTable==NULL)
{
TRACE("Error! SKILL_Monster_ApplyActive pSkillTable==NULL \n");
return ;
}
targetType = pSkillTable->m_nTargetType;
switch( targetType )
{
case SKILL_TARGET_MONSTER :
if( !GTH_GetTargetPosition( pMonster, pos ) ) return;
vec_sub( pos, pMonster->position, pos );
vectoangles( pos, angles );
pMonster->angles[YAW] = angles[YAW];
break;
case SKILL_TARGET_PLAYER :
if( !GTH_GetTargetPosition( pMonster, pos) ) return;
vec_sub(pos, pMonster->position, pos);
vectoangles(pos, angles);
pMonster->angles[YAW] = angles[YAW];
break;
}
}
void CSkillLogic::SKILL_Monster_GetValue( monsterCharacter_t *pMonster, int tableIdx, float value[] )
{
}
void CSkillLogic::GTH_UseSkillItem_DeleteSend(int invenPos)
{
int itemIdx = g_curPC->inventory[invenPos];
item_t *item = &g_curPC->item[itemIdx];
g_logSystem->WriteItemDeleteLog(g_curPC,g_curPC->item[itemIdx]);
if( item->durability > 0 )
{
item->durability --;
g_DBGameServer->SaveItem( g_curPC, item, itemIdx );
}
else
{
GTH_DeleteMyItem( g_curPC, item );
g_curPC->inventory[invenPos] = -1;
if ( !g_DBGameServer->RemoveItem( g_curPC, itemIdx ) )
{
return;
}
}
GTH_SendMessage_Reply_Use_Potion( g_curPC, 0, invenPos );
}
void CSkillLogic::GTH_ProcessMessage_Request_Use_Potion()
{
item_t *item;
int itemIdx, itemTableIdx;
int invenPos;
int reply = 1;
invenPos = MSG_ReadByte();
int TargetIdx = MSG_ReadShort();
int TargetType = MSG_ReadByte();
itemIdx = g_curPC->inventory[invenPos];
if( itemIdx < 0 )
{
reply = 0;
int error = ERROR_CONSUMPTIVE_0;
GTH_SendMessage_Reply_Use_Potion( g_curPC, error, invenPos );
return;
}
else
{
item = &g_curPC->item[itemIdx];
itemTableIdx = item->itemTableIdx;
if(g_SkillItem.IfSkillItem(itemTableIdx))
{
int SkillTableIndex = g_SkillItem.GetSkillTableIndex(itemTableIdx);
if(SkillTableIndex < 0 ) return;
int level = g_SkillItem.GetLevel(itemTableIdx);
if(level < 0) return;
if(TargetIdx != -1 && TargetType != -1)
{
g_curPC->targetIdx = TargetIdx;
g_curPC->targetType= TargetType;
}
g_PcSkill.GTH_PC_SkillNotOwn( g_curPC, CSkillItem::SELECT_ITEM,invenPos,SkillTableIndex, level, 0 );
}
else
{
GTH_UseSkillItem_DeleteSend(invenPos);
}
}
}
| C++ |
#if !defined(AFX_SKILLDATASUBPROC_H__3C7DA846_1062_437E_93AD_9311A50B8D02__INCLUDED_)
#define AFX_SKILLDATASUBPROC_H__3C7DA846_1062_437E_93AD_9311A50B8D02__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CSkillDataSubProc
{
public:
CSkillDataSubProc();
virtual ~CSkillDataSubProc();
void SKILL_AttractAttention(void *pPc,CStr_Skill_Msg *msg);
bool SubActionProc(void *pPc,CStr_Skill_Msg *msg);
};
extern CSkillDataSubProc g_SkillDataSubProc;
#endif
| C++ |
#include "../global.h"
#ifdef _OLD_SKILL_VER
void SKILL_ETC_WhiteDayEventPhyDmg( void* pPc, float* pValue )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float addDmg;
messageInfo_t msginfo;
message_t message;
addDmg = pValue[SKILL_VALUE_0];
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = 16;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_ATTACK;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msginfo.affect.startTime = g_globalTime;
msginfo.affect.keepTime = g_globalTime + 180000;
msginfo.targetType = ENTITY_PC;
msginfo.targetIdx = pc->idx;
msginfo.affect.common.type[0] = AFFDATA_TYPE_PHYDAMAGE;
msginfo.affect.common.data[0] = (int)addDmg;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_ETC_WhiteDayEventHitPower( void* pPc, float* pValue )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float addHitPower;
messageInfo_t msginfo;
message_t message;
addHitPower = pValue[SKILL_VALUE_0];
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = 21;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_ATTACK;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msginfo.affect.startTime = g_globalTime;
msginfo.affect.keepTime = g_globalTime + 180000;
msginfo.targetType = ENTITY_PC;
msginfo.targetIdx = pc->idx;
msginfo.affect.common.type[0] = AFFDATA_TYPE_HITPOWER;
msginfo.affect.common.data[0] = (int)addHitPower;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_ETC_WhiteDayEventMagDmg( void* pPc, float* pValue )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float addDmg;
messageInfo_t msginfo;
message_t message;
addDmg = pValue[SKILL_VALUE_0];
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = 41;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_ATTACK;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msginfo.affect.startTime = g_globalTime;
msginfo.affect.keepTime = g_globalTime + 180000;
msginfo.targetType = ENTITY_PC;
msginfo.targetIdx = pc->idx;
msginfo.affect.common.type[0] = AFFDATA_TYPE_MAGDAMAGE;
msginfo.affect.common.data[0] = (int)addDmg;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_ETC_MedicineOFAtkSpeed( void* pPc, float* pValue )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float atkSpeed, keeptime, sktidx;
messageInfo_t msginfo;
message_t message;
atkSpeed = pValue[SKILL_VALUE_0];
sktidx = 67;
keeptime = pValue[SKILL_VALUE_1];
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = sktidx;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_ATTACK;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msginfo.affect.startTime = g_globalTime;
msginfo.affect.keepTime = g_globalTime + (keeptime * 1000 );
msginfo.targetType = pc->entityType;
msginfo.targetIdx = pc->idx;
msginfo.affect.common.type[0] = AFFDATA_TYPE_ATTACKSPEED;
msginfo.affect.common.data[0] = atkSpeed;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_ETC_MedicineOFVelocity( void* pPc, float* pValue )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float Velocity, keeptime, sktidx, initvar;
messageInfo_t msginfo;
message_t message;
Velocity = pValue[SKILL_VALUE_0];
sktidx = 68;
initvar = pValue[3] * 100;
keeptime = pValue[4];
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = sktidx;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_ATTACK;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msginfo.affect.startTime = g_globalTime;
msginfo.affect.keepTime = g_globalTime + ( keeptime * 1000 );
msginfo.targetType = ENTITY_PC;
msginfo.targetIdx = pc->idx;
msginfo.affect.common.type[0] = AFFDATA_TYPE_VELOCITY;
msginfo.affect.common.data[0] = (int)initvar ;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_ETC_MedicineOFSpeedAndAttack( void* pPc, float* pValue )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float Velocity, atkSpeed, keeptime, sktidx, initvar;
messageInfo_t msginfo;
message_t message;
atkSpeed = pValue[SKILL_VALUE_0];
Velocity = pValue[SKILL_VALUE_1];
sktidx = 69;
initvar = Velocity * 100;
keeptime = pValue[SKILL_VALUE_2];
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = sktidx;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_ATTACK;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msginfo.affect.startTime = g_globalTime;
msginfo.affect.keepTime = g_globalTime + ( keeptime * 1000 );
msginfo.targetType = pc->entityType;
msginfo.targetIdx = pc->idx;
msginfo.affect.common.type[0] = AFFDATA_TYPE_VELOCITY;
msginfo.affect.common.data[0] = (int)initvar ;
msginfo.affect.common.type[1] = AFFDATA_TYPE_ATTACKSPEED;
msginfo.affect.common.data[1] = atkSpeed;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_ETC_MedicineOFAtkSpeed_China( void* pPc, float* pValue )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float atkSpeed, keeptime, sktidx;
messageInfo_t msginfo;
message_t message;
atkSpeed = pValue[SKILL_VALUE_0];
sktidx = 70;
keeptime = pValue[SKILL_VALUE_1];
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = sktidx;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_ATTACK;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msginfo.affect.startTime = g_globalTime;
msginfo.affect.keepTime = g_globalTime + (keeptime * 1000 );
msginfo.targetType = pc->entityType;
msginfo.targetIdx = pc->idx;
msginfo.affect.common.type[0] = AFFDATA_TYPE_ATTACKSPEED;
msginfo.affect.common.data[0] = atkSpeed;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_ETC_MedicineOFVelocity_China( void* pPc, float* pValue )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float Velocity, keeptime, sktidx, initvar;
messageInfo_t msginfo;
message_t message;
Velocity = pValue[SKILL_VALUE_0];
sktidx = 71;
initvar = Velocity * 100;
keeptime = pValue[SKILL_VALUE_1];
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = sktidx;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_ATTACK;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msginfo.affect.startTime = g_globalTime;
msginfo.affect.keepTime = g_globalTime + ( keeptime * 1000 );
msginfo.targetType = ENTITY_PC;
msginfo.targetIdx = pc->idx;
msginfo.affect.common.type[0] = AFFDATA_TYPE_VELOCITY;
msginfo.affect.common.data[0] = (int)initvar ;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
#endif
| C++ |
#if !defined(AFX_SKILLTABLEMAP_H__43AFC84D_AEC8_4BD1_9965_C61D49301226__INCLUDED_)
#define AFX_SKILLTABLEMAP_H__43AFC84D_AEC8_4BD1_9965_C61D49301226__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CSkillTableMap
{
private:
public:
CSkillTableMap();
~CSkillTableMap();
bool SAFE_ARRAY(int index);
void ClearDB();
CSkilTable * FindDB(int nID);
void InsertDB(int nID, CSkilTable *pData);
CSkilTable * m_SkillDB[MAX_SKILL_NUMBER];
};
extern CSkillTableMap g_SkillTableDB;
#endif
| C++ |
#include "../global.h"
#ifdef _OLD_SKILL_VER
void SKILL_ConcentrateHit( void *pPc, float *pValue )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float dmg, hitPro, oneHandShockPro, twoHandShockPro, stunTime, cursePro, curseTime, phybonus;
int curseType;
messageInfo_t msginfo;
message_t message;
dmg = pValue[SKILL_VALUE_0];
hitPro = pValue[SKILL_VALUE_1];
oneHandShockPro = pValue[SKILL_VALUE_2];
twoHandShockPro = pValue[SKILL_VALUE_3];
stunTime = pValue[SKILL_VALUE_4];
phybonus = pValue[SKILL_VALUE_5];
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_ATTACK;
msginfo.attack.atkType = MSGINFO_ATK_TYPE_NORMAL;
msginfo.attack.hitPower = (int)( (float)pc->calHitPower * hitPro * 0.01f );
msginfo.attack.phyMinDmg = (int)( (float)pc->calPhyMinDmg * ( 1.0f + dmg * 0.01f ) + phybonus + pc->calMagMinDmg );
msginfo.attack.phyMaxDmg = (int)( (float)pc->calPhyMinDmg * ( 1.0f + dmg * 0.01f ) + phybonus + pc->calMagMinDmg );
msginfo.attack.criticalRate = 0;
msginfo.attack.criticalDamage = 0;
msginfo.attack.delayTime = pc->calAttackDelay;
msginfo.attack.repeatNum = 0;
msginfo.targetType = pc->targetType;
msginfo.targetIdx = pc->targetIdx;
if( pc->atkWeaponType == WEAPON_TYPE_ONEHAND_SWORD )
{
curseType = MSGINFO_ATK_ETC_INFO_SHOCK;
cursePro = (int)oneHandShockPro;
if( pc->targetType == ENTITY_PC ) curseTime = g_pc[pc->targetIdx].calAttackDelay;
else curseTime = g_monster[pc->targetIdx].calAttackDelay;
}
else if( pc->atkWeaponType == WEAPON_TYPE_TWOHAND_SWORD )
{
curseType = MSGINFO_ATK_ETC_INFO_STUN;
cursePro = (int)twoHandShockPro;
curseTime = stunTime * 1000.0f;
}
msginfo.attack.etcInfo = curseType;
msginfo.attack.etcData0 = cursePro;
msginfo.attack.etcData1 = curseTime;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_ConsecutiveSlash( void *pPc, float *pValue )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float dmg, hitPro, criticalPro, phybonus;
messageInfo_t msginfo;
message_t message;
dmg = pValue[SKILL_VALUE_0];
hitPro = pValue[SKILL_VALUE_1];
criticalPro = pValue[SKILL_VALUE_2];
phybonus = pValue[SKILL_VALUE_3];
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_ATTACK;
msginfo.attack.atkType = MSGINFO_ATK_TYPE_NORMAL;
msginfo.attack.hitPower = (int)( (float)pc->calHitPower * hitPro * 0.01f );
msginfo.attack.phyMinDmg = (int)( (float)pc->calPhyMinDmg * ( 1.0f + dmg * 0.01f ) + phybonus + pc->calMagMinDmg ) / 3;
msginfo.attack.phyMaxDmg = (int)( (float)pc->calPhyMaxDmg * ( 1.0f + dmg * 0.01f ) + phybonus + pc->calMagMaxDmg ) / 3;
msginfo.attack.criticalRate = (int)criticalPro;
msginfo.attack.criticalDamage = 0;
msginfo.attack.delayTime = pc->calAttackDelay;
msginfo.attack.repeatNum = 0;
msginfo.targetType = pc->targetType;
msginfo.targetIdx = pc->targetIdx;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_SpinSlash( void *pPc, float *pValue )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float dmg, hitPro, shockPro, cursePro, curseTime, phybonus;
int curseType;
messageInfo_t msginfo;
message_t message;
dmg = pValue[SKILL_VALUE_0];
hitPro = pValue[SKILL_VALUE_1];
shockPro = pValue[SKILL_VALUE_2];
phybonus = pValue[SKILL_VALUE_3];
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_ATTACK;
msginfo.attack.atkType = MSGINFO_ATK_TYPE_NORMAL;
msginfo.attack.hitPower = (int)( (float)pc->calHitPower * hitPro * 0.01f );
msginfo.attack.phyMinDmg = (int)( (float)pc->calPhyMinDmg * ( 1.0f + dmg * 0.01f ) + phybonus + pc->calMagMinDmg );
msginfo.attack.phyMaxDmg = (int)( (float)pc->calPhyMaxDmg * ( 1.0f + dmg * 0.01f ) + phybonus + pc->calMagMaxDmg );
msginfo.attack.criticalRate = 0;
msginfo.attack.criticalDamage = 0;
msginfo.attack.delayTime = pc->calAttackDelay;
msginfo.attack.repeatNum = 0;
msginfo.targetType = pc->targetType;
msginfo.targetIdx = pc->targetIdx;
msginfo.attack.etcInfo = MSGINFO_ATK_ETC_DEC_DAMAGE_AS_TARGET_NUMBER;
curseType = MSGINFO_ATK_ETC_INFO_SHOCK;
cursePro = (int)shockPro;
if( pc->targetType == ENTITY_PC ) curseTime = g_pc[pc->targetIdx].calAttackDelay;
else curseTime = g_monster[pc->targetIdx].calAttackDelay;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message, pc->calAttackLength );
}
void SKILL_TrainOneHandSword( void *pPc, float *pValue )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float dmg;
dmg = pValue[SKILL_VALUE_0];
pc->calPhyMinDmg += dmg;
pc->calPhyMaxDmg += dmg;
}
void SKILL_TrainTwoHandSword( void *pPc, float *pValue )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float dmg;
dmg = pValue[SKILL_VALUE_0];
pc->calPhyMinDmg += dmg;
pc->calPhyMaxDmg += dmg;
}
void SKILL_IncreaseAttackPower(void* pPc, float* pValue)
{
playerCharacter_t* pc = NULL;
pc = static_cast<playerCharacter_t *>(pPc);
if( pc == NULL ) return;
float incDmg, useSA;
message_t message;
messageInfo_t msginfo;
incDmg = pValue[SKILL_VALUE_0];
useSA = pValue[SKILL_VALUE_1];
memset( &msginfo, 0, sizeof(messageInfo_t) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = 26;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_TOGGLE;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msginfo.affect.startTime = g_globalTime;
msginfo.targetType = ENTITY_PC;
msginfo.targetIdx = pc->idx;
msginfo.affect.common.type[0] = AFFDATA_TYPE_PHYDAMAGE;
msginfo.affect.common.data[0] = (int)incDmg;
msginfo.affect.common.type[1] = AFFDATA_TYPE_INCSARECOVERY;
msginfo.affect.common.data[1] = -(int)useSA;
msginfo.affect.delayTime = 1000;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_IncreaseRARecovery(void* pPc, float* pValue)
{
playerCharacter_t* pc = NULL;
pc = static_cast<playerCharacter_t*>(pPc);
if( pc == NULL ) return;
float raRecInc, keepTime;
message_t message;
messageInfo_t msginfo;
raRecInc = pValue[SKILL_VALUE_0];
keepTime = pValue[SKILL_VALUE_1] * 1000.0f;
memset( &msginfo, 0, sizeof(messageInfo_t) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = 27;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_ASSIST;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msginfo.affect.startTime = g_globalTime;
msginfo.affect.keepTime = g_globalTime + (int)keepTime;
msginfo.targetType = ENTITY_PC;
msginfo.targetIdx = pc->idx;
msginfo.affect.common.type[0] = AFFDATA_TYPE_INCRARECOVERY;
msginfo.affect.common.data[0] = (int)raRecInc;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_DisturbMental( void* pPc, float* pValue)
{
float hitPro, dmg, phyBonus, listPoint;
messageInfo_t msginfo;
message_t message;
playerCharacter_t* pc = NULL;
pc = static_cast<playerCharacter_t *>(pPc);
if( pc == NULL ) return;
hitPro = pValue[SKILL_VALUE_0];
dmg = pValue[SKILL_VALUE_1];
phyBonus = pValue[SKILL_VALUE_2];
listPoint = pValue[SKILL_VALUE_3];
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_ATTACK;
msginfo.attack.atkType = MSGINFO_ATK_TYPE_NORMAL;
msginfo.attack.hitPower = (int)( (float)pc->calHitPower * hitPro * 0.01f );
msginfo.attack.phyMinDmg = (int)( (float)pc->calPhyMinDmg * ( 1.0f + dmg * 0.01f ) + phyBonus + pc->calMagMinDmg );
msginfo.attack.phyMaxDmg = (int)( (float)pc->calPhyMinDmg * ( 1.0f + dmg * 0.01f ) + phyBonus + pc->calMagMinDmg );
msginfo.attack.criticalRate = 0;
msginfo.attack.criticalDamage = 0;
msginfo.attack.delayTime = pc->calAttackDelay;
msginfo.attack.repeatNum = 0;
msginfo.targetType = pc->targetType;
msginfo.targetIdx = pc->targetIdx;
if( pc->targetType == ENTITY_MONSTER )
AddMonster_ContributionPoint(pc, pc->targetIdx, ATTACK_POINT, listPoint);
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_ConcentrateHitEx( void* pPc, float* pValue )
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float dmg, hitPro, phyBonus, stunPro, stunTime, cursePro, curseTime;
int curseType;
messageInfo_t msginfo;
message_t message;
hitPro = pValue[SKILL_VALUE_0];
dmg = pValue[SKILL_VALUE_1];
phyBonus = pValue[SKILL_VALUE_2];
stunPro = pValue[SKILL_VALUE_3];
stunTime = pValue[SKILL_VALUE_4];
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_ATTACK;
msginfo.attack.atkType = MSGINFO_ATK_TYPE_NORMAL;
msginfo.attack.hitPower = (int)( (float)pc->calHitPower * hitPro * 0.01f );
msginfo.attack.phyMinDmg = (int)( (float)pc->calPhyMinDmg * ( 1.0f + dmg * 0.01f ) + phyBonus + pc->calMagMinDmg );
msginfo.attack.phyMaxDmg = (int)( (float)pc->calPhyMinDmg * ( 1.0f + dmg * 0.01f ) + phyBonus + pc->calMagMinDmg );
msginfo.attack.criticalRate = 0;
msginfo.attack.criticalDamage = 0;
msginfo.attack.delayTime = pc->calAttackDelay;
msginfo.attack.repeatNum = 0;
msginfo.targetType = pc->targetType;
msginfo.targetIdx = pc->targetIdx;
curseType = MSGINFO_ATK_ETC_INFO_STUN;
cursePro = (int)stunPro;
curseTime = stunTime * 1000.0f;
msginfo.attack.etcInfo = curseType;
msginfo.attack.etcData0 = cursePro;
msginfo.attack.etcData1 = curseTime;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_layhands( void* pPc, float* pValue )
{
float incVel;
float RADecRate, RAIncreRate;
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
RADecRate = pValue[SKILL_VALUE_0];
RAIncreRate = pValue[SKILL_VALUE_1];
if ( pc->idx == pc->targetIdx) return;
if ( pc->curRA <= 0) return;
incVel = pc->curRA * ( RADecRate / 100 );
if ( incVel <= 0) return;
pc->curRA -= incVel;
incVel *= RAIncreRate;
g_pc[pc->targetIdx].curRA += incVel;
if( g_pc[pc->targetIdx].curRA > g_pc[pc->targetIdx].calMaxRA )
g_pc[pc->targetIdx].curRA = g_pc[pc->targetIdx].calMaxRA;
}
void SKILL_IncreaseMoveSpeed( void* pPc, float* pValue )
{
float incVel, keepTime;
messageInfo_t msginfo;
message_t message;
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
incVel = pValue[SKILL_VALUE_0];
keepTime = pValue[SKILL_VALUE_1] * 1000.0f;
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = 38;
msginfo.affect.level = g_affectSkillLevel;
msginfo.affect.type = AFFECT_ASSIST;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msginfo.affect.startTime = g_globalTime;
msginfo.affect.keepTime = g_globalTime + (int)keepTime;
msginfo.targetType = ENTITY_PC;
msginfo.targetIdx = pc->idx;
msginfo.affect.common.type[0] = AFFDATA_TYPE_VELOCITY_RATE;
msginfo.affect.common.data[0] = (int)incVel;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
GTH_DeleteAffect( pc, ENTITY_PC, 43 );
}
void SKILL_SoulBreaker(void* pPc, float* pValue)
{
float hitPro, dmg, phyBonus;
messageInfo_t msginfo;
message_t message;
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
hitPro = pValue[SKILL_VALUE_0];
dmg = pValue[SKILL_VALUE_1];
phyBonus = pValue[SKILL_VALUE_2];
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_ATTACK;
msginfo.attack.atkType = MSGINFO_ATK_TYPE_NORMAL;
msginfo.attack.hitPower = (int)( (float)pc->calHitPower * hitPro * 0.01f );
msginfo.attack.phyMinDmg = (int)( (float)pc->calPhyMinDmg * ( 1.0f + dmg * 0.01f ) + phyBonus + pc->calMagMinDmg );
msginfo.attack.phyMaxDmg = (int)( (float)pc->calPhyMinDmg * ( 1.0f + dmg * 0.01f ) + phyBonus + pc->calMagMinDmg );
msginfo.attack.delayTime = pc->calAttackDelay;
msginfo.targetType = pc->targetType;
msginfo.targetIdx = pc->targetIdx;
AI_MakeMessage( pc, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_SelfHeal(void* pPc, float* pValue)
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
float raRecovery = pValue[SKILL_VALUE_0];
switch( pc->entityType )
{
case ENTITY_PC :
g_pc[pc->idx].curRA += raRecovery;
g_pc[pc->idx].curRA += (float)raRecovery * g_pc[pc->idx].optValue[OV_HEAL_EFFICIENCY] * 0.01f;
if( g_pc[pc->idx].curRA > g_pc[pc->idx].calMaxRA )
g_pc[pc->idx].curRA = g_pc[pc->idx].calMaxRA;
break;
}
}
#endif
| C++ |
#include "../Global.h"
CSkillPartyProc g_SkillPartyProc;
CSkillPartyProc::CSkillPartyProc()
{
}
CSkillPartyProc::~CSkillPartyProc()
{
}
bool CSkillPartyProc::Proc(void *pPc,CStr_Skill_Msg *msg)
{
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(msg->nSkillID);
if(pSkillTable==NULL) return false;
CSkillDataFormat *pDataFormat = pSkillTable->GetDataFormat();
if(pDataFormat == NULL) return false;
CSkillDataParty * pParty = pDataFormat->GetParty();
if(pParty == NULL) return false;
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(pc==NULL) return false;
msg->pParty = pParty;
int i;
for(i=0;i<MAX_NUMBER_OF_PARTY_MEMBER; i++)
{
if(!Check(pPc,i,msg)) continue;
msg->pPartyMeber = pPc;
playerCharacter_t* pMemberPc=
g_SkillDataGlobal.GetPCPointer(pc->member[i].idxOnServer);
g_SkillProc.CastActive(pMemberPc,msg);
g_SkillProc.Proc(pMemberPc,msg);
}
return true;
}
bool CSkillPartyProc::Check(void* pPc,int nIndex,CStr_Skill_Msg *msg )
{
for(int i=0;i<MAX_SKILL_PARTY_CHECK;i++)
{
switch(msg->pParty->m_Check[i]) {
case SKILL_PARTY_CHECK_NORMAL:
{
if(!PartyCheck(pPc,nIndex,msg)) return false;
}
break;
case SKILL_PARTY_CHECK_CRITICAL_RATE:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(pc==NULL) return false;
float IncCriticalRate = g_SkillDataGlobal.GetValue(pPc,SKILL_AFFDATA_TYPE_CRITICALRATE,msg);
int pcIdx = pc->member[nIndex].idxOnServer;
float mastercalCriticalRate = g_pc[pc->idx].calCriticalRate;
if ( mastercalCriticalRate < 0.0f) return false;
float calcriticalrate = IncCriticalRate + g_pc[pc->idx].calCriticalRate;
if ( pc->idx != pcIdx )
{
if ( IncCriticalRate + mastercalCriticalRate < calcriticalrate)
calcriticalrate = IncCriticalRate + mastercalCriticalRate;
if ( calcriticalrate <= g_pc[pcIdx].calCriticalRate)
continue;
}
}
break;
}
}
return true;
}
bool CSkillPartyProc::PartyCheck(void* pPc,int nIndex,CStr_Skill_Msg *msg)
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(pc==NULL) return false;
if(nIndex < 0 || nIndex >= MAX_NUMBER_OF_PARTY_MEMBER) return false;
int pcIdx = pc->member[nIndex].idxOnServer;
if ( pcIdx < 0 || pcIdx >= MAX_PCS) return false;
if ( pcIdx == pc->idx) return false;
if( pc->member[nIndex].serverIndex < 0 ) return false;
if ( pc->member[nIndex].serverIndex != g_config.gameServerNo ) return false;
if ( g_pc[pcIdx].worldIdx != pc->worldIdx ) return false;
if ( !g_pc[pcIdx].active || !g_pc[pcIdx].alive ) return false;
if( stricmp( g_pc[pcIdx].name, pc->member[nIndex].memberName ) ) return false;
if ( g_pc[pcIdx].worldIdx == tagGolryunBattle::Golryun_Battle_Map_Index) return false;
float fRange = g_SkillDataGlobal.GetValue(pPc,SKILL_TYPE_RANGE,msg);
if(fRange > 0.0f)
{
if( GTH_GetDistance2D( pc->position, g_pc[nIndex].position) > fRange )return false;
}
return true;
}
bool CSkillPartyProc::IfPartyMember(int MyIndex,int PartyMemberIndex)
{
if(MyIndex < 0 || MyIndex >= MAX_PCS) return false;
if(PartyMemberIndex < 0 || PartyMemberIndex >= MAX_PCS) return false;
int i;
for(i=0;i<MAX_NUMBER_OF_PARTY_MEMBER; i++)
{
if(g_pc[MyIndex].member[i].idxOnServer == PartyMemberIndex)
{
return true;
}
}
return false;
} | C++ |
#if !defined(AFX_SKILLTRANSINFO_H__E2BEA656_07D6_4B99_AA4B_160158A63005__INCLUDED_)
#define AFX_SKILLTRANSINFO_H__E2BEA656_07D6_4B99_AA4B_160158A63005__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CSkillTransformUnit
{
public:
CSkillTransformUnit()
{
Init();
}
~CSkillTransformUnit()
{
}
void Init()
{
m_nSkillID =-1;
m_nTransformEntityIdx=-1;
m_nEffectID=-1;
}
public:
int m_nSkillID;
int m_nTransformEntityIdx;
int m_nEffectID;
};
class CSkillTransformData
{
public:
CSkillTransformData()
{
}
~CSkillTransformData()
{
}
CSkillTransformUnit * Get(int Index);
void Insert(CSkillTransformUnit *temp);
void Clear();
int GetEffectID(const int _EntityIdx);
public:
vector <CSkillTransformUnit *> m_TransData;
};
class CSkillTransInfo
{
public:
CSkillTransformData m_TransList;
public:
CSkillTransInfo();
virtual ~CSkillTransInfo();
CSkillTransformData * Get()
{
return &m_TransList;
}
};
extern CSkillTransInfo m_SkillTransInfo;
#endif
| C++ |
#include "../global.h"
#ifdef _OLD_SKILL_VER
void SKILL_MON_MeteoStrike( void* pMonster, float* pValue )
{
monsterCharacter_t* pMon = static_cast<monsterCharacter_t*>(pMonster);
float dmg = pValue[SKILL_VALUE_0];
float range = pValue[SKILL_VALUE_1];
if( pMon->targetType == ENTITY_PC )
{
if( g_pc[pMon->targetIdx].event == GTH_EV_CHAR_DIE ) return;
}
messageInfo_t msginfo;
message_t message;
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_ATTACK;
msginfo.affect.skillTableIdx = 131;
msginfo.attack.atkType = MSGINFO_ATK_TYPE_MAGIC;
msginfo.attack.posMinDmg = (int)dmg + pMon->calMagMinDmg;
msginfo.attack.posMaxDmg = (int)dmg + pMon->calMagMaxDmg;
msginfo.attack.delayTime = 400;
msginfo.attack.etcInfo = MSGINFO_ATK_ETC_INFO_STUN;
msginfo.attack.etcData0 = 100;
if(pMon->targetType == ENTITY_PC )
{
if( pMon->targetIdx > 0 )
msginfo.attack.etcData1 = g_pc[pMon->targetIdx].calStunTime;
}
else
{
if( pMon->targetIdx > 0 )
msginfo.attack.etcData1 = g_monster[pMon->targetIdx].calStunTime;
}
msginfo.targetType = pMon->targetType;
msginfo.targetIdx = pMon->targetIdx;
AI_MakeMessage( pMon, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message );
}
void SKILL_MON_Slow( void* pMonster, float* pValue )
{
float decVel, attackspeed, range, keepTime;
monsterCharacter_t* pMon = static_cast<monsterCharacter_t*>(pMonster);
decVel = pValue[SKILL_VALUE_0];
attackspeed = pValue[SKILL_VALUE_1];
range = pValue[SKILL_VALUE_2];
keepTime = pValue[SKILL_VALUE_3] * 1000.0f;
if( g_pc[pMon->targetIdx].event == GTH_EV_CHAR_DIE ) return;
messageInfo_t msginfo;
message_t message;
memset( &msginfo, 0, sizeof( messageInfo_t ) );
msginfo.infoType = MSGINFO_TYPE_AFFECT;
msginfo.affect.skillTableIdx = 133;
msginfo.affect.level = 1;
msginfo.affect.type = AFFECT_ATTACK;
msginfo.affect.affectType = MSGINFO_AFF_TYPE_NORMAL;
msginfo.affect.startTime = g_globalTime;
msginfo.affect.keepTime = g_globalTime + (int)keepTime;
msginfo.targetType = ENTITY_PC;
msginfo.targetIdx = pMon->targetIdx;
msginfo.affect.level = 1;
msginfo.affect.common.type[0] = AFFDATA_TYPE_ATTACKSPEEDRATE;
msginfo.affect.common.data[0] = -(int)attackspeed;
msginfo.affect.common.type[1] = AFFDATA_TYPE_VELOCITY_RATE;
msginfo.affect.common.data[1] = -(int)decVel;
AI_MakeMessage( pMon, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message, (int)range );
}
void SKILL_MON_BazmoStrike( void* pMonster, float* pValue )
{
float dmg, range, pro;
monsterCharacter_t* pMon = static_cast<monsterCharacter_t *>(pMonster);
messageInfo_t msginfo;
message_t message;
memset( &msginfo, 0, sizeof(messageInfo_t) );
msginfo.infoType = MSGINFO_TYPE_ATTACK;
dmg = pValue[SKILL_VALUE_0];
range = pValue[SKILL_VALUE_1];
pro = pValue[SKILL_VALUE_2];
msginfo.attack.atkType = MSGINFO_ATK_TYPE_NORMAL;
msginfo.attack.hitPower = (int)pro;
msginfo.attack.phyMinDmg = (int)dmg + pMon->calPhyMinDmg;
msginfo.attack.phyMaxDmg = (int)dmg + pMon->calPhyMaxDmg;
msginfo.attack.criticalRate = 0;
msginfo.attack.criticalDamage = 0;
msginfo.attack.delayTime = pMon->calAttackDelay;
msginfo.attack.delayTime = 1000.0f;
msginfo.attack.repeatNum = 3;
msginfo.attack.repeatDelayTime = 300.0f;
msginfo.targetType = pMon->targetType;
msginfo.targetIdx = pMon->targetIdx;
AI_MakeMessage( pMon, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message, (int)range );
}
void SKILL_MON_SpikeShield( void* pMonster, float* pValue )
{
float dmg, range, keepTime;
messageInfo_t msginfo;
message_t message;
monsterCharacter_t* pMon = static_cast<monsterCharacter_t *>(pMonster);
memset( &msginfo, 0, sizeof(messageInfo_t) );
dmg = pValue[SKILL_VALUE_0];
range = pValue[SKILL_VALUE_1];
keepTime = pValue[SKILL_VALUE_2] * 1000.0f;
msginfo.infoType = MSGINFO_TYPE_ATTACK;
msginfo.attack.atkType = MSGINFO_ATK_TYPE_MAGIC;
msginfo.attack.posMinDmg = (int)dmg + pMon->calMagMinDmg;
msginfo.attack.posMaxDmg = (int)dmg + pMon->calMagMaxDmg;
msginfo.targetType = pMon->targetType;
msginfo.targetIdx = pMon->targetIdx;
AI_MakeMessage( pMon, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message, (int)range );
}
void SKILL_MON_DevonHead( void* pMonster, float* pValue )
{
float dmg, pro;
messageInfo_t msginfo;
message_t message;
monsterCharacter_t* pMon = static_cast<monsterCharacter_t *>(pMonster);
memset( &msginfo, 0, sizeof(messageInfo_t) );
dmg = pValue[SKILL_VALUE_0];
pro = pValue[SKILL_VALUE_1];
msginfo.infoType = MSGINFO_TYPE_ATTACK;
msginfo.attack.atkType = MSGINFO_ATK_TYPE_NORMAL;
msginfo.attack.phyMinDmg = (int)dmg + pMon->calPhyMinDmg;
msginfo.attack.phyMaxDmg = (int)dmg + pMon->calPhyMaxDmg;
msginfo.attack.hitPower = (int)pro;
msginfo.targetType = pMon->targetType;
msginfo.targetIdx = pMon->targetIdx;
AI_MakeMessage( pMon, &message, MESSAGE_USEINFO, &msginfo );
AI_SendMessage( &message);
}
#endif | C++ |
#include "../Global.h"
#include "..\Tools\CTools.h"
extern CTools* gcpTools;
CSkillDataMsgProc g_SkillDataMsgProc;
CSkillDataMsgProc::CSkillDataMsgProc()
{
}
CSkillDataMsgProc::~CSkillDataMsgProc()
{
}
int CSkillDataMsgProc::GetType(int _Type,void *pPc,int nSkillID)
{
switch(_Type) {
case SKILL_MES_TYPE: return MSG_ETC;
break;
}
return NO_TYPE;
}
int CSkillDataMsgProc::GetFromIdx(int _Type,void *pPc,int nSkillID)
{
switch(_Type) {
case SKILL_MES_FROMIDX:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(pc)
{
return pc->idx;
}
}
break;
}
return NO_TYPE;
}
int CSkillDataMsgProc::GetFromType(int _Type,void *pPc,int nSkillID)
{
switch(_Type) {
case SKILL_MES_FROMTYPE: return ENTITY_PC;
break;
}
return NO_TYPE;
}
int CSkillDataMsgProc::GetName(int _Type,message_t *message,void *pPc,int nSkillID)
{
switch(_Type) {
case SKILL_MES_NAME:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(pc)
{
int len = strlen(pc->name);
if(len <0 || len > 255)
{
}
strncpy( message->fromNameV2, pc->name,NAMESTRING);
message->fromNameV2[NAMESTRING]=NULL;
return true;
}
}
break;
}
return NO_TYPE;
}
int CSkillDataMsgProc::GetToType(int _Type,void *pPc,int nSkillID)
{
switch(_Type) {
case SKILL_MES_TOTYPE:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(pc)
{
return pc->targetType;
}
}
break;
}
return NO_TYPE;
}
int CSkillDataMsgProc::GetToIdx(int _Type,void *pPc,int nSkillID)
{
switch(_Type) {
case SKILL_MES_TOIDX:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(pc)
{
return pc->targetIdx;
}
}
break;
}
return NO_TYPE;
}
int CSkillDataMsgProc::GetWorldIdx(int _Type,void *pPc,int nSkillID)
{
switch(_Type) {
case SKILL_MES_WORLDIDX:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(pc)
{
return pc->worldIdx;
}
}
break;
}
return NO_TYPE;
}
int CSkillDataMsgProc::GetSendTime(int _Type,void *pPc,int nSkillID)
{
switch(_Type) {
case SKILL_MES_SENDTIME: return g_globalTime;
break;
}
return NO_TYPE;
}
int CSkillDataMsgProc::GetReceiveTime(int _Type,void *pPc,int nSkillID)
{
switch(_Type) {
case SKILL_MES_RECEIVETIME: return g_globalTime + 1500;
break;
}
return NO_TYPE;
}
int CSkillDataMsgProc::GetData(int _Type,void *pPc,CStr_Skill_Msg *msg)
{
switch(_Type) {
case SKILL_MES_DATA_MSG_ETC_RESURRECTION: return MSG_ETC_RESURRECTION;
break;
case SKILL_MES_DATA_RAREC:
{
float fVal = (int)g_SkillDataGlobal.GetValue(msg->pPc,SKILL_MSG_TYPE_RAREC,msg);
return fVal;
}
break;
case SKILL_MES_DATA_SAREC:
{
float fVal = (int)g_SkillDataGlobal.GetValue(msg->pPc,SKILL_MSG_TYPE_SAREC,msg);
return fVal;
}
break;
case SKILL_MES_DATA_EXRECRATE:
{
playerCharacter_t* pPlayer=NULL;
pPlayer = gcpTools->GetPlayerRecordPointer(msg->message->toIdx);
if(NULL == pPlayer) return 0;
float fVal = (int)g_SkillDataGlobal.GetValue(msg->pPc,SKILL_MSG_TYPE_EXP_REC_RATE,msg);
float recoveryExp= pPlayer->reduceExp * (fVal * 0.01f);
return recoveryExp;
}
break;
case SKILL_MES_DATA_RA_REC_RATE:
{
playerCharacter_t* pPlayer=NULL;
pPlayer = gcpTools->GetPlayerRecordPointer(msg->message->toIdx);
if(NULL == pPlayer) return 0;
float fVal = (int)g_SkillDataGlobal.GetValue(msg->pPc,SKILL_MSG_TYPE_RA_REC_RATE,msg);
float fRa= pPlayer->calMaxRA * (fVal * 0.01);
return fRa;
}
break;
case SKILL_MES_DATA_SA_REC_RATE:
{
playerCharacter_t* pPlayer=NULL;
pPlayer = gcpTools->GetPlayerRecordPointer(msg->message->toIdx);
if(NULL == pPlayer) return 0;
float fVal = (int)g_SkillDataGlobal.GetValue(msg->pPc,SKILL_MSG_TYPE_SA_REC_RATE,msg);
float fSa= pPlayer->calMaxSA * (fVal * 0.01);
return fSa;
}
break;
}
return NO_TYPE;
}
| C++ |
#include "../global.h"
#include "SkillApp.h"
CSkillProcBasic::CSkillProcBasic()
{
}
CSkillProcBasic::~CSkillProcBasic()
{
}
int CSkillProcBasic::GetInfoType(BYTE _Type)
{
switch(_Type) {
case SKILL_TYPE_COMMON: return MSGINFO_TYPE_COMMON ;
case SKILL_TYPE_ATTACK: return MSGINFO_TYPE_ATTACK ;
case SKILL_TYPE_AFFECT: return MSGINFO_TYPE_AFFECT ;
}
return NO_TYPE;
}
int CSkillProcBasic::GetTargetType(BYTE _Type,void *pPc)
{
switch(_Type) {
case ATTACK_TARGET_PC:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(pc) return pc->targetType;
}
break;
case ATTACK_TARGET_ENTITY_PC:
return ENTITY_PC;
case ATTACK_TARGET_MONSTER:
{
monsterCharacter_t* pMon = static_cast<monsterCharacter_t*>(pPc);
if(pMon) return pMon->targetType;
}
break;
case ATTACK_TARGET_ENTITY:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(pc) return pc->entityType;
}
break;
}
return NO_TYPE;
}
int CSkillProcBasic::GetTargetIdx(BYTE _Type,void *pPc,int index)
{
switch(_Type) {
case ATTACK_TARGET_INDEX_TARGETPC:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(pc) return pc->targetIdx;
}
break;
case ATTACK_TARGET_INDEX_PC:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(pc) return pc->idx;
}
break;
case ATTACK_TARGET_INDEX_MON_TARGETPC:
{
monsterCharacter_t* pMon = static_cast<monsterCharacter_t*>(pPc);
if(pMon) return pMon->targetIdx;
}
break;
case ATTACK_TARGET_INDEX_IDXONSERVER:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(pc)
{
if(index <0 || index >= MAX_NUMBER_OF_PARTY_MEMBER)
{
return NO_TYPE;
}
return pc->member[index].idxOnServer;
}
}
break;
case ATTACK_TARGET_INDEX_MONSTER:
{
monsterCharacter_t* pMon = static_cast<monsterCharacter_t*>(pPc);
if(pMon) return pMon->idx;
}
break;
}
return NO_TYPE;
}
| C++ |
#if !defined(AFX_SKILLDATAATTACK_H__2982A5F7_FE1E_4316_8AF0_22853F186100__INCLUDED_)
#define AFX_SKILLDATAATTACK_H__2982A5F7_FE1E_4316_8AF0_22853F186100__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CSkillProcAttack
{
public:
CSkillProcAttack();
virtual ~CSkillProcAttack();
int GetAttackType(BYTE _Type,void *pPc,int nSkillID);
int GetHitPower(BYTE _Type,CStr_Skill_Msg *msg);
int GetHiteRate(BYTE _Type,CStr_Skill_Msg *msg);
int GetPhyMinDmg(BYTE _Type,CStr_Skill_Msg *msg);
int GetPhyMaxDmg(BYTE _Type,CStr_Skill_Msg *msg);
int GetPosMinDmg(BYTE _Type,CStr_Skill_Msg *msg);
int GetPosMaxDmg(BYTE _Type,CStr_Skill_Msg *msg);
int GetNegMinDmg(BYTE _Type,CStr_Skill_Msg *msg);
int GetNegMaxDmg(BYTE _Type,CStr_Skill_Msg *msg);
int GetCriticalRate(BYTE _Type,CStr_Skill_Msg *msg);
int GetCriticalDamage(BYTE _Type,CStr_Skill_Msg *msg);
int GetDelayTime(BYTE _Type,CStr_Skill_Msg *msg);
int GetRepeatNum(BYTE _Type,CStr_Skill_Msg *msg);
int GetRepeatDelayTime(BYTE _Type,CStr_Skill_Msg *msg);
int GetEtcInfo(BYTE _Type,CStr_Skill_Msg *msg);
int GetEtcType(BYTE _Type,CStr_Skill_Msg *msg);
};
#endif
| C++ |
#if !defined(AFX_SKILLDATAMEGPROC_H__2F292335_32E0_4A79_B216_9B78DCB5197C__INCLUDED_)
#define AFX_SKILLDATAMEGPROC_H__2F292335_32E0_4A79_B216_9B78DCB5197C__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CSkillDataMsgProc
{
public:
CSkillDataMsgProc();
virtual ~CSkillDataMsgProc();
int GetType(int _Type,void *pPc,int nSkillID);
int GetFromIdx(int _Type,void *pPc,int nSkillID);
int GetFromType(int _Type,void *pPc,int nSkillID);
int GetName(int _Type,message_t *message,void *pPc,int nSkillID);
int GetToType(int _Type,void *pPc,int nSkillID);
int GetToIdx(int _Type,void *pPc,int nSkillID);
int GetWorldIdx(int _Type,void *pPc,int nSkillID);
int GetSendTime(int _Type,void *pPc,int nSkillID);
int GetReceiveTime(int _Type,void *pPc,int nSkillID);
int GetData(int _Type,void *pPc,CStr_Skill_Msg *msg);
};
extern CSkillDataMsgProc g_SkillDataMsgProc;
#endif
| C++ |
#include "../global.h"
#include "SkillApp.h"
CSkillTransInfo m_SkillTransInfo;
CSkillTransInfo::CSkillTransInfo()
{
}
CSkillTransInfo::~CSkillTransInfo()
{
}
CSkillTransformUnit * CSkillTransformData::Get(int Index)
{
if(Index < 0 || Index >= m_TransData.size())
{
return NULL;
}
return m_TransData[Index];
}
void CSkillTransformData::Insert(CSkillTransformUnit *temp)
{
m_TransData.push_back(temp);
}
void CSkillTransformData::Clear()
{
int size = m_TransData.size();
for(int i=0;i<size;i++)
{
CSkillTransformUnit *temp = m_TransData[i];
SAFE_DELETE(temp);
}
m_TransData.clear();
}
int CSkillTransformData::GetEffectID(const int _EntityIdx)
{
int size = m_TransData.size();
for(int i=0;i<size;i++)
{
if(m_TransData[i]->m_nTransformEntityIdx == _EntityIdx)
{
return m_TransData[i]->m_nEffectID;
}
}
return -1;
}
| C++ |
#ifndef _SKILL_LOGIC_H
#define _SKILL_LOGIC_H
#define MAX_COUNT_AUTO_OBTAIN_SKILL 200
enum
{
SKILL_VALUE_0 = 3,
SKILL_VALUE_1 = 4,
SKILL_VALUE_2 = 5,
SKILL_VALUE_3 = 6,
SKILL_VALUE_4 = 7,
SKILL_VALUE_5 = 8,
SKILL_VALUE_6 = 9,
};
struct SKILLSTATUS
{
int level;
int tableIdx;
};
struct AUTO_OBTAIN_SKILL
{
SKILLSTATUS status[MAX_COUNT_AUTO_OBTAIN_SKILL];
int count;
};
typedef struct
{
AUTO_OBTAIN_SKILL autoObtainSkill[GEN_NUMBER];
} skillObtain_t;
class CSkillLogic
{
public:
CSkillLogic()
{
}
~CSkillLogic()
{
}
void SKILL_Empty( void* pPc, float* pValue );
void SKILL_MakeAutoObtain();
int SKILL_IsValid( playerCharacter_t* pc, int skillIdx );
void SKILL_GetAutoObtain( playerCharacter_t *pc, int newLevel, int skillIdx[], int &num );
void SKILL_GetInitSkillLevel( int skillTableIdx, SKILL_GEN_LEVEL *level );
int SKILL_Add( playerCharacter_t *pc, int skillTableIdx );
int SKILL_LevelUp( playerCharacter_t* pc, int idx, int genType );
void SKILL_SendMessageMultiTarget( playerCharacter_t *pc, messageInfo_t *msginfo, int targetNumber, int dupflag, int delay );
void SKILL_GetValue( playerCharacter_t *pc, int skillIdx, float value[] );
int SKILL_CheckPassive( playerCharacter_t* pc, int skillIdx );
void SKILL_ApplyPassive( playerCharacter_t* pc );
int SKILL_CheckActive( playerCharacter_t* pc, int skillIdx );
void SKILL_ApplyActive( playerCharacter_t* pc, int skillIdx, int &coolTime );
CSkillCastValue * SKILL_GetValueNotOwnSkill( int skillTableIdx, int level);
void SKILL_ApplyActiveNotOwnSkill( playerCharacter_t *pc, int skillTableIdx, int skillLevel );
void SKILL_Monster_ApplyActive( monsterCharacter_t* pMonster, int skillIdx, int& coolTime );
void SKILL_Monster_GetValue( monsterCharacter_t *pMonster, int tableIdx, float value[] );
void GTH_ProcessMessage_Request_Use_Potion();
void GTH_UseSkillItem_DeleteSend(int invenPos);
public:
};
#ifndef _SKILL_DEFINE_
#define _SKILL_DEFINE_
#define MAX_COUNT_SKILL_MULTI_TARGET 8
typedef struct
{
int targetNumber;
int targetType[MAX_COUNT_SKILL_MULTI_TARGET];
int targetIdx[MAX_COUNT_SKILL_MULTI_TARGET];
} skillReturnData_t;
struct SKILLFUNC
{
void (*pFunc)( void* pc, float* pParam );
};
#endif
extern skillReturnData_t g_skillMultiTarget;
extern float g_tempCoolTime;
extern int g_affectSkillLevel;
extern CSkillLogic g_SkillLogic;
#endif | C++ |
#include "../global.h"
#include "SkillApp.h"
CSkillProcAffectSpe::CSkillProcAffectSpe()
{
}
CSkillProcAffectSpe::~CSkillProcAffectSpe()
{
}
int CSkillProcAffectSpe::GetType(BYTE _Type)
{
switch(_Type) {
case SKILL_AFF_SPE_LEVEL_VALUE: return 0;
break;
}
TRACE("Error!! CSkillProcAffectSpe::GetType \n");
return NO_TYPE;
}
int CSkillProcAffectSpe::GetSpecialIdx(BYTE _Type,void *pPc,CStr_Skill_Msg *msg)
{
switch(_Type) {
case SKILL_AFF_SPE_SPECIALIDX_TABLEIDX:
{
return msg->msginfo->affect.skillTableIdx;
}
break;
}
TRACE("Error!! GetSpecialIdx \n");
return NO_TYPE;
}
float CSkillProcAffectSpe::GetSpecialData(BYTE _Type,BYTE _Index, void *pPc,CStr_Skill_Msg *msg)
{
float fVal = g_SkillDataGlobal.GetValue(pPc,_Index,msg);
return fVal;
}
bool CSkillProcAffectSpe::Proc(int nSkillID,void *pPc,AFFECTDATA_SPECIAL *spe)
{
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(nSkillID);
if(pSkillTable==NULL) return false;
CSkillDataFormat *pDataFormat = pSkillTable->GetDataFormat();
if(pDataFormat == NULL) return false;
CSkillDataFormat_Affect *pAffect = pDataFormat->GetAffect();
if(pAffect == NULL) return false;
CSkillDataAffectSpe *pSpe = pAffect->GetSpe();
if(pSpe == NULL) return false;
if(!pSpe->m_bUse) return false;
playerCharacter_t *pc= static_cast<playerCharacter_t*>(pPc);
if(pc == NULL) return false;
pc->isTransform = pSpe->m_IsTransform;
pc->transformEntityIdx = pSpe->m_TransformEntityIndex;
pc->transformType = pSpe->m_TransformType-1;
int nMySkillIndex = spe->specialData[MAX_COUNT_AFFECT_SPE_DATA-1];
for(int i=0;i<MAX_COUNT_AFFECT_SPE_DATA-1;i++)
{
float fVal = g_SkillDataGlobal.GetValue(pPc,pSpe->m_Data[i].m_nIndex,NULL,nSkillID);
switch(pSpe->m_Data[i].m_Type)
{
case SKILL_AFF_SPEC_VELOCITY:
{
pc->calVelocity += pc->baseVelocity * ( fVal * 0.01f );
}
break;
case SKILL_AFF_SPEC_MAXRA:
{
pc->calMaxRA += fVal;
if( pc->curRA > pc->calMaxRA ) pc->curRA = pc->calMaxRA;
}
break;
case SKILL_AFF_SPEC_PHYMINDMG:
{
pc->calPhyMinDmg += (int)( (float)pc->basePhyMinDmg * (float)fVal * 0.01f );
}
break;
case SKILL_AFF_SPEC_PHYMAXDMG:
{
pc->calPhyMaxDmg += (int)( (float)pc->basePhyMaxDmg * (float)fVal * 0.01f );
}
break;
case SKILL_AFF_SPEC_HIT_POWER:
{
pc->calHitPower += (int)( (float)pc->baseHitPower * fVal * 0.01f );
}
break;
case SKILL_AFF_SPEC_AVOID_POWER:
{
pc->calAvoidPower += (int)( (float)pc->baseAvoidPower * fVal * 0.01f );
}
break;
case SKILL_AFF_SPEC_ATTACK_SPPED_RATE:
{
pc->attackSpeedRate += fVal;
}
break;
default:
return false;
}
}
return true;
}
| C++ |
#if !defined(AFX_SKILLAPP_H__3697DB0A_964F_474C_A321_9941001E4B8D__INCLUDED_)
#define AFX_SKILLAPP_H__3697DB0A_964F_474C_A321_9941001E4B8D__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "skills.h"
#include "SkillDataGlobal.h"
#include "SkillTalbeDefine.h"
#include "SkillTableMap.h"
#include "SkillProcAffectSpe.h"
#include "SkillDataAttack.h"
#include "SkillDataAffectCommon.h"
#include "SkillDataAffect.h"
#include "SkillDataBasic.h"
#include "SkillLogic.h"
#include "Skillproc.h"
#include "PcSkill.h"
#include "SkillDataMegProc.h"
#include "SkillCast.h"
#include "SkillDataSubProc.h"
#include "SkillDataCheckProc.h"
#include "SkillPartyProc.h"
#include "SkillItem.h"
#include "SkillTransInfo.h"
class CSkillApp
{
public:
CSkillApp();
virtual ~CSkillApp();
void InitSkillTable();
int LoadSkillTable( char *filename,int &skillNumber );
bool LoadSkillTableCheckSize(FILE *fp);
bool CheckSize(FILE *fp, int Val , LPSTR str);
bool LoadSkillTableCheckValue(FILE *fp);
public:
};
extern CSkillApp g_SkillApp;
#endif
| C++ |
#if !defined(AFX_PCSKILL_H__04F7C9B3_4385_4747_92BB_5422F7B36545__INCLUDED_)
#define AFX_PCSKILL_H__04F7C9B3_4385_4747_92BB_5422F7B36545__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
enum
{
SKILL_ERROR_BATTLE_TEST=1,
SKILL_ERROR_BATTLE,
SKILL_ERROR_PK_DISABLE,
SKILL_ERROR_COOLTIME,
};
class CPcSkill
{
public:
CPcSkill();
virtual ~CPcSkill();
void GTH_PC_Skill(playerCharacter_t *pc, int skillIdx, int skillTargetType);
void GTH_PC_SkillNotOwn(playerCharacter_t *pc,int UseType, int invenPos, int SkillTableIndex, int level, int skillTargetType);
void GTH_PC_SkillCooltime( playerCharacter_t *pc );
void GTH_PC_SkillExecute( playerCharacter_t *pc );
void GTH_PC_SkillCasting( playerCharacter_t *pc );
void GTH_ProcessMessage_Request_SkillLevelUp();
void GTH_ProcessMessage_Request_Learn_Skill();
void GTH_ProcessEventMessage_Skill(void);
bool FindHideSkill(int index);
void GTH_Recv_UseSkill();
void GTH_Recv_UseItemSkill();
bool CheckEnableUseSkill(int targetType,int targetIdx,int skillTargetType);
inline bool CheckEnableUseSkill_Player(const int targetType,const int targetIdx,const int skillTargetType);
inline bool CheckEnableUseSkill_Monster(const int targetType,const int targetIdx,const int skillTargetType);
};
extern CPcSkill g_PcSkill;
#endif
| C++ |
#include "../global.h"
#include "SkillApp.h"
CSkillTableMap g_SkillTableDB;
CSkillTableMap::CSkillTableMap()
{
for(int i=0;i<MAX_SKILL_NUMBER;i++)
{
m_SkillDB[i]=NULL;
}
}
CSkillTableMap::~CSkillTableMap()
{
ClearDB();
}
void CSkillTableMap::ClearDB()
{
for(int i=0;i<MAX_SKILL_NUMBER;i++)
{
if(m_SkillDB[i] != NULL)
{
if(m_SkillDB[i]->m_nId >= 0)
{
SAFE_DELETE(m_SkillDB[i]);
}
}
}
}
CSkilTable *CSkillTableMap::FindDB(int nID)
{
if(nID < 0 || nID >= MAX_SKILL_NUMBER)
{
TRACE(" Error CSkilTable *CSkillTableMap::FindDB( %d)\n",nID);
return NULL;
}
return m_SkillDB[nID];
}
void CSkillTableMap::InsertDB(int nID, CSkilTable *pData)
{
m_SkillDB[nID] = pData;
}
bool CSkillTableMap::SAFE_ARRAY(int index)
{
if(index < 0 || index >= MAX_SKILL_NUMBER) return false;
return true;
}
| C++ |
#include "../global.h"
#include "SkillApp.h"
CSkillProcAffectCommon::CSkillProcAffectCommon()
{
}
CSkillProcAffectCommon::~CSkillProcAffectCommon()
{
}
short CSkillProcAffectCommon::GetData(int idx,BYTE _Type,BYTE _Index,void *pPc,CStr_Skill_Msg *msg)
{
float fVal = g_SkillDataGlobal.GetValue(pPc,_Index,msg);
if(fVal == 0.0f)
{
if(msg) TRACE("Error!! GetData ... SkillID %d ... idx %d, _Type %d, _Index %d \n",msg->nSkillID,idx,_Type,_Index);
}
msg->msginfo->affect.common.type[idx] = _Type;
msg->msginfo->affect.common.data[idx] = fVal;
return true;
}
short CSkillProcAffectCommon::DeleteBuffSkill(void *pPc)
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(NULL == pc) return 0;
for( int i = 0; i < pc->affectNumber; i ++ )
{
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(pc->affect[i].skillTableIdx);
if(NULL != pSkillTable)
{
for(int j=0;j<CSkillDataFormat::MAX_NUM_OF_DATA;j++)
{
if(0 == pSkillTable->m_DataFormat.m_Data[j]) break;
if(SKILL_UNIQUE_TYPE_BUFF == pSkillTable->m_DataFormat.m_Data[j])
{
pc->affect[i].forcedDelete = true;
break;
}
}
}
}
return 0;
}
short CSkillProcAffectCommon::OnceAffectProcess(int idx,BYTE _Type,BYTE _Index,void *pPc,CStr_Skill_Msg *msg)
{
float fVal = g_SkillDataGlobal.GetValue(pPc,_Index,msg);
if(fVal == 0.0f)
{
if(msg) TRACE("Error!! GetData ... SkillID %d ... idx %d, _Type %d, _Index %d \n",msg->nSkillID,idx,_Type,_Index);
}
switch(_Type)
{
case AFF_DATA_TYPE_DECREASE_SA:
{
playerCharacter_t *pPlayer = static_cast<playerCharacter_t*>(pPc);
if(pPlayer !=NULL)
{
pPlayer->curSA += (float)fVal;
if( pPlayer->curSA < 0 ) pPlayer->curSA = 0;
}
}
break;
case AFF_DATA_TYPE_DELETE_BUFF_SKILL:
{
DeleteBuffSkill(pPc);
}
break;
}
return true;
}
| C++ |
#include "../Global.h"
CSkillDataCheckProc g_SkillDataCheckProc;
CSkillDataCheckProc::CSkillDataCheckProc()
{
}
CSkillDataCheckProc::~CSkillDataCheckProc()
{
}
bool CSkillDataCheckProc::CheckSkillProc(void *pPc,CStr_Skill_Msg *msg)
{
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(msg->nSkillID);
if(pSkillTable==NULL) return false;
CSkillDataFormat *pDataFormat = pSkillTable->GetDataFormat();
if(pDataFormat == NULL) return false;
for(int i=0;i<MAX_SKILL_CHECK_FLAG;i++)
{
switch(pDataFormat->m_CheckFlag[i]) {
case CHECK_PC:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(!pc) return false;
}
break;
case CHECK_SKILL_MON_ALIVE_CHECK:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(!pc) return false;
if(pc->targetIdx >= 0 && pc->targetIdx < MAX_MONSTERS)
{
if( g_monster[pc->targetIdx].aliveState != MON_ALIVE_STATE_NORMAL ) return false;
}
}
break;
case CHECK_SKILL_TO_USE_MY:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(!pc) return false;
if ( pc->idx == pc->targetIdx) return false;
if ( pc->curRA <= 0) return false;
}
break;
case CHECK_TARGETPC_ALIVE:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(!pc) return false;
switch(pc->targetType)
{
case ENTITY_PC :
if(!SAFE_PCS(pc->targetIdx)) return false;
if( g_pc[pc->targetIdx].alive ) return false;
break;
}
}
break;
case CHECK_TARGETALL_ALIVE:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(!pc) return false;
switch( pc->targetType )
{
case ENTITY_PC :
if(!SAFE_PCS(pc->targetIdx)) return false;
if( g_pc[pc->targetIdx].alive ) return false;
break;
case ENTITY_MONSTER :
case ENTITY_NPC : return false;
}
}
break;
case CHECK_BREEDRATE:
{
}
break;
case CHECK_ACTIVEAFFECT:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(!pc) return false;
playerCharacter_t* pTargetpc = NULL;
if ( pc->targetIdx < 0 || pc->targetIdx >= MAX_PCS) return false;
pTargetpc = &g_pc[pc->targetIdx];
if ( pTargetpc == NULL) return false;
if ( GTH_IsActiveAffect(pTargetpc, ENTITY_PC, 38) )
{
GTH_SendMessage_ChattingMsg(pc, 1, 9, 20 );
return false;
}
if ( GTH_IsActiveAffect(pTargetpc, ENTITY_PC, 34) )
{
GTH_SendMessage_ChattingMsg(pc, 1, 9, 20 );
return false;
}
}
break;
case CHECK_GTH_EV_CHAR_DIE:
{
monsterCharacter_t* pMon = static_cast<monsterCharacter_t*>(pPc);
if(!pMon) return false;
if( pMon->targetType == ENTITY_PC )
{
if( g_pc[pMon->targetIdx].event == GTH_EV_CHAR_DIE ) return false;
}
}
break;
case CHECK_CRITICAL_RATE:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(!pc) return false;
float mastercalCriticalRate = g_pc[pc->idx].calCriticalRate;
if ( mastercalCriticalRate < 0.0f) return false;
}
break;
case CHECK_NOT_USE_MYSELF:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(!pc) return false;
if ( pc->idx == pc->targetIdx) return false;
}
break;
case CHECK_ONLY_USE_MYSELF:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(!pc) return false;
if ( pc->idx != pc->targetIdx) return false;
}
break;
}
}
return true;
}
| C++ |
#if !defined(AFX_SKILLCAST_H__8888D8C9_0EC5_4305_8AB8_FF5D2CF34ECD__INCLUDED_)
#define AFX_SKILLCAST_H__8888D8C9_0EC5_4305_8AB8_FF5D2CF34ECD__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CSkillCast
{
public:
CSkillCast();
virtual ~CSkillCast();
int RaProc(BYTE _Type,void *pPc,CStr_Skill_Msg *msg);
};
extern CSkillCast g_SkillCast;
#endif
| C++ |
#if !defined(AFX_SKILLITEM_H__000E36C4_7627_4D3D_A8A5_00D611C82BBF__INCLUDED_)
#define AFX_SKILLITEM_H__000E36C4_7627_4D3D_A8A5_00D611C82BBF__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#pragma warning( disable : 4786 )
#pragma warning( disable : 4251 )
#define MAX_SKILLITEM_UNIT 10
class CSkillItemUnit
{
public:
CSkillItemUnit()
{
Init();
}
~CSkillItemUnit()
{
}
void Init()
{
m_nItemTableIdx = -1;
m_nLevel = -1;
m_nType=-1;
}
void Set(int Index,int Level,int nType=-1)
{
m_nItemTableIdx = Index;
m_nLevel = Level;
m_nType = nType;
}
public:
int m_nItemTableIdx;
int m_nLevel;
int m_nType;
};
class CSkillItemSet
{
public:
CSkillItemSet()
{
Init();
}
~CSkillItemSet()
{
}
void Init()
{
m_nSkillID=-1;
for(int i=0;i<MAX_SKILLITEM_UNIT;i++)
{
m_ItemList[i].Init();
}
}
void Insert(CSkillItemUnit temp)
{
for(int i=0;i<MAX_SKILLITEM_UNIT;i++)
{
if(m_ItemList[i].m_nItemTableIdx < 0)
{
m_ItemList[i] = temp;
break;
}
}
}
void Delete(int Idx)
{
if(Idx <0 || Idx >= MAX_SKILLITEM_UNIT) return;
m_ItemList[Idx].Init();
for(int i=Idx;i<MAX_SKILLITEM_UNIT-1;i++)
{
m_ItemList[i] = m_ItemList[i+1];
}
m_ItemList[MAX_SKILLITEM_UNIT-1].Init();
}
int Size()
{
int count=0;
for(int i=0;i<MAX_SKILLITEM_UNIT;i++)
{
if(m_ItemList[i].m_nItemTableIdx>= 0)
{
count ++;
}
}
return count;
}
public:
int m_nSkillID;
CSkillItemUnit m_ItemList[MAX_SKILLITEM_UNIT];
};
class CSkillItemData
{
public:
CSkillItemData()
{
}
~CSkillItemData()
{
}
CSkillItemSet * Get(int Index)
{
if(Index < 0 || Index >= m_SkillItemList.size())
{
return NULL;
}
return m_SkillItemList[Index];
}
void Insert(CSkillItemSet *temp)
{
m_SkillItemList.push_back(temp);
}
void Clear()
{
int size = m_SkillItemList.size();
for(int i=0;i<size;i++)
{
CSkillItemSet *temp = m_SkillItemList[i];
SAFE_DELETE(temp);
}
m_SkillItemList.clear();
}
public:
vector <CSkillItemSet *> m_SkillItemList;
};
class CSkillItem
{
public:
enum
{
SELECT_NONE=0,
SELECT_ITEM,
SELECT_SKILL_HOTKEY,
};
enum
{
ITEM_TYPE_NONE=0,
ITEM_TYPE_ENABLE_DEAD_SELF_ITEM,
ITEM_TYPE_NOT_USE_ALIVE_PLAYER,
ITEM_TYPE_TRANSFORM_ITEM,
NUM_OF_ITEM_TYPE,
};
CSkillItem();
virtual ~CSkillItem();
CSkillItemData * GetSkillItemList()
{
return &m_SkillItemData;
}
bool IfSkillItem(int itemTableIdx);
void SetDataList();
int GetLevel(int itemTableIdx);
int GetSkillTableIndex(int itemTableIdx);
CSkillItemSet * GetSkillItem_UseItemTableIdx(int itemTableIdx);
bool IsType_UseItemID(int itemTableIdx, int Type);
CSkillItemSet * GetSkillItem_UseSkillTableIdx(int SkillTableIdx);
bool IsType_UseSkillID(int itemTableIdx, int Type);
public:
typedef map<int , int> CMap_SkillItemData;
CMap_SkillItemData m_mapSkillItem;
CSkillItemData m_SkillItemData;
};
extern CSkillItem g_SkillItem;
#endif
| C++ |
#if !defined(AFX_SKILLDATAAFFECTCOMMON_H__A0452C32_E973_408A_9D97_4246253E6348__INCLUDED_)
#define AFX_SKILLDATAAFFECTCOMMON_H__A0452C32_E973_408A_9D97_4246253E6348__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CSkillProcAffectCommon
{
public:
CSkillProcAffectCommon();
virtual ~CSkillProcAffectCommon();
short GetData(int idx,BYTE _Type,BYTE _Index,void *pPc,CStr_Skill_Msg *msg);
short DeleteBuffSkill(void *pPc);
short OnceAffectProcess(int idx,BYTE _Type,BYTE _Index,void *pPc,CStr_Skill_Msg *msg);
};
#endif
| C++ |
#include "../Global.h"
CSkillDataSubProc g_SkillDataSubProc;
CSkillDataSubProc::CSkillDataSubProc()
{
}
CSkillDataSubProc::~CSkillDataSubProc()
{
}
bool CSkillDataSubProc::SubActionProc(void *pPc,CStr_Skill_Msg *msg)
{
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(msg->nSkillID);
if(pSkillTable==NULL) return false;
CSkillDataFormat *pDataFormat = pSkillTable->GetDataFormat();
if(pDataFormat == NULL) return false;
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
for(int i=0;i<MAX_SKILL_SUB_ACTION;i++)
{
switch(pDataFormat->m_SubAtion[i].m_Type)
{
case SKILL_SUB_ACTION_MORE_AFFECT :
{
CStr_Skill_Msg SubMsg;
SubMsg.nSkillID =(int)pDataFormat->m_SubAtion[i].m_fValue;
SubMsg.nMySkillIndex = msg->nMySkillIndex;
SubMsg.pcIdx = msg->pcIdx;
SubMsg.monsterIdx = msg->monsterIdx;
g_SkillProc.Active(pPc,&SubMsg);
}
break;
case SKILL_SUB_ACTION_DELETEAFFECT:
{
if(pc)
{
int nVal = (int) pDataFormat->m_SubAtion[i].m_fValue;
GTH_DeleteAffect( pc, ENTITY_PC, nVal);
}
}
break;
case SKILL_SUB_ACTION_ADDMONSTER_CONTRIBUTIONPOINT:
{
if(pc)
{
if( pc->targetType == ENTITY_MONSTER )
{
float fVal = g_SkillDataGlobal.GetValue(pPc,SKILL_TYPE_LISTPOINT,msg);
AddMonster_ContributionPoint(pc, pc->targetIdx, ATTACK_POINT, fVal);
}
}
}
case SKILL_SUB_ACTION_ATTRACT_ATTENTION:
SKILL_AttractAttention(pPc,msg);
break;
}
}
return true;
}
void CSkillDataSubProc::SKILL_AttractAttention(void *pPc,CStr_Skill_Msg *msg)
{
float fLevel, fPanelty;
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(!SAFE_MONSTER(pc->targetIdx)) return ;
if( g_monster[pc->targetIdx].aliveState != MON_ALIVE_STATE_NORMAL ) return;
fLevel = fabs((float)(g_monster[pc->targetIdx].basic.level - pc->level));
if( fLevel > 33.0f ) fLevel = 33.0f;
fPanelty = 1.0f - fLevel * 0.03f;
float fHitPro = g_SkillDataGlobal.GetValue(pPc,SKILL_HITPOWER,msg);
fHitPro *= fPanelty;
if( GTH_Random() < fHitPro )
{
g_monster[pc->targetIdx].targetIdx = pc->idx;
g_monster[pc->targetIdx].targetType = ENTITY_PC;
g_monster[pc->targetIdx].ai.callProcedureAddr = g_monster[pc->targetIdx].ai.aiProcedureAddr[1];
g_monster[pc->targetIdx].ai.aiAddr = g_monster[pc->targetIdx].ai.aiProcedureAddr[1];
g_monster[pc->targetIdx].ai.isCall = true;
AI_StopPathFinding( &g_monster[pc->targetIdx] );
AI_InterpretImmediately( &g_monster[pc->targetIdx] );
}
else
{
}
}
| C++ |
#include "../Global.h"
#include "../Tools/CTools.h"
extern CTools* gcpTools;
CSkillCast g_SkillCast;
CSkillCast::CSkillCast()
{
}
CSkillCast::~CSkillCast()
{
}
int CSkillCast::RaProc(BYTE _Type,void *pPc,CStr_Skill_Msg *msg)
{
int nSkillID = msg->nSkillID;
int nMySkillIndex = msg->nMySkillIndex;
switch(_Type) {
case SKILL_RA_TARGETIDX:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(!pc)
{
break;
}
float raRecovery = g_SkillDataGlobal.GetValue(pPc,SKILL_TYPE_RA_RECOVERY ,msg);
playerCharacter_t* pTargetPlayer=gcpTools->GetPlayerRecordPointer(pc->targetIdx);
if(NULL == pTargetPlayer) return false;
pTargetPlayer->curRA += raRecovery;
pTargetPlayer->curRA += (float)raRecovery * pTargetPlayer->optValue[OV_HEAL_EFFICIENCY] * 0.01f;
if(pTargetPlayer->curRA > pTargetPlayer->calMaxRA )
pTargetPlayer->curRA = pTargetPlayer->calMaxRA;
return true;
}
break;
case SKILL_RA_ENTITY_TYPE_ENTITYPC:
{
if(msg->pDataFormat->m_ClassType == SKILL_CLASS_PC)
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(!pc)
{
break;
}
float raRecovery = g_SkillDataGlobal.GetValue(pPc,SKILL_TYPE_RA_RECOVERY,msg);
switch( pc->entityType){
case ENTITY_PC :
pc->curRA += raRecovery;
pc->curRA += (float)raRecovery * pc->optValue[OV_HEAL_EFFICIENCY] * 0.01f;
if( pc->curRA > pc->calMaxRA ) pc->curRA = pc->calMaxRA;
return true;
}
}
else if(msg->pDataFormat->m_ClassType == SKILL_CLASS_MON)
{
monsterCharacter_t* pMon = static_cast<monsterCharacter_t*>(msg->pPc);
if(!pMon)
{
break;
}
float raRecovery = g_SkillDataGlobal.GetValue(pPc,SKILL_TYPE_RA_RECOVERY,msg);
switch( pMon->entityType)
{
case ENTITY_MONSTER :
pMon->curRA += raRecovery;
if( pMon->curRA > pMon->calMaxRA ) pMon->curRA = pMon->calMaxRA;
return true;
}
}
}
break;
case SKILL_RA_TARGETTYPE_ENTITY_PC:
break;
case SKILL_RA_LAYHAND:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(pc)
{
float fRADecRate = g_SkillDataGlobal.GetValue(pPc,SKILL_RA_DEC_RATE,msg);
float fRAIncreRate = g_SkillDataGlobal.GetValue(pPc,SKILL_RA_INC_RATE,msg);
if ( pc->idx == pc->targetIdx) return false;
if ( pc->curRA <= 0) return false;
float incVel = pc->curRA * ( fRADecRate / 100 );
if ( incVel <= 0) return false;
playerCharacter_t* pTargetPlayer=gcpTools->GetPlayerRecordPointer(pc->targetIdx);
if(NULL == pTargetPlayer) return false;
pc->curRA -= incVel;
incVel *= fRAIncreRate;
pTargetPlayer->curRA += incVel;
if(pTargetPlayer->curRA > pTargetPlayer->calMaxRA )
pTargetPlayer->curRA = pTargetPlayer->calMaxRA;
return true;
}
}
break;
case SKILL_RA_PC:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(!pc) return false;
float raRecovery = g_SkillDataGlobal.GetValue(pPc,SKILL_TYPE_RA_RECOVERY,msg);
pc->curRA += raRecovery;
pc->curRA += (float)raRecovery * pc->optValue[OV_HEAL_EFFICIENCY] * 0.01f;
if(pc->curRA > pc->calMaxRA) pc->curRA = pc->calMaxRA;
return true;
}
break;
}
TRACE("Error!! RaProc %d \n",_Type);
return NO_TYPE;
}
| C++ |
#include "../global.h"
#include "SkillApp.h"
CSkillProc g_SkillProc;
CSkillProc::CSkillProc()
{
}
CSkillProc::~CSkillProc()
{
}
bool CSkillProc::Active(void *pPc,CStr_Skill_Msg *msg)
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
messageInfo_t msginfo;
message_t message;
memset( &msginfo, 0, sizeof( messageInfo_t ) );
memset( &message, 0, sizeof( message ) );
msg->message = &message;
msg->msginfo = &msginfo;
msg->pPc = pPc;
pc->generalSpeed = 100;
bool bCheck = g_SkillDataCheckProc.CheckSkillProc(pPc,msg);
if(!bCheck) return false;
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(msg->nSkillID);
if(pSkillTable==NULL) return false;
CSkillDataFormat *pDataFormat = pSkillTable->GetDataFormat();
if(pDataFormat == NULL) return false;
msg->pDataFormat = pDataFormat;
CSkillDataParty * pParty = pDataFormat->GetParty();
if(pParty == NULL) return false;
message.data[MSG_SKILL_TABLE_INDEX] = msg->nSkillID;
if(pParty->m_Type)
{
g_SkillPartyProc.Proc(pPc,msg);
}
else
{
CastActive(pPc,msg);
Proc(pPc,msg);
}
g_SkillDataSubProc.SubActionProc(pPc,msg);
return true;
}
int CSkillProc::Proc(void *pPc,CStr_Skill_Msg *msg)
{
CSkillDataFormat *pDataFormat = msg->pDataFormat;
if(pDataFormat->m_MessageType ==SKILL_MSG_TYPE_ONLYSEND)
{
MessageActive(pPc,msg);
AI_SendMessage( msg->message );
}
else if(pDataFormat->m_MessageType)
{
BasicActive(pPc,msg);
if(msg->pcIdx > -1)
{
if( pDataFormat->m_ClassType != SKILL_CLASS_PC) return 0;
}
else if(msg->monsterIdx > -1)
{
if( pDataFormat->m_ClassType != SKILL_CLASS_MON) return 0;
}
if(pDataFormat->GetAttack()->Use())
AttackActive(pPc,msg);
if(pDataFormat->GetAffect()->Use())
AffectActive(pPc,msg);
if(pDataFormat->GetAffect()->GetCommon()->Use())
AffectCommonActive(pPc,msg);
if(pDataFormat->GetAffect()->GetSpe()->Use())
AffectSpe(pPc,msg);
if(pDataFormat->m_MessageType ==SKILL_MSG_TYPE_PASSIVE) return true;
if(pDataFormat->m_MultiSkill)
{
for(int i=0;i<pDataFormat->m_MultiSkill;i++)
{
MultiDamageSkill(pPc,msg,i);
MakeMessageProc(pPc,msg);
SendMessageProc(pPc,msg);
}
}
else
{
MakeMessageProc(pPc,msg);
SendMessageProc(pPc,msg);
}
}
return true;
}
bool CSkillProc::MakeMessageProc(void *pPc,CStr_Skill_Msg *msg)
{
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(msg->nSkillID);
if(pSkillTable==NULL) return false;
CSkillDataFormat *pDataFormat = pSkillTable->GetDataFormat();
if(pDataFormat == NULL) return false;
switch(pDataFormat->m_ClassType)
{
case SKILL_CLASS_PC:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(pc)
AI_MakeMessage( pc, msg->message, MESSAGE_USEINFO, msg->msginfo );
else
{
return false;
}
}
break;
case SKILL_CLASS_MON:
{
monsterCharacter_t* pMon = static_cast<monsterCharacter_t*>(pPc);
if(pMon)
AI_MakeMessage( pMon, msg->message, MESSAGE_USEINFO, msg->msginfo );
else
{
return false;
}
}
break;
}
return true;
}
bool CSkillProc::SendMessageProc(void *pPc,CStr_Skill_Msg *msg)
{
CSkilTable *pSkillTable = g_SkillTableDB.FindDB(msg->nSkillID);
if(pSkillTable==NULL) return false;
CSkillDataFormat *pDataFormat = pSkillTable->GetDataFormat();
if(pDataFormat == NULL) return false;
switch(pDataFormat->m_MessageType) {
case SKILL_MSG_TYPE_ONLYSEND:
case SKILL_MSG_TYPE_MAKESEND:
{
AI_SendMessage( msg->message );
}
break;
case SKILL_MSG_TYPE_ATTACK_LENGTH:
{
playerCharacter_t *pc = static_cast<playerCharacter_t*>(pPc);
if(pc)
{
CAISendMessage AIMsg;
AIMsg.range = pc->calAttackLength;
AIMsg.rangeType = MSG_RANGE_TYPE_EXCEPT_PARTY;
AIMsg.m_pSkillMsg = msg;
AI_SendMessage( msg->message,&AIMsg);
}
}
break;
case SKILL_MSG_TYPE_RANGE_TYPE_TARGET:
{
float fRange = g_SkillDataGlobal.GetValue(pPc,SKILL_TYPE_RANGE,msg);
CAISendMessage AIMsg;
AIMsg.range = (int)fRange;
AIMsg.rangeType = MSG_RANGE_TYPE_TARGET;
AIMsg.m_pSkillMsg = msg;
AI_SendMessage( msg->message,&AIMsg);
}
break;
case SKILL_MSG_TYPE_RANGE:
{
float fRange = g_SkillDataGlobal.GetValue(pPc,SKILL_TYPE_RANGE,msg);
CAISendMessage AIMsg;
AIMsg.range = fRange;
AIMsg.m_pSkillMsg = msg;
AI_SendMessage( msg->message,&AIMsg);
}
break;
case SKILL_MSG_TYPE_RANGE_OF_SELF:
{
float fRange = g_SkillDataGlobal.GetValue(pPc,SKILL_TYPE_RANGE,msg);
CAISendMessage AIMsg;
AIMsg.range = fRange;
AIMsg.rangeType = MSG_RANGE_TYPE_MYSELF;
AIMsg.m_pSkillMsg = msg;
AI_SendMessage( msg->message,&AIMsg);
}
break;
}
return true;
}
bool CSkillProc::BasicActive(void *pPc,CStr_Skill_Msg *msg)
{
CSkillDataFormat *pDataFormat = msg->pDataFormat;
messageInfo_t *msginfo =msg->msginfo;
if(pDataFormat->m_InfoType )
msginfo->infoType = m_BasicDataProc.GetInfoType(pDataFormat->m_InfoType);
if(pDataFormat->m_TargetIdx )
msginfo->targetIdx = m_BasicDataProc.GetTargetIdx(pDataFormat->m_TargetIdx,pPc);
if(pDataFormat->m_TargetType )
msginfo->targetType = m_BasicDataProc.GetTargetType(pDataFormat->m_TargetType,pPc);
return true;
}
bool CSkillProc::AttackActive(void *pPc,CStr_Skill_Msg *msg)
{
messageInfo_t *msginfo =msg->msginfo;
CSkillDataFormat_Attack *pAttack = msg->pDataFormat->GetAttack();
if(pAttack == NULL) return false;
if(pAttack->m_AtkType )
msginfo->attack.atkType = m_AttackDataProc.GetAttackType(pAttack->m_AtkType,pPc,msg->nSkillID);
if(pAttack->m_HitPower )
msginfo->attack.hitPower = m_AttackDataProc.GetHitPower(pAttack->m_HitPower,msg);
if(pAttack->m_HitRate )
msginfo->attack.hitRate = m_AttackDataProc.GetHiteRate(pAttack->m_HitRate,msg);
if(pAttack->m_PhyMinDmg )
msginfo->attack.phyMinDmg = m_AttackDataProc.GetPhyMinDmg(pAttack->m_PhyMinDmg,msg);
if(pAttack->m_PhyMaxDmg )
msginfo->attack.phyMaxDmg = m_AttackDataProc.GetPhyMaxDmg(pAttack->m_PhyMaxDmg,msg);
if(pAttack->m_PosMinDmg )
msginfo->attack.posMinDmg = m_AttackDataProc.GetPosMinDmg(pAttack->m_PosMinDmg,msg);
if(pAttack->m_PosMaxDmg )
msginfo->attack.posMaxDmg = m_AttackDataProc.GetPosMaxDmg(pAttack->m_PosMaxDmg,msg);
if(pAttack->m_CriticalRate )
msginfo->attack.criticalRate = m_AttackDataProc.GetCriticalRate(pAttack->m_CriticalRate,msg);
if(pAttack->m_CriticalDamage )
msginfo->attack.criticalDamage = m_AttackDataProc.GetCriticalDamage(pAttack->m_CriticalDamage,msg);
if(pAttack->m_DelayTime )
msginfo->attack.delayTime = m_AttackDataProc.GetDelayTime(pAttack->m_DelayTime,msg);
if(pAttack->m_RepeatNum )
msginfo->attack.repeatNum = m_AttackDataProc.GetRepeatNum(pAttack->m_RepeatNum,msg);
if(pAttack->m_RepeatDelayTime )
msginfo->attack.repeatDelayTime = m_AttackDataProc.GetRepeatDelayTime(pAttack->m_RepeatDelayTime,msg);
if(pAttack->m_EtcData[0].m_nIndex )
{
msginfo->attack.etcInfo = m_AttackDataProc.GetEtcType(pAttack->m_EtcData[0].m_nIndex,msg);
msginfo->attack.etcData0 = m_AttackDataProc.GetEtcInfo(pAttack->m_EtcData[0].m_nIndex,msg);
}
if(pAttack->m_EtcData[1].m_nIndex )
{
msginfo->attack.etcInfo = m_AttackDataProc.GetEtcType(pAttack->m_EtcData[0].m_nIndex,msg);
msginfo->attack.etcData1 = m_AttackDataProc.GetEtcInfo(pAttack->m_EtcData[1].m_nIndex,msg);
}
return true;
}
bool CSkillProc::AffectActive(void *pPc,CStr_Skill_Msg *msg)
{
messageInfo_t *msginfo =msg->msginfo;
CSkillDataFormat_Affect *pAffect = msg->pDataFormat->GetAffect();
if(pAffect == NULL) return false;
if(pAffect->m_Type)
msginfo->affect.type = m_AffectDataProc.GetAffType(pAffect->m_Type);
if(pAffect->m_AffectType)
msginfo->affect.affectType = m_AffectDataProc.GetAffectType(pAffect->m_AffectType);
if(pAffect->m_StartTime )
msginfo->affect.startTime = m_AffectDataProc.GetStartTime(pAffect->m_StartTime,msg);
if(pAffect->m_KeepTime )
msginfo->affect.keepTime = m_AffectDataProc.GetKeepTime(pAffect->m_KeepTime,msg);
if(pAffect->m_Level )
msginfo->affect.level = m_AffectDataProc.GetPosMinDmg(pAffect->m_Level,msg);
if(pAffect->m_HitRate)
msginfo->affect.hitRate = m_AffectDataProc.GetHitRate(pAffect->m_HitRate,msg);
if(pAffect->m_SkillTableIdx)
msginfo->affect.skillTableIdx = pAffect->m_SkillTableIdx;
if(pAffect->m_DelayTime)
msginfo->affect.delayTime = m_AffectDataProc.GetDelayTime(pAffect->m_DelayTime,msg);
return true;
}
bool CSkillProc::AffectCommonActive(void *pPc,CStr_Skill_Msg *msg)
{
CSkillDataFormat_Affect *pAffect = msg->pDataFormat->GetAffect();
if(pAffect == NULL) return false;
CSkillDataCommon *pCommon = pAffect->GetCommon();
if(pCommon == NULL) return false;
for(int i=0;i<MAX_COUNT_AFFECT_DATA;i++)
{
if(pCommon->m_Data[i].m_Type)
{
m_AffectCommonDataProc.GetData(i,pCommon->m_Data[i].m_Type,pCommon->m_Data[i].m_nIndex,pPc,msg);
}
else
{
break;
}
}
for(i=0;i<MAX_COUNT_AFFECT_DATA;i++)
{
if(pCommon->m_OnceData[i].m_Type)
{
m_AffectCommonDataProc.OnceAffectProcess(i,
pCommon->m_OnceData[i].m_Type,pCommon->m_OnceData[i].m_nIndex,pPc,msg);
}
else
{
break;
}
}
return true;
}
bool CSkillProc::AffectSpe(void *pPc,CStr_Skill_Msg *msg)
{
messageInfo_t *msginfo =msg->msginfo;
CSkillDataFormat_Affect *pAffect = msg->pDataFormat->GetAffect();
if(pAffect == NULL) return false;
CSkillDataAffectSpe *pSpe = pAffect->GetSpe();
if(pSpe == NULL) return false;
if(pSpe->m_SpecialType)
msginfo->affect.spe.specialType = m_AffectSpe.GetType(pSpe->m_SpecialType);
if(pSpe->m_SpecialIdx)
msginfo->affect.spe.specialIdx = m_AffectSpe.GetSpecialIdx(pSpe->m_SpecialIdx,pPc,msg);
for(int i=0;i<MAX_COUNT_AFFECT_SPE_DATA;i++)
{
if(pSpe->m_Data[i].m_Type)
{
msginfo->affect.spe.specialData[i] = m_AffectSpe.GetSpecialData(pSpe->m_Data[i].m_Type,pSpe->m_Data[i].m_nIndex,pPc,msg);
}
else
{
break;
}
}
msginfo->affect.spe.specialData[MAX_COUNT_AFFECT_SPE_DATA-1] = msg->nMySkillIndex;
return true;
}
bool CSkillProc::MessageActive(void *pPc,CStr_Skill_Msg *msg)
{
message_t *message = msg->message;
CSkillData_Message *pMessage = msg->pDataFormat->GetMessage();
if(pMessage == NULL) return false;
if(pMessage->m_Type)
message->type = g_SkillDataMsgProc.GetType(pMessage->m_Type,pPc,msg->nSkillID);
if(pMessage->m_FromIdx)
message->fromIdx = g_SkillDataMsgProc.GetFromIdx(pMessage->m_FromIdx,pPc,msg->nSkillID);
if(pMessage->m_FromType)
message->fromType = g_SkillDataMsgProc.GetFromType(pMessage->m_FromType,pPc,msg->nSkillID);
if(pMessage->m_Name)
g_SkillDataMsgProc.GetName(pMessage->m_Name,message,pPc,msg->nSkillID);
if(pMessage->m_ToType)
message->toType = g_SkillDataMsgProc.GetToType(pMessage->m_ToType,pPc,msg->nSkillID);
if(pMessage->m_ToIdx)
message->toIdx = g_SkillDataMsgProc.GetToIdx(pMessage->m_ToIdx,pPc,msg->nSkillID);
if(pMessage->m_WorldIdx)
message->worldIdx = g_SkillDataMsgProc.GetWorldIdx(pMessage->m_WorldIdx,pPc,msg->nSkillID);
if(pMessage->m_SendTime)
message->sendTime = g_SkillDataMsgProc.GetSendTime(pMessage->m_SendTime,pPc,msg->nSkillID);
if(pMessage->m_ReceiveTime)
message->receiveTime = g_SkillDataMsgProc.GetReceiveTime(pMessage->m_ReceiveTime,pPc,msg->nSkillID);
for(int i=0;i<MAX_SKILL_MESSAGE_DATA;i++)
{
if(pMessage->m_Data[i].m_nIndex)
{
message->data[i] = g_SkillDataMsgProc.GetData(pMessage->m_Data[i].m_nIndex,pPc,msg);
}
else
{
break;
}
}
for(i=0;i<MAX_SKILL_MESSAGE_DATA;i++)
{
if(pMessage->m_Data[i].m_Type)
{
message->Type[i] = pMessage->m_Data[i].m_Type;
}
else
{
break;
}
}
return true;
}
bool CSkillProc::CastActive(void *pPc,CStr_Skill_Msg *msg)
{
BasicActive(pPc,msg);
CSkillDataCast *pCast = msg->pDataFormat->GetCast();
if(pCast == NULL) return false;
if(pCast->m_Type)
{
g_SkillCast.RaProc(pCast->m_Type,pPc,msg);
}
return true;
}
void CSkillProc::MultiDamageSkill(void *pPc,CStr_Skill_Msg *msg,int Index)
{
CSkillDataFormat_Attack *pAttack = msg->pDataFormat->GetAttack();
if(pAttack == NULL) return;
messageInfo_t *msginfo =msg->msginfo;
if(msginfo == NULL) return;
if(msginfo->attack.etcInfo == MSGINFO_ATK_ETC_MULTIDAMAGE_DELAY)
{
msginfo->attack.etcData0 += 300;
}
}
| C++ |
#include "GameTarget.h"
CGameTarget::CGameTarget()
{
}
CGameTarget::~CGameTarget()
{
}
| C++ |
#pragma once
#include "CriticalSection.h"
#include "Billing.h"
#include "Thread.h"
class CRecvBuffer
{
public:
CRecvBuffer (int packetCount = 512) ;
~CRecvBuffer () ;
void Clear () ;
bool Input (unsigned char * data, int size) ;
bool Get (PACKET_GAME * packetGame) ;
size_t GetDataSize () { return m_dataSize ; }
private:
const int m_bufferSize ;
unsigned char * m_pBuffer ;
int m_dataSize ;
int m_write ;
int m_read ;
bool m_init ;
CCriticalSection m_cs ;
void RemoveBuffer () ;
};
class CInternetAddress : public SOCKADDR_IN
{
public:
explicit CInternetAddress (unsigned long address, unsigned short port) ;
} ;
class tcpSocket : public CThread
{
public:
tcpSocket () ;
virtual ~tcpSocket () ;
bool Create () ;
bool Connect (unsigned long addr, unsigned short port) ;
bool Send ( PACKET_GAME * pPacket ) ;
void Close () ;
void SetStatus(BOOL bStatus);
BOOL GetStatus();
virtual int Run () ;
CRecvBuffer m_recv ;
CRecvBuffer m_send ;
private:
BOOL m_run ;
SOCKET m_sock ;
unsigned long m_addr ;
unsigned short m_port ;
} ;
| C++ |
#include "Thread.h"
#include <process.h>
CThread::CThread ()
: m_hThread (INVALID_HANDLE_VALUE)
{
}
CThread::~CThread ()
{
if (m_hThread != INVALID_HANDLE_VALUE)
{
::CloseHandle (m_hThread) ;
}
}
HANDLE CThread::GetHandle () const
{
return m_hThread ;
}
bool CThread::Start ()
{
if (m_hThread == INVALID_HANDLE_VALUE)
{
unsigned int threadID = 0 ;
m_hThread = (HANDLE)_beginthreadex(0, 0, ThreadFunction, (void*)this, 0, &threadID) ;
if (m_hThread == INVALID_HANDLE_VALUE)
{
return false ;
}
}
else
{
return false ;
}
return true ;
}
bool CThread::Wait () const
{
if (!Wait (INFINITE))
{
return false ;
}
return true ;
}
bool CThread::Wait (DWORD timeoutMillis) const
{
bool ok ;
DWORD result = ::WaitForSingleObject (m_hThread, timeoutMillis) ;
if (WAIT_TIMEOUT == result)
{
ok = false ;
}
else if (WAIT_OBJECT_0 == result)
{
ok = true ;
}
else
{
ok = false ;
}
return ok ;
}
unsigned int __stdcall CThread::ThreadFunction (void* pV)
{
int result = 0 ;
CThread* pThis = (CThread*)pV ;
if (pThis)
{
result = pThis->Run () ;
}
return result ;
}
| C++ |
#include "..\\global.h"
#define CANT_FIND_PC -1
void ProcessBillingQueue ()
{
PACKET_GAME packetGame ;
while ( g_pBillingSocket->m_recv.Get ( &packetGame ) )
{
switch ( ntohl (packetGame.PacketType) )
{
case GameStart:
Billing_ProcessGameStart (&packetGame) ;
break ;
case SeverAlive:
Billing_ProcessServerAlive (&packetGame) ;
break ;
case UserAlert:
Billing_ProcessUserAlert (&packetGame) ;
break ;
case UserSync:
Billing_ProcessUserSync (&packetGame) ;
break ;
default:
Billing_WrongPacket (&packetGame) ;
break ;
}
}
}
void Billing_SendGameStart(playerCharacter_t* pc)
{
if (g_pBillingSocket->GetStatus()==FALSE)
return;
if (pc->BillSendType==BILL_SEND_START)
return;
pc->BillSendType=BILL_SEND_START;
PACKET_GAME packetGame ;
memset(&packetGame,0,sizeof(PACKET_GAME));
packetGame.PacketType = htonl (GameStart) ;
strncpy (packetGame.UserID,
pc->userID,
sizeof (packetGame.UserID));
strncpy (packetGame.UserIP,
inet_ntoa (pc->sock.addr.sin_addr),
sizeof (packetGame.UserIP));
packetGame.GameNo = htonl (1) ;
_snprintf(
packetGame.GameServer, sizeof (packetGame.GameServer),
"%s%03d:s%03d", _strlwr (g_config.serverLocation), g_config.serverGroupNo,
g_config.gameServerNo
);
g_logSystem->WriteRLog( "Send Game Start !! UserID : %s, Character Name : %s",pc->userID,pc->name );
g_pBillingSocket->Send(&packetGame);
}
void Billing_SendMessage(playerCharacter_t *pc,int msgIdx)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_BILLING);
MSG_WriteByte(&netMessage, msgIdx);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void Billing_ProcessGameStart (PPACKET_GAME pPacket)
{
int idx = Billing_FindPCbyUserID (pPacket->UserID) ;
if (CANT_FIND_PC == idx)
{
g_logSystem->Write ("Billing: recv GameStart "
"but can't find userID: %s",
pPacket->UserID) ;
Billing_SendGameEnd( pPacket );
return ;
}
if ( 0 != ntohl(pPacket->PacketResult) )
{
g_logSystem->WriteRLog("Disconnect User User ID : %s, PacketResult : %d",pPacket->UserID,ntohl(pPacket->PacketResult));
char msg[MAX_PATH];
memset(msg,0,MAX_PATH);
switch ( ntohl(pPacket->PacketResult) )
{
case 3 :
Billing_SendMessage ( &g_pc[idx], 0 ) ;
break;
case 10 :
case 11 :
case 33 :
Billing_SendMessage ( &g_pc[idx], 1 ) ;
break;
default :
Billing_SendMessage ( &g_pc[idx], 2 ) ;
break;
}
GTH_DisconnectGameServer (idx) ;
}
}
void Billing_SendGameEnd (playerCharacter_t *pc)
{
if (pc == NULL) return ;
if (pc->userID == NULL || pc->userID[0] == '\0') return ;
if ( pc->BillSendType==BILL_SEND_END)
return;
pc->BillSendType=BILL_SEND_END;
PACKET_GAME packetGame ;
memset(&packetGame,0,sizeof(PACKET_GAME));
packetGame.PacketType = htonl (GameEnd) ;
_snprintf (packetGame.GameServer, sizeof (packetGame.GameServer),
"%s%03d:s%03d",
g_config.serverLocation,
g_config.serverGroupNo,
g_config.gameServerNo) ;
_snprintf (packetGame.UserID, sizeof (packetGame.UserID),
pc->userID) ;
_snprintf (packetGame.UserIP, sizeof (packetGame.UserIP),
inet_ntoa (pc->sock.addr.sin_addr)) ;
packetGame.GameNo = htonl (1) ;
g_logSystem->WriteRLog( "Send Game End !! UserID : %s, Character Name : %s",pc->userID, pc->name );
g_pBillingSocket->Send (&packetGame) ;
}
void Billing_SendGameEnd (PPACKET_GAME pRecvPacket)
{
PACKET_GAME packetGame ;
memset(&packetGame,0,sizeof(PACKET_GAME));
packetGame.PacketType = htonl (GameEnd) ;
_snprintf (packetGame.GameServer, sizeof (packetGame.GameServer),
"%s%03d:s%03d",
g_config.serverLocation,
g_config.serverGroupNo,
g_config.gameServerNo) ;
_snprintf (packetGame.UserID, sizeof (packetGame.UserID),
pRecvPacket->UserID) ;
_snprintf (packetGame.UserIP, sizeof (packetGame.UserIP),
pRecvPacket->UserIP) ;
packetGame.GameNo = htonl (1) ;
g_logSystem->WriteRLog( "Send Game End Recv Packet!! UserID : %s",packetGame.UserID );
g_pBillingSocket->Send (&packetGame) ;
}
void Billing_ProcessServerAlive (PPACKET_GAME pPacket)
{
}
void Billing_ProcessUserAlert (PPACKET_GAME pPacket)
{
int idx = Billing_FindPCbyUserID (pPacket->UserID) ;
if ( CANT_FIND_PC == idx )
{
return ;
}
char msg[MAX_PATH] ;
if ( 0 < ntohl (pPacket->BillRemain) )
{
int hours = ntohl (pPacket->BillRemain)/3600 ;
_snprintf ( msg, MAX_PATH, "Your remain time is "
"%02d hours %02d minutes %02d seconds",
hours,
(ntohl (pPacket->BillRemain)/60) - (hours * 60),
ntohl (pPacket->BillRemain)%60 ) ;
GTH_SendMessage_NoticeMessage ( &g_pc[idx], msg ) ;
}
else
{
Billing_SendMessage( &g_pc[idx], 3 );
GTH_DisconnectGameServer (idx) ;
}
}
void Billing_ProcessUserSync (PPACKET_GAME pPacket)
{
PACKET_GAME packetGame = { 0, } ;
packetGame.PacketType = htonl (UserSync) ;
strcpy ( packetGame.UserID, pPacket->UserID ) ;
int idx = Billing_FindPCbyUserID (pPacket->UserID) ;
if ( CANT_FIND_PC == idx )
{
packetGame.PacketResult = htonl ( 0 ) ;
}
else
{
packetGame.PacketResult = htonl ( 1 ) ;
strncpy ( packetGame.UserID,
inet_ntoa (g_pc[idx].sock.addr.sin_addr),
sizeof (packetGame.UserID) ) ;
}
if ( !g_pBillingSocket->Send ( &packetGame ) )
{
g_logSystem->WriteToError ("Billing link broken");
}
}
void Billing_WrongPacket (PPACKET_GAME pPacket)
{
g_logSystem->WriteToError ("Wrong Billing Packet: "
"Type: %d, "
"Result: %d, "
"GameServer: %s, "
"User_ID: %s, "
"User_IP: %s, "
"Game_No: %d, "
"BillMethod: %c%c, "
"BillExpire: %c%c%c%c%c%c%c%c%c%c%c%c, "
"BillRemain: %d",
ntohl (pPacket->PacketType),
ntohl (pPacket->PacketResult),
pPacket->GameServer,
pPacket->UserID,
pPacket->UserIP,
ntohl (pPacket->GameNo),
pPacket->BillMethod[0], pPacket->BillMethod[1],
pPacket->BillExpire[0],
pPacket->BillExpire[1],
pPacket->BillExpire[2],
pPacket->BillExpire[3],
pPacket->BillExpire[4],
pPacket->BillExpire[5],
pPacket->BillExpire[6],
pPacket->BillExpire[7],
pPacket->BillExpire[8],
pPacket->BillExpire[9],
pPacket->BillExpire[10],
pPacket->BillExpire[11],
ntohl (pPacket->BillRemain) ) ;
}
void Billing_ServerConnect()
{
PACKET_GAME packetGame ;
DWORD kkk=ServerConnection;
memset(&packetGame,0,sizeof(PACKET_GAME));
packetGame.PacketType = htonl (ServerConnection) ;
_snprintf (packetGame.GameServer, sizeof (packetGame.GameServer),
"%s%03d:s%03d",
g_config.serverLocation,
g_config.serverGroupNo,
g_config.gameServerNo) ;
packetGame.GameNo = htonl (1) ;
g_pBillingSocket->Send (&packetGame) ;
}
void Billing_ServerReset()
{
PACKET_GAME packetGame ;
DWORD kkk=ServerReset;
memset(&packetGame,0,sizeof(PACKET_GAME));
packetGame.PacketType = htonl (ServerReset) ;
_snprintf (packetGame.GameServer, sizeof (packetGame.GameServer),
"%s%03d:s%03d",
g_config.serverLocation,
g_config.serverGroupNo,
g_config.gameServerNo) ;
packetGame.GameNo = htonl (1) ;
g_pBillingSocket->Send (&packetGame) ;
}
int Billing_FindPCbyUserID ( char *userID )
{
playerCharacter_t *pc = &g_pc[0] ;
for (int idx = 0 ; idx < MAX_PCS ; ++idx, ++pc)
{
if (!pc->active || !pc->ready )
continue ;
if ( !stricmp (userID, pc->userID ) )
return idx ;
}
return CANT_FIND_PC ;
}
bool InitBilling ()
{
if (!g_config.bCheckBilling)
{
g_logSystem->Write("CHECK!! Billing System Do Not Active By Server.cfg File!!");
return TRUE;
}
if ( NULL != g_pBillingSocket )
{
delete g_pBillingSocket ;
g_pBillingSocket = NULL ;
}
g_pBillingSocket = new tcpSocket ;
if (!g_pBillingSocket->Create ())
{
char tbuf[128] ;
sprintf (tbuf, "ret: %d", WSAGetLastError ()) ;
MessageBox (NULL, tbuf, "Error", MB_OK) ;
}
if (!g_pBillingSocket->Connect (inet_addr (g_config.billingServerIP),
g_config.billingServerPort))
{
MessageBox(NULL,"Can't Connect Billing Server!!","Error",MB_OK);
return FALSE;
}
g_logSystem->Write("Billing System Initialize Complete!!");
if (g_pBillingSocket->Start ())
{
Billing_ServerConnect();
Billing_ServerReset();
}
return true;
}
void CloseBilling()
{
if (!g_config.bCheckBilling)
return;
if ( NULL != g_pBillingSocket )
{
g_pBillingSocket->Close();
delete g_pBillingSocket ;
g_pBillingSocket = NULL ;
}
}
| C++ |
#pragma once
#include <windows.h>
class CThread
{
public:
CThread () ;
virtual ~CThread () ;
HANDLE GetHandle () const ;
bool Wait () const ;
bool Wait (DWORD timeoutMillis) const ;
bool Start () ;
private:
virtual int Run () = 0 ;
static unsigned int __stdcall ThreadFunction (void* pV) ;
HANDLE m_hThread ;
CThread (const CThread& rhs) ;
CThread &operator= (const CThread& rhs) ;
} ;
| C++ |
#include "..\\global.h"
extern CLogSystem *g_logSystem;
extern void Billing_ServerConnect();
tcpSocket::tcpSocket ()
: m_sock (INVALID_SOCKET),
m_run (true)
{
}
tcpSocket::~tcpSocket ()
{
Close () ;
}
void tcpSocket::Close ()
{
SetStatus( false );
if ( INVALID_SOCKET != m_sock )
{
closesocket ( m_sock ) ;
m_sock = INVALID_SOCKET ;
}
}
void tcpSocket::SetStatus(BOOL bStatus)
{
m_run = bStatus;
}
BOOL tcpSocket::GetStatus()
{
return m_run;
}
bool tcpSocket::Create ()
{
m_sock = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP) ;
if ( INVALID_SOCKET == m_sock )
{
return false ;
}
return true ;
}
bool tcpSocket::Connect (unsigned long addr, unsigned short port)
{
if ( INVALID_SOCKET == m_sock )
{
return false ;
}
CInternetAddress servAddr (addr, port) ;
int result = connect ( m_sock, (sockaddr*)&servAddr, sizeof (servAddr ) ) ;
if ( SOCKET_ERROR == result )
{
return false ;
}
m_addr = addr ;
m_port = port ;
return true ;
}
int tcpSocket::Run ()
{
int ret ;
PACKET_GAME packetGame ;
while (m_run)
{
ret = recv ( m_sock, (char*)&packetGame, sizeof (packetGame), 0 ) ;
if ( SOCKET_ERROR == ret || ret==0)
{
Close () ;
Wait (200) ;
m_recv.Clear();
Create () ;
while (!Connect (m_addr, m_port))
{
static int ConCount=0;
Wait (200) ;
}
SetStatus(TRUE);
Start () ;
Billing_ServerConnect();
continue;
}
if (!m_recv.Input ((unsigned char*)&packetGame, ret))
{
}
}
return 0 ;
}
bool tcpSocket::Send (PACKET_GAME * pPacket)
{
if ( !m_run ) return false ;
int ret = send ( m_sock, (char*) pPacket, sizeof (PACKET_GAME), 0 ) ;
if ( SOCKET_ERROR == ret )
{
}
return true ;
}
CInternetAddress::CInternetAddress (unsigned long address, unsigned short port)
{
sin_family = AF_INET ;
sin_port = htons (port) ;
sin_addr.s_addr = address ;
}
CRecvBuffer::CRecvBuffer (int packetCount)
: m_bufferSize (packetCount * sizeof (PACKET_GAME)),
m_init (true)
{
m_pBuffer = new unsigned char [m_bufferSize] ;
if ( NULL == m_pBuffer )
{
m_init = false ;
RemoveBuffer () ;
}
Clear () ;
}
CRecvBuffer::~CRecvBuffer ()
{
RemoveBuffer () ;
}
void CRecvBuffer::RemoveBuffer ()
{
if ( NULL != m_pBuffer )
{
delete [] m_pBuffer ;
m_pBuffer = NULL ;
}
}
void CRecvBuffer::Clear ()
{
m_dataSize = 0 ;
m_write = 0 ;
m_read = 0 ;
}
bool CRecvBuffer::Input (unsigned char *pData, int size)
{
if ( size + m_dataSize > m_bufferSize || !m_init)
{
return false ;
}
CCriticalSection::Owner lock (m_cs) ;
if ( m_write + size >= m_bufferSize )
{
int part1 = m_bufferSize - m_write ;
int part2 = size - part1 ;
memcpy (&m_pBuffer[m_write], pData, part1) ;
memcpy (m_pBuffer, &pData[part1], part2) ;
m_write = part2 ;
}
else
{
memcpy (&m_pBuffer[m_write], pData, size) ;
m_write += size ;
}
m_dataSize += size ;
return true ;
}
bool CRecvBuffer::Get (PACKET_GAME *packetGame)
{
if ( sizeof (PACKET_GAME) > m_dataSize )
{
return false ;
}
CCriticalSection::Owner lock (m_cs) ;
if ( m_bufferSize - m_read > sizeof (PACKET_GAME) )
{
memcpy ( packetGame, &m_pBuffer[m_read], sizeof (PACKET_GAME) ) ;
m_read += sizeof (PACKET_GAME) ;
}
else
{
int part1 = m_bufferSize - m_read ;
int part2 = sizeof (PACKET_GAME) - part1 ;
memcpy ( packetGame, &m_pBuffer[m_read], part1 ) ;
memcpy ( &packetGame[part1], m_pBuffer, part2 ) ;
m_read = part2;
}
m_dataSize -= sizeof (PACKET_GAME) ;
return true ;
}
| C++ |
#pragma once
#include <windows.h>
class CCriticalSection
{
public:
class Owner
{
public:
explicit Owner (CCriticalSection& crit) ;
~Owner () ;
private:
CCriticalSection& m_crit ;
Owner (const Owner& rhs) ;
Owner &operator= (const Owner& rhs) ;
} ;
CCriticalSection () ;
~CCriticalSection () ;
void Enter () ;
void Leave () ;
private:
CRITICAL_SECTION m_cs ;
} ;
| C++ |
#include "CriticalSection.h"
CCriticalSection::CCriticalSection ()
{
::InitializeCriticalSection (&m_cs) ;
}
CCriticalSection::~CCriticalSection ()
{
::DeleteCriticalSection (&m_cs) ;
}
void CCriticalSection::Enter ()
{
::EnterCriticalSection (&m_cs) ;
}
void CCriticalSection::Leave ()
{
::LeaveCriticalSection (&m_cs) ;
}
CCriticalSection::Owner::Owner (CCriticalSection& cs)
: m_crit (cs)
{
m_crit.Enter () ;
}
CCriticalSection::Owner::~Owner ()
{
m_crit.Leave () ;
}
| C++ |
#include "global.h"
#include "CTools.h"
extern CTools* gcpTools;
CLogSystem::CLogSystem()
{
m_updateTime = 0;
m_generationHour = -1;
}
CLogSystem::~CLogSystem()
{
}
void CLogSystem::Initialize(const BOOL in_bCreateLog,const BOOL in_bCreateDebug)
{
m_updateTime = g_globalTime;
m_updateCycle = 1000;
m_UserLogTTCtrl.SetActive(in_bCreateLog);
m_UserLogCtrl.SetActive(in_bCreateLog);
m_DebugLogCtrl.SetActive(in_bCreateDebug);
m_ErrorLogCtrl.SetActive(TRUE);
m_NewDanbattleLogCtrl.SetActive(TRUE);
m_HackingUserLogCtrl.SetActive(TRUE);
}
BOOL CLogSystem::Close(void)
{
m_UserLogTTCtrl.Close();
m_UserLogCtrl.Close();
m_DebugLogCtrl.Close();
m_ErrorLogCtrl.Close();
m_NewDanbattleLogCtrl.Close();
m_HackingUserLogCtrl.Close();
return TRUE;
}
BOOL CLogSystem::Open(void)
{
struct tm* date_tm=NULL;
time_t logTime;
time( &logTime );
date_tm = localtime( &logTime );
if (m_generationHour != date_tm->tm_hour)
{
m_generationHour = date_tm->tm_hour;
date_tm->tm_year += 1900;
date_tm->tm_mon += 1;
sprintf(m_logFileName, "logs/GS%02d%02d_%04d%02d%02d_%02d.log",
g_config.serverGroupNo,
g_config.gameServerNo,
date_tm->tm_year,
date_tm->tm_mon,
date_tm->tm_mday,
date_tm->tm_hour);
sprintf(m_logTTFileName, "TTlogs/TT%02d%02d_%04d%02d%02d_%02d.log",
g_config.serverGroupNo,
g_config.gameServerNo,
date_tm->tm_year,
date_tm->tm_mon,
date_tm->tm_mday,
date_tm->tm_hour);
sprintf(m_debugFileName, "debugs/GS%02d%02d_%04d%02d%02d_%02d.dbg",
g_config.serverGroupNo,
g_config.gameServerNo,
date_tm->tm_year,
date_tm->tm_mon,
date_tm->tm_mday,
date_tm->tm_hour);
sprintf(m_NewDanBattleFileName, "NewDanBattleLog/GS%02d%02d_%04d%02d%02d_%02d.dbg",
g_config.serverGroupNo,
g_config.gameServerNo,
date_tm->tm_year,
date_tm->tm_mon,
date_tm->tm_mday,
date_tm->tm_hour);
sprintf(m_HackingUserFileName, "HackingLog/GS%02d%02d_%04d%02d%02d_%02d.dbg",
g_config.serverGroupNo,
g_config.gameServerNo,
date_tm->tm_year,
date_tm->tm_mon,
date_tm->tm_mday,
date_tm->tm_hour);
}
m_UserLogCtrl.Open(m_logFileName);
m_UserLogTTCtrl.Open(m_logTTFileName);
m_DebugLogCtrl.Open(m_debugFileName);
m_ErrorLogCtrl.Open("error.dbg");
m_NewDanbattleLogCtrl.Open(m_NewDanBattleFileName);
m_HackingUserLogCtrl.Open(m_HackingUserFileName);
return TRUE;
}
BOOL CLogSystem::Update(void)
{
if (m_updateTime > g_globalTime) return FALSE;
m_updateTime = g_globalTime + m_updateCycle;
Close();
Open();
return TRUE;
}
void CLogSystem::Write( const char *format, ... )
{
va_list argptr;
const int buffer_maxbytes=4095;
char buffer[buffer_maxbytes+1]="";
va_start(argptr, format);
_vsnprintf(buffer,buffer_maxbytes, format, argptr);
buffer[buffer_maxbytes]=NULL;
va_end(argptr);
m_DebugLogCtrl.WriteLog(buffer);
}
void CLogSystem::WriteToLogTT( const char *format, ... )
{
va_list argptr;
const int buffer_maxbytes=4095;
char buffer[buffer_maxbytes+1]="";
va_start(argptr, format);
_vsnprintf(buffer,buffer_maxbytes, format, argptr);
buffer[buffer_maxbytes]=NULL;
va_end(argptr);
m_UserLogTTCtrl.WriteLog(buffer);
}
void CLogSystem::WriteToLog( const char *format, ... )
{
va_list argptr;
const int buffer_maxbytes=4095;
char buffer[buffer_maxbytes+1]="";
va_start(argptr, format);
_vsnprintf(buffer,buffer_maxbytes, format, argptr);
buffer[buffer_maxbytes]=NULL;
va_end(argptr);
m_UserLogCtrl.WriteLog(buffer);
}
void CLogSystem::WriteToError( const char *format, ... )
{
va_list argptr;
const int buffer_maxbytes=4095;
char buffer[buffer_maxbytes+1]="";
va_start(argptr, format);
_vsnprintf(buffer, buffer_maxbytes,format, argptr);
buffer[buffer_maxbytes]=NULL;
va_end(argptr);
m_ErrorLogCtrl.WriteLog(buffer);
}
void CLogSystem::WriteToNewDanBattleLog( const char *format, ... )
{
va_list argptr;
const int buffer_maxbytes=4095;
char buffer[buffer_maxbytes+1]="";
va_start(argptr, format);
_vsnprintf(buffer, buffer_maxbytes,format, argptr);
buffer[buffer_maxbytes]=NULL;
va_end(argptr);
m_NewDanbattleLogCtrl.WriteLog(buffer);
}
void CLogSystem::WriteToHackingLog( const char *format, ... )
{
va_list argptr;
const int buffer_maxbytes=4095;
char buffer[buffer_maxbytes+1]="";
va_start(argptr, format);
_vsnprintf(buffer, buffer_maxbytes,format, argptr);
buffer[buffer_maxbytes]=NULL;
va_end(argptr);
m_HackingUserLogCtrl.WriteLog(buffer);
}
void CLogSystem::
WriteToLog(const playerCharacter_t* in_pPlayer,const int in_logClass,const char* in_format, ... )
{
if(NULL == in_pPlayer) return;
va_list argptr;
const int buffer_maxbytes=4095;
char buffer[buffer_maxbytes+1]="";
char cTimeStamp[30]="";
va_start(argptr, in_format);
_vsnprintf(buffer,buffer_maxbytes, in_format, argptr);
buffer[buffer_maxbytes]=NULL;
va_end(argptr);
char logBuffer[4096]="";
_snprintf( logBuffer, 4096,
"%d;"
"%s;"
"%s;"
"%d;"
"%d;"
"%d;"
"%.0f;"
"%.0f;"
"%.0f;"
"%d;"
"%I64d;"
"%d;"
"%I64d;"
"%d;"
,
g_config.serverGroupNo,
in_pPlayer->userID,
in_pPlayer->name,
in_pPlayer->pcJob,
in_logClass,
in_pPlayer->worldIdx,
in_pPlayer->position[0],
in_pPlayer->position[1],
in_pPlayer->position[2],
in_pPlayer->level,
in_pPlayer->exp,
in_pPlayer->genLevel,
in_pPlayer->genExp,
in_pPlayer->curChargeSE
);
m_UserLogCtrl.WriteLog(buffer, logBuffer);
}
void CLogSystem::WriteRLog( const char *format, ... )
{
}
char* GetItemInformationLog( int isStack, int itemTableIdx, int itemIdx, int inventoryPos )
{
static char buffer[100];
_snprintf( buffer, 100,
"isStack[%d] "
"itemTableIdx[%d] "
"itemIdx[%d] "
"invenPos[%d]"
,
isStack,
itemTableIdx,
itemIdx,
inventoryPos
);
return buffer;
}
void CLogSystem::WriteItemDeleteLog(const playerCharacter_t* in_pPlayer,const item_t& in_item)
{
itemTable_t* pItemTableRecord = gcpTools->GetItemTablePointer(in_item.itemTableIdx);
if(NULL == pItemTableRecord) return;
int number=1;
if(pItemTableRecord->stackFlag) number = in_item.durability+1;
char name[20]="unknown";
strncpy(name,in_item.name,20); name[20-1]=NULL;
WriteToLog(
in_pPlayer,
LOG_CLASS_ITEM, "%d;%d;;;;%s;itemTableIdx[%d]",
LOG_CLASS_ITEM_DESTROY,
number,
name,
in_item.itemTableIdx);
}
| C++ |
#if !defined(AFX_CHELPERMANAGER_ENCODER_H__AEE01AEB_29A6_4503_B077_6569AA0D154A__INCLUDED_)
#define AFX_CHELPERMANAGER_ENCODER_H__AEE01AEB_29A6_4503_B077_6569AA0D154A__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CHelperManager_Encoder
{
public:
void SendMessage_Helper_StackOpen(playerCharacter_t* pPlayer);
protected:
void PC_SetSummonsInfo(playerCharacter_t* pPlayer, char* name, int worldIdx, vec3_t position);
void PC_InitSummonsInfo(playerCharacter_t* pPlayer);
void SendMessage_Invite_Request_toTaker( playerCharacter_t* pTaker,char* pHelperName);
void SendMessage_Invite_Respond_toHelper ( playerCharacter_t* pPlayer, int errorCode);
void SendMessage_Invite_Respond_toTaker( playerCharacter_t* pPlayer, int errorCode);
void SendMessage_Added_toPlayer(
playerCharacter_t* pPlayer, char* name, int level, int job, int worldIdx );
void SendMessage_Remove_Respond_toPlayer(
playerCharacter_t* pPlayer, char* name, int errorCode);
void SendMessage_Remove_Notify_toRemovePlayer(playerCharacter_t* pPlayer,char* pName);
void SendMessage_UpdatePointInfo_toPlayer(playerCharacter_t* pPlayer);
void SendMessage_RequestSummons(playerCharacter_t* pPlayer,char* toName);
void SendMessage_ReplySummons(int reply, char* toName, char* fromName);
void SendMessage_Helper_Mypoint(playerCharacter_t* pPlayer);
void SendMessage_Helper_Helppoint(playerCharacter_t* pPlayer);
void SendMessage_Mypoint_toTaker(
playerCharacter_t* pPlayer,char* pTakerName, char* pHelperName, int MyPoint);
void SendMessage_Helppoint_toHelper(
playerCharacter_t* pPlayer, char* pgiverName, int HelpPoint);
public:
CHelperManager_Encoder();
virtual ~CHelperManager_Encoder();
};
#endif
| C++ |
#include "..\global.h"
#include "CHelperManager_Encoder.h"
#include "tagHelperPacket.h"
#include "..\Tools\CTools.h"
#include <assert.h>
extern CTools* gcpTools;
#include "..\GonryunPracticeBattle\CGonryunPracticeBattle.h"
extern CGonryunPracticeBattle g_GonryunPracticeBattle;
CHelperManager_Encoder::CHelperManager_Encoder()
{
}
CHelperManager_Encoder::~CHelperManager_Encoder()
{
}
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 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);
}
void CHelperManager_Encoder::SendMessage_Invite_Respond_toTaker(
playerCharacter_t* pTaker,int errorCode)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, HELPER_SYSTEM);
MSG_WriteShort(&netMessage, SC_INVITE_Res_toTAKER);
MSG_WriteShort(&netMessage, errorCode);
NET_SendMessage(&pTaker->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
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 CHelperManager_Encoder::SendMessage_Added_toPlayer (
playerCharacter_t* pHelper, char* name, int level, int job, int worldIdx )
{
MSG_BeginWriting ( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort( &netMessage, HELPER_SYSTEM );
MSG_WriteShort( &netMessage, SC_SEND_ADD_toPlayer );
MSG_WriteByte ( &netMessage, level );
MSG_WriteByte ( &netMessage, job );
MSG_WriteByte ( &netMessage, worldIdx );
MSG_WriteString ( &netMessage, name );
if ( pHelper->ready )
{
NET_SendMessage ( &pHelper->sock, &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 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);
}
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_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_Encoder::SendMessage_Helper_Mypoint(playerCharacter_t* pHelper)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort ( &netMessage, HELPER_SYSTEM );
MSG_WriteShort(&netMessage, SC_CONFIRM_MYPOINT_Res_toPlayer);
MSG_WriteLong(&netMessage, pHelper->tHelper.tPoint.iMyPoint);
NET_SendMessage(&pHelper->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CHelperManager_Encoder::SendMessage_Helper_Helppoint(playerCharacter_t* pHelper)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort ( &netMessage, HELPER_SYSTEM );
MSG_WriteShort(&netMessage, SC_CONFIRM_HELPPOINT_Res_toPlayer);
MSG_WriteLong(&netMessage, pHelper->tHelper.tPoint.iHelpPoint);
NET_SendMessage(&pHelper->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CHelperManager_Encoder::SendMessage_Helper_StackOpen(playerCharacter_t* pHelper)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort ( &netMessage, HELPER_SYSTEM );
MSG_WriteShort(&netMessage, SC_STACK_OPEN_Req_toPlayer);
NET_SendMessage(&pHelper->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CHelperManager_Encoder::PC_InitSummonsInfo(playerCharacter_t* pHelper)
{
memset(&pHelper->summonsInfo, 0, sizeof(summons_t));
}
void CHelperManager_Encoder::PC_SetSummonsInfo(
playerCharacter_t *pHelper, char *name, int worldIdx, vec3_t position)
{
strcpy(pHelper->summonsInfo.summoner, name);
pHelper->summonsInfo.worldIdx = worldIdx;
vec_copy(position, pHelper->summonsInfo.position);
}
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 CHelperManager_Encoder::SendMessage_Helppoint_toHelper(
playerCharacter_t* pc, char* pGiverName, int HelpPoint)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort ( &netMessage, HELPER_SYSTEM );
MSG_WriteShort(&netMessage, SC_SENDHELPPOINT_toHelper);
MSG_WriteString(&netMessage,pGiverName);
MSG_WriteLong(&netMessage,HelpPoint);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
} | C++ |
#if !defined(AFX_HELPERMANAGER_H__FBD7FE93_AF5C_40EE_A0D0_6175CD1245FF__INCLUDED_)
#define AFX_HELPERMANAGER_H__FBD7FE93_AF5C_40EE_A0D0_6175CD1245FF__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "tagHelper.h"
#include "CHelperManager_Encoder.h"
class CHelperManager : public CHelperManager_Encoder
{
public:
enum Memberstate {
HelpersLogin = 0,
HelpersLogout= 1,
HelpersUpdate= 2,
};
enum define_{
USERCOUNT = 0,
RESPOND_NO = 0,
RESPOND_YES = 1,
LEVEL_FOUR = 4,
LEVEL_TEN = 10,
LEVEL_TWENTY = 20,
LEVEL_THIRTY = 30,
HELPER_STANDARD_LEVEL = 31,
MAX_HELPERS_LIST = 5000,
};
public:
CHelperManager();
virtual ~CHelperManager();
public:
void ProcessMessage_MemberList_Request_List ();
void ProcessMessage_MemberList_Request_Update ();
void ProcessMessage_Reply_Helpers_List ();
void ProcessMessage_Reply_Helpers_Update ();
public:
void ProcessMessage_Helper();
BOOL ProcessMessage_Helper_SS(const enum enumHelperPacket& SecoundPacket);
BOOL ProcessMessage_Helper_CS(const enum enumHelperPacket& SecoundPacket);
public:
void GiveHelpPointToUser(playerCharacter_t* pPlayer);
struct tagHelper* GetHelperPtr(const int idx);
public:
void MemberList_Send_toPlayer( entityPCList_t* pPlayerList );
void MemberListInfo_Send_toAllPlayer(entityPCList_t* pPlayerList, int iFstate );
void MemberList_Request_List( playerCharacter_t* pPlayer);
void MemberList_Request_Update( playerCharacter_t* pPlayer, int iFstate );
void MemberList_Request_List_OtherServer( playerCharacter_t* pPlayer );
void MemberList_Request_Update_OtherServer( playerCharacter_t* pPlayer, int iFstate );
private:
void ProcessMessage_Invite_REQ_fromHELPER(playerCharacter_t* pPlayer);
void ProcessMessage_Invite_RES_fromTAKER (playerCharacter_t* pPlayer);
void ProcessMessage_CS_REMOVE_REQ_fromPlayer(playerCharacter_t* pPlayer);
void ProcessMessage_Helper_GivePoint_Req_fromHelper(playerCharacter_t * pPlayer);
void ProcessMessage_Recall_Req_fromHelper(playerCharacter_t* pPlayer);
void ProcessMessage_Recall_Res_fromTaker(playerCharacter_t* pPlayer);
void ProcessMessage_ServerRequestSummons();
void ProcessMessage_ServerReplySummons();
void ProcessMessage_MyPointConfirm(playerCharacter_t* pPlayer);
void ProcessMessage_HelpPointConfirm(playerCharacter_t* pPlayer);
void ProcessMessage_Change_WepPoint(playerCharacter_t* pPlayer);
void ProcessMessage_SC_REMOVE_NOTIFY_toPlayer();
void ProcessMessage_MemberList_Req_fromPlayer(playerCharacter_t* pPlayer);
private:
void Add_toMemberList( playerCharacter_t* pPlayer, playerCharacter_t* pTarget );
void Remove_toMemberList( playerCharacter_t* pPlayer, char* name );
private:
BOOL isvalidIndex(const int idx)const;
BOOL isMyChild(const playerCharacter_t* pPlayer,const char* pChildName) const;
private:
struct tagHelper m_tHelpersList[MAX_HELPERS_LIST];
};
inline BOOL CHelperManager::isvalidIndex(const int idx) const
{
return ((0 <=idx) && (idx<MAX_HELPERS_LIST)) ? TRUE : FALSE;
}
#endif
| C++ |
// CTerraCtrl.h: interface for the CTerraCtrl class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_CTERRACTRL_H__64C0883E_1487_4603_BD88_B78568152D24__INCLUDED_)
#define AFX_CTERRACTRL_H__64C0883E_1487_4603_BD88_B78568152D24__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <comutil.h>
#include <stdio.h>
#import "EGameEncrypt.dll" no_namespace
class CTerraCtrl
{
private:
BOOL m_bOK;
IEGameEncryptPtr m_pEGameEncrypto;
public:
BOOL isOK(void) const;
BOOL Encrypt(const unsigned char* pTIDStr,unsigned char* pEncryptStr,const int EncryptStrLength) const;
public:
CTerraCtrl();
virtual ~CTerraCtrl();
};
#endif // !defined(AFX_CTERRACTRL_H__64C0883E_1487_4603_BD88_B78568152D24__INCLUDED_)
| C++ |
#include "../../global.h"
#include "CTerraBillingCtrl_LogCtrl.h"
#include "tagTerraBilling.h"
extern struct tagTerraBilling gTerraBilling;
CTerraBillingCtrl_LogCtrl::CTerraBillingCtrl_LogCtrl()
{
m_bOK=FALSE;
m_generationHour=25;
m_fp=NULL;
m_NextUpdateTime=g_globalTime-100;
m_bOK=TRUE;
}
CTerraBillingCtrl_LogCtrl::~CTerraBillingCtrl_LogCtrl()
{
CloseFile();
}
BOOL CTerraBillingCtrl_LogCtrl::isOK(void) const
{
return m_bOK;
}
void CTerraBillingCtrl_LogCtrl::Update(void)
{
if(FALSE == gTerraBilling.Log.bOutput) return;
if(m_NextUpdateTime > g_globalTime) return;
m_NextUpdateTime=g_globalTime + gTerraBilling.Log.UpdateCycle;
CloseFile();
OpenFile();
}
inline void CTerraBillingCtrl_LogCtrl::CloseFile(void)
{
if(NULL != m_fp){ fclose(m_fp); m_fp=NULL; }
}
void CTerraBillingCtrl_LogCtrl::Write(const char* format, ... )
{
if(FALSE == gTerraBilling.Log.bOutput) return;
if(NULL == m_fp){
if(FALSE == OpenFile()) return;
}
const int buffer_maxbytes=4095;
char buffer[buffer_maxbytes+1];
va_list argptr;
va_start(argptr, format);
_vsnprintf(buffer,buffer_maxbytes,format,argptr);
buffer[buffer_maxbytes]=NULL;
va_end(argptr);
const int bytes_strTime=24;
char strTime[bytes_strTime+1];
time_t Time;
time( &Time );
strncpy(strTime, ::ctime(&Time),bytes_strTime);
strTime[bytes_strTime] = NULL;
fprintf(m_fp,"[%s] %s\n",strTime,buffer);
}
char* CTerraBillingCtrl_LogCtrl::GetYESNOstring(BOOL bYESorNO)
{
static char* pYESstring = "yes";
static char* pNOstring = "no";
if(TRUE == bYESorNO) return pYESstring;
return pNOstring;
}
inline BOOL CTerraBillingCtrl_LogCtrl::OpenFile(void)
{
struct tm* date_tm;
long Time;
time(&Time);
date_tm = localtime(&Time);
if(m_generationHour != date_tm->tm_hour){
m_generationHour = date_tm->tm_hour;
date_tm->tm_year += 1900;
date_tm->tm_mon += 1;
#ifdef _GAME_SERVER
wsprintf(m_szFileName,"billinglogs/Terra%02d%02d_%04d%02d%02d_%02d.log",g_config.serverGroupNo,g_config.gameServerNo,date_tm->tm_year,date_tm->tm_mon,date_tm->tm_mday,date_tm->tm_hour);
#endif
#ifdef _MASTER_SERVER
wsprintf(m_szFileName,"billinglogs/Terra%02d_%04d%02d%02d_%02d.log",g_config.serverNo,date_tm->tm_year,date_tm->tm_mon,date_tm->tm_mday,date_tm->tm_hour);
#endif
}
m_fp = fopen(m_szFileName,"a+");
if(NULL == m_fp) return FALSE;
return TRUE;
} | C++ |
#include "../../global.h"
#include "CTerraBillingCtrl_CommunicationCtrl.h"
#include <process.h>
#include <assert.h>
#include "CTerraBillingCtrl_CircularQueueCtrl.h"
#include "CTerraBillingCtrl_ReceiveCircualrQueueCtrl.h"
extern CTerraBillingCtrl_CircularQueueCtrl* gcpTerraBillingCtrl_TransmiteCircularQueueCtrl;
extern CTerraBillingCtrl_ReceiveCircualrQueueCtrl* gcpTerraBillingCtrl_ReceiveCircularQueueCtrl;
#include "CTerraBillingCtrl_Encoder.h"
extern CTerraBillingCtrl_Encoder* gcpTerraBillingCtrl_Encder;
CTerraBillingCtrl_CommunicationCtrl::CTerraBillingCtrl_CommunicationCtrl()
{
m_bOK=FALSE;
m_sock =INVALID_SOCKET;
m_ThreadVar.bLive=FALSE;
m_ThreadVar.bReqExit=FALSE;
m_Step = step_disconnect;
{
unsigned int threadID = 0 ;
HANDLE hThread = INVALID_HANDLE_VALUE;
hThread = (HANDLE)_beginthreadex(0, 0, ThreadFunction, (void*)this, 0, &threadID) ;
if(hThread == INVALID_HANDLE_VALUE) return;
::CloseHandle(hThread);
hThread = INVALID_HANDLE_VALUE;
}
m_bOK=TRUE;
}
CTerraBillingCtrl_CommunicationCtrl::~CTerraBillingCtrl_CommunicationCtrl()
{
SocketDestory();
m_ThreadVar.bReqExit=TRUE;
while(TRUE == m_ThreadVar.bLive){
Sleep(100);
}
Sleep(10);
}
BOOL CTerraBillingCtrl_CommunicationCtrl::isOK(void) const
{
return m_bOK;
}
enum CTerraBillingCtrl_CommunicationCtrl::enumStep
CTerraBillingCtrl_CommunicationCtrl::GetStep(void)
{
return m_Step;
}
inline void CTerraBillingCtrl_CommunicationCtrl::SocketDestory(void)
{
if(INVALID_SOCKET != m_sock){
closesocket(m_sock);
m_sock=INVALID_SOCKET;
}
}
inline BOOL CTerraBillingCtrl_CommunicationCtrl::SocketCreate(void)
{
m_sock = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP) ;
if ( INVALID_SOCKET == m_sock )
{
return FALSE;
}
return TRUE;
}
inline void CTerraBillingCtrl_CommunicationCtrl::Disconnect(void)
{
assert(INVALID_SOCKET != m_sock);
SocketDestory() ;
gcpTerraBillingCtrl_ReceiveCircularQueueCtrl->Clear();
gcpTerraBillingCtrl_TransmiteCircularQueueCtrl->Clear();
}
unsigned int __stdcall CTerraBillingCtrl_CommunicationCtrl::ThreadFunction(void* pV)
{
CTerraBillingCtrl_CommunicationCtrl* cpCommunicationCtrl = (CTerraBillingCtrl_CommunicationCtrl*)pV ;
assert(NULL != cpCommunicationCtrl);
cpCommunicationCtrl->RealThreadFunction();
return 1;
}
inline BOOL CTerraBillingCtrl_CommunicationCtrl::Connect(void)
{
SocketDestory();
gcpTerraBillingCtrl_ReceiveCircularQueueCtrl->Clear();
gcpTerraBillingCtrl_TransmiteCircularQueueCtrl->Clear();
if(FALSE == SocketCreate()) return FALSE;
CInternetAddress servAddr(m_addr,m_port) ;
if(SOCKET_ERROR == connect(m_sock,(sockaddr*)&servAddr,sizeof(servAddr))) return FALSE;
return TRUE;
}
int CTerraBillingCtrl_CommunicationCtrl::RealThreadFunction(void)
{
struct tagAddBillPacket Packet;
int ret ;
m_ThreadVar.bLive=TRUE;
while(FALSE == m_ThreadVar.bReqExit){
switch(m_Step){
case step_disconnect:
default:
Sleep(10);
break;
case step_connect:
ret = recv( m_sock, (char*)&Packet, sizeof(struct tagAddBillPacket), 0 ) ;
if((SOCKET_ERROR == ret) || (0 == ret)){
m_Step = step_disconnect;
break;
}
gcpTerraBillingCtrl_ReceiveCircularQueueCtrl->Push((unsigned char*)&Packet, ret);
break;
case step_connect_try:
if(TRUE == Connect()) m_Step = step_connect;
Sleep(10);
break;
}
}
m_ThreadVar.bLive=FALSE;
return 0 ;
}
BOOL CTerraBillingCtrl_CommunicationCtrl::TryDisconnect(void)
{
switch(m_Step){
case step_connect:
SocketDestory();
m_Step = step_disconnect_try;
return TRUE;
}
return FALSE;
}
BOOL CTerraBillingCtrl_CommunicationCtrl::
TryConnect(const unsigned long addr,const unsigned short port)
{
switch(m_Step){
case step_disconnect:
m_addr = addr;
m_port = port;
m_Step = step_connect_try;
return TRUE;
}
return FALSE;
}
BOOL CTerraBillingCtrl_CommunicationCtrl::
Send(const struct tagAddBillPacket& Packet)
{
if(INVALID_SOCKET == m_sock) return FALSE;
int ret = send(m_sock,(char*)&Packet, sizeof(struct tagAddBillPacket), 0 ) ;
if(SOCKET_ERROR == ret) return FALSE;
return TRUE;
}
| C++ |
#if !defined(AFX_CTERRABILLINGCTRL_DECODER_H__0C021EEE_EF4D_445A_89C9_EF91A9ABCB06__INCLUDED_)
#define AFX_CTERRABILLINGCTRL_DECODER_H__0C021EEE_EF4D_445A_89C9_EF91A9ABCB06__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "tagTerraPacket.h"
class CTerraBillingCtrl_Decoder
{
private:
BOOL m_bOK;
private:
#ifdef _MASTER_SERVER
inline i3client_t* GetPlayerRecodPointer(const struct tagAddBillPacket& Packet) const;
inline void Decoder_billing_authorization(const struct tagAddBillPacket& Packet) const;
#endif
public:
#ifdef _GAME_SERVER
inline playerCharacter_t* GetPlayerRecodPointer(const struct tagAddBillPacket& Packet) const;
inline void Decoder_game_start(const struct tagAddBillPacket& Packet) const;
inline void Decoder_user_sync(const struct tagAddBillPacket& Packet) const;
inline void Decoder_user_alert(const struct tagAddBillPacket& Packet) const;
#endif
public:
inline void Decoder_server_alive(const struct tagAddBillPacket& Packet) const;
public:
BOOL isOK(void) const;
void Decoder(const struct tagAddBillPacket& Packet);
private:
#ifdef _GAME_SERVER
void Transmite_TerraGCPacket_OpenMessageBox(
playerCharacter_t* pToPlayerRecord,
enum tagTerraGCPacket_OpenMessageBox::enumLPACKType LPACKType,
const int LPACKIdx,
enum tagTerraGCPacket_OpenMessageBox::enumAfter after) const;
void Transmite_TerraGCPacket_NoticeMessage(
playerCharacter_t* pToPlayerRecord,
enum tagTerraGCPacket_NoticeMessage::enumLPACKType LPACKType,
const int LPACKIdx) const;
void Transmite_TerraGCPacket_Remain_Minute_NoticeMessage(
playerCharacter_t* pToPlayerRecord,
const int RemainMinute) const;
#endif
public:
CTerraBillingCtrl_Decoder();
virtual ~CTerraBillingCtrl_Decoder();
};
#endif
| C++ |
#if !defined(AFX_CTERRABILLINGCTRL_CIRCULARQUEUECTRL_H__784A5F0E_B881_4660_BAA6_CF1333DD1626__INCLUDED_)
#define AFX_CTERRABILLINGCTRL_CIRCULARQUEUECTRL_H__784A5F0E_B881_4660_BAA6_CF1333DD1626__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "tagAddBill.h"
class CTerraBillingCtrl_CircularQueueCtrl
{
protected:
BOOL m_bOK;
struct tagAddBillPacket* m_pBuffer;
int m_Number;
int m_ReadIdx;
int m_WriteIdx;
CRITICAL_SECTION m_critcalsection;
private:
BOOL Init(const int Number);
protected:
inline BOOL isEmpty(void) const;
inline BOOL isFull(void) const;
public:
BOOL isOK(void) const;
BOOL Push(const struct tagAddBillPacket* pData);
BOOL Pop(struct tagAddBillPacket& Data);
void Clear(void);
public:
CTerraBillingCtrl_CircularQueueCtrl(const int Number);
virtual ~CTerraBillingCtrl_CircularQueueCtrl();
};
#endif
| C++ |
#include "../../Global.h"
#include "CTerraBillingCtrl_Decoder.h"
#include "tagAddBill.h"
#include "CTerraBillingCtrl_Encoder.h"
extern CTerraBillingCtrl_Encoder* gcpTerraBillingCtrl_Encder;
#ifdef _MASTER_SERVER
#endif
CTerraBillingCtrl_Decoder::CTerraBillingCtrl_Decoder()
{
m_bOK=FALSE;
m_bOK=TRUE;
}
CTerraBillingCtrl_Decoder::~CTerraBillingCtrl_Decoder()
{
}
BOOL CTerraBillingCtrl_Decoder::isOK(void) const
{
return m_bOK;
}
#ifdef _GAME_SERVER
inline playerCharacter_t* CTerraBillingCtrl_Decoder::GetPlayerRecodPointer(const struct tagAddBillPacket& Packet) const
{
char strIdx[tagAddBillPacket::maxbytes_session+1];
char strPlayerID[IDSTRING+1];
strncpy(strIdx,Packet.Session,tagAddBillPacket::maxbytes_session);
strIdx[tagAddBillPacket::maxbytes_session]=NULL;
strncpy(strPlayerID,Packet.User_ID,IDSTRING);
strPlayerID[IDSTRING]=NULL;
int Idx=atoi(strIdx);
if(Idx < 0) return NULL;
if(Idx > MAX_PCS) return NULL;
playerCharacter_t* pPlayerRecord=&g_pc[Idx];
if(FALSE == pPlayerRecord->active) return NULL;
if(FALSE == pPlayerRecord->ready) return NULL;
if(0 != strcmp(strPlayerID,pPlayerRecord->userID)) return NULL;
return pPlayerRecord;
}
#endif
#ifdef _GAME_SERVER
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);
}
#endif
#ifdef _GAME_SERVER
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);
}
#endif
#ifdef _GAME_SERVER
void CTerraBillingCtrl_Decoder::
Transmite_TerraGCPacket_OpenMessageBox(
playerCharacter_t* pToPlayerRecord,
enum tagTerraGCPacket_OpenMessageBox::enumLPACKType LPACKType,
const int LPACKIdx,
enum tagTerraGCPacket_OpenMessageBox::enumAfter after) const
{
MSG_BeginWriting(&netMessage);
MSG_Clear(&netMessage);
{
MSG_WriteByte(&netMessage, GSC_EXTEND);
MSG_WriteByte(&netMessage, GSC_EXTEND_TERRA);
MSG_WriteByte(&netMessage, tagTerraGCPacket::Open_MessageBox);
MSG_WriteByte(&netMessage, LPACKType);
MSG_WriteByte(&netMessage, LPACKIdx);
MSG_WriteByte(&netMessage, after);
NET_SendMessage(&pToPlayerRecord->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
#endif
#ifdef _GAME_SERVER
inline void CTerraBillingCtrl_Decoder::
Decoder_game_start(const struct tagAddBillPacket& Packet) const
{
playerCharacter_t* pPlayerRecord=GetPlayerRecodPointer(Packet);
if(NULL == pPlayerRecord){
gcpTerraBillingCtrl_Encder->Transmite_Game_End(Packet);
return;
}
switch(ntohl(Packet.Packet_Result)){
case tagAddBillPacket_Game_Start::enumResult::success:
pPlayerRecord->AddBill.step = playerCharacter_t::tagAddBill::step_billing;
break;
case tagAddBillPacket_Game_Start::enumResult::already_connected:
Transmite_TerraGCPacket_OpenMessageBox(
pPlayerRecord,
tagTerraGCPacket_OpenMessageBox::enumLPACKType::Billing,
1,
tagTerraGCPacket_OpenMessageBox::enumAfter::after_client_exit);
GTH_DisconnectGameServer(pPlayerRecord->idx);
break;
case tagAddBillPacket_Game_Start::enumResult::illegal_user:
case tagAddBillPacket_Game_Start::enumResult::shortage_point:
case tagAddBillPacket_Game_Start::enumResult::not_exist_authorization:
Transmite_TerraGCPacket_OpenMessageBox(
pPlayerRecord,
tagTerraGCPacket_OpenMessageBox::enumLPACKType::Billing,
2,
tagTerraGCPacket_OpenMessageBox::enumAfter::after_client_exit);
GTH_DisconnectGameServer(pPlayerRecord->idx);
break;
case tagAddBillPacket_Game_Start::enumResult::access_deny_db:
case tagAddBillPacket_Game_Start::enumResult::network_error:
case tagAddBillPacket_Game_Start::enumResult::not_exist_session:
case tagAddBillPacket_Game_Start::enumResult::unknown_packet:
case tagAddBillPacket_Game_Start::enumResult::error_com:
case tagAddBillPacket_Game_Start::enumResult::error_timeout_response_billserver:
case tagAddBillPacket_Game_Start::enumResult::connect_fail_billingDB:
case tagAddBillPacket_Game_Start::enumResult::unknown_game_no:
case tagAddBillPacket_Game_Start::enumResult::error_billing_account_service_module:
case tagAddBillPacket_Game_Start::enumResult::not_exist_authorization_this_game:
case tagAddBillPacket_Game_Start::enumResult::error_busy:
case tagAddBillPacket_Game_Start::enumResult::unknown:
case tagAddBillPacket_Game_Start::enumResult::com_error_when_ip_check:
case tagAddBillPacket_Game_Start::enumResult::not_enougf_service_provider:
case tagAddBillPacket_Game_Start::enumResult::com_error_when_authorization_key_check:
case tagAddBillPacket_Game_Start::enumResult::not_found_authorization_key:
default:
Transmite_TerraGCPacket_OpenMessageBox(
pPlayerRecord,
tagTerraGCPacket_OpenMessageBox::enumLPACKType::Billing,
3,
tagTerraGCPacket_OpenMessageBox::enumAfter::after_client_exit);
GTH_DisconnectGameServer(pPlayerRecord->idx);
break;
}
}
#endif
#ifdef _GAME_SERVER
inline void CTerraBillingCtrl_Decoder::
Decoder_user_sync(const struct tagAddBillPacket& Packet) const
{
playerCharacter_t* pPlayerRecord=GetPlayerRecodPointer(Packet);
if(NULL == pPlayerRecord){
gcpTerraBillingCtrl_Encder->Transmite_User_Sync(Packet);
return;
}
gcpTerraBillingCtrl_Encder->Transmite_User_Sync(pPlayerRecord);
}
#endif
#ifdef _GAME_SERVER
inline void CTerraBillingCtrl_Decoder::
Decoder_user_alert(const struct tagAddBillPacket& Packet) const
{
static char message[_MAX_PATH];
playerCharacter_t* pPlayerRecord=GetPlayerRecodPointer(Packet);
if(NULL == pPlayerRecord) return;
switch(ntohl(Packet.Packet_Result)){
case tagAddBillPacket_User_Alert::enumResult::remain_time:
Transmite_TerraGCPacket_Remain_Minute_NoticeMessage(
pPlayerRecord,
ntohl(Packet.Bill_Remain));
return;
case tagAddBillPacket_User_Alert::enumResult::now_log_off:
Transmite_TerraGCPacket_OpenMessageBox(
pPlayerRecord,
tagTerraGCPacket_OpenMessageBox::enumLPACKType::Billing,
4,
tagTerraGCPacket_OpenMessageBox::enumAfter::after_client_exit);
GTH_DisconnectGameServer(pPlayerRecord->idx);
return;
case tagAddBillPacket_User_Alert::enumResult::refund:
Transmite_TerraGCPacket_OpenMessageBox(
pPlayerRecord,
tagTerraGCPacket_OpenMessageBox::enumLPACKType::Billing,
5,
tagTerraGCPacket_OpenMessageBox::enumAfter::after_client_exit);
GTH_DisconnectGameServer(pPlayerRecord->idx);
return;
case tagAddBillPacket_User_Alert::enumResult::double_login:
Transmite_TerraGCPacket_OpenMessageBox(
pPlayerRecord,
tagTerraGCPacket_OpenMessageBox::enumLPACKType::Billing,
1,
tagTerraGCPacket_OpenMessageBox::enumAfter::after_client_exit);
GTH_DisconnectGameServer(pPlayerRecord->idx);
return;
case tagAddBillPacket_User_Alert::enumResult::force_exit:
Transmite_TerraGCPacket_OpenMessageBox(
pPlayerRecord,
tagTerraGCPacket_OpenMessageBox::enumLPACKType::Billing,
6,
tagTerraGCPacket_OpenMessageBox::enumAfter::after_client_exit);
GTH_DisconnectGameServer(pPlayerRecord->idx);
return;
case tagAddBillPacket_User_Alert::enumResult::start_reserved_bill:
Transmite_TerraGCPacket_NoticeMessage(
pPlayerRecord,
tagTerraGCPacket_NoticeMessage::enumLPACKType::Billing,
7);
return;
}
}
#endif
inline void CTerraBillingCtrl_Decoder::
Decoder_server_alive(const struct tagAddBillPacket& ) const
{
}
void CTerraBillingCtrl_Decoder::Decoder(const struct tagAddBillPacket& Packet)
{
switch(ntohl(Packet.Packet_Type)){
case tagAddBillPacket::packet_type_server_alive:
Decoder_server_alive(Packet);
break;
#ifdef _GAME_SERVER
case tagAddBillPacket::packet_type_user_alert:
Decoder_user_alert(Packet);
break;
case tagAddBillPacket::packet_type_user_sync:
Decoder_user_sync(Packet);
break;
case tagAddBillPacket::packet_type_game_start:
Decoder_game_start(Packet);
break;
#endif
#ifdef _MASTER_SERVER
case tagAddBillPacket::packet_type_billing_authorization:
Decoder_billing_authorization(Packet);
break;
#endif
}
}
#ifdef _MASTER_SERVER
inline i3client_t* CTerraBillingCtrl_Decoder::GetPlayerRecodPointer(const struct tagAddBillPacket& Packet) const
{
char strIdx[tagAddBillPacket::maxbytes_session+1];
char strPlayerID[IDSTRING+1];
strncpy(strIdx,Packet.Session,tagAddBillPacket::maxbytes_session);
strIdx[tagAddBillPacket::maxbytes_session]=NULL;
if(NULL != strchr(strIdx,'-')) *strchr(strIdx,'-')=NULL;
int Idx=atoi(strIdx);
if(Idx < 0) return NULL;
if(Idx > MAX_CLIENTS) return NULL;
strncpy(strPlayerID,Packet.User_ID,IDSTRING);
strPlayerID[IDSTRING]=NULL;
i3client_t* pPlayerRecord=&g_clients[Idx];
if(!pPlayerRecord->active) return NULL;
if(0 != strcmp(strPlayerID,pPlayerRecord->id)) return NULL;
return pPlayerRecord;
};
#endif
#ifdef _MASTER_SERVER
inline void CTerraBillingCtrl_Decoder::Decoder_billing_authorization(const struct tagAddBillPacket& Packet) const
{
i3client_t* pPlayerRecord = GetPlayerRecodPointer(Packet);
if(NULL == pPlayerRecord){
return;
}
int result=ntohl(Packet.Packet_Result);
switch(result){
case tagAddBillPacket::enumResult_billing_authorization::network_error:
GTH_ReplyLoginV2(pPlayerRecord,FALSE,tagMCPaket_MSC_REPLYLOGIN::enumError::billing_network_error);
return;
case tagAddBillPacket::enumResult_billing_authorization::success:
GTH_ReplyLoginV2(pPlayerRecord,TRUE,tagMCPaket_MSC_REPLYLOGIN::enumError::none);
g_DBAccountServer->InsertLogin(pPlayerRecord);
return;
case tagAddBillPacket::enumResult_billing_authorization::already_connected:
GTH_ReplyLoginV2(pPlayerRecord,FALSE,tagMCPaket_MSC_REPLYLOGIN::enumError::double_login);
return;
case tagAddBillPacket::enumResult_billing_authorization::illegal_user:
case tagAddBillPacket::enumResult_billing_authorization::shortage_point:
case tagAddBillPacket::enumResult_billing_authorization::not_exist_authorization:
GTH_ReplyLoginV2(pPlayerRecord,FALSE,tagMCPaket_MSC_REPLYLOGIN::enumError::billing_point_not_enough);
return;
case tagAddBillPacket::enumResult_billing_authorization::access_deny_db:
case tagAddBillPacket::enumResult_billing_authorization::not_exist_session:
case tagAddBillPacket::enumResult_billing_authorization::unknown_packet:
case tagAddBillPacket::enumResult_billing_authorization::error_com:
case tagAddBillPacket::enumResult_billing_authorization::error_timeout_response_billserver:
case tagAddBillPacket::enumResult_billing_authorization::connect_fail_billingDB:
case tagAddBillPacket::enumResult_billing_authorization::unknown_game_no:
case tagAddBillPacket::enumResult_billing_authorization::error_billing_account_service_module:
case tagAddBillPacket::enumResult_billing_authorization::not_exist_authorization_this_game:
case tagAddBillPacket::enumResult_billing_authorization::error_busy:
case tagAddBillPacket::enumResult_billing_authorization::unknown:
case tagAddBillPacket::enumResult_billing_authorization::com_error_when_ip_check:
case tagAddBillPacket::enumResult_billing_authorization::not_enougf_service_provider:
case tagAddBillPacket::enumResult_billing_authorization::com_error_when_authorization_key_check:
case tagAddBillPacket::enumResult_billing_authorization::not_found_authorization_key:
break;
}
GTH_ReplyLoginV2(pPlayerRecord,FALSE,tagMCPaket_MSC_REPLYLOGIN::enumError::unknown);
return;
}
#endif
| C++ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.