sardar/client
1
0
Fork 0
forked from metin2/client
Code Pull Requests Activity

Remove P2P UDP & Hackshield packets

Browse Source
This commit is contained in:
Exynox 2025-04-13 09:05:07 +03:00
parent 5ba1cb44b9
commit 1e96dae60b
15 changed files with 0 additions and 432 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
bin/pack/root/networkmodule.py
View File

@ -85,7 +85,6 @@ class MainStream(object):
net.SetHandler(self) net.SetHandler(self)
net.SetTCPRecvBufferSize(128*1024) net.SetTCPRecvBufferSize(128*1024)
net.SetTCPSendBufferSize(4096) net.SetTCPSendBufferSize(4096)
net.SetUDPRecvBufferSize(4096)
self.id="" self.id=""
self.pwd="" self.pwd=""
@ -261,8 +260,6 @@ class MainStream(object):
else: else:
net.ConnectTCP(self.addr, self.port) net.ConnectTCP(self.addr, self.port)
#net.ConnectUDP(IP, Port)
def SetConnectInfo(self, addr, port, account_addr=0, account_port=0): def SetConnectInfo(self, addr, port, account_addr=0, account_port=0):
self.addr = addr self.addr = addr
self.port = port self.port = port

1
src/EterLib/NetStream.cpp
View File

@ -524,7 +524,6 @@ const char * GetRecvHeaderName(BYTE header)
stringList[154] = "HEADER_GC_AUTH_SUCCESS_OPENID"; stringList[154] = "HEADER_GC_AUTH_SUCCESS_OPENID";
stringList[0xfc] = "HEADER_GC_HANDSHAKE_OK"; stringList[0xfc] = "HEADER_GC_HANDSHAKE_OK";
stringList[0xfd] = "HEADER_GC_PHASE"; stringList[0xfd] = "HEADER_GC_PHASE";
stringList[0xfe] = "HEADER_GC_BINDUDP";
stringList[0xff] = "HEADER_GC_HANDSHAKE"; stringList[0xff] = "HEADER_GC_HANDSHAKE";
} }
return stringList[header].c_str(); return stringList[header].c_str();

24
src/UserInterface/Packet.h
View File

@ -339,9 +339,6 @@ enum
// END_OF_AUTOBAN // END_OF_AUTOBAN
HEADER_GC_HS_REQUEST = 207, // Origially it's 204 on devel branch HEADER_GC_HS_REQUEST = 207, // Origially it's 204 on devel branch
#else
HEADER_GC_HS_REQUEST = 204,
HEADER_GC_XTRAP_CS1_REQUEST = 205,
#endif #endif
#ifdef __AUCTION__ #ifdef __AUCTION__
@ -354,7 +351,6 @@ enum
HEADER_GC_HANDSHAKE_OK = 0xfc, // 252 HEADER_GC_HANDSHAKE_OK = 0xfc, // 252
HEADER_GC_PHASE = 0xfd, // 253 HEADER_GC_PHASE = 0xfd, // 253
HEADER_GC_BINDUDP = 0xfe, // 254
HEADER_GC_HANDSHAKE = 0xff, // 255 HEADER_GC_HANDSHAKE = 0xff, // 255
///////////////////////////////////////////////// /////////////////////////////////////////////////
@ -1149,13 +1145,6 @@ typedef struct packet_header_handshake
LONG lDelta; LONG lDelta;
} TPacketGCHandshake; } TPacketGCHandshake;
typedef struct packet_header_bindudp
{
BYTE header;
DWORD addr;
WORD port;
} TPacketGCBindUDP;
typedef struct packet_header_dynamic_size typedef struct packet_header_dynamic_size
{ {
BYTE header; BYTE header;
@ -2620,19 +2609,6 @@ typedef struct packet_state
TPixelPosition kPPos; TPixelPosition kPPos;
} TPacketCCState; } TPacketCCState;
typedef struct packet_hs_check_req
{
BYTE bHeader;
AHNHS_TRANS_BUFFER Req;
} TPacketHSCheck;
//NOTE : recv/send에 공통으로 생김, bPacketData의 내용만 바뀐다.
typedef struct packet_xtrap_verify
{
BYTE bHeader;
BYTE bPacketData[128];
} TPacketXTrapCSVerify;
// AUTOBAN // AUTOBAN
typedef struct packet_autoban_quiz typedef struct packet_autoban_quiz
{ {

213
src/UserInterface/PythonNetworkDatagram.cpp
View File

@ -1,213 +0,0 @@
#include "StdAfx.h"
/*
#include "PythonNetworkDatagram.h"
#include "PythonNetworkStream.h"
class CDatagramPacketHeaderMap : public CNetworkPacketHeaderMap
{
public:
CDatagramPacketHeaderMap()
{
Set(HEADER_CC_STATE_WALKING, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketCCState), false));
}
};
void CPythonNetworkDatagram::Destroy()
{
m_NetSenderPool.Clear();
}
BOOL CPythonNetworkDatagram::CheckPacket(TPacketHeader * piRetHeader)
{
static CDatagramPacketHeaderMap s_packetHeaderMap;
if (!m_NetReceiver.isBind())
return FALSE;
*piRetHeader = 0;
TPacketHeader header;
if (!m_NetReceiver.Peek(&header, sizeof(TPacketHeader)))
return false;
CNetworkPacketHeaderMap::TPacketType PacketType;
if (!s_packetHeaderMap.Get(header, &PacketType))
{
Tracef("Unknown UDP packet header");
assert(!"Unknown UDP packet header");
return FALSE;
}
if (!header)
return FALSE;
*piRetHeader = header;
return TRUE;
}
void CPythonNetworkDatagram::Process()
{
while (m_NetReceiver.Process())
{
TPacketHeader iHeader;
if (!CheckPacket(&iHeader))
continue;
switch(iHeader)
{
case HEADER_CC_STATE_WALKING:
RecvStateWalkingPacket();
break;
case HEADER_CC_STATE_WAITING:
case HEADER_CC_STATE_GOING:
case HEADER_CC_EVENT_NORMAL_ATTACKING:
case HEADER_CC_EVENT_COMBO_ATTACKING:
case HEADER_CC_EVENT_HIT:
break;
}
}
}
void CPythonNetworkDatagram::SetConnection(const char * c_szIP, WORD wPortIndex)
{
m_NetSender.SetSocket(c_szIP, wPortIndex);
}
void CPythonNetworkDatagram::SetRecvBufferSize(DWORD dwSize)
{
m_NetReceiver.SetRecvBufferSize(dwSize);
}
void CPythonNetworkDatagram::SendToServer(const void * c_pBuffer, DWORD dwSize)
{
if (!m_NetSender.isSocket())
{
assert(!"UDP Socket has not set!");
return;
}
m_NetSender.Send(c_pBuffer, dwSize);
}
void CPythonNetworkDatagram::Bind(DWORD dwAddress, WORD wPortIndex)
{
m_NetReceiver.Bind(dwAddress, wPortIndex);
}
void CPythonNetworkDatagram::RegisterSender(DWORD dwID, DWORD dwAddress, WORD wPortIndex)
{
CNetDatagramSender * pSender = m_NetSenderPool.Alloc();
pSender->SetSocket(dwAddress, wPortIndex);
m_NetSenderMap.insert(TNetSenderMap::value_type(dwID, pSender));
}
void CPythonNetworkDatagram::DeleteSender(DWORD dwID)
{
CNetDatagramSender * pSender;
if (!GetSenderPointer(dwID, &pSender))
return;
m_NetSenderPool.Free(pSender);
m_NetSenderMap.erase(dwID);
}
void CPythonNetworkDatagram::Select(DWORD dwID)
{
CNetDatagramSender * pSender;
if (!GetSenderPointer(dwID, &pSender))
return;
m_NetSenderList.push_back(pSender);
}
void CPythonNetworkDatagram::SendToSenders(const void * c_pBuffer, DWORD dwSize)
{
// NOTE : Temporary Code
// Now, Send to every around client.
for (TNetSenderMapIterator itorMap = m_NetSenderMap.begin(); itorMap != m_NetSenderMap.end(); ++itorMap)
{
CNetDatagramSender * pSender = itorMap->second;
m_NetSenderList.push_back(pSender);
}
// NOTE : Temporary Code
for (TNetSenderListIterator itor = m_NetSenderList.begin(); itor != m_NetSenderList.end(); ++itor)
{
CNetDatagramSender * pSender = *itor;
pSender->Send(c_pBuffer, dwSize);
}
m_NetSenderList.clear();
}
BOOL CPythonNetworkDatagram::GetSenderPointer(DWORD dwID, CNetDatagramSender ** ppSender)
{
TNetSenderMapIterator itor = m_NetSenderMap.find(dwID);
if (m_NetSenderMap.end() == itor)
return FALSE;
*ppSender = itor->second;
return TRUE;
}
//////////////////////////////////
// Walking
void CPythonNetworkDatagram::SendCharacterStatePacket(DWORD dwVID, DWORD dwCmdTime, const TPixelPosition& c_rkPPosDst, float fDstRot, UINT eFunc, UINT uArg)
{
fDstRot=fmod(fDstRot, 360.0f);
if (fDstRot<0)
fDstRot=360.0f-fDstRot;
TPacketCCState kStatePacket;
kStatePacket.bHeader=HEADER_CC_STATE_WALKING;
kStatePacket.dwVID=dwVID;
kStatePacket.bFunc=eFunc;
kStatePacket.bArg=uArg;
kStatePacket.bRot=fDstRot/5.0f;
kStatePacket.dwTime=dwCmdTime;
kStatePacket.kPPos=c_rkPPosDst;
//SendToSenders(&kStatePacket, sizeof(kStatePacket));
}
BOOL CPythonNetworkDatagram::RecvStateWalkingPacket()
{
TPacketCCState kStatePacket;
if (!m_NetReceiver.Recv(&kStatePacket, sizeof(kStatePacket)))
{
assert(!"CPythonNetworkDatagram::RecvStatePacket - PAKCET READ ERROR");
Tracenf("CPythonNetworkDatagram::RecvStatePacket - PAKCET READ ERROR");
return FALSE;
}
CInstanceBase * pkChrInst = CPythonCharacterManager::Instance().GetInstancePtr(kStatePacket.dwVID);
if (!pkChrInst)
{
//Tracenf("CPythonNetworkDatagram::RecvStatePacket - NOT EXIST VID(kStateWaitingPacket.vid = %d)", kStatePacket.m_dwVID);
return TRUE;
}
pkChrInst->PushUDPState(kStatePacket.dwTime, kStatePacket.kPPos, kStatePacket.bRot*5.0f, kStatePacket.bFunc, kStatePacket.bArg);
return TRUE;
}
CPythonNetworkDatagram::CPythonNetworkDatagram()
{
}
CPythonNetworkDatagram::~CPythonNetworkDatagram()
{
}
*/

58
src/UserInterface/PythonNetworkDatagram.h
View File

@ -1,58 +0,0 @@
#pragma once
/*
#include "../eterLib/NetDatagramReceiver.h"
#include "../eterLib/NetDatagramSender.h"
#include "Packet.h"
class CPythonNetworkDatagram : public CSingleton<CPythonNetworkDatagram>
{
public:
CPythonNetworkDatagram();
virtual ~CPythonNetworkDatagram();
void Destroy();
// With Server
void SetRecvBufferSize(DWORD dwSize);
void SetConnection(const char * c_szIP, WORD wPortIndex);
void SendToServer(const void * c_pBuffer, DWORD dwSize);
void Bind(DWORD dwAddress, WORD wPortIndex);
// With UDP Senders
void RegisterSender(DWORD dwID, DWORD dwAddress, WORD wPortIndex);
void DeleteSender(DWORD dwID);
void Select(DWORD dwID);
void SendToSenders(const void * c_pBuffer, DWORD dwSize);
// Regulary update function
void Process();
void SendCharacterStatePacket(DWORD dwVID, DWORD dwCmdTime, const TPixelPosition& c_rkPPosDst, float fDstRot, UINT eFunc, UINT uArg);
protected:
BOOL CheckPacket(TPacketHeader * piRetHeader);
BOOL GetSenderPointer(DWORD dwID, CNetDatagramSender ** ppSender);
BOOL RecvStateWalkingPacket();
protected:
// Sender Map
typedef std::map<DWORD, CNetDatagramSender*> TNetSenderMap;
typedef TNetSenderMap::iterator TNetSenderMapIterator;
// Sender List
typedef std::list<CNetDatagramSender*> TNetSenderList;
typedef TNetSenderList::iterator TNetSenderListIterator;
protected:
// Sender
TNetSenderMap m_NetSenderMap;
TNetSenderList m_NetSenderList;
// Connection with server
CNetDatagramSender m_NetSender;
CNetDatagramReceiver m_NetReceiver;
private:
CDynamicPool<CNetDatagramSender> m_NetSenderPool;
};
*/

29
src/UserInterface/PythonNetworkDatagramModule.cpp
View File

@ -1,29 +0,0 @@
#include "StdAfx.h"
#include "PythonNetworkDatagram.h"
/*
PyObject * udpEnable(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkDatagram::Instance().Enable();
return Py_BuildNone();
}
PyObject * udpDisable(PyObject* poSelf, PyObject* poArgs)
{
CPythonNetworkDatagram::Instance().Disable();
return Py_BuildNone();
}
*/
void initudp()
{
/*
static PyMethodDef s_methods[] =
{
{ "Enable", udpEnable, METH_VARARGS },
{ "Disable", udpDisable, METH_VARARGS },
{ NULL, NULL, NULL }
};
PyObject * poModule = Py_InitModule("udp", s_methods);
*/
}

5
src/UserInterface/PythonNetworkStream.cpp
View File

@ -104,7 +104,6 @@ class CMainPacketHeaderMap : public CNetworkPacketHeaderMap
Set(HEADER_GC_HANDSHAKE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCHandshake), STATIC_SIZE_PACKET)); Set(HEADER_GC_HANDSHAKE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCHandshake), STATIC_SIZE_PACKET));
Set(HEADER_GC_HANDSHAKE_OK, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCBlank), STATIC_SIZE_PACKET)); Set(HEADER_GC_HANDSHAKE_OK, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCBlank), STATIC_SIZE_PACKET));
Set(HEADER_GC_BINDUDP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCBindUDP), STATIC_SIZE_PACKET));
Set(HEADER_GC_OWNERSHIP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCOwnership), STATIC_SIZE_PACKET)); Set(HEADER_GC_OWNERSHIP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCOwnership), STATIC_SIZE_PACKET));
Set(HEADER_GC_CREATE_FLY, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCreateFly), STATIC_SIZE_PACKET)); Set(HEADER_GC_CREATE_FLY, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCreateFly), STATIC_SIZE_PACKET));
Set(HEADER_GC_ADD_FLY_TARGETING, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCFlyTargeting), STATIC_SIZE_PACKET)); Set(HEADER_GC_ADD_FLY_TARGETING, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCFlyTargeting), STATIC_SIZE_PACKET));
@ -173,12 +172,8 @@ class CMainPacketHeaderMap : public CNetworkPacketHeaderMap
Set(HEADER_GC_DIG_MOTION, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDigMotion), STATIC_SIZE_PACKET)); Set(HEADER_GC_DIG_MOTION, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDigMotion), STATIC_SIZE_PACKET));
Set(HEADER_GC_DAMAGE_INFO, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDamageInfo), STATIC_SIZE_PACKET)); Set(HEADER_GC_DAMAGE_INFO, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDamageInfo), STATIC_SIZE_PACKET));
Set(HEADER_GC_HS_REQUEST, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketHSCheck), STATIC_SIZE_PACKET));
Set(HEADER_GC_XTRAP_CS1_REQUEST, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketXTrapCSVerify), STATIC_SIZE_PACKET));
Set(HEADER_GC_SPECIFIC_EFFECT, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSpecificEffect), STATIC_SIZE_PACKET)); Set(HEADER_GC_SPECIFIC_EFFECT, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSpecificEffect), STATIC_SIZE_PACKET));
Set(HEADER_GC_DRAGON_SOUL_REFINE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDragonSoulRefine), STATIC_SIZE_PACKET)); Set(HEADER_GC_DRAGON_SOUL_REFINE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDragonSoulRefine), STATIC_SIZE_PACKET));
} }
}; };

4
src/UserInterface/PythonNetworkStream.h
View File

@ -546,10 +546,6 @@ class CPythonNetworkStream : public CNetworkStream, public CSingleton<CPythonNet
// Channel // Channel
bool RecvChannelPacket(); bool RecvChannelPacket();
//Security
bool RecvHSCheckRequest();
bool RecvXTrapVerifyRequest();
protected: protected:
// 이모티콘 // 이모티콘
bool ParseEmoticon(const char * pChatMsg, DWORD * pdwEmoticon); bool ParseEmoticon(const char * pChatMsg, DWORD * pdwEmoticon);

25
src/UserInterface/PythonNetworkStreamModule.cpp
View File

@ -290,16 +290,6 @@ PyObject* netSetTCPSendBufferSize(PyObject* poSelf, PyObject* poArgs)
return Py_BuildNone(); 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) PyObject* netSetMarkServer(PyObject* poSelf, PyObject* poArgs)
{ {
char* szAddr; char* szAddr;
@ -330,19 +320,6 @@ PyObject* netConnectTCP(PyObject* poSelf, PyObject* poArgs)
return Py_BuildNone(); 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) PyObject* netConnectToAccountServer(PyObject* poSelf, PyObject* poArgs)
{ {
char* addr; char* addr;
@ -1736,14 +1713,12 @@ void initnet()
{ "SetHandler", netSetHandler, METH_VARARGS }, { "SetHandler", netSetHandler, METH_VARARGS },
{ "SetTCPRecvBufferSize", netSetTCPRecvBufferSize, METH_VARARGS }, { "SetTCPRecvBufferSize", netSetTCPRecvBufferSize, METH_VARARGS },
{ "SetTCPSendBufferSize", netSetTCPSendBufferSize, METH_VARARGS }, { "SetTCPSendBufferSize", netSetTCPSendBufferSize, METH_VARARGS },
{ "SetUDPRecvBufferSize", netSetUDPRecvBufferSize, METH_VARARGS },
{ "DirectEnter", netDirectEnter, METH_VARARGS }, { "DirectEnter", netDirectEnter, METH_VARARGS },
{ "LogOutGame", netLogOutGame, METH_VARARGS }, { "LogOutGame", netLogOutGame, METH_VARARGS },
{ "ExitGame", netExitGame, METH_VARARGS }, { "ExitGame", netExitGame, METH_VARARGS },
{ "ExitApplication", netExitApplication, METH_VARARGS }, { "ExitApplication", netExitApplication, METH_VARARGS },
{ "ConnectTCP", netConnectTCP, METH_VARARGS }, { "ConnectTCP", netConnectTCP, METH_VARARGS },
{ "ConnectUDP", netConnectUDP, METH_VARARGS },
{ "ConnectToAccountServer", netConnectToAccountServer, METH_VARARGS }, { "ConnectToAccountServer", netConnectToAccountServer, METH_VARARGS },
{ "SendLoginPacket", netSendLoginPacket, METH_VARARGS }, { "SendLoginPacket", netSendLoginPacket, METH_VARARGS },

8
src/UserInterface/PythonNetworkStreamPhaseGame.cpp
View File

@ -591,14 +591,6 @@ void CPythonNetworkStream::GamePhase()
return; return;
break; break;
case HEADER_GC_HS_REQUEST:
ret = RecvHSCheckRequest();
break;
case HEADER_GC_XTRAP_CS1_REQUEST:
ret = RecvXTrapVerifyRequest();
break;
case HEADER_GC_SPECIFIC_EFFECT: case HEADER_GC_SPECIFIC_EFFECT:
ret = RecvSpecificEffect(); ret = RecvSpecificEffect();
break; break;

48
src/UserInterface/PythonNetworkStreamPhaseHandShake.cpp
View File

@ -19,17 +19,6 @@ void CPythonNetworkStream::HandShakePhase()
return; return;
break; break;
case HEADER_GC_BINDUDP:
{
TPacketGCBindUDP BindUDP;
if (!Recv(sizeof(TPacketGCBindUDP), &BindUDP))
return;
return;
}
break;
case HEADER_GC_HANDSHAKE: case HEADER_GC_HANDSHAKE:
{ {
if (!Recv(sizeof(TPacketGCHandshake), &m_HandshakeData)) if (!Recv(sizeof(TPacketGCHandshake), &m_HandshakeData))
@ -134,40 +123,3 @@ bool CPythonNetworkStream::RecvHandshakeOKPacket()
return true; return true;
} }
bool CPythonNetworkStream::RecvHSCheckRequest()
{
TPacketHSCheck packet;
if (!Recv(sizeof(packet), &packet))
{
TraceError("HShield: Recv failed");
return false;
}
return false;
}
bool CPythonNetworkStream::RecvXTrapVerifyRequest()
{
TPacketXTrapCSVerify packet;
if (!Recv(sizeof(packet), &packet))
{
TraceError("XTrap: Recv failed");
return false;
}
TPacketXTrapCSVerify packet_res;
packet_res.bHeader = HEADER_CG_XTRAP_ACK;
if (!Send(sizeof(packet_res), &packet_res))
{
TraceError("XTrap: Send failed");
return false;
}
return true;
}

1
src/UserInterface/StdAfx.h
View File

@ -42,7 +42,6 @@ enum
#endif #endif
}; };
void initudp();
void initapp(); void initapp();
void initime(); void initime();
void initsystem(); void initsystem();

1
src/UserInterface/UserInterface.cpp
View File

@ -292,7 +292,6 @@ bool RunMainScript(CPythonLauncher& pyLauncher, const char* lpCmdLine)
initgrpText(); initgrpText();
initwndMgr(); initwndMgr();
///////////////////////////////////////////// /////////////////////////////////////////////
initudp();
initapp(); initapp();
initsystem(); initsystem();
initchr(); initchr();

3
src/UserInterface/UserInterface.vcxproj
View File

@ -281,8 +281,6 @@
<ClCompile Include="PythonMessenger.cpp" /> <ClCompile Include="PythonMessenger.cpp" />
<ClCompile Include="PythonMiniMap.cpp" /> <ClCompile Include="PythonMiniMap.cpp" />
<ClCompile Include="PythonMiniMapModule.cpp" /> <ClCompile Include="PythonMiniMapModule.cpp" />
<ClCompile Include="PythonNetworkDatagram.cpp" />
<ClCompile Include="PythonNetworkDatagramModule.cpp" />
<ClCompile Include="PythonNetworkStream.cpp" /> <ClCompile Include="PythonNetworkStream.cpp" />
<ClCompile Include="PythonNetworkStreamCommand.cpp" /> <ClCompile Include="PythonNetworkStreamCommand.cpp" />
<ClCompile Include="PythonNetworkStreamEvent.cpp" /> <ClCompile Include="PythonNetworkStreamEvent.cpp" />
@ -357,7 +355,6 @@
<ClInclude Include="PythonItem.h" /> <ClInclude Include="PythonItem.h" />
<ClInclude Include="PythonMessenger.h" /> <ClInclude Include="PythonMessenger.h" />
<ClInclude Include="PythonMiniMap.h" /> <ClInclude Include="PythonMiniMap.h" />
<ClInclude Include="PythonNetworkDatagram.h" />
<ClInclude Include="PythonNetworkStream.h" /> <ClInclude Include="PythonNetworkStream.h" />
<ClInclude Include="PythonNonPlayer.h" /> <ClInclude Include="PythonNonPlayer.h" />
<ClInclude Include="PythonPlayer.h" /> <ClInclude Include="PythonPlayer.h" />

9
src/UserInterface/UserInterface.vcxproj.filters
View File

@ -250,12 +250,6 @@
<ClCompile Include="PythonExceptionSender.cpp"> <ClCompile Include="PythonExceptionSender.cpp">
<Filter>Network</Filter> <Filter>Network</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="PythonNetworkDatagram.cpp">
<Filter>Network</Filter>
</ClCompile>
<ClCompile Include="PythonNetworkDatagramModule.cpp">
<Filter>Network</Filter>
</ClCompile>
<ClCompile Include="PythonNetworkStream.cpp"> <ClCompile Include="PythonNetworkStream.cpp">
<Filter>Network</Filter> <Filter>Network</Filter>
</ClCompile> </ClCompile>
@ -424,9 +418,6 @@
<ClInclude Include="PythonExceptionSender.h"> <ClInclude Include="PythonExceptionSender.h">
<Filter>Network</Filter> <Filter>Network</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="PythonNetworkDatagram.h">
<Filter>Network</Filter>
</ClInclude>
<ClInclude Include="PythonNetworkStream.h"> <ClInclude Include="PythonNetworkStream.h">
<Filter>Network</Filter> <Filter>Network</Filter>
</ClInclude> </ClInclude>