Biri bana yardım edebilir mi lütfen?

[A]Demonul · 31 May 2020

#include "StdAfx.h"
#include "PythonNetworkStream.h"
#include "PythonNetworkDatagram.h"
#include "AccountConnector.h"
#include "PythonGuild.h"
#include "Test.h"

#include "AbstractPlayer.h"

static std::string gs_stServerInfo;
extern BOOL gs_bEmpireLanuageEnable;
std::list<std::string> g_kList_strCommand;

PyObject* netGetBettingGuildWarValue(PyObject* poSelf, PyObject* poArgs)
{
char* szName;
if (!PyTuple_GetString(poArgs, 0, &szName))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
return Py_BuildValue("i", rkNetStream.EXPORT_GetBettingGuildWarValue(szName));
}

PyObject* netSetServerInfo(PyObject* poSelf, PyObject* poArgs)
{
char* szFileName;
if (!PyTuple_GetString(poArgs, 0, &szFileName))
return Py_BuildException();

gs_stServerInfo=szFileName;
return Py_BuildNone();
}

PyObject* netGetServerInfo(PyObject* poSelf, PyObject* poArgs)
{
return Py_BuildValue("s", gs_stServerInfo.c_str());
}

PyObject* netPreserveServerCommand(PyObject* poSelf, PyObject* poArgs)
{
char* szLine;
if (!PyTuple_GetString(poArgs, 0, &szLine))
return Py_BuildException();

g_kList_strCommand.push_back(szLine);

return Py_BuildNone();
}

PyObject* netGetPreservedServerCommand(PyObject* poSelf, PyObject* poArgs)
{
if (g_kList_strCommand.empty())
return Py_BuildValue("s", "");

std::string strCommand = g_kList_strCommand.front();
g_kList_strCommand.pop_front();

return Py_BuildValue("s", strCommand.c_str());
}

PyObject* netStartGame(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.StartGame();

return Py_BuildNone();
}

PyObject* netIsTest(PyObject* poSelf, PyObject* poArgs)
{
return Py_BuildValue("i", __IS_TEST_SERVER_MODE__);
}

PyObject* netWarp(PyObject* poSelf, PyObject* poArgs)
{
int nX;
if (!PyTuple_GetInteger(poArgs, 0, &nX))
return Py_BuildException();

int nY;
if (!PyTuple_GetInteger(poArgs, 1, &nY))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.Warp(nX, nY);

return Py_BuildNone();
}

PyObject* netLoadInsultList(PyObject* poSelf, PyObject* poArgs)
{
char* szFileName;
if (!PyTuple_GetString(poArgs, 0, &szFileName))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
return Py_BuildValue("i", rkNetStream.LoadInsultList(szFileName));
}

PyObject* netUploadMark(PyObject* poSelf, PyObject* poArgs)
{
char* szFileName;
if (!PyTuple_GetString(poArgs, 0, &szFileName))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
return Py_BuildValue("i", rkNetStream.UploadMark(szFileName));
}

PyObject* netUploadSymbol(PyObject* poSelf, PyObject* poArgs)
{
char* szFileName;
if (!PyTuple_GetString(poArgs, 0, &szFileName))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
return Py_BuildValue("i", rkNetStream.UploadSymbol(szFileName));
}

PyObject* netGetGuildID(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
return Py_BuildValue("i", rkNetStream.GetGuildID());
}

PyObject* netGetEmpireID(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
return Py_BuildValue("i", rkNetStream.GetEmpireID());
}

PyObject* netGetMainActorVID(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
return Py_BuildValue("i", rkNetStream.GetMainActorVID());
}

PyObject* netGetMainActorRace(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
return Py_BuildValue("i", rkNetStream.GetMainActorRace());
}

PyObject* netGetMainActorEmpire(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
return Py_BuildValue("i", rkNetStream.GetMainActorEmpire());
}

PyObject* netGetMainActorSkillGroup(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
return Py_BuildValue("i", rkNetStream.GetMainActorSkillGroup());
}

PyObject* netIsSelectedEmpire(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
return Py_BuildValue("i", rkNetStream.IsSelectedEmpire());
}

PyObject* netGetAccountCharacterSlotDataInteger(PyObject* poSelf, PyObject* poArgs)
{
int nIndex;
if (!PyTuple_GetInteger(poArgs, 0, &nIndex))
return Py_BuildException();

int nType;
if (!PyTuple_GetInteger(poArgs, 1, &nType))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
UINT uResult=rkNetStream.GetAccountCharacterSlotDatau(nIndex, nType);
return Py_BuildValue("i", uResult);
}

PyObject* netGetAccountCharacterSlotDataString(PyObject* poSelf, PyObject* poArgs)
{
int nIndex;
if (!PyTuple_GetInteger(poArgs, 0, &nIndex))
return Py_BuildException();

int nType;
if (!PyTuple_GetInteger(poArgs, 1, &nType))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
return Py_BuildValue("s", rkNetStream.GetAccountCharacterSlotDataz(nIndex, nType));
}

// SUPPORT_BGM
PyObject* netGetFieldMusicFileName(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
return Py_BuildValue("s", rkNetStream.GetFieldMusicFileName());
}

PyObject* netGetFieldMusicVolume(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
return Py_BuildValue("f", rkNetStream.GetFieldMusicVolume());
}
// END_OF_SUPPORT_BGM

PyObject* netSetPhaseWindow(PyObject* poSelf, PyObject* poArgs)
{
int ePhaseWnd;
if (!PyTuple_GetInteger(poArgs, 0, &ePhaseWnd))
return Py_BuildException();

PyObject* poPhaseWnd;
if (!PyTuple_GetObject(poArgs, 1, &poPhaseWnd))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SetPhaseWindow(ePhaseWnd, poPhaseWnd);
return Py_BuildNone();
}

PyObject* netClearPhaseWindow(PyObject* poSelf, PyObject* poArgs)
{
int ePhaseWnd;
if (!PyTuple_GetInteger(poArgs, 0, &ePhaseWnd))
return Py_BuildException();

PyObject* poPhaseWnd;
if (!PyTuple_GetObject(poArgs, 1, &poPhaseWnd))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.ClearPhaseWindow(ePhaseWnd, poPhaseWnd);
return Py_BuildNone();
}

PyObject* netSetServerCommandParserWindow(PyObject* poSelf, PyObject* poArgs)
{
PyObject* poPhaseWnd;
if (!PyTuple_GetObject(poArgs, 0, &poPhaseWnd))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SetServerCommandParserWindow(poPhaseWnd);
return Py_BuildNone();
}

PyObject* netSetAccountConnectorHandler(PyObject* poSelf, PyObject* poArgs)
{
PyObject* poPhaseWnd;
if (!PyTuple_GetObject(poArgs, 0, &poPhaseWnd))
return Py_BuildException();

CAccountConnector & rkAccountConnector = CAccountConnector::Instance();
rkAccountConnector.SetHandler(poPhaseWnd);
return Py_BuildNone();
}

PyObject* netSetHandler(PyObject* poSelf, PyObject* poArgs)
{
PyObject* poHandler;

if (!PyTuple_GetObject(poArgs, 0, &poHandler))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SetHandler(poHandler);
return Py_BuildNone();
}

PyObject* netSetTCPRecvBufferSize(PyObject* poSelf, PyObject* poArgs)
{
int bufSize;
if (!PyTuple_GetInteger(poArgs, 0, &bufSize))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SetRecvBufferSize(bufSize);
return Py_BuildNone();
}

PyObject* netSetTCPSendBufferSize(PyObject* poSelf, PyObject* poArgs)
{
int bufSize;
if (!PyTuple_GetInteger(poArgs, 0, &bufSize))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SetSendBufferSize(bufSize);
return Py_BuildNone();
}

PyObject* netSetUDPRecvBufferSize(PyObject* poSelf, PyObject* poArgs)
{
int bufSize;
if (!PyTuple_GetInteger(poArgs, 0, &bufSize))
return Py_BuildException();

//CPythonNetworkDatagram::Instance().SetRecvBufferSize(bufSize);
return Py_BuildNone();
}

PyObject* netSetMarkServer(PyObject* poSelf, PyObject* poArgs)
{
char* szAddr;
if (!PyTuple_GetString(poArgs, 0, &szAddr))
return Py_BuildException();

int port;
if (!PyTuple_GetInteger(poArgs, 1, &port))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SetMarkServer(szAddr, port);
return Py_BuildNone();
}

PyObject* netConnectTCP(PyObject* poSelf, PyObject* poArgs)
{
char* szAddr;
if (!PyTuple_GetString(poArgs, 0, &szAddr))
return Py_BuildException();

int port;
if (!PyTuple_GetInteger(poArgs, 1, &port))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.ConnectLoginServer(szAddr, port);
return Py_BuildNone();
}

PyObject* netConnectUDP(PyObject* poSelf, PyObject* poArgs)
{
char * c_szIP;
if (!PyTuple_GetString(poArgs, 0, &c_szIP))
return Py_BuildException();
int iPort;
if (!PyTuple_GetInteger(poArgs, 1, &iPort))
return Py_BuildException();

//CPythonNetworkDatagram::Instance().SetConnection(c_szIP, iPort);
return Py_BuildNone();
}

PyObject* netConnectToAccountServer(PyObject* poSelf, PyObject* poArgs)
{
char* addr;
if (!PyTuple_GetString(poArgs, 0, &addr))
return Py_BuildException();

int port;
if (!PyTuple_GetInteger(poArgs, 1, &port))
return Py_BuildException();

char* account_addr;
if (!PyTuple_GetString(poArgs, 2, &account_addr))
return Py_BuildException();

int account_port;
if (!PyTuple_GetInteger(poArgs, 3, &account_port))
return Py_BuildException();

CAccountConnector & rkAccountConnector = CAccountConnector::Instance();
rkAccountConnector.Connect(addr, port, account_addr, account_port);
return Py_BuildNone();
}

#ifdef ENABLE_SEND_TARGET_INFO
PyObject* netTargetInfoLoad(PyObject* poSelf, PyObject* poArgs)
{
DWORD dwVID;

if (!PyArg_ParseTuple(poArgs, "i", &dwVID))
{
return Py_BuildException();
}
if (dwVID < 0)
{
return Py_BuildNone();
}

CPythonNetworkStream& rns = CPythonNetworkStream::Instance();
rns.SendTargetInfoLoadPacket(dwVID);

return Py_BuildNone();
}
#endif

///////////////////////////////////////////////////////////////////////////////////////////////////

PyObject* netSetLoginInfo(PyObject* poSelf, PyObject* poArgs)
{
char* szName;
if (!PyTuple_GetString(poArgs, 0, &szName))
return Py_BuildException();

char* szPwd;
if (!PyTuple_GetString(poArgs, 1, &szPwd))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
CAccountConnector & rkAccountConnector = CAccountConnector::Instance();
rkNetStream.SetLoginInfo(szName, szPwd);
rkAccountConnector.SetLoginInfo(szName, szPwd);
return Py_BuildNone();
}

PyObject* netSetOfflinePhase(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SetOffLinePhase();
return Py_BuildNone();
}

PyObject* netSendSelectEmpirePacket(PyObject* poSelf, PyObject* poArgs)
{
int iEmpireIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iEmpireIndex))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendSelectEmpirePacket(iEmpireIndex);
return Py_BuildNone();
}

PyObject* netSendLoginPacket(PyObject* poSelf, PyObject* poArgs)
{
char* szName;
if (!PyTuple_GetString(poArgs, 0, &szName))
return Py_BuildException();

char* szPwd;
if (!PyTuple_GetString(poArgs, 1, &szPwd))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendLoginPacket(szName, szPwd);
return Py_BuildNone();
}

PyObject* netSendChinaMatrixCardPacket(PyObject* poSelf, PyObject* poArgs)
{
char* szMatrixCardString;
if (!PyTuple_GetString(poArgs, 0, &szMatrixCardString))
return Py_BuildException();

CAccountConnector & rkAccountConnector = CAccountConnector::Instance();
rkAccountConnector.SendChinaMatrixCardPacket(szMatrixCardString);
return Py_BuildNone();
}

PyObject* netSendRunupMatrixCardPacket(PyObject* poSelf, PyObject* poArgs)
{
char* szMatrixCardString;
if (!PyTuple_GetString(poArgs, 0, &szMatrixCardString))
return Py_BuildException();

CAccountConnector & rkAccountConnector = CAccountConnector::Instance();
rkAccountConnector.SendRunupMatrixCardPacket(szMatrixCardString);
return Py_BuildNone();
}

PyObject* netSendNEWCIBNPasspodAnswerPacket(PyObject* poSelf, PyObject* poArgs)
{
char* szMatrixCardString;
if (!PyTuple_GetString(poArgs, 0, &szMatrixCardString))
return Py_BuildException();

CAccountConnector & rkAccountConnector = CAccountConnector::Instance();
rkAccountConnector.SendNEWCIBNPasspodAnswerPacket(szMatrixCardString);
return Py_BuildNone();
}

PyObject* netDirectEnter(PyObject* poSelf, PyObject* poArgs)
{
int nChrSlot;
if (!PyTuple_GetInteger(poArgs, 0, &nChrSlot))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.ConnectGameServer(nChrSlot);
return Py_BuildNone();
}

PyObject* netSendSelectCharacterPacket(PyObject* poSelf, PyObject* poArgs)
{
int Index;
if (!PyTuple_GetInteger(poArgs, 0, &Index))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendSelectCharacterPacket((BYTE) Index);
return Py_BuildNone();
}

PyObject* netSendChangeNamePacket(PyObject* poSelf, PyObject* poArgs)
{
int iIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
return Py_BuildException();
char* szName;
if (!PyTuple_GetString(poArgs, 1, &szName))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendChangeNamePacket((BYTE)iIndex, szName);
return Py_BuildNone();
}

PyObject* netEnableChatInsultFilter(PyObject* poSelf, PyObject* poArgs)
{
int nEnable;
if (!PyTuple_GetInteger(poArgs, 0, &nEnable))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.EnableChatInsultFilter(nEnable ? true : false);
return Py_BuildNone();
}

PyObject* netIsChatInsultIn(PyObject* poSelf, PyObject* poArgs)
{
char* szMsg;
if (!PyTuple_GetString(poArgs, 0, &szMsg))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
return Py_BuildValue("i", rkNetStream.IsChatInsultIn(szMsg));
}

PyObject* netIsInsultIn(PyObject* poSelf, PyObject* poArgs)
{
char* szMsg;
if (!PyTuple_GetString(poArgs, 0, &szMsg))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
return Py_BuildValue("i", rkNetStream.IsInsultIn(szMsg));
}

PyObject* netSendWhisperPacket(PyObject* poSelf, PyObject* poArgs)
{
char* szName;
char* szLine;

if (!PyTuple_GetString(poArgs, 0, &szName))
return Py_BuildException();

if (!PyTuple_GetString(poArgs, 1, &szLine))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendWhisperPacket(szName, szLine);
return Py_BuildNone();
}
#ifdef OFFLINE_MESSAGE
PyObject* netSendOfflineMessagePacket(PyObject* poSelf, PyObject* poArgs)
{
char* szName;
char* szMsg;

if (!PyTuple_GetString(poArgs, 0, &szName))
return Py_BuildException();

if (!PyTuple_GetString(poArgs, 1, &szMsg))
return Py_BuildException();

CPythonNetworkStream& rkNetStream = CPythonNetworkStream::Instance();
rkNetStream.SendOfflineMessagePacket(szName, szMsg);
return Py_BuildNone();
}
#endif
PyObject* netSendMobileMessagePacket(PyObject* poSelf, PyObject* poArgs)
{
char* szName;
char* szLine;
if (!PyTuple_GetString(poArgs, 0, &szName))
return Py_BuildException();

if (!PyTuple_GetString(poArgs, 1, &szLine))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendMobileMessagePacket(szName, szLine);
return Py_BuildNone();
}

PyObject* netSendCharacterPositionPacket(PyObject* poSelf, PyObject* poArgs)
{
int iPosition;
if (!PyTuple_GetInteger(poArgs, 0, &iPosition))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendCharacterPositionPacket((BYTE) iPosition);
return Py_BuildNone();
}

PyObject* netSendChatPacket(PyObject* poSelf, PyObject* poArgs)
{
char* szLine;
if (!PyTuple_GetString(poArgs, 0, &szLine))
return Py_BuildException();
int iType;
if (!PyTuple_GetInteger(poArgs, 1, &iType))
{
iType = CHAT_TYPE_TALKING;
}

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendChatPacket(szLine, iType);
return Py_BuildNone();
}

PyObject* netSendEmoticon(PyObject* poSelf, PyObject* poArgs)
{
int eEmoticon;
if (!PyTuple_GetInteger(poArgs, 0, &eEmoticon))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendEmoticon(eEmoticon);
return Py_BuildNone();
}

PyObject* netSendCreateCharacterPacket(PyObject* poSelf, PyObject* poArgs)
{
int index;
if (!PyTuple_GetInteger(poArgs, 0, &index))
return Py_BuildException();

char* name;
if (!PyTuple_GetString(poArgs, 1, &name))
return Py_BuildException();

int job;
if (!PyTuple_GetInteger(poArgs, 2, &job))
return Py_BuildException();

int shape;
if (!PyTuple_GetInteger(poArgs, 3, &shape))
return Py_BuildException();

int stat1;
if (!PyTuple_GetInteger(poArgs, 4, &stat1))
return Py_BuildException();
int stat2;
if (!PyTuple_GetInteger(poArgs, 5, &stat2))
return Py_BuildException();
int stat3;
if (!PyTuple_GetInteger(poArgs, 6, &stat3))
return Py_BuildException();
int stat4;
if (!PyTuple_GetInteger(poArgs, 7, &stat4))
return Py_BuildException();

if (index<0 && index>3)
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendCreateCharacterPacket((BYTE) index, name, (BYTE) job, (BYTE) shape, stat1, stat2, stat3, stat4);
return Py_BuildNone();
}

PyObject* netSendDestroyCharacterPacket(PyObject* poSelf, PyObject* poArgs)
{
int index;
if (!PyTuple_GetInteger(poArgs, 0, &index))
return Py_BuildException();

char * szPrivateCode;
if (!PyTuple_GetString(poArgs, 1, &szPrivateCode))
return Py_BuildException();

if (index<0 && index>3)
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendDestroyCharacterPacket((BYTE) index, szPrivateCode);
return Py_BuildNone();
}

PyObject* netSendEnterGamePacket(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendEnterGame();
return Py_BuildNone();
}

PyObject* netOnClickPacket(PyObject* poSelf, PyObject* poArgs)
{
int index;
if (!PyTuple_GetInteger(poArgs, 0, &index))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendOnClickPacket(index);

return Py_BuildNone();
}

PyObject* netSendItemUsePacket(PyObject* poSelf, PyObject* poArgs)
{
TItemPos Cell;
switch (PyTuple_Size(poArgs))
{
case 1:
if (!PyTuple_GetInteger(poArgs, 0, &Cell.cell))
return Py_BuildException();
break;
case 2:
if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BuildException();
break;
default:
return Py_BuildException();
}

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendItemUsePacket(Cell);
return Py_BuildNone();
}

PyObject* netSendItemUseToItemPacket(PyObject* poSelf, PyObject* poArgs)
{
TItemPos SourceCell;
TItemPos TargetCell;
switch (PyTuple_Size(poArgs))
{
case 2:
if (!PyTuple_GetInteger(poArgs, 0, &SourceCell.cell))
return Py_BuildException();

if (!PyTuple_GetInteger(poArgs, 1, &TargetCell.cell))
return Py_BuildException();
break;
case 4:
if (!PyTuple_GetByte(poArgs, 0, &SourceCell.window_type))
return Py_BuildException();

if (!PyTuple_GetInteger(poArgs, 1, &SourceCell.cell))
return Py_BuildException();

if (!PyTuple_GetByte(poArgs, 2, &TargetCell.window_type))
return Py_BuildException();

if (!PyTuple_GetInteger(poArgs, 3, &TargetCell.cell))
return Py_BuildException();
break;
default:
return Py_BuildException();
}
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendItemUseToItemPacket(SourceCell, TargetCell);
return Py_BuildNone();
}

PyObject* netSendItemDropPacket(PyObject* poSelf, PyObject* poArgs)
{
TItemPos Cell;
switch (PyTuple_Size(poArgs))
{
case 1:
if (!PyTuple_GetInteger(poArgs, 0, &Cell.cell))
return Py_BuildException();
break;
case 2:
if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BuildException();
break;
default:
return Py_BuildException();
}

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendItemDropPacket(Cell, 0);
return Py_BuildNone();
}

#ifdef ENABLE_DESTROY_ITEM
PyObject* netSendItemDestroyPacket(PyObject* poSelf, PyObject* poArgs)
{
TItemPos Cell;

if (!PyTuple_GetInteger(poArgs, 0, &Cell.cell))
return Py_BuildException();

CPythonNetworkStream& rkNetStream = CPythonNetworkStream::Instance();
rkNetStream.SendItemDestroyPacket(Cell);
return Py_BuildNone();
}
#endif

PyObject* netSendItemDropPacketNew(PyObject* poSelf, PyObject* poArgs)
{
TItemPos Cell;
int count;
switch (PyTuple_Size(poArgs))
{
case 2:
if (!PyTuple_GetInteger(poArgs, 0, &Cell.cell))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &count))
return Py_BuildException();

break;
case 3:
if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 2, &count))
return Py_BuildException();

break;
default:
return Py_BuildException();
}
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendItemDropPacketNew(Cell, 0, count);
return Py_BuildNone();
}

PyObject* netSendElkDropPacket(PyObject* poSelf, PyObject* poArgs)
{
int iElk;
if (!PyTuple_GetInteger(poArgs, 0, &iElk))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendItemDropPacket(TItemPos(RESERVED_WINDOW, 0), (DWORD) iElk);
return Py_BuildNone();
}

PyObject* netSendGoldDropPacketNew(PyObject* poSelf, PyObject* poArgs)
{
int iElk;
if (!PyTuple_GetInteger(poArgs, 0, &iElk))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendItemDropPacketNew(TItemPos (RESERVED_WINDOW, 0), (DWORD) iElk, 0);
return Py_BuildNone();
}

PyObject* netSendItemMovePacket(PyObject* poSelf, PyObject* poArgs)
{
TItemPos Cell;
TItemPos ChangeCell;
int num;

switch (PyTuple_Size(poArgs))
{
case 3:
if (!PyTuple_GetInteger(poArgs, 0, &Cell.cell))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &ChangeCell.cell))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 2, &num))
return Py_BuildException();
break;
case 5:
{
if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BuildException();
if (!PyTuple_GetByte(poArgs, 2, &ChangeCell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 3, &ChangeCell.cell))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 4, &num))
return Py_BuildException();
}
break;
default:
return Py_BuildException();
}

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendItemMovePacket(Cell, ChangeCell, (BYTE) num);
return Py_BuildNone();
}

PyObject* netSendItemPickUpPacket(PyObject* poSelf, PyObject* poArgs)
{
int vid;
if (!PyTuple_GetInteger(poArgs, 0, &vid))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendItemPickUpPacket(vid);
return Py_BuildNone();
}

PyObject* netSendGiveItemPacket(PyObject* poSelf, PyObject* poArgs)
{
int iTargetVID;
TItemPos Cell;
int iItemCount;
switch (PyTuple_Size(poArgs))
{
case 3:
if (!PyTuple_GetInteger(poArgs, 0, &iTargetVID))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 2, &iItemCount))
return Py_BuildException();
break;
case 4:
if (!PyTuple_GetInteger(poArgs, 0, &iTargetVID))
return Py_BuildException();
if (!PyTuple_GetByte(poArgs, 1, &Cell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 2, &Cell.cell))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 3, &iItemCount))
return Py_BuildException();
break;
default:
break;
}

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendGiveItemPacket(iTargetVID, Cell, iItemCount);
return Py_BuildNone();
}

PyObject* netSendShopEndPacket(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendShopEndPacket();
return Py_BuildNone();
}

PyObject* netSendShopBuyPacket(PyObject* poSelf, PyObject* poArgs)
{
int iCount;
if (!PyTuple_GetInteger(poArgs, 0, &iCount))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendShopBuyPacket(iCount);
return Py_BuildNone();
}

#ifdef OFFLINE_SHOP_FIX
PyObject* netSendShopRemoveItemPacket(PyObject* poSelf, PyObject* poArgs)
{
int shop_id;
if (!PyTuple_GetInteger(poArgs, 0, &shop_id))
return Py_BuildException();

int bPos;
if (!PyTuple_GetInteger(poArgs, 1, &bPos))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendShopRemoveItemPacket(shop_id, bPos);
return Py_BuildNone();
}

PyObject* netSendShopAddItemPacket(PyObject* poSelf, PyObject* poArgs)
{
int shop_id;
if (!PyTuple_GetInteger(poArgs, 0, &shop_id))
return Py_BuildException();

BYTE bPos;
if (!PyTuple_GetInteger(poArgs, 1, &bPos))
return Py_BuildException();

int sPos;
if (!PyTuple_GetInteger(poArgs, 2, &sPos))
return Py_BuildException();

BYTE window_type;
if (!PyTuple_GetInteger(poArgs, 3, &window_type))
return Py_BuildException();

long long price;
if (!PyTuple_GetLongLong(poArgs, 4, &price))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendShopAddItemPacket(shop_id, bPos, sPos, window_type, price);
return Py_BuildNone();
}
#endif

PyObject* netSendShopSellPacket(PyObject* poSelf, PyObject* poArgs)
{
int iSlotNumber;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotNumber))
return Py_BuildException();
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendShopSellPacket(iSlotNumber);
return Py_BuildNone();
}

PyObject* netSendShopSellPacketNew(PyObject* poSelf, PyObject* poArgs)
{
int iSlotNumber;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotNumber))
return Py_BuildException();
int iCount;
if (!PyTuple_GetInteger(poArgs, 1, &iCount))
return Py_BuildException();
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendShopSellPacketNew(iSlotNumber, iCount);
return Py_BuildNone();
}

PyObject* netSendExchangeStartPacket(PyObject* poSelf, PyObject* poArgs)
{
int vid;
if (!PyTuple_GetInteger(poArgs, 0, &vid))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendExchangeStartPacket(vid);
return Py_BuildNone();
}

PyObject* netSendExchangeElkAddPacket(PyObject* poSelf, PyObject* poArgs)
{
//int iElk;
//if (!PyTuple_GetInteger(poArgs, 0, &iElk))
//return Py_BuildException();
long long iElk;
if (!PyTuple_GetLongLong(poArgs, 0, &iElk))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendExchangeElkAddPacket(iElk);
return Py_BuildNone();
}

PyObject* netSendExchangeItemAddPacket(PyObject* poSelf, PyObject* poArgs)
{
BYTE bWindowType;
if (!PyTuple_GetInteger(poArgs, 0, &bWindowType))
return Py_BuildException();
WORD wSlotIndex;
if (!PyTuple_GetInteger(poArgs, 1, &wSlotIndex))
return Py_BuildException();
int iDisplaySlotIndex;
if (!PyTuple_GetInteger(poArgs, 2, &iDisplaySlotIndex))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendExchangeItemAddPacket(TItemPos(bWindowType, wSlotIndex), iDisplaySlotIndex);
return Py_BuildNone();
}

PyObject* netSendExchangeItemDelPacket(PyObject* poSelf, PyObject* poArgs)
{
int pos;
if (!PyTuple_GetInteger(poArgs, 0, &pos))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendExchangeItemDelPacket((BYTE) pos);
return Py_BuildNone();
}

PyObject* netSendExchangeAcceptPacket(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendExchangeAcceptPacket();
return Py_BuildNone();
}

PyObject* netSendExchangeExitPacket(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendExchangeExitPacket();
return Py_BuildNone();
}

PyObject* netExitApplication(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.ExitApplication();
return Py_BuildNone();
}

PyObject* netExitGame(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.ExitGame();
return Py_BuildNone();
}

PyObject* netLogOutGame(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.LogOutGame();
return Py_BuildNone();
}

PyObject* netDisconnect(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SetOffLinePhase();
rkNetStream.Disconnect();

return Py_BuildNone();
}

PyObject* netIsConnect(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
return Py_BuildValue("i", rkNetStream.IsOnline());
}

PyObject* netToggleGameDebugInfo(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.ToggleGameDebugInfo();
return Py_BuildNone();
}

PyObject* netRegisterEmoticonString(PyObject* poSelf, PyObject* poArgs)
{
char * pcEmoticonString;
if (!PyTuple_GetString(poArgs, 0, &pcEmoticonString))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.RegisterEmoticonString(pcEmoticonString);
return Py_BuildNone();
}

PyObject* netSendMessengerAddByVIDPacket(PyObject* poSelf, PyObject* poArgs)
{
int vid;
if (!PyTuple_GetInteger(poArgs, 0, &vid))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendMessengerAddByVIDPacket(vid);

return Py_BuildNone();
}

PyObject* netSendMessengerAddByNamePacket(PyObject* poSelf, PyObject* poArgs)
{
char * szName;
if (!PyTuple_GetString(poArgs, 0, &szName))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendMessengerAddByNamePacket(szName);

return Py_BuildNone();
}

PyObject* netSendMessengerRemovePacket(PyObject* poSelf, PyObject* poArgs)
{
char * szKey;
if (!PyTuple_GetString(poArgs, 0, &szKey))
return Py_BuildException();
char * szName;
if (!PyTuple_GetString(poArgs, 1, &szName))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendMessengerRemovePacket(szKey, szName);

return Py_BuildNone();
}

PyObject* netSendPartyInvitePacket(PyObject* poSelf, PyObject* poArgs)
{
int vid;
if (!PyTuple_GetInteger(poArgs, 0, &vid))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendPartyInvitePacket(vid);

return Py_BuildNone();
}

PyObject* netSendPartyInviteAnswerPacket(PyObject* poSelf, PyObject* poArgs)
{
int vid;
if (!PyTuple_GetInteger(poArgs, 0, &vid))
return Py_BuildException();
int answer;
if (!PyTuple_GetInteger(poArgs, 1, &answer))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendPartyInviteAnswerPacket(vid, answer);

return Py_BuildNone();
}

PyObject* netSendPartyExitPacket(PyObject* poSelf, PyObject* poArgs)
{
IAbstractPlayer& rPlayer=IAbstractPlayer::GetSingleton();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();

DWORD dwVID = rPlayer.GetMainCharacterIndex();
DWORD dwPID;
if (rPlayer.PartyMemberVIDToPID(dwVID, &dwPID))
rns.SendPartyRemovePacket(dwPID);

return Py_BuildNone();
}

PyObject* netSendPartyRemovePacket(PyObject* poSelf, PyObject* poArgs)
{
int vid;
if (!PyTuple_GetInteger(poArgs, 0, &vid))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendPartyRemovePacket(vid);

return Py_BuildNone();
}

PyObject* netSendPartySetStatePacket(PyObject* poSelf, PyObject* poArgs)
{
int iVID;
if (!PyTuple_GetInteger(poArgs, 0, &iVID))
return Py_BuildException();
int iState;
if (!PyTuple_GetInteger(poArgs, 1, &iState))
return Py_BuildException();
int iFlag;
if (!PyTuple_GetInteger(poArgs, 2, &iFlag))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendPartySetStatePacket(iVID, iState, iFlag);

return Py_BuildNone();
}

PyObject* netSendPartyUseSkillPacket(PyObject* poSelf, PyObject* poArgs)
{
int iSkillIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
return Py_BuildException();
int iVID;
if (!PyTuple_GetInteger(poArgs, 1, &iVID))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendPartyUseSkillPacket(iSkillIndex, iVID);

return Py_BuildNone();
}

PyObject* netSendPartyParameterPacket(PyObject* poSelf, PyObject* poArgs)
{
int iMode;
if (!PyTuple_GetInteger(poArgs, 0, &iMode))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendPartyParameterPacket(iMode);

return Py_BuildNone();
}

PyObject* netSendSafeboxSaveMoneyPacket(PyObject* poSelf, PyObject* poArgs)
{
int iMoney;
if (!PyTuple_GetInteger(poArgs, 0, &iMoney))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendSafeBoxMoneyPacket(SAFEBOX_MONEY_STATE_SAVE, iMoney);

return Py_BuildNone();
}

PyObject* netSendSafeboxWithdrawMoneyPacket(PyObject* poSelf, PyObject* poArgs)
{
int iMoney;
if (!PyTuple_GetInteger(poArgs, 0, &iMoney))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendSafeBoxMoneyPacket(SAFEBOX_MONEY_STATE_WITHDRAW, iMoney);

return Py_BuildNone();
}

PyObject* netSendSafeboxCheckinPacket(PyObject* poSelf, PyObject* poArgs)
{
TItemPos InventoryPos;
int iSafeBoxPos;

switch (PyTuple_Size(poArgs))
{
case 2:
InventoryPos.window_type = INVENTORY;
if (!PyTuple_GetInteger(poArgs, 0, &InventoryPos.cell))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &iSafeBoxPos))
return Py_BuildException();
break;
case 3:
if (!PyTuple_GetInteger(poArgs, 0, &InventoryPos.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &InventoryPos.cell))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 2, &iSafeBoxPos))
return Py_BuildException();
break;

}

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendSafeBoxCheckinPacket(InventoryPos, iSafeBoxPos);

return Py_BuildNone();
}

PyObject* netSendSafeboxCheckoutPacket(PyObject* poSelf, PyObject* poArgs)
{
int iSafeBoxPos;
TItemPos InventoryPos;

switch (PyTuple_Size(poArgs))
{
case 2:
if (!PyTuple_GetInteger(poArgs, 0, &iSafeBoxPos))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &InventoryPos.cell))
return Py_BuildException();
break;
case 3:
if (!PyTuple_GetInteger(poArgs, 0, &iSafeBoxPos))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &InventoryPos.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 2, &InventoryPos.cell))
return Py_BuildException();
break;
default:
break;
}

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendSafeBoxCheckoutPacket(iSafeBoxPos, InventoryPos);

return Py_BuildNone();
}

PyObject* netSendSafeboxItemMovePacket(PyObject* poSelf, PyObject* poArgs)
{
int iSourcePos;
if (!PyTuple_GetInteger(poArgs, 0, &iSourcePos))
return Py_BuildException();
int iTargetPos;
if (!PyTuple_GetInteger(poArgs, 1, &iTargetPos))
return Py_BuildException();
int iCount;
if (!PyTuple_GetInteger(poArgs, 2, &iCount))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendSafeBoxItemMovePacket(iSourcePos, iTargetPos, iCount);

return Py_BuildNone();
}

PyObject* netSendMallCheckoutPacket(PyObject* poSelf, PyObject* poArgs)
{
int iMallPos;
TItemPos InventoryPos;

switch (PyTuple_Size(poArgs))
{
case 2:
if (!PyTuple_GetInteger(poArgs, 0, &iMallPos))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &InventoryPos.cell))
return Py_BuildException();
break;
case 3:
if (!PyTuple_GetInteger(poArgs, 0, &iMallPos))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &InventoryPos.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 2, &InventoryPos.cell))
return Py_BuildException();
break;
default:
return Py_BuildException();
}
CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendMallCheckoutPacket(iMallPos, InventoryPos);

return Py_BuildNone();
}

PyObject* netSendAnswerMakeGuildPacket(PyObject* poSelf, PyObject* poArgs)
{
char * szName;
if (!PyTuple_GetString(poArgs, 0, &szName))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendAnswerMakeGuildPacket(szName);

return Py_BuildNone();
}

PyObject* netSendQuestInputStringPacket(PyObject* poSelf, PyObject* poArgs)
{
char * szString;
if (!PyTuple_GetString(poArgs, 0, &szString))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendQuestInputStringPacket(szString);

return Py_BuildNone();
}

PyObject* netSendQuestConfirmPacket(PyObject* poSelf, PyObject* poArgs)
{
int iAnswer;
if (!PyTuple_GetInteger(poArgs, 0, &iAnswer))
return Py_BuildException();
int iPID;
if (!PyTuple_GetInteger(poArgs, 1, &iPID))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendQuestConfirmPacket(iAnswer, iPID);

return Py_BuildNone();
}

PyObject* netSendGuildAddMemberPacket(PyObject* poSelf, PyObject* poArgs)
{
int iVID;
if (!PyTuple_GetInteger(poArgs, 0, &iVID))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendGuildAddMemberPacket(iVID);

return Py_BuildNone();
}

PyObject* netSendGuildRemoveMemberPacket(PyObject* poSelf, PyObject* poArgs)
{
char * szKey;
if (!PyTuple_GetString(poArgs, 0, &szKey))
return Py_BuildException();

CPythonGuild::TGuildMemberData * pGuildMemberData;
if (!CPythonGuild::Instance().GetMemberDataPtrByName(szKey, &pGuildMemberData))
{
TraceError("netSendGuildRemoveMemberPacket(szKey=%s) - Can't Find Guild Member\n", szKey);
return Py_BuildNone();
}

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendGuildRemoveMemberPacket(pGuildMemberData->dwPID);

return Py_BuildNone();
}

PyObject* netSendGuildChangeGradeNamePacket(PyObject* poSelf, PyObject* poArgs)
{
int iGradeNumber;
if (!PyTuple_GetInteger(poArgs, 0, &iGradeNumber))
return Py_BuildException();
char * szGradeName;
if (!PyTuple_GetString(poArgs, 1, &szGradeName))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendGuildChangeGradeNamePacket(iGradeNumber, szGradeName);

return Py_BuildNone();
}

PyObject* netSendGuildChangeGradeAuthorityPacket(PyObject* poSelf, PyObject* poArgs)
{
int iGradeNumber;
if (!PyTuple_GetInteger(poArgs, 0, &iGradeNumber))
return Py_BuildException();
int iAuthority;
if (!PyTuple_GetInteger(poArgs, 1, &iAuthority))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendGuildChangeGradeAuthorityPacket(iGradeNumber, iAuthority);

return Py_BuildNone();
}

PyObject* netSendGuildOfferPacket(PyObject* poSelf, PyObject* poArgs)
{
int iExperience;
if (!PyTuple_GetInteger(poArgs, 0, &iExperience))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendGuildOfferPacket(iExperience);

return Py_BuildNone();
}

PyObject* netSnedGuildPostCommentPacket(PyObject* poSelf, PyObject* poArgs)
{
char * szComment;
if (!PyTuple_GetString(poArgs, 0, &szComment))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendGuildPostCommentPacket(szComment);

return Py_BuildNone();
}

PyObject* netSnedGuildDeleteCommentPacket(PyObject* poSelf, PyObject* poArgs)
{
int iIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendGuildDeleteCommentPacket(iIndex);

return Py_BuildNone();
}

PyObject* netSendGuildRefreshCommentsPacket(PyObject* poSelf, PyObject* poArgs)
{
int iHightestIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iHightestIndex))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendGuildRefreshCommentsPacket(iHightestIndex);

return Py_BuildNone();
}

PyObject* netSendGuildChangeMemberGradePacket(PyObject* poSelf, PyObject* poArgs)
{
int iPID;
if (!PyTuple_GetInteger(poArgs, 0, &iPID))
return Py_BuildException();
int iGradeNumber;
if (!PyTuple_GetInteger(poArgs, 1, &iGradeNumber))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendGuildChangeMemberGradePacket(iPID, iGradeNumber);

return Py_BuildNone();
}

PyObject* netSendGuildUseSkillPacket(PyObject* poSelf, PyObject* poArgs)
{
int iSkillID;
if (!PyTuple_GetInteger(poArgs, 0, &iSkillID))
return Py_BuildException();
int iTargetVID;
if (!PyTuple_GetInteger(poArgs, 1, &iTargetVID))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendGuildUseSkillPacket(iSkillID, iTargetVID);

return Py_BuildNone();
}

PyObject* netSendGuildChangeMemberGeneralPacket(PyObject* poSelf, PyObject* poArgs)
{
int iPID;
if (!PyTuple_GetInteger(poArgs, 0, &iPID))
return Py_BuildException();
int iFlag;
if (!PyTuple_GetInteger(poArgs, 1, &iFlag))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendGuildChangeMemberGeneralPacket(iPID, iFlag);

return Py_BuildNone();
}

PyObject* netSendGuildInviteAnswerPacket(PyObject* poSelf, PyObject* poArgs)
{
int iGuildID;
if (!PyTuple_GetInteger(poArgs, 0, &iGuildID))
return Py_BuildException();
int iAnswer;
if (!PyTuple_GetInteger(poArgs, 1, &iAnswer))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendGuildInviteAnswerPacket(iGuildID, iAnswer);

return Py_BuildNone();
}

PyObject* netSendGuildChargeGSPPacket(PyObject* poSelf, PyObject* poArgs)
{
int iGSP;
if (!PyTuple_GetInteger(poArgs, 0, &iGSP))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendGuildChargeGSPPacket(iGSP);

return Py_BuildNone();
}

PyObject* netSendGuildDepositMoneyPacket(PyObject* poSelf, PyObject* poArgs)
{
int iGSP;
if (!PyTuple_GetInteger(poArgs, 0, &iGSP))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendGuildDepositMoneyPacket(iGSP);

return Py_BuildNone();
}

PyObject* netSendGuildWithdrawMoneyPacket(PyObject* poSelf, PyObject* poArgs)
{
int iGSP;
if (!PyTuple_GetInteger(poArgs, 0, &iGSP))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendGuildWithdrawMoneyPacket(iGSP);

return Py_BuildNone();
}

PyObject* netSendRequestRefineInfoPacket(PyObject* poSelf, PyObject* poArgs)
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();

// CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
// rns.SendRequestRefineInfoPacket(iSlotIndex);
assert(!"netSendRequestRefineInfoPacket - 더이상 사용하지 않는 함수 입니다");

return Py_BuildNone();
}

PyObject* netSendRefinePacket(PyObject* poSelf, PyObject* poArgs)
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
int iType;
if (!PyTuple_GetInteger(poArgs, 1, &iType))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendRefinePacket(iSlotIndex, iType);

return Py_BuildNone();
}

PyObject* netSendSelectItemPacket(PyObject* poSelf, PyObject* poArgs)
{
int iItemPos;
if (!PyTuple_GetInteger(poArgs, 0, &iItemPos))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendSelectItemPacket(iItemPos);

return Py_BuildNone();
}

PyObject* netSetPacketSequenceMode(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
CAccountConnector & rkAccountConnector = CAccountConnector::Instance();
rns.SetPacketSequenceMode(true);
rkAccountConnector.SetPacketSequenceMode(true);

return Py_BuildNone();
}

PyObject* netSetEmpireLanguageMode(PyObject* poSelf, PyObject* poArgs)
{
int iMode;
if (!PyTuple_GetInteger(poArgs, 0, &iMode))
return Py_BuildException();

//CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
gs_bEmpireLanuageEnable = iMode;

return Py_BuildNone();
}

PyObject* netSetSkillGroupFake(PyObject* poSelf, PyObject* poArgs)
{
int iIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
return Py_BuildException();

CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.__TEST_SetSkillGroupFake(iIndex);

return Py_BuildNone();
}

#include "GuildMarkUploader.h"
#include "GuildMarkDownloader.h"

PyObject* netSendGuildSymbol(PyObject* poSelf, PyObject* poArgs)
{
char * szIP;
if (!PyTuple_GetString(poArgs, 0, &szIP))
return Py_BuildException();
int iPort;
if (!PyTuple_GetInteger(poArgs, 1, &iPort))
return Py_BuildException();
char * szFileName;
if (!PyTuple_GetString(poArgs, 2, &szFileName))
return Py_BuildException();
int iGuildID;
if (!PyTuple_GetInteger(poArgs, 3, &iGuildID))
return Py_BuildException();

CNetworkAddress kAddress;
kAddress.Set(szIP, iPort);

UINT uiError;

CGuildMarkUploader& rkGuildMarkUploader=CGuildMarkUploader::Instance();
if (!rkGuildMarkUploader.ConnectToSendSymbol(kAddress, 0, 0, iGuildID, szFileName, &uiError))
{
assert(!"Failed connecting to send symbol");
}

return Py_BuildNone();
}

PyObject* netDisconnectUploader(PyObject* poSelf, PyObject* poArgs)
{
CGuildMarkUploader& rkGuildMarkUploader=CGuildMarkUploader::Instance();
rkGuildMarkUploader.Disconnect();
return Py_BuildNone();
}

PyObject* netRecvGuildSymbol(PyObject* poSelf, PyObject* poArgs)
{
char * szIP;
if (!PyTuple_GetString(poArgs, 0, &szIP))
return Py_BuildException();
int iPort;
if (!PyTuple_GetInteger(poArgs, 1, &iPort))
return Py_BuildException();
int iGuildID;
if (!PyTuple_GetInteger(poArgs, 2, &iGuildID))
return Py_BuildException();

CNetworkAddress kAddress;
kAddress.Set(szIP, iPort);

std::vector<DWORD> kVec_dwGuildID;
kVec_dwGuildID.clear();
kVec_dwGuildID.push_back(iGuildID);

CGuildMarkDownloader& rkGuildMarkDownloader=CGuildMarkDownloader::Instance();
if (!rkGuildMarkDownloader.ConnectToRecvSymbol(kAddress, 0, 0, kVec_dwGuildID))
{
assert(!"Failed connecting to recv symbol");
}

return Py_BuildNone();
}

PyObject* netRegisterErrorLog(PyObject* poSelf, PyObject* poArgs)
{
char * szLog;
if (!PyTuple_GetString(poArgs, 0, &szLog))
return Py_BuildException();

return Py_BuildNone();
}

#ifdef ENABLE_SHOW_CHEST_DROP
PyObject* netSendChestDropInfo(PyObject* poSelf, PyObject* poArgs)
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BadArgument();

CPythonNetworkStream& rkNetStream = CPythonNetworkStream::Instance();
rkNetStream.SendChestDropInfo(iSlotIndex);

return Py_BuildNone();
}
#endif

#ifdef ENABLE_DICE_SYSTEM
PyObject* netSendDiceStartPacket(PyObject* poSelf, PyObject* poArgs)
{
int vid;
if (!PyTuple_GetInteger(poArgs, 0, &vid))
return Py_BuildException();

CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendDiceStartPacket(vid);
return Py_BuildNone();
}
#endif

void initnet()
{
static PyMethodDef s_methods[] =
{
{ "GetBettingGuildWarValue", netGetBettingGuildWarValue, METH_VARARGS },
{ "EnableChatInsultFilter", netEnableChatInsultFilter, METH_VARARGS },
{ "SetServerInfo", netSetServerInfo, METH_VARARGS },
{ "GetServerInfo", netGetServerInfo, METH_VARARGS },
{ "PreserveServerCommand", netPreserveServerCommand, METH_VARARGS },
{ "GetPreservedServerCommand", netGetPreservedServerCommand, METH_VARARGS },

{ "StartGame", netStartGame, METH_VARARGS },
{ "Warp", netWarp, METH_VARARGS },
{ "IsTest", netIsTest, METH_VARARGS },
{ "SetMarkServer", netSetMarkServer, METH_VARARGS },
{ "IsChatInsultIn", netIsChatInsultIn, METH_VARARGS },
{ "IsInsultIn", netIsInsultIn, METH_VARARGS },
{ "LoadInsultList", netLoadInsultList, METH_VARARGS },
{ "UploadMark", netUploadMark, METH_VARARGS },
{ "UploadSymbol", netUploadSymbol, METH_VARARGS },
{ "GetGuildID", netGetGuildID, METH_VARARGS },
{ "GetEmpireID", netGetEmpireID, METH_VARARGS },
{ "GetMainActorVID", netGetMainActorVID, METH_VARARGS },
{ "GetMainActorRace", netGetMainActorRace, METH_VARARGS },
{ "GetMainActorEmpire", netGetMainActorEmpire, METH_VARARGS },
{ "GetMainActorSkillGroup", netGetMainActorSkillGroup, METH_VARARGS },
{ "GetAccountCharacterSlotDataInteger", netGetAccountCharacterSlotDataInteger, METH_VARARGS },
{ "GetAccountCharacterSlotDataString", netGetAccountCharacterSlotDataString, METH_VARARGS },

// FIELD_MUSIC
{ "GetFieldMusicFileName", netGetFieldMusicFileName, METH_VARARGS },
{ "GetFieldMusicVolume", netGetFieldMusicVolume, METH_VARARGS },
// END_OF_FIELD_MUSIC

{ "ToggleGameDebugInfo", netToggleGameDebugInfo, METH_VARARGS },
{ "SetLoginInfo", netSetLoginInfo, METH_VARARGS },
{ "SetPhaseWindow", netSetPhaseWindow, METH_VARARGS },
{ "ClearPhaseWindow", netClearPhaseWindow, METH_VARARGS },
{ "SetServerCommandParserWindow", netSetServerCommandParserWindow, METH_VARARGS },
{ "SetAccountConnectorHandler", netSetAccountConnectorHandler, METH_VARARGS },
{ "SetHandler", netSetHandler, METH_VARARGS },
{ "SetTCPRecvBufferSize", netSetTCPRecvBufferSize, METH_VARARGS },
{ "SetTCPSendBufferSize", netSetTCPSendBufferSize, METH_VARARGS },
{ "SetUDPRecvBufferSize", netSetUDPRecvBufferSize, METH_VARARGS },
{ "DirectEnter", netDirectEnter, METH_VARARGS },

{ "LogOutGame", netLogOutGame, METH_VARARGS },
{ "ExitGame", netExitGame, METH_VARARGS },
{ "ExitApplication", netExitApplication, METH_VARARGS },
{ "ConnectTCP", netConnectTCP, METH_VARARGS },
{ "ConnectUDP", netConnectUDP, METH_VARARGS },
{ "ConnectToAccountServer", netConnectToAccountServer, METH_VARARGS },
#ifdef ENABLE_SEND_TARGET_INFO
{ "SendTargetInfoLoad", netTargetInfoLoad, METH_VARARGS },
#endif
{ "SendLoginPacket", netSendLoginPacket, METH_VARARGS },
{ "SendChinaMatrixCardPacket", netSendChinaMatrixCardPacket, METH_VARARGS },
{ "SendRunupMatrixCardPacket", netSendRunupMatrixCardPacket, METH_VARARGS },
{ "SendNEWCIBNPasspodAnswerPacket", netSendNEWCIBNPasspodAnswerPacket, METH_VARARGS },
{ "SendSelectEmpirePacket", netSendSelectEmpirePacket, METH_VARARGS },
{ "SendSelectCharacterPacket", netSendSelectCharacterPacket, METH_VARARGS },
{ "SendChangeNamePacket", netSendChangeNamePacket, METH_VARARGS },
{ "SendCreateCharacterPacket", netSendCreateCharacterPacket, METH_VARARGS },
{ "SendDestroyCharacterPacket", netSendDestroyCharacterPacket, METH_VARARGS },
{ "SendEnterGamePacket", netSendEnterGamePacket, METH_VARARGS },

{ "SendItemUsePacket", netSendItemUsePacket, METH_VARARGS },
{ "SendItemUseToItemPacket", netSendItemUseToItemPacket, METH_VARARGS },
{ "SendItemDropPacket", netSendItemDropPacket, METH_VARARGS },
{ "SendItemDropPacketNew", netSendItemDropPacketNew, METH_VARARGS },
#ifdef ENABLE_DESTROY_ITEM
{ "SendItemDestroyPacket", netSendItemDestroyPacket, METH_VARARGS },
#endif
{ "SendElkDropPacket", netSendElkDropPacket, METH_VARARGS },
{ "SendGoldDropPacketNew", netSendGoldDropPacketNew, METH_VARARGS },
{ "SendItemMovePacket", netSendItemMovePacket, METH_VARARGS },
{ "SendItemPickUpPacket", netSendItemPickUpPacket, METH_VARARGS },
{ "SendGiveItemPacket", netSendGiveItemPacket, METH_VARARGS },

{ "SetOfflinePhase", netSetOfflinePhase, METH_VARARGS },
{ "Disconnect", netDisconnect, METH_VARARGS },
{ "IsConnect", netIsConnect, METH_VARARGS },

{ "SendChatPacket", netSendChatPacket, METH_VARARGS },
{ "SendEmoticon", netSendEmoticon, METH_VARARGS },
{ "SendWhisperPacket", netSendWhisperPacket, METH_VARARGS },
#ifdef OFFLINE_MESSAGE
{ "SendOfflineMessagePacket", netSendOfflineMessagePacket, METH_VARARGS },
#endif
{ "SendMobileMessagePacket", netSendMobileMessagePacket, METH_VARARGS },

{ "SendCharacterPositionPacket", netSendCharacterPositionPacket, METH_VARARGS },

{ "SendShopEndPacket", netSendShopEndPacket, METH_VARARGS },
{ "SendShopBuyPacket", netSendShopBuyPacket, METH_VARARGS },
{ "SendShopSellPacket", netSendShopSellPacket, METH_VARARGS },
{ "SendShopSellPacketNew", netSendShopSellPacketNew, METH_VARARGS },

#ifdef OFFLINE_SHOP_FIX
{ "SendShopRemoveItemPacket", netSendShopRemoveItemPacket, METH_VARARGS },
{ "SendShopAddItemPacket", netSendShopAddItemPacket, METH_VARARGS },
#endif

{ "SendExchangeStartPacket", netSendExchangeStartPacket, METH_VARARGS },
{ "SendExchangeItemAddPacket", netSendExchangeItemAddPacket, METH_VARARGS },
{ "SendExchangeItemDelPacket", netSendExchangeItemDelPacket, METH_VARARGS },
{ "SendExchangeElkAddPacket", netSendExchangeElkAddPacket, METH_VARARGS },
{ "SendExchangeAcceptPacket", netSendExchangeAcceptPacket, METH_VARARGS },
{ "SendExchangeExitPacket", netSendExchangeExitPacket, METH_VARARGS },

{ "SendOnClickPacket", netOnClickPacket, METH_VARARGS },

// Emoticon String
{ "RegisterEmoticonString", netRegisterEmoticonString, METH_VARARGS },

// Messenger
{ "SendMessengerAddByVIDPacket", netSendMessengerAddByVIDPacket, METH_VARARGS },
{ "SendMessengerAddByNamePacket", netSendMessengerAddByNamePacket, METH_VARARGS },
{ "SendMessengerRemovePacket", netSendMessengerRemovePacket, METH_VARARGS },

// Party
{ "SendPartyInvitePacket", netSendPartyInvitePacket, METH_VARARGS },
{ "SendPartyInviteAnswerPacket", netSendPartyInviteAnswerPacket, METH_VARARGS },
{ "SendPartyExitPacket", netSendPartyExitPacket, METH_VARARGS },
{ "SendPartyRemovePacket", netSendPartyRemovePacket, METH_VARARGS },
{ "SendPartySetStatePacket", netSendPartySetStatePacket, METH_VARARGS },
{ "SendPartyUseSkillPacket", netSendPartyUseSkillPacket, METH_VARARGS },
{ "SendPartyParameterPacket", netSendPartyParameterPacket, METH_VARARGS },

// Safebox
{ "SendSafeboxSaveMoneyPacket", netSendSafeboxSaveMoneyPacket, METH_VARARGS },
{ "SendSafeboxWithdrawMoneyPacket", netSendSafeboxWithdrawMoneyPacket, METH_VARARGS },
{ "SendSafeboxCheckinPacket", netSendSafeboxCheckinPacket, METH_VARARGS },
{ "SendSafeboxCheckoutPacket", netSendSafeboxCheckoutPacket, METH_VARARGS },
{ "SendSafeboxItemMovePacket", netSendSafeboxItemMovePacket, METH_VARARGS },

// Mall
{ "SendMallCheckoutPacket", netSendMallCheckoutPacket, METH_VARARGS },

// Guild
{ "SendAnswerMakeGuildPacket", netSendAnswerMakeGuildPacket, METH_VARARGS },
{ "SendQuestInputStringPacket", netSendQuestInputStringPacket, METH_VARARGS },
{ "SendQuestConfirmPacket", netSendQuestConfirmPacket, METH_VARARGS },
{ "SendGuildAddMemberPacket", netSendGuildAddMemberPacket, METH_VARARGS },
{ "SendGuildRemoveMemberPacket", netSendGuildRemoveMemberPacket, METH_VARARGS },
{ "SendGuildChangeGradeNamePacket", netSendGuildChangeGradeNamePacket, METH_VARARGS },
{ "SendGuildChangeGradeAuthorityPacket", netSendGuildChangeGradeAuthorityPacket, METH_VARARGS },
{ "SendGuildOfferPacket", netSendGuildOfferPacket, METH_VARARGS },
{ "SendGuildPostCommentPacket", netSnedGuildPostCommentPacket, METH_VARARGS },
{ "SendGuildDeleteCommentPacket", netSnedGuildDeleteCommentPacket, METH_VARARGS },
{ "SendGuildRefreshCommentsPacket", netSendGuildRefreshCommentsPacket, METH_VARARGS },
{ "SendGuildChangeMemberGradePacket", netSendGuildChangeMemberGradePacket, METH_VARARGS },
{ "SendGuildUseSkillPacket", netSendGuildUseSkillPacket, METH_VARARGS },
{ "SendGuildChangeMemberGeneralPacket", netSendGuildChangeMemberGeneralPacket, METH_VARARGS },
{ "SendGuildInviteAnswerPacket", netSendGuildInviteAnswerPacket, METH_VARARGS },
{ "SendGuildChargeGSPPacket", netSendGuildChargeGSPPacket, METH_VARARGS },
{ "SendGuildDepositMoneyPacket", netSendGuildDepositMoneyPacket, METH_VARARGS },
{ "SendGuildWithdrawMoneyPacket", netSendGuildWithdrawMoneyPacket, METH_VARARGS },

// Refine
{ "SendRequestRefineInfoPacket", netSendRequestRefineInfoPacket, METH_VARARGS },
{ "SendRefinePacket", netSendRefinePacket, METH_VARARGS },
{ "SendSelectItemPacket", netSendSelectItemPacket, METH_VARARGS },

// SYSTEM
{ "SetPacketSequenceMode", netSetPacketSequenceMode, METH_VARARGS },
{ "SetEmpireLanguageMode", netSetEmpireLanguageMode, METH_VARARGS },

// For Test
{ "SetSkillGroupFake", netSetSkillGroupFake, METH_VARARGS },

// Guild Symbol
{ "SendGuildSymbol", netSendGuildSymbol, METH_VARARGS },
{ "DisconnectUploader", netDisconnectUploader, METH_VARARGS },
{ "RecvGuildSymbol", netRecvGuildSymbol, METH_VARARGS },

// Log
{ "RegisterErrorLog", netRegisterErrorLog, METH_VARARGS },
#ifdef ENABLE_SHOW_CHEST_DROP
{ "SendChestDropInfo", netSendChestDropInfo, METH_VARARGS },
#endif
#ifdef ENABLE_DICE_SYSTEM
{ "SendDiceStartPacket", netSendDiceStartPacket, METH_VARARGS },
#endif
{ NULL, NULL, NULL },
};

PyObject* poModule = Py_InitModule("net", s_methods);

PyModule_AddIntConstant(poModule, "ERROR_NONE", CPythonNetworkStream::ERROR_NONE);
PyModule_AddIntConstant(poModule, "ERROR_CONNECT_MARK_SERVER", CPythonNetworkStream::ERROR_CONNECT_MARK_SERVER);
PyModule_AddIntConstant(poModule, "ERROR_LOAD_MARK", CPythonNetworkStream::ERROR_LOAD_MARK);
PyModule_AddIntConstant(poModule, "ERROR_MARK_WIDTH", CPythonNetworkStream::ERROR_MARK_WIDTH);
PyModule_AddIntConstant(poModule, "ERROR_MARK_HEIGHT", CPythonNetworkStream::ERROR_MARK_HEIGHT);

// MARK_BUG_FIX
PyModule_AddIntConstant(poModule, "ERROR_MARK_UPLOAD_NEED_RECONNECT", CPythonNetworkStream::ERROR_MARK_UPLOAD_NEED_RECONNECT);
PyModule_AddIntConstant(poModule, "ERROR_MARK_CHECK_NEED_RECONNECT", CPythonNetworkStream::ERROR_MARK_CHECK_NEED_RECONNECT);
// END_OF_MARK_BUG_FIX

PyModule_AddIntConstant(poModule, "PHASE_WINDOW_LOGIN", CPythonNetworkStream:

HASE_WINDOW_LOGIN);
PyModule_AddIntConstant(poModule, "PHASE_WINDOW_SELECT", CPythonNetworkStream:

HASE_WINDOW_SELECT);
PyModule_AddIntConstant(poModule, "PHASE_WINDOW_CREATE", CPythonNetworkStream:

HASE_WINDOW_CREATE);
PyModule_AddIntConstant(poModule, "PHASE_WINDOW_LOAD", CPythonNetworkStream:

HASE_WINDOW_LOAD);
PyModule_AddIntConstant(poModule, "PHASE_WINDOW_GAME", CPythonNetworkStream:

HASE_WINDOW_GAME);
PyModule_AddIntConstant(poModule, "PHASE_WINDOW_EMPIRE", CPythonNetworkStream:

HASE_WINDOW_EMPIRE);
PyModule_AddIntConstant(poModule, "PHASE_WINDOW_LOGO", CPythonNetworkStream:

HASE_WINDOW_LOGO);

PyModule_AddIntConstant(poModule, "ACCOUNT_CHARACTER_SLOT_ID", CPythonNetworkStream::ACCOUNT_CHARACTER_SLOT_ID);
PyModule_AddIntConstant(poModule, "ACCOUNT_CHARACTER_SLOT_NAME", CPythonNetworkStream::ACCOUNT_CHARACTER_SLOT_NAME);
PyModule_AddIntConstant(poModule, "ACCOUNT_CHARACTER_SLOT_RACE", CPythonNetworkStream::ACCOUNT_CHARACTER_SLOT_RACE);
PyModule_AddIntConstant(poModule, "ACCOUNT_CHARACTER_SLOT_LEVEL", CPythonNetworkStream::ACCOUNT_CHARACTER_SLOT_LEVEL);
PyModule_AddIntConstant(poModule, "ACCOUNT_CHARACTER_SLOT_STR", CPythonNetworkStream::ACCOUNT_CHARACTER_SLOT_STR);
PyModule_AddIntConstant(poModule, "ACCOUNT_CHARACTER_SLOT_DEX", CPythonNetworkStream::ACCOUNT_CHARACTER_SLOT_DEX);
PyModule_AddIntConstant(poModule, "ACCOUNT_CHARACTER_SLOT_INT", CPythonNetworkStream::ACCOUNT_CHARACTER_SLOT_INT);
PyModule_AddIntConstant(poModule, "ACCOUNT_CHARACTER_SLOT_HTH", CPythonNetworkStream::ACCOUNT_CHARACTER_SLOT_HTH);
PyModule_AddIntConstant(poModule, "ACCOUNT_CHARACTER_SLOT_PLAYTIME", CPythonNetworkStream::ACCOUNT_CHARACTER_SLOT_PLAYTIME);
PyModule_AddIntConstant(poModule, "ACCOUNT_CHARACTER_SLOT_FORM", CPythonNetworkStream::ACCOUNT_CHARACTER_SLOT_FORM);
PyModule_AddIntConstant(poModule, "ACCOUNT_CHARACTER_SLOT_ADDR", CPythonNetworkStream::ACCOUNT_CHARACTER_SLOT_ADDR);
PyModule_AddIntConstant(poModule, "ACCOUNT_CHARACTER_SLOT_PORT", CPythonNetworkStream::ACCOUNT_CHARACTER_SLOT_PORT);
PyModule_AddIntConstant(poModule, "ACCOUNT_CHARACTER_SLOT_GUILD_ID", CPythonNetworkStream::ACCOUNT_CHARACTER_SLOT_GUILD_ID);
PyModule_AddIntConstant(poModule, "ACCOUNT_CHARACTER_SLOT_GUILD_NAME", CPythonNetworkStream::ACCOUNT_CHARACTER_SLOT_GUILD_NAME);
PyModule_AddIntConstant(poModule, "ACCOUNT_CHARACTER_SLOT_CHANGE_NAME_FLAG", CPythonNetworkStream::ACCOUNT_CHARACTER_SLOT_CHANGE_NAME_FLAG);
PyModule_AddIntConstant(poModule, "ACCOUNT_CHARACTER_SLOT_HAIR", CPythonNetworkStream::ACCOUNT_CHARACTER_SLOT_HAIR);
#ifdef ENABLE_SASH_SYSTEM
PyModule_AddIntConstant(poModule, "ACCOUNT_CHARACTER_SLOT_SASH", CPythonNetworkStream::ACCOUNT_CHARACTER_SLOT_SASH);
#endif

PyModule_AddIntConstant(poModule, "SERVER_COMMAND_LOG_OUT", CPythonNetworkStream::SERVER_COMMAND_LOG_OUT);
PyModule_AddIntConstant(poModule, "SERVER_COMMAND_RETURN_TO_SELECT_CHARACTER", CPythonNetworkStream::SERVER_COMMAND_RETURN_TO_SELECT_CHARACTER);
PyModule_AddIntConstant(poModule, "SERVER_COMMAND_QUIT", CPythonNetworkStream::SERVER_COMMAND_QUIT);

PyModule_AddIntConstant(poModule, "EMPIRE_A", 1);
PyModule_AddIntConstant(poModule, "EMPIRE_B", 2);
PyModule_AddIntConstant(poModule, "EMPIRE_C", 3);
PyModule_AddIntConstant(poModule, "DS_SUB_HEADER_REFINE_FAIL", DS_SUB_HEADER_REFINE_FAIL);
PyModule_AddIntConstant(poModule, "DS_SUB_HEADER_REFINE_FAIL_MAX_REFINE", DS_SUB_HEADER_REFINE_FAIL_MAX_REFINE);
PyModule_AddIntConstant(poModule, "DS_SUB_HEADER_REFINE_FAIL_INVALID_MATERIAL", DS_SUB_HEADER_REFINE_FAIL_INVALID_MATERIAL);
PyModule_AddIntConstant(poModule, "DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MONEY", DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MONEY);
PyModule_AddIntConstant(poModule, "DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MATERIAL", DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MATERIAL);
PyModule_AddIntConstant(poModule, "DS_SUB_HEADER_REFINE_FAIL_TOO_MUCH_MATERIAL", DS_SUB_HEADER_REFINE_FAIL_TOO_MUCH_MATERIAL);
PyModule_AddIntConstant(poModule, "DS_SUB_HEADER_REFINE_SUCCEED", DS_SUB_HEADER_REFINE_SUCCEED);
}

#include "StdAfx.h"
#include "PythonNetworkStream.h"
#include "PythonItem.h"
#include "PythonShop.h"
#include "PythonExchange.h"
#include "PythonSafeBox.h"
#include "PythonCharacterManager.h"

#include "AbstractPlayer.h"

//////////////////////////////////////////////////////////////////////////
// SafeBox

bool CPythonNetworkStream::SendSafeBoxMoneyPacket(BYTE byState, DWORD dwMoney)
{
assert(!"CPythonNetworkStream::SendSafeBoxMoneyPacket - 사용하지 않는 함수");
return false;

// TPacketCGSafeboxMoney kSafeboxMoney;
// kSafeboxMoney.bHeader = HEADER_CG_SAFEBOX_MONEY;
// kSafeboxMoney.bState = byState;
// kSafeboxMoney.dwMoney = dwMoney;
// if (!Send(sizeof(kSafeboxMoney), &kSafeboxMoney))
// return false;
//
// return SendSequence();
}

#if defined(__EXTENDED_SAFEBOX__)
bool CPythonNetworkStream::SendSafeBoxCheckinPacket(TItemPos InventoryPos, DWORD bySafeBoxPos)
#else
bool CPythonNetworkStream::SendSafeBoxCheckinPacket(TItemPos InventoryPos, BYTE bySafeBoxPos)
#endif
{
__PlayInventoryItemDropSound(InventoryPos);

TPacketCGSafeboxCheckin kSafeboxCheckin;
kSafeboxCheckin.bHeader = HEADER_CG_SAFEBOX_CHECKIN;
kSafeboxCheckin.ItemPos = InventoryPos;
kSafeboxCheckin.bSafePos = bySafeBoxPos;
if (!Send(sizeof(kSafeboxCheckin), &kSafeboxCheckin))
return false;

return SendSequence();
}

#if defined(__EXTENDED_SAFEBOX__)
bool CPythonNetworkStream::SendSafeBoxCheckoutPacket(DWORD bySafeBoxPos, TItemPos InventoryPos)
#else
bool CPythonNetworkStream::SendSafeBoxCheckoutPacket(BYTE bySafeBoxPos, TItemPos InventoryPos)
#endif
{
__PlaySafeBoxItemDropSound(bySafeBoxPos);

TPacketCGSafeboxCheckout kSafeboxCheckout;
kSafeboxCheckout.bHeader = HEADER_CG_SAFEBOX_CHECKOUT;
kSafeboxCheckout.bSafePos = bySafeBoxPos;
kSafeboxCheckout.ItemPos = InventoryPos;
if (!Send(sizeof(kSafeboxCheckout), &kSafeboxCheckout))
return false;

return SendSequence();
}

#if defined(__EXTENDED_SAFEBOX__)
bool CPythonNetworkStream::SendSafeBoxItemMovePacket(DWORD bySourcePos, DWORD byTargetPos, BYTE byCount)
#else
bool CPythonNetworkStream::SendSafeBoxItemMovePacket(BYTE bySourcePos, BYTE byTargetPos, BYTE byCount)
#endif
{
__PlaySafeBoxItemDropSound(bySourcePos);

TPacketCGItemMove kItemMove;
kItemMove.header = HEADER_CG_SAFEBOX_ITEM_MOVE;
kItemMove.pos = TItemPos(INVENTORY, bySourcePos);
kItemMove.num = byCount;
kItemMove.change_pos = TItemPos(INVENTORY, byTargetPos);
if (!Send(sizeof(kItemMove), &kItemMove))
return false;

return SendSequence();
}

bool CPythonNetworkStream::RecvSafeBoxSetPacket()
{
TPacketGCItemSet2 kItemSet;
if (!Recv(sizeof(kItemSet), &kItemSet))
return false;

TItemData kItemData;
kItemData.vnum = kItemSet.vnum;
kItemData.count = kItemSet.count;
kItemData.flags = kItemSet.flags;
kItemData.anti_flags = kItemSet.anti_flags;
for (int isocket=0; isocket<ITEM_SOCKET_SLOT_MAX_NUM; ++isocket)
kItemData.alSockets[isocket] = kItemSet.alSockets[isocket];
for (int iattr=0; iattr<ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++iattr)
kItemData.aAttr[iattr] = kItemSet.aAttr[iattr];

CPythonSafeBox::Instance().SetItemData(kItemSet.Cell.cell, kItemData);

__RefreshSafeboxWindow();

return true;
}

bool CPythonNetworkStream::RecvSafeBoxDelPacket()
{
TPacketGCItemDel kItemDel;
if (!Recv(sizeof(kItemDel), &kItemDel))
return false;

CPythonSafeBox::Instance().DelItemData(kItemDel.pos);

__RefreshSafeboxWindow();

return true;
}

bool CPythonNetworkStream::RecvSafeBoxWrongPasswordPacket()
{
TPacketGCSafeboxWrongPassword kSafeboxWrongPassword;

if (!Recv(sizeof(kSafeboxWrongPassword), &kSafeboxWrongPassword))
return false;

PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnSafeBoxError", Py_BuildValue("()"));

return true;
}

bool CPythonNetworkStream::RecvSafeBoxSizePacket()
{
TPacketGCSafeboxSize kSafeBoxSize;
if (!Recv(sizeof(kSafeBoxSize), &kSafeBoxSize))
return false;

CPythonSafeBox::Instance().OpenSafeBox(kSafeBoxSize.bSize);
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OpenSafeboxWindow", Py_BuildValue("(i)", kSafeBoxSize.bSize));

return true;
}

bool CPythonNetworkStream::RecvSafeBoxMoneyChangePacket()
{
TPacketGCSafeboxMoneyChange kMoneyChange;
if (!Recv(sizeof(kMoneyChange), &kMoneyChange))
return false;

CPythonSafeBox::Instance().SetMoney(kMoneyChange.dwMoney);
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshSafeboxMoney", Py_BuildValue("()"));

return true;
}

// SafeBox
//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////
// Mall
#if defined(__EXTENDED_SAFEBOX__)
bool CPythonNetworkStream::SendMallCheckoutPacket(DWORD byMallPos, TItemPos InventoryPos)
#else
bool CPythonNetworkStream::SendMallCheckoutPacket(BYTE byMallPos, TItemPos InventoryPos)
#endif
{
__PlayMallItemDropSound(byMallPos);

TPacketCGMallCheckout kMallCheckoutPacket;
kMallCheckoutPacket.bHeader = HEADER_CG_MALL_CHECKOUT;
kMallCheckoutPacket.bMallPos = byMallPos;
kMallCheckoutPacket.ItemPos = InventoryPos;
if (!Send(sizeof(kMallCheckoutPacket), &kMallCheckoutPacket))
return false;

return SendSequence();
}

bool CPythonNetworkStream::RecvMallOpenPacket()
{
TPacketGCMallOpen kMallOpen;
if (!Recv(sizeof(kMallOpen), &kMallOpen))
return false;

CPythonSafeBox::Instance().OpenMall(kMallOpen.bSize);
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OpenMallWindow", Py_BuildValue("(i)", kMallOpen.bSize));

return true;
}
bool CPythonNetworkStream::RecvMallItemSetPacket()
{
TPacketGCItemSet2 kItemSet;
if (!Recv(sizeof(kItemSet), &kItemSet))
return false;

TItemData kItemData;
kItemData.vnum = kItemSet.vnum;
kItemData.count = kItemSet.count;
kItemData.flags = kItemSet.flags;
kItemData.anti_flags = kItemSet.anti_flags;
for (int isocket=0; isocket<ITEM_SOCKET_SLOT_MAX_NUM; ++isocket)
kItemData.alSockets[isocket] = kItemSet.alSockets[isocket];
for (int iattr=0; iattr<ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++iattr)
kItemData.aAttr[iattr] = kItemSet.aAttr[iattr];

CPythonSafeBox::Instance().SetMallItemData(kItemSet.Cell.cell, kItemData);

__RefreshMallWindow();

return true;
}
bool CPythonNetworkStream::RecvMallItemDelPacket()
{
TPacketGCItemDel kItemDel;
if (!Recv(sizeof(kItemDel), &kItemDel))
return false;

CPythonSafeBox::Instance().DelMallItemData(kItemDel.pos);

__RefreshMallWindow();
Tracef(" >> CPythonNetworkStream::RecvMallItemDelPacket\n");

return true;
}
// Mall
//////////////////////////////////////////////////////////////////////////

// Item
// Recieve
bool CPythonNetworkStream::RecvItemSetPacket()
{
TPacketGCItemSet packet_item_set;

if (!Recv(sizeof(TPacketGCItemSet), &packet_item_set))
return false;

TItemData kItemData;
kItemData.vnum = packet_item_set.vnum;
kItemData.count = packet_item_set.count;
kItemData.flags = 0;
for (int i=0; i<ITEM_SOCKET_SLOT_MAX_NUM; ++i)
kItemData.alSockets=packet_item_set.alSockets;
for (int j=0; j<ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++j)
kItemData.aAttr[j]=packet_item_set.aAttr[j];

IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();

rkPlayer.SetItemData(packet_item_set.Cell, kItemData);

__RefreshInventoryWindow();
return true;
}

bool CPythonNetworkStream::RecvItemSetPacket2()
{
TPacketGCItemSet2 packet_item_set;

if (!Recv(sizeof(TPacketGCItemSet2), &packet_item_set))
return false;

TItemData kItemData;
kItemData.vnum = packet_item_set.vnum;
kItemData.count = packet_item_set.count;
kItemData.flags = packet_item_set.flags;
kItemData.anti_flags = packet_item_set.anti_flags;

for (int i=0; i<ITEM_SOCKET_SLOT_MAX_NUM; ++i)
kItemData.alSockets=packet_item_set.alSockets;
for (int j=0; j<ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++j)
kItemData.aAttr[j]=packet_item_set.aAttr[j];

IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
rkPlayer.SetItemData(packet_item_set.Cell, kItemData);

if (packet_item_set.highlight)
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Highlight_Item", Py_BuildValue("(ii)", packet_item_set.Cell.window_type, packet_item_set.Cell.cell));

__RefreshInventoryWindow();
return true;
}

bool CPythonNetworkStream::RecvItemUsePacket()
{
TPacketGCItemUse packet_item_use;

if (!Recv(sizeof(TPacketGCItemUse), &packet_item_use))
return false;

__RefreshInventoryWindow();
return true;
}

bool CPythonNetworkStream::RecvItemUpdatePacket()
{
TPacketGCItemUpdate packet_item_update;

if (!Recv(sizeof(TPacketGCItemUpdate), &packet_item_update))
return false;

IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
rkPlayer.SetItemCount(packet_item_update.Cell, packet_item_update.count);
for (int i = 0; i < ITEM_SOCKET_SLOT_MAX_NUM; ++i)
rkPlayer.SetItemMetinSocket(packet_item_update.Cell, i, packet_item_update.alSockets);
for (int j = 0; j < ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++j)
rkPlayer.SetItemAttribute(packet_item_update.Cell, j, packet_item_update.aAttr[j].bType, packet_item_update.aAttr[j].sValue);

__RefreshInventoryWindow();
return true;
}

bool CPythonNetworkStream::RecvItemGroundAddPacket()
{
TPacketGCItemGroundAdd packet_item_ground_add;

if (!Recv(sizeof(TPacketGCItemGroundAdd), &packet_item_ground_add))
return false;

__GlobalPositionToLocalPosition(packet_item_ground_add.lX, packet_item_ground_add.lY);

CPythonItem::Instance().CreateItem(packet_item_ground_add.dwVID,
packet_item_ground_add.dwVnum,
packet_item_ground_add.lX,
packet_item_ground_add.lY,
packet_item_ground_add.lZ);
return true;
}

bool CPythonNetworkStream::RecvItemOwnership()
{
TPacketGCItemOwnership p;

if (!Recv(sizeof(TPacketGCItemOwnership), &p))
return false;

CPythonItem::Instance().SetOwnership(p.dwVID, p.szName);
return true;
}

bool CPythonNetworkStream::RecvItemGroundDelPacket()
{
TPacketGCItemGroundDel packet_item_ground_del;

if (!Recv(sizeof(TPacketGCItemGroundDel), &packet_item_ground_del))
return false;

CPythonItem::Instance().DeleteItem(packet_item_ground_del.vid);
return true;
}

bool CPythonNetworkStream::RecvQuickSlotAddPacket()
{
TPacketGCQuickSlotAdd packet_quick_slot_add;

if (!Recv(sizeof(TPacketGCQuickSlotAdd), &packet_quick_slot_add))
return false;

IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
rkPlayer.AddQuickSlot(packet_quick_slot_add.pos, packet_quick_slot_add.slot.Type, packet_quick_slot_add.slot.Position);

__RefreshInventoryWindow();

return true;
}

bool CPythonNetworkStream::RecvQuickSlotDelPacket()
{
TPacketGCQuickSlotDel packet_quick_slot_del;

if (!Recv(sizeof(TPacketGCQuickSlotDel), &packet_quick_slot_del))
return false;

IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
rkPlayer.DeleteQuickSlot(packet_quick_slot_del.pos);

__RefreshInventoryWindow();

return true;
}

bool CPythonNetworkStream::RecvQuickSlotMovePacket()
{
TPacketGCQuickSlotSwap packet_quick_slot_swap;

if (!Recv(sizeof(TPacketGCQuickSlotSwap), &packet_quick_slot_swap))
return false;

IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
rkPlayer.MoveQuickSlot(packet_quick_slot_swap.pos, packet_quick_slot_swap.change_pos);

__RefreshInventoryWindow();

return true;
}

bool CPythonNetworkStream::SendShopEndPacket()
{
if (!__CanActMainInstance())
return true;

TPacketCGShop packet_shop;
packet_shop.header = HEADER_CG_SHOP;
packet_shop.subheader = SHOP_SUBHEADER_CG_END;

if (!Send(sizeof(packet_shop), &packet_shop))
{
Tracef("SendShopEndPacket Error\n");
return false;
}

return SendSequence();
}

bool CPythonNetworkStream::SendShopBuyPacket(BYTE bPos)
{
if (!__CanActMainInstance())
return true;

TPacketCGShop PacketShop;
PacketShop.header = HEADER_CG_SHOP;
PacketShop.subheader = SHOP_SUBHEADER_CG_BUY;

if (!Send(sizeof(TPacketCGShop), &PacketShop))
{
Tracef("SendShopBuyPacket Error\n");
return false;
}

BYTE bCount=1;
if (!Send(sizeof(BYTE), &bCount))
{
Tracef("SendShopBuyPacket Error\n");
return false;
}

if (!Send(sizeof(BYTE), &bPos))
{
Tracef("SendShopBuyPacket Error\n");
return false;
}

return SendSequence();
}

#ifdef OFFLINE_SHOP_FIX
bool CPythonNetworkStream::SendShopRemoveItemPacket(DWORD shop_id, BYTE bPos)
{
if (!__CanActMainInstance())
return true;

TPacketCGShop2 PacketShop;
PacketShop.header = HEADER_CG_SHOP2;
PacketShop.subheader = SHOP2_SUBHEADER_CG_REMOVE_ITEM;
PacketShop.shop_id = shop_id;
PacketShop.bPos = bPos;

if (!Send(sizeof(TPacketCGShop2), &PacketShop))
{
Tracef("SendShopRemoveItemPacket Error\n");
return false;
}

return SendSequence();
}

bool CPythonNetworkStream::SendShopAddItemPacket(DWORD shop_id, BYTE bPos, DWORD sPos, BYTE window_type, long long price)
{
if (!__CanActMainInstance())
return true;

TPacketCGShop2 PacketShop;
PacketShop.header = HEADER_CG_SHOP2;
PacketShop.subheader = SHOP2_SUBHEADER_CG_ADD_ITEM;
PacketShop.shop_id = shop_id;
PacketShop.bPos = bPos;
PacketShop.sPos = sPos;
PacketShop.window_type = window_type;
PacketShop.price = price;

if (!Send(sizeof(TPacketCGShop2), &PacketShop))
{
Tracef("SendShopAddItemPacket Error\n");
return false;
}

return SendSequence();
}
#endif

bool CPythonNetworkStream::SendShopSellPacket(BYTE bySlot)
{
if (!__CanActMainInstance())
return true;

TPacketCGShop PacketShop;
PacketShop.header = HEADER_CG_SHOP;
PacketShop.subheader = SHOP_SUBHEADER_CG_SELL;

if (!Send(sizeof(TPacketCGShop), &PacketShop))
{
Tracef("SendShopSellPacket Error\n");
return false;
}
if (!Send(sizeof(BYTE), &bySlot))
{
Tracef("SendShopAddSellPacket Error\n");
return false;
}

return SendSequence();
}

bool CPythonNetworkStream::SendShopSellPacketNew(BYTE bySlot, BYTE byCount)
{
if (!__CanActMainInstance())
return true;

TPacketCGShop PacketShop;
PacketShop.header = HEADER_CG_SHOP;
PacketShop.subheader = SHOP_SUBHEADER_CG_SELL2;

if (!Send(sizeof(TPacketCGShop), &PacketShop))
{
Tracef("SendShopSellPacket Error\n");
return false;
}
if (!Send(sizeof(BYTE), &bySlot))
{
Tracef("SendShopAddSellPacket Error\n");
return false;
}
if (!Send(sizeof(BYTE), &byCount))
{
Tracef("SendShopAddSellPacket Error\n");
return false;
}

Tracef(" SendShopSellPacketNew(bySlot=%d, byCount=%d)\n", bySlot, byCount);

return SendSequence();
}

// Send
bool CPythonNetworkStream::SendItemUsePacket(TItemPos pos)
{
if (!__CanActMainInstance())
return true;

if (__IsEquipItemInSlot(pos))
{
if (CPythonExchange::Instance().isTrading())
{
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_AppendNotifyMessage", Py_BuildValue("(s)", "CANNOT_EQUIP_EXCHANGE"));
return true;
}

if (CPythonShop::Instance().IsOpen())
{
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_AppendNotifyMessage", Py_BuildValue("(s)", "CANNOT_EQUIP_SHOP"));
return true;
}

if (__IsPlayerAttacking())
return true;
}

__PlayInventoryItemUseSound(pos);

TPacketCGItemUse itemUsePacket;
itemUsePacket.header = HEADER_CG_ITEM_USE;
itemUsePacket.pos = pos;

if (!Send(sizeof(TPacketCGItemUse), &itemUsePacket))
{
Tracen("SendItemUsePacket Error");
return false;
}

return SendSequence();
}

bool CPythonNetworkStream::SendItemUseToItemPacket(TItemPos source_pos, TItemPos target_pos)
{
if (!__CanActMainInstance())
return true;

TPacketCGItemUseToItem itemUseToItemPacket;
itemUseToItemPacket.header = HEADER_CG_ITEM_USE_TO_ITEM;
itemUseToItemPacket.source_pos = source_pos;
itemUseToItemPacket.target_pos = target_pos;

if (!Send(sizeof(TPacketCGItemUseToItem), &itemUseToItemPacket))
{
Tracen("SendItemUseToItemPacket Error");
return false;
}

#ifdef _DEBUG
Tracef(" << SendItemUseToItemPacket(src=%d, dst=%d)\n", source_pos, target_pos);
#endif

return SendSequence();
}

bool CPythonNetworkStream::SendItemDropPacket(TItemPos pos, DWORD elk)
{
if (!__CanActMainInstance())
return true;

TPacketCGItemDrop itemDropPacket;
itemDropPacket.header = HEADER_CG_ITEM_DROP;
itemDropPacket.pos = pos;
itemDropPacket.elk = elk;

if (!Send(sizeof(TPacketCGItemDrop), &itemDropPacket))
{
Tracen("SendItemDropPacket Error");
return false;
}

return SendSequence();
}

bool CPythonNetworkStream::SendItemDropPacketNew(TItemPos pos, DWORD elk, DWORD count)
{
if (!__CanActMainInstance())
return true;

TPacketCGItemDrop2 itemDropPacket;
itemDropPacket.header = HEADER_CG_ITEM_DROP2;
itemDropPacket.pos = pos;
itemDropPacket.gold = elk;
itemDropPacket.count = count;

if (!Send(sizeof(itemDropPacket), &itemDropPacket))
{
Tracen("SendItemDropPacket Error");
return false;
}

return SendSequence();
}

#ifdef ENABLE_DESTROY_ITEM
bool CPythonNetworkStream::SendItemDestroyPacket(TItemPos pos)
{
if (!__CanActMainInstance())
return true;

TPacketCGItemDestroy itemDestroyPacket;
itemDestroyPacket.header = HEADER_CG_ITEM_DESTROY;
itemDestroyPacket.pos = pos;

if (!Send(sizeof(itemDestroyPacket), &itemDestroyPacket))
{
Tracen("SendItemDestroyPacket Error");
return false;
}

return SendSequence();
}
#endif

bool CPythonNetworkStream::__IsEquipItemInSlot(TItemPos uSlotPos)
{
IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
return rkPlayer.IsEquipItemInSlot(uSlotPos);
}

void CPythonNetworkStream::__PlayInventoryItemUseSound(TItemPos uSlotPos)
{
IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
DWORD dwItemID=rkPlayer.GetItemIndex(uSlotPos);

CPythonItem& rkItem=CPythonItem::Instance();
rkItem.PlayUseSound(dwItemID);
}

void CPythonNetworkStream::__PlayInventoryItemDropSound(TItemPos uSlotPos)
{
IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
DWORD dwItemID=rkPlayer.GetItemIndex(uSlotPos);

CPythonItem& rkItem=CPythonItem::Instance();
rkItem.PlayDropSound(dwItemID);
}

//void CPythonNetworkStream::__PlayShopItemDropSound(UINT uSlotPos)
//{
// DWORD dwItemID;
// CPythonShop& rkShop=CPythonShop::Instance();
// if (!rkShop.GetSlotItemID(uSlotPos, &dwItemID))
// return;
//
// CPythonItem& rkItem=CPythonItem::Instance();
// rkItem.PlayDropSound(dwItemID);
//}

void CPythonNetworkStream::__PlaySafeBoxItemDropSound(UINT uSlotPos)
{
DWORD dwItemID;
CPythonSafeBox& rkSafeBox=CPythonSafeBox::Instance();
if (!rkSafeBox.GetSlotItemID(uSlotPos, &dwItemID))
return;

CPythonItem& rkItem=CPythonItem::Instance();
rkItem.PlayDropSound(dwItemID);
}

void CPythonNetworkStream::__PlayMallItemDropSound(UINT uSlotPos)
{
DWORD dwItemID;
CPythonSafeBox& rkSafeBox=CPythonSafeBox::Instance();
if (!rkSafeBox.GetSlotMallItemID(uSlotPos, &dwItemID))
return;

CPythonItem& rkItem=CPythonItem::Instance();
rkItem.PlayDropSound(dwItemID);
}

bool CPythonNetworkStream::SendItemMovePacket(TItemPos pos, TItemPos change_pos, BYTE num)
{
if (!__CanActMainInstance())
return true;

if (__IsEquipItemInSlot(pos))
{
if (CPythonExchange::Instance().isTrading())
{
if (pos.IsEquipCell() || change_pos.IsEquipCell())
{
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_AppendNotifyMessage", Py_BuildValue("(s)", "CANNOT_EQUIP_EXCHANGE"));
return true;
}
}

if (CPythonShop::Instance().IsOpen())
{
if (pos.IsEquipCell() || change_pos.IsEquipCell())
{
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_AppendNotifyMessage", Py_BuildValue("(s)", "CANNOT_EQUIP_SHOP"));
return true;
}
}

if (__IsPlayerAttacking())
return true;
}

__PlayInventoryItemDropSound(pos);

TPacketCGItemMove itemMovePacket;
itemMovePacket.header = HEADER_CG_ITEM_MOVE;
itemMovePacket.pos = pos;
itemMovePacket.change_pos = change_pos;
itemMovePacket.num = num;

if (!Send(sizeof(TPacketCGItemMove), &itemMovePacket))
{
Tracen("SendItemMovePacket Error");
return false;
}

return SendSequence();
}

bool CPythonNetworkStream::SendItemPickUpPacket(DWORD vid)
{
if (!__CanActMainInstance())
return true;

TPacketCGItemPickUp itemPickUpPacket;
itemPickUpPacket.header = HEADER_CG_ITEM_PICKUP;
itemPickUpPacket.vid = vid;

if (!Send(sizeof(TPacketCGItemPickUp), &itemPickUpPacket))
{
Tracen("SendItemPickUpPacket Error");
return false;
}

return SendSequence();
}

bool CPythonNetworkStream::SendQuickSlotAddPacket(BYTE wpos, BYTE type, BYTE pos)
{
if (!__CanActMainInstance())
return true;

TPacketCGQuickSlotAdd quickSlotAddPacket;

quickSlotAddPacket.header = HEADER_CG_QUICKSLOT_ADD;
quickSlotAddPacket.pos = wpos;
quickSlotAddPacket.slot.Type = type;
quickSlotAddPacket.slot.Position = pos;

if (!Send(sizeof(TPacketCGQuickSlotAdd), &quickSlotAddPacket))
{
Tracen("SendQuickSlotAddPacket Error");
return false;
}

return SendSequence();
}

bool CPythonNetworkStream::SendQuickSlotDelPacket(BYTE pos)
{
if (!__CanActMainInstance())
return true;

TPacketCGQuickSlotDel quickSlotDelPacket;

quickSlotDelPacket.header = HEADER_CG_QUICKSLOT_DEL;
quickSlotDelPacket.pos = pos;

if (!Send(sizeof(TPacketCGQuickSlotDel), &quickSlotDelPacket))
{
Tracen("SendQuickSlotDelPacket Error");
return false;
}

return SendSequence();
}

bool CPythonNetworkStream::SendQuickSlotMovePacket(BYTE pos, BYTE change_pos)
{
if (!__CanActMainInstance())
return true;

TPacketCGQuickSlotSwap quickSlotSwapPacket;

quickSlotSwapPacket.header = HEADER_CG_QUICKSLOT_SWAP;
quickSlotSwapPacket.pos = pos;
quickSlotSwapPacket.change_pos = change_pos;

if (!Send(sizeof(TPacketCGQuickSlotSwap), &quickSlotSwapPacket))
{
Tracen("SendQuickSlotSwapPacket Error");
return false;
}

return SendSequence();
}

bool CPythonNetworkStream::RecvSpecialEffect()
{
TPacketGCSpecialEffect kSpecialEffect;
if (!Recv(sizeof(kSpecialEffect), &kSpecialEffect))
return false;

DWORD effect = -1;
bool bPlayPotionSound = false; //포션을 먹을 경우는 포션 사운드를 출력하자.!!
bool bAttachEffect = true; //캐리터에 붙는 어태치 이펙트와 일반 이펙트 구분.!!
switch (kSpecialEffect.type)
{
case SE_HPUP_RED:
effect = CInstanceBase::EFFECT_HPUP_RED;
bPlayPotionSound = true;
break;
case SE_SPUP_BLUE:
effect = CInstanceBase::EFFECT_SPUP_BLUE;
bPlayPotionSound = true;
break;
case SE_SPEEDUP_GREEN:
effect = CInstanceBase::EFFECT_SPEEDUP_GREEN;
bPlayPotionSound = true;
break;
case SE_DXUP_PURPLE:
effect = CInstanceBase::EFFECT_DXUP_PURPLE;
bPlayPotionSound = true;
break;
case SE_CRITICAL:
effect = CInstanceBase::EFFECT_CRITICAL;
break;
case SE_PENETRATE:
effect = CInstanceBase::EFFECT_PENETRATE;
break;
case SE_BLOCK:
effect = CInstanceBase::EFFECT_BLOCK;
break;
case SE_DODGE:
effect = CInstanceBase::EFFECT_DODGE;
break;
case SE_CHINA_FIREWORK:
effect = CInstanceBase::EFFECT_FIRECRACKER;
bAttachEffect = false;
break;
case SE_SPIN_TOP:
effect = CInstanceBase::EFFECT_SPIN_TOP;
bAttachEffect = false;
break;
case SE_SUCCESS :
effect = CInstanceBase::EFFECT_SUCCESS ;
bAttachEffect = false ;
break ;
case SE_FAIL :
effect = CInstanceBase::EFFECT_FAIL ;
break ;
case SE_FR_SUCCESS:
effect = CInstanceBase::EFFECT_FR_SUCCESS;
bAttachEffect = false ;
break;
case SE_LEVELUP_ON_14_FOR_GERMANY: //레벨업 14일때 ( 독일전용 )
effect = CInstanceBase::EFFECT_LEVELUP_ON_14_FOR_GERMANY;
bAttachEffect = false ;
break;
case SE_LEVELUP_UNDER_15_FOR_GERMANY: //레벨업 15일때 ( 독일전용 )
effect = CInstanceBase::EFFECT_LEVELUP_UNDER_15_FOR_GERMANY;
bAttachEffect = false ;
break;
case SE_PERCENT_DAMAGE1:
effect = CInstanceBase::EFFECT_PERCENT_DAMAGE1;
break;
case SE_PERCENT_DAMAGE2:
effect = CInstanceBase::EFFECT_PERCENT_DAMAGE2;
break;
case SE_PERCENT_DAMAGE3:
effect = CInstanceBase::EFFECT_PERCENT_DAMAGE3;
break;
case SE_AUTO_HPUP:
effect = CInstanceBase::EFFECT_AUTO_HPUP;
break;
case SE_AUTO_SPUP:
effect = CInstanceBase::EFFECT_AUTO_SPUP;
break;
case SE_EQUIP_RAMADAN_RING:
effect = CInstanceBase::EFFECT_RAMADAN_RING_EQUIP;
break;
case SE_EQUIP_HALLOWEEN_CANDY:
effect = CInstanceBase::EFFECT_HALLOWEEN_CANDY_EQUIP;
break;
case SE_EQUIP_HAPPINESS_RING:
effect = CInstanceBase::EFFECT_HAPPINESS_RING_EQUIP;
break;
case SE_EQUIP_LOVE_PENDANT:
effect = CInstanceBase::EFFECT_LOVE_PENDANT_EQUIP;
break;
#ifdef ENABLE_SASH_SYSTEM
case SE_EFFECT_SASH_SUCCEDED:
effect = CInstanceBase::EFFECT_SASH_SUCCEDED;
break;
case SE_EFFECT_SASH_EQUIP:
effect = CInstanceBase::EFFECT_SASH_EQUIP;
break;
#endif
#ifdef ENABLE_AGGREGATE_MONSTER_EFFECT
case SE_AGGREGATE_MONSTER_EFFECT:
effect = CInstanceBase::EFFECT_AGGREGATE_MONSTER;
break;
#endif
default:
TraceError("%d 는 없는 스페셜 이펙트 번호입니다.TPacketGCSpecialEffect",kSpecialEffect.type);
break;
}

if (bPlayPotionSound)
{
IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
if(rkPlayer.IsMainCharacterIndex(kSpecialEffect.vid))
{
CPythonItem& rkItem=CPythonItem::Instance();
rkItem.PlayUsePotionSound();
}
}

if (-1 != effect)
{
CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(kSpecialEffect.vid);
if (pInstance)
{
if(bAttachEffect)
pInstance->AttachSpecialEffect(effect);
else
pInstance->CreateSpecialEffect(effect);
}
}

return true;
}

bool CPythonNetworkStream::RecvSpecificEffect()
{
TPacketGCSpecificEffect kSpecificEffect;
if (!Recv(sizeof(kSpecificEffect), &kSpecificEffect))
return false;

CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(kSpecificEffect.vid);
//EFFECT_TEMP
if (pInstance)
{
CInstanceBase::RegisterEffect(CInstanceBase::EFFECT_TEMP, "", kSpecificEffect.effect_file, false);
pInstance->AttachSpecialEffect(CInstanceBase::EFFECT_TEMP);
}

return true;
}

bool CPythonNetworkStream::RecvDragonSoulRefine()
{
TPacketGCDragonSoulRefine kDragonSoul;

if (!Recv(sizeof(kDragonSoul), &kDragonSoul))
return false;

switch (kDragonSoul.bSubType)
{
case DS_SUB_HEADER_OPEN:
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_DragonSoulRefineWindow_Open", Py_BuildValue("()"));
break;
case DS_SUB_HEADER_REFINE_FAIL:
case DS_SUB_HEADER_REFINE_FAIL_MAX_REFINE:
case DS_SUB_HEADER_REFINE_FAIL_INVALID_MATERIAL:
case DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MONEY:
case DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MATERIAL:
case DS_SUB_HEADER_REFINE_FAIL_TOO_MUCH_MATERIAL:
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_DragonSoulRefineWindow_RefineFail", Py_BuildValue("(iii)",
kDragonSoul.bSubType, kDragonSoul.Pos.window_type, kDragonSoul.Pos.cell));
break;
case DS_SUB_HEADER_REFINE_SUCCEED:
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_DragonSoulRefineWindow_RefineSucceed",
Py_BuildValue("(ii)", kDragonSoul.Pos.window_type, kDragonSoul.Pos.cell));
break;
}

return true;
}

Hikayeler

Biri bana yardım edebilir mi lütfen?

[A]Demonul

Level 2

Ekli dosyalar

Şu an konuyu görüntüleyenler (Toplam : 1, Üye: 0, Misafir: 1)

Benzer konular