376 lines
11 KiB
C++
376 lines
11 KiB
C++
#pragma once
|
|
|
|
#define WISE_CLIENT_VERSION "ver2.0"
|
|
#define WISE_CLIENT_BUILD_VERSION "0010"
|
|
|
|
#include "LogicFlowDef.h"
|
|
|
|
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
|
|
// <TYPE DEFINITIONs>
|
|
enum eCONNECT_SESSIONS
|
|
{
|
|
AGENT_SESSION,
|
|
WORLD_SESSION,
|
|
LOGIN_FRONT_SESSION,
|
|
MAX_SESSION,
|
|
};
|
|
|
|
//----------------------------------------------------------------------------|
|
|
typedef PVOID PASSING_ARG;
|
|
//----------------------------------------------------------------------------|
|
|
#define DECL_SIG_WISEMSG_T static const eSIG_TYPE
|
|
#define DECL_SIG_WISEMSG_VT(val) ((eSIG_TYPE)(SIGMSG_NORMAL+(val)))
|
|
|
|
#define DECL_SIG_SUB_T static const eWISESUBTYPE
|
|
#define DECL_SIG_SUB_VT(val) ((eWISESUBTYPE)(WISESUBTYPE_EMPTY+(val)))
|
|
|
|
#define DECL_SIG_DATA_T static const DWORD
|
|
#define DECL_SIG_DATA_VT(val) (DWORD)(val)
|
|
#define DECL_SIG_DATA_SIZE_VT(val) (DWORD)(sizeof(val))
|
|
|
|
#define DEF_SIGBUFFER_SIZE (2000)
|
|
//----------------------------------------------------------------------------|
|
|
//
|
|
struct eSIG_WISEMSG
|
|
{
|
|
DECL_SIG_WISEMSG_T EMPTY = DECL_SIG_WISEMSG_VT(100);
|
|
DECL_SIG_WISEMSG_T NOTIFY_SIGNAL = DECL_SIG_WISEMSG_VT(102);
|
|
DECL_SIG_WISEMSG_T NETMSG_SIGNAL = DECL_SIG_WISEMSG_VT(103);
|
|
DECL_SIG_WISEMSG_T NETMSG_SIGNAL_EX = DECL_SIG_WISEMSG_VT(104);
|
|
|
|
DECL_SIG_WISEMSG_T LF_BASE_CMD = DECL_SIG_WISEMSG_VT(120);
|
|
DECL_SIG_WISEMSG_T LF_MAIN_CMD = DECL_SIG_WISEMSG_VT(121);
|
|
DECL_SIG_WISEMSG_T LF_SUB_CMD = DECL_SIG_WISEMSG_VT(122);
|
|
|
|
DECL_SIG_WISEMSG_T GAMEOBJ_CONTROL = DECL_SIG_WISEMSG_VT(130);
|
|
};
|
|
//----------------------------------------------------------------------------|
|
|
//
|
|
enum eWISESUBTYPE { WISESUBTYPE_EMPTY = 0x100, };
|
|
|
|
|
|
class WiseUser;
|
|
class ServerSession;
|
|
|
|
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
|
|
// <sSIG_WISEBASE>
|
|
// WiseClientV2에서 사용하는 기본 Signal Type
|
|
struct sSIG_WISEBASE : sSIG_MSG
|
|
{
|
|
sSIG_WISEBASE(eSIG_TYPE eSIGTYPE) : _SUBTYPE(WISESUBTYPE_EMPTY) { _TYPE = eSIGTYPE; }
|
|
inline eSIG_TYPE SIGTYPE() { return _TYPE; }
|
|
inline eWISESUBTYPE& SUBTYPE() { return _SUBTYPE; }
|
|
|
|
// <FIELD>
|
|
eWISESUBTYPE _SUBTYPE;
|
|
};
|
|
|
|
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
|
|
// <sSIG_NOTIFY>
|
|
// WiseClient의 내부 메시지 교환 수단은 이것을 사용한다.
|
|
// 통보하는 시그널이며, 세션의 끊기고 연결되는 신호나 Network Msg의 송수신,
|
|
// 객체 소멸등을 통보하는데 사용한다.
|
|
struct sSIG_NOTIFY : sSIG_WISEBASE
|
|
{
|
|
struct {
|
|
DECL_SIG_SUB_T NTF_NO_TYPE = WISESUBTYPE_EMPTY;
|
|
DECL_SIG_SUB_T NTF_SESSION_ON_CONNECTED_LOGINFRONT = DECL_SIG_SUB_VT(110);
|
|
DECL_SIG_SUB_T NTF_SESSION_ON_CONNECTED_AGENTSERVER = DECL_SIG_SUB_VT(111);
|
|
DECL_SIG_SUB_T NTF_SESSION_ON_CONNECTED_WORLDSERVER = DECL_SIG_SUB_VT(112);
|
|
DECL_SIG_SUB_T NTF_SESSION_ON_DISCONNECTED_LOGINFRONT = DECL_SIG_SUB_VT(113);
|
|
DECL_SIG_SUB_T NTF_SESSION_ON_DISCONNECTED_AGENTSERVER = DECL_SIG_SUB_VT(114);
|
|
DECL_SIG_SUB_T NTF_SESSION_ON_DISCONNECTED_WORLDSERVER = DECL_SIG_SUB_VT(115);
|
|
DECL_SIG_SUB_T SENDMSG = DECL_SIG_SUB_VT(120);
|
|
DECL_SIG_SUB_T RECVMSG = DECL_SIG_SUB_VT(121);
|
|
DECL_SIG_SUB_T NTF_USER_RELEASED = DECL_SIG_SUB_VT(200);
|
|
};
|
|
|
|
sSIG_NOTIFY() : sSIG_WISEBASE(eSIG_WISEMSG::NOTIFY_SIGNAL) {}
|
|
|
|
inline WiseUser*& USER() { return m_pUser; }
|
|
// <FIELD>
|
|
WiseUser* m_pUser;
|
|
};
|
|
|
|
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
|
|
// <sSIG_NETMSG>
|
|
// 연속된 데이터 스트림 처리용, 그냥 변수 추가도 허용될 것이다.
|
|
struct sSIG_NETMSG : sSIG_NOTIFY
|
|
{
|
|
sSIG_NETMSG() : sSIG_NOTIFY() { _TYPE = eSIG_WISEMSG::NETMSG_SIGNAL; }
|
|
|
|
inline ServerSession*& SESSION_PTR() { return m_pSESSION; }
|
|
inline BYTE*& MSG_HDR() { return m_pMSG_HDR; }
|
|
inline WORD& MSG_LEN() { return m_wMSG_LEN; }
|
|
|
|
template<typename _TY>
|
|
inline _TY& MsgTypeOf() { return *(_TY*)m_pMSG_HDR; }
|
|
|
|
ServerSession* m_pSESSION;
|
|
BYTE* m_pMSG_HDR;
|
|
WORD m_wMSG_LEN;
|
|
};
|
|
|
|
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
|
|
// <sSIG_NETMSG>
|
|
// 연속된 데이터 스트림 처리용, 그냥 변수 추가도 허용될 것이다.
|
|
enum eWISE_OBJECT_INDEX;
|
|
|
|
struct sSIG_OBJCTRL : sSIG_WISEBASE
|
|
{
|
|
sSIG_OBJCTRL() : sSIG_WISEBASE(eSIG_WISEMSG::GAMEOBJ_CONTROL) { ; }
|
|
|
|
struct {
|
|
//DECL_SIG_SUB_T OBJ_NONE = WISESUBTYPE_EMPTY;
|
|
//DECL_SIG_SUB_T OBJ_USER = DECL_SIG_SUB_VT(110);
|
|
//DECL_SIG_SUB_T OBJ_PLAYER = DECL_SIG_SUB_VT(111);
|
|
//DECL_SIG_SUB_T OBJ_MONSTER = DECL_SIG_SUB_VT(112);
|
|
|
|
DECL_SIG_SUB_T ST_NONE = WISESUBTYPE_EMPTY;
|
|
DECL_SIG_SUB_T ST_RENDERINFO = DECL_SIG_SUB_VT(199);
|
|
DECL_SIG_SUB_T ST_ENTER = DECL_SIG_SUB_VT(200);
|
|
DECL_SIG_SUB_T ST_LEAVE = DECL_SIG_SUB_VT(201);
|
|
DECL_SIG_SUB_T ST_MOVE = DECL_SIG_SUB_VT(202);
|
|
DECL_SIG_SUB_T ST_ATTACK = DECL_SIG_SUB_VT(203);
|
|
DECL_SIG_SUB_T ST_STATUS = DECL_SIG_SUB_VT(204);
|
|
};
|
|
|
|
inline eWISE_OBJECT_INDEX& OBJTYPE() { return _OBJTYPE; }
|
|
inline DWORD& OBJECT_KEY() { return m_dwObjectKey; }
|
|
inline BYTE*& MSG_HDR() { return m_pMSG_HDR; }
|
|
inline WORD& MSG_LEN() { return m_wMSG_LEN; }
|
|
|
|
template<typename _TY>
|
|
inline _TY& MsgTypeOf() { return *(_TY*)m_pMSG_HDR; }
|
|
|
|
eWISE_OBJECT_INDEX _OBJTYPE;
|
|
DWORD m_dwObjectKey;
|
|
BYTE* m_pMSG_HDR;
|
|
WORD m_wMSG_LEN;
|
|
};
|
|
|
|
|
|
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
|
|
// <sSIG_NETMSG_WITH_BUFFER>
|
|
// 별도의 버퍼 정보를 사용하는 Network Msg를 위한 것이지만,
|
|
// 아직 사용방법이 확정되지 않았다.
|
|
struct sSIG_NETMSG_WITH_BUFFER : sSIG_NETMSG
|
|
{
|
|
sSIG_NETMSG_WITH_BUFFER() : sSIG_NETMSG() { _TYPE = eSIG_WISEMSG::NETMSG_SIGNAL_EX; }
|
|
|
|
template<typename _TY>
|
|
inline _TY& TypeOf() { return *(_TY*)STREAM_HDR; }
|
|
|
|
template<typename _TY>
|
|
inline _TY& InstanceOf()
|
|
{
|
|
_TY* pTYPE = new (STREAM_HDR) _TY;
|
|
return *pTYPE;
|
|
}
|
|
|
|
BYTE STREAM_HDR[DEF_SIGBUFFER_SIZE];
|
|
};
|
|
|
|
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
|
|
// <sSIGDATA_JUMPSTEP_WITH_ARG>
|
|
// 아직 사용방법이 확정되지 않았다. 데유까, sSIG_STEP에 포함시켰다.
|
|
struct sSIGDATA_JUMPSTEP_WITH_ARG
|
|
{
|
|
LF_DEFINE STEP;
|
|
WORD EXTEND_SIZE;
|
|
sSIG_MSG SIGNAL;
|
|
|
|
template<typename _TY>
|
|
inline _TY& TypeOf() { return *(_TY*)&SIGNAL; }
|
|
|
|
BYTE STREAM_HDR[DEF_SIGBUFFER_SIZE];
|
|
};
|
|
|
|
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
|
|
// <sSIG_LF_MAIN>
|
|
// Active Logic Flow에서 수신해서 사용하는 시그널, STEP 컨트롤에 사용하는
|
|
// sSIG_STEP과 동일하다.
|
|
struct sSIG_LF_MAIN : sSIG_WISEBASE
|
|
{
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// (TYPE)
|
|
struct {
|
|
DECL_SIG_SUB_T NO_TYPE = DECL_SIG_SUB_VT(100);
|
|
DECL_SIG_SUB_T UPDATE = DECL_SIG_SUB_VT(101);
|
|
DECL_SIG_SUB_T ACTIVATE_NEXT_STEP = DECL_SIG_SUB_VT(111);
|
|
DECL_SIG_SUB_T ACTIVATE_JUMP_STEP = DECL_SIG_SUB_VT(112);
|
|
DECL_SIG_SUB_T ACTIVATE_NEXT_STEP_WITH_ARG = DECL_SIG_SUB_VT(113);
|
|
DECL_SIG_SUB_T ACTIVATE_JUMP_STEP_WITH_ARG = DECL_SIG_SUB_VT(114);
|
|
DECL_SIG_SUB_T CLOSURE_STEP = DECL_SIG_SUB_VT(119);
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// (TYPE FORMAT)
|
|
// ACTIVATE_NEXT_STEP (NULL)
|
|
// ACTIVATE_JUMP_STEP (LF_DEFINE)
|
|
// ACTIVATE_NEXT_STEP_WITH_ARG (not defined)
|
|
// ACTIVATE_JUMP_STEP_WITH_ARG (not defined)
|
|
struct {
|
|
DECL_SIG_DATA_T ACTIVATE_JUMP_STEP_DATA = DECL_SIG_DATA_SIZE_VT(LF_DEFINE);
|
|
};
|
|
|
|
sSIG_LF_MAIN() : sSIG_WISEBASE(eSIG_WISEMSG::LF_MAIN_CMD)
|
|
{ ; }
|
|
|
|
template<typename _TY>
|
|
inline _TY& TypeOf() { return *(_TY*)STREAM_HDR; }
|
|
|
|
template<typename _TY>
|
|
inline _TY& InstanceOf()
|
|
{
|
|
_TY* pTYPE = new (STREAM_HDR) _TY;
|
|
return *pTYPE;
|
|
}
|
|
|
|
BYTE STREAM_HDR[DEF_SIGBUFFER_SIZE];
|
|
};
|
|
|
|
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
|
|
// <sSIG_STEP>
|
|
// sSIG_LF_MAIN 과 동일
|
|
struct sSIG_STEP : sSIG_LF_MAIN
|
|
{
|
|
sSIG_STEP() : sSIG_LF_MAIN()
|
|
{ _TYPE = eSIG_WISEMSG::LF_MAIN_CMD; }
|
|
};
|
|
|
|
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
|
|
// <sSIG_LF_BASE>
|
|
// sSIG_LF_MAIN 과 유사한 성격을 가지는 시그널이지만, 사용하지 않는다.
|
|
struct sSIG_LF_BASE : sSIG_LF_MAIN
|
|
{
|
|
sSIG_LF_BASE() : sSIG_LF_MAIN()
|
|
{ _TYPE = eSIG_WISEMSG::LF_BASE_CMD; }
|
|
};
|
|
|
|
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
|
|
// <sSIG_LF_SUB>
|
|
// sSIG_LF_MAIN 과 유사한 성격을 가지는 시그널이지만, 사용하지 않는다.
|
|
struct sSIG_LF_SUB : sSIG_WISEBASE
|
|
{
|
|
struct {
|
|
DECL_SIG_SUB_T NO_TYPE = DECL_SIG_SUB_VT(100);
|
|
//DECL_SIG_SUB_T BEGIN_NUMBER = DECL_SIG_SUB_VT(200);
|
|
};
|
|
|
|
sSIG_LF_SUB() : sSIG_WISEBASE(eSIG_WISEMSG::LF_SUB_CMD)
|
|
{ ; }
|
|
|
|
template<typename _TY>
|
|
inline _TY& TypeOf() { return *(_TY*)STREAM_HDR; }
|
|
|
|
template<typename _TY>
|
|
inline _TY& InstanceOf()
|
|
{
|
|
_TY* pTYPE = new (STREAM_HDR) _TY;
|
|
return *pTYPE;
|
|
}
|
|
|
|
BYTE STREAM_HDR[DEF_SIGBUFFER_SIZE];
|
|
};
|
|
|
|
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
|
|
// <sSIG_STEP_ARG_BUFBLK> - <NOT USED>
|
|
// sSIG_STEP_ARG를 내포하기 위한 버퍼 공간
|
|
struct sSIG_STEP_ARG_BUFBLK
|
|
{
|
|
struct
|
|
{
|
|
LF_GROUP_DEFINE GROUP; // Active Logic Flow 종류, (ACTIVATE_NEXT_STEP)
|
|
LF_DEFINE STEP; // 이동한 단계 (ACTIVATE_JUMP_STEP)
|
|
WORD ADDIN_S; // 추가 정보 여부 (ARGUMENT) 없는 경우 0
|
|
} HDR;
|
|
|
|
BYTE STREAM[DEF_SIGBUFFER_SIZE];
|
|
};
|
|
|
|
//━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
|
|
// <sSIG_STEP_ARG>
|
|
// sSIG_STEP에서 추가 인자로 사용하는 것으로, 패킷 수신등을 했을 경우
|
|
// Active Logic Flow에 이 상황을 알리거나 추가 처리가 가능하도록
|
|
// 필요한 정보들을 담게 된다.
|
|
struct sSIG_STEP_ARG
|
|
{
|
|
enum eADDIN_S { EMPTY_ARG = 0, };
|
|
LF_GROUP_DEFINE GROUP; // Active Logic Flow 종류, (ACTIVATE_NEXT_STEP)
|
|
LF_DEFINE STEP; // 이동한 단계 (ACTIVATE_JUMP_STEP)
|
|
WORD ADDIN_S; // 추가 정보 여부 (ARGUMENT) 없는 경우 0
|
|
BYTE ARG[1]; // ADDIN_B == TRUE시 입력되어야 할 ARG의 삽입위치
|
|
|
|
sSIG_STEP_ARG() {}
|
|
~sSIG_STEP_ARG() {}
|
|
|
|
void SetInfo(
|
|
LF_GROUP_DEFINE IN setGROUP,
|
|
LF_DEFINE IN setSTEP,
|
|
WORD IN setARG_SIZE = 0,
|
|
BYTE* IN setARG_BLK = NULL
|
|
)
|
|
{
|
|
GROUP = setGROUP;
|
|
STEP = setSTEP;
|
|
if(setARG_SIZE && !(setARG_SIZE > DEF_SIGBUFFER_SIZE) && setARG_BLK)
|
|
{
|
|
ADDIN_S = setARG_SIZE;
|
|
CopyMemory(ARG, setARG_BLK, ADDIN_S);
|
|
}
|
|
ADDIN_S = 0;
|
|
*(DWORD*)ARG = 0;
|
|
}
|
|
|
|
template<typename _TY>
|
|
inline _TY& TypeOfArg() { return *(_TY*)ARG; }
|
|
|
|
BOOL CopyArgFrom(sSIG_STEP_ARG* IN pARG)
|
|
{
|
|
WORD& rADDIN_S = pARG->ADDIN_S;
|
|
if(pARG && !(rADDIN_S > DEF_SIGBUFFER_SIZE))
|
|
{
|
|
if(rADDIN_S)
|
|
{
|
|
CopyMemory(ARG, pARG->ARG, rADDIN_S);
|
|
ADDIN_S = rADDIN_S;
|
|
return TRUE;
|
|
}
|
|
|
|
*(DWORD*)ARG = 0;
|
|
ADDIN_S = 0;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL CopyArgFrom(BYTE* pARGBLK, WORD wSize)
|
|
{
|
|
WORD rADDIN_S = wSize;
|
|
if(pARGBLK && !(rADDIN_S > DEF_SIGBUFFER_SIZE))
|
|
{
|
|
if(rADDIN_S)
|
|
{
|
|
CopyMemory(ARG, pARGBLK, rADDIN_S);
|
|
ADDIN_S = rADDIN_S;
|
|
return TRUE;
|
|
}
|
|
|
|
*(DWORD*)ARG = 0;
|
|
ADDIN_S = 0;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
#include "WiseMsgBuffer.h"
|
|
//
|
|
#include "WiseAutoPlayAction.h"
|
|
|
|
|
|
|