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

Merge pull request 'Used antialiasing filter, removed unused code' (#21) from nightly into master

Browse Source 
Reviewed-on: metin2/client#21
This commit is contained in:
Exynox 2025-04-13 16:48:54 +03:00
commit bb19e9abda
35 changed files with 114 additions and 776 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

157
extern/include/armadillo/SecuredSections.h vendored
View File

@ -1,157 +0,0 @@
#if defined(__BORLANDC__)
/* These definitions provided by Dr. Todd Brennan, 04Oct2002 */
#define SECUREBEGIN _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0x00;}
#define SECUREEND _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0xFF;}
#define SECUREBEGIN_A _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0x01;}
#define SECUREEND_A _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0xFF;}
#define SECUREBEGIN_B _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0x02;}
#define SECUREEND_B _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0xFF;}
#define SECUREBEGIN_C _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0x03;}
#define SECUREEND_C _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0xFF;}
#define SECUREBEGIN_D _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0x04;}
#define SECUREEND_D _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0xFF;}
#define SECUREBEGIN_E _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0x05;}
#define SECUREEND_E _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0xFF;}
#define SECUREBEGIN_F _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0x06;}
#define SECUREEND_F _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0xFF;}
#define SECUREBEGIN_G _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0x07;}
#define SECUREEND_G _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0xFF;}
#define SECUREBEGIN_H _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0x08;}
#define SECUREEND_H _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0xFF;}
#define SECUREBEGIN_I _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0x09;}
#define SECUREEND_I _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0xFF;}
#define SECUREBEGIN_J _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0x0A;}
#define SECUREEND_J _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0xFF;}
#define SECUREBEGIN_K _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0x0B;}
#define SECUREEND_K _asm {db 0xEB; db 0x03; db 0xD6; db 0xD6; db 0xFF;}
#define NANOBEGIN _asm {db 0xEB; db 0x03; db 0xD6; db 0xD7; db 0x01;}
#define NANOEND _asm {db 0xEB; db 0x03; db 0xD6; db 0xD7; db 0x00;}
/* The former definitions for Borland C++ Builder, if anyone needs them. */
/*
#define SECUREBEGIN __emit__ (0xEB,0x03,0xD6,0xD6,0x00);
#define SECUREEND __emit__ (0xEB,0x03,0xD6,0xD6,0xFF);
#define SECUREBEGIN_A __emit__ (0xEB,0x03,0xD6,0xD6,0x01);
#define SECUREEND_A __emit__ (0xEB,0x03,0xD6,0xD6,0xFF);
#define SECUREBEGIN_B __emit__ (0xEB,0x03,0xD6,0xD6,0x02);
#define SECUREEND_B __emit__ (0xEB,0x03,0xD6,0xD6,0xFF);
#define SECUREBEGIN_C __emit__ (0xEB,0x03,0xD6,0xD6,0x03);
#define SECUREEND_C __emit__ (0xEB,0x03,0xD6,0xD6,0xFF);
#define NANOBEGIN __emit__ (0xEB,0x03,0xD6,0xD7,0x01);
#define NANOEND __emit__ (0xEB,0x03,0xD6,0xD7,0x00);
*/
#elif defined(__LCC__)
/* Provided by Rubem Pechansky, 26Feb2003 */
#define SECUREBEGIN _asm(".byte 0xEB,0x03,0xD6,0xD6,0x00");
#define SECUREEND _asm(".byte 0xEB,0x03,0xD6,0xD6,0xFF");
#define SECUREBEGIN_A _asm(".byte 0xEB,0x03,0xD6,0xD6,0x01");
#define SECUREEND_A _asm(".byte 0xEB,0x03,0xD6,0xD6,0xFF");
#define SECUREBEGIN_B _asm(".byte 0xEB,0x03,0xD6,0xD6,0x02");
#define SECUREEND_B _asm(".byte 0xEB,0x03,0xD6,0xD6,0xFF");
#define SECUREBEGIN_C _asm(".byte 0xEB,0x03,0xD6,0xD6,0x03");
#define SECUREEND_C _asm(".byte 0xEB,0x03,0xD6,0xD6,0xFF");
#define SECUREBEGIN_D _asm(".byte 0xEB,0x03,0xD6,0xD6,0x04");
#define SECUREEND_D _asm(".byte 0xEB,0x03,0xD6,0xD6,0xFF");
#define SECUREBEGIN_E _asm(".byte 0xEB,0x03,0xD6,0xD6,0x05");
#define SECUREEND_E _asm(".byte 0xEB,0x03,0xD6,0xD6,0xFF");
#define SECUREBEGIN_F _asm(".byte 0xEB,0x03,0xD6,0xD6,0x06");
#define SECUREEND_F _asm(".byte 0xEB,0x03,0xD6,0xD6,0xFF");
#define SECUREBEGIN_G _asm(".byte 0xEB,0x03,0xD6,0xD6,0x07");
#define SECUREEND_G _asm(".byte 0xEB,0x03,0xD6,0xD6,0xFF");
#define SECUREBEGIN_H _asm(".byte 0xEB,0x03,0xD6,0xD6,0x08");
#define SECUREEND_H _asm(".byte 0xEB,0x03,0xD6,0xD6,0xFF");
#define SECUREBEGIN_I _asm(".byte 0xEB,0x03,0xD6,0xD6,0x09");
#define SECUREEND_I _asm(".byte 0xEB,0x03,0xD6,0xD6,0xFF");
#define SECUREBEGIN_J _asm(".byte 0xEB,0x03,0xD6,0xD6,0x0A");
#define SECUREEND_J _asm(".byte 0xEB,0x03,0xD6,0xD6,0xFF");
#define SECUREBEGIN_K _asm(".byte 0xEB,0x03,0xD6,0xD6,0x0B");
#define SECUREEND_K _asm(".byte 0xEB,0x03,0xD6,0xD6,0xFF");
#define NANOBEGIN _asm(".byte 0xEB,0x03,0xD6,0xD7,0x01");
#define NANOEND _asm(".byte 0xEB,0x03,0xD6,0xD7,0x00");
#endif
#ifdef _WIN64
#define ARMACCESS_API __declspec(dllimport) __stdcall
extern "C" void ARMACCESS_API SECUREBEGIN(void);
extern "C" void ARMACCESS_API SECUREBEGIN_A(void);
extern "C" void ARMACCESS_API SECUREBEGIN_B(void);
extern "C" void ARMACCESS_API SECUREBEGIN_C(void);
extern "C" void ARMACCESS_API SECUREBEGIN_D(void);
extern "C" void ARMACCESS_API SECUREBEGIN_E(void);
extern "C" void ARMACCESS_API SECUREBEGIN_F(void);
extern "C" void ARMACCESS_API SECUREBEGIN_G(void);
extern "C" void ARMACCESS_API SECUREBEGIN_H(void);
extern "C" void ARMACCESS_API SECUREBEGIN_I(void);
extern "C" void ARMACCESS_API SECUREBEGIN_J(void);
extern "C" void ARMACCESS_API SECUREBEGIN_K(void);
extern "C" void ARMACCESS_API SECUREEND(void);
extern "C" void ARMACCESS_API SECUREEND_A(void);
extern "C" void ARMACCESS_API SECUREEND_B(void);
extern "C" void ARMACCESS_API SECUREEND_C(void);
extern "C" void ARMACCESS_API SECUREEND_D(void);
extern "C" void ARMACCESS_API SECUREEND_E(void);
extern "C" void ARMACCESS_API SECUREEND_F(void);
extern "C" void ARMACCESS_API SECUREEND_G(void);
extern "C" void ARMACCESS_API SECUREEND_H(void);
extern "C" void ARMACCESS_API SECUREEND_I(void);
extern "C" void ARMACCESS_API SECUREEND_J(void);
extern "C" void ARMACCESS_API SECUREEND_K(void);
extern "C" void ARMACCESS_API NANOBEGIN(void);
extern "C" void ARMACCESS_API NANOEND(void);
#define SECUREBEGIN SECUREBEGIN()
#define SECUREEND SECUREEND()
#define SECUREBEGIN_A SECUREBEGIN_A()
#define SECUREEND_A SECUREEND_A()
#define SECUREBEGIN_B SECUREBEGIN_B()
#define SECUREEND_B SECUREEND_B()
#define SECUREBEGIN_C SECUREBEGIN_C()
#define SECUREEND_C SECUREEND_C()
#define SECUREBEGIN_D SECUREBEGIN_D()
#define SECUREEND_D SECUREEND_D()
#define SECUREBEGIN_E SECUREBEGIN_E()
#define SECUREEND_E SECUREEND_E()
#define SECUREBEGIN_F SECUREBEGIN_F()
#define SECUREEND_F SECUREEND_F()
#define SECUREBEGIN_G SECUREBEGIN_G()
#define SECUREEND_G SECUREEND_G()
#define SECUREBEGIN_H SECUREBEGIN_H()
#define SECUREEND_H SECUREEND_H()
#define SECUREBEGIN_I SECUREBEGIN_I()
#define SECUREEND_I SECUREEND_I()
#define SECUREBEGIN_J SECUREBEGIN_J()
#define SECUREEND_J SECUREEND_J()
#define SECUREBEGIN_K SECUREBEGIN_K()
#define SECUREEND_K SECUREEND_K()
#define NANOBEGIN NANOBEGIN()
#define NANOEND NANOEND()
#else
#define SECUREBEGIN __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0x00
#define SECUREEND __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0xFF
#define SECUREBEGIN_A __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0x01
#define SECUREEND_A __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0xFF
#define SECUREBEGIN_B __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0x02
#define SECUREEND_B __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0xFF
#define SECUREBEGIN_C __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0x03
#define SECUREEND_C __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0xFF
#define SECUREBEGIN_D __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0x04
#define SECUREEND_D __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0xFF
#define SECUREBEGIN_E __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0x05
#define SECUREEND_E __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0xFF
#define SECUREBEGIN_F __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0x06
#define SECUREEND_F __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0xFF
#define SECUREBEGIN_G __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0x07
#define SECUREEND_G __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0xFF
#define SECUREBEGIN_H __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0x08
#define SECUREEND_H __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0xFF
#define SECUREBEGIN_I __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0x09
#define SECUREEND_I __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0xFF
#define SECUREBEGIN_J __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0x0A
#define SECUREEND_J __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0xFF
#define SECUREBEGIN_K __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0x0B
#define SECUREEND_K __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD6 __asm _emit 0xFF
#define NANOBEGIN __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD7 __asm _emit 0x01
#define NANOEND __asm _emit 0xEB __asm _emit 0x03 __asm _emit 0xD6 __asm _emit 0xD7 __asm _emit 0x00
#endif

8
src/Config/version_info.rc
View File

@ -15,8 +15,8 @@
#endif #endif
VS_VERSION_INFO VERSIONINFO VS_VERSION_INFO VERSIONINFO
FILEVERSION 0,4,0,0 FILEVERSION 0,4,1,0
PRODUCTVERSION 0,4,0,0 PRODUCTVERSION 0,4,1,0
FILEFLAGSMASK VS_FFI_FILEFLAGSMASK FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
FILEFLAGS METIN2_DEBUG FILEFLAGS METIN2_DEBUG
FILEOS VOS__WINDOWS32 FILEOS VOS__WINDOWS32
@ -29,12 +29,12 @@ BEGIN
BEGIN BEGIN
VALUE "CompanyName", "The Old Metin2 Project" VALUE "CompanyName", "The Old Metin2 Project"
VALUE "FileDescription", METIN2_COMPONENT_DESCRIPTION VALUE "FileDescription", METIN2_COMPONENT_DESCRIPTION
VALUE "FileVersion", "0.4.0.0" VALUE "FileVersion", "0.4.1.0"
VALUE "InternalName", METIN2_COMPONENT_INTERNALNAME VALUE "InternalName", METIN2_COMPONENT_INTERNALNAME
VALUE "LegalCopyright", "Copyright (C) 2022-2025" VALUE "LegalCopyright", "Copyright (C) 2022-2025"
VALUE "OriginalFilename", METIN2_COMPONENT_FILENAME VALUE "OriginalFilename", METIN2_COMPONENT_FILENAME
VALUE "ProductName", "Metin2Config" VALUE "ProductName", "Metin2Config"
VALUE "ProductVersion", "0.4.0.0" VALUE "ProductVersion", "0.4.1.0"
END END
END END

10
src/EterBase/StdAfx.h
View File

@ -40,16 +40,6 @@
#define atoi _atoi64 #define atoi _atoi64
#endif #endif
// Armadillo nanomite protection
#if !defined(NANOBEGIN) && !defined(NANOEND)
#ifdef _DEBUG
#define NANOBEGIN
#define NANOEND
#else
#include <armadillo/SecuredSections.h>
#endif
#endif
#include "vk.h" #include "vk.h"
#include "filename.h" #include "filename.h"
#include "ServiceDefs.h" #include "ServiceDefs.h"

10
src/EterBase/Timer.cpp
View File

@ -34,15 +34,10 @@ DWORD ELTimer_GetMSec()
} }
VOID ELTimer_SetServerMSec(DWORD dwServerTime) VOID ELTimer_SetServerMSec(DWORD dwServerTime)
{
NANOBEGIN
if (0 != dwServerTime) // nanomite를 위한 더미 if
{ {
gs_dwServerTime = dwServerTime; gs_dwServerTime = dwServerTime;
gs_dwClientTime = CTimer::instance().GetCurrentMillisecond(); gs_dwClientTime = CTimer::instance().GetCurrentMillisecond();
} }
NANOEND
}
DWORD ELTimer_GetServerMSec() DWORD ELTimer_GetServerMSec()
{ {
@ -69,9 +64,6 @@ CTimer::CTimer()
{ {
ELTimer_Init(); ELTimer_Init();
NANOBEGIN
if (this) // nanomite를 위한 더미 if
{
m_dwCurrentTime = 0; m_dwCurrentTime = 0;
m_bUseRealTime = true; m_bUseRealTime = true;
m_index = 0; m_index = 0;
@ -80,8 +72,6 @@ CTimer::CTimer()
m_fCurrentTime = 0.0f; m_fCurrentTime = 0.0f;
} }
NANOEND
}
CTimer::~CTimer() CTimer::~CTimer()
{ {

2
src/EterGrnLib/LODController.cpp
View File

@ -91,7 +91,6 @@ void __FreeDeformVertexBuffer(CGraphicVertexBuffer* pkDelVB)
void __ReserveSharedVertexBuffers(unsigned index, unsigned count) void __ReserveSharedVertexBuffers(unsigned index, unsigned count)
{ {
NANOBEGIN
if (index >= SHARED_VB_NUM) if (index >= SHARED_VB_NUM)
return; return;
@ -107,7 +106,6 @@ void __ReserveSharedVertexBuffers(unsigned index, unsigned count)
D3DPOOL_MANAGED); D3DPOOL_MANAGED);
gs_vbs[index].push_back(pkNewVB); gs_vbs[index].push_back(pkNewVB);
} }
NANOEND
} }
void GrannyCreateSharedDeformBuffer() void GrannyCreateSharedDeformBuffer()

10
src/EterGrnLib/StdAfx.h
View File

@ -10,13 +10,3 @@
#include "../eterBase/Stl.h" #include "../eterBase/Stl.h"
#include "Util.h" #include "Util.h"
// Armadillo nanomite protection
#if !defined(NANOBEGIN) && !defined(NANOEND)
#ifdef _DEBUG
#define NANOBEGIN
#define NANOEND
#else
#include <armadillo/SecuredSections.h>
#endif
#endif

3
src/EterLib/Input.cpp
View File

@ -55,8 +55,6 @@ void CInputKeyboard::ResetKeyboard()
bool CInputKeyboard::InitializeKeyboard(HWND hWnd) bool CInputKeyboard::InitializeKeyboard(HWND hWnd)
{ {
NANOBEGIN
if (ms_lpKeyboard) if (ms_lpKeyboard)
return true; return true;
@ -82,7 +80,6 @@ bool CInputKeyboard::InitializeKeyboard(HWND hWnd)
ms_lpKeyboard->Acquire(); ms_lpKeyboard->Acquire();
NANOEND
return true; return true;
} }

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();

6
src/EterPythonLib/PythonGraphic.cpp
View File

@ -25,9 +25,9 @@ void CPythonGraphic::SetInterfaceRenderState()
STATEMANAGER.SetTransform(D3DTS_VIEW, &ms_matIdentity); STATEMANAGER.SetTransform(D3DTS_VIEW, &ms_matIdentity);
STATEMANAGER.SetTransform(D3DTS_WORLD, &ms_matIdentity); STATEMANAGER.SetTransform(D3DTS_WORLD, &ms_matIdentity);
STATEMANAGER.SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_NONE); STATEMANAGER.SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
STATEMANAGER.SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_NONE); STATEMANAGER.SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_ANISOTROPIC);
STATEMANAGER.SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE); STATEMANAGER.SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
STATEMANAGER.SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); STATEMANAGER.SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
STATEMANAGER.SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA); STATEMANAGER.SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);

2
src/GameLib/FlyingData.cpp
View File

@ -124,7 +124,6 @@ void CFlyingData::DuplicateAttach(int iIndex)
bool CFlyingData::LoadScriptFile(const char* c_szFilename) bool CFlyingData::LoadScriptFile(const char* c_szFilename)
{ {
NANOBEGIN
Destroy(); Destroy();
m_strFilename = c_szFilename; m_strFilename = c_szFilename;
@ -278,7 +277,6 @@ bool CFlyingData::LoadScriptFile(const char* c_szFilename)
} }
} }
NANOEND
return true; return true;
} }

3
src/GameLib/MapOutdoorLoad.cpp
View File

@ -289,7 +289,6 @@ bool CMapOutdoor::LoadTerrain(WORD wTerrainCoordX, WORD wTerrainCoordY, WORD wCe
bool CMapOutdoor::LoadSetting(const char * c_szFileName) bool CMapOutdoor::LoadSetting(const char * c_szFileName)
{ {
NANOBEGIN
CTokenVectorMap stTokenVectorMap; CTokenVectorMap stTokenVectorMap;
if (!LoadMultipleTextData(c_szFileName, stTokenVectorMap)) if (!LoadMultipleTextData(c_szFileName, stTokenVectorMap))
@ -440,7 +439,7 @@ bool CMapOutdoor::LoadSetting(const char * c_szFileName)
D3DXMatrixScaling(&m_matBuildingTransparent, 1.0f / ((float)ms_iWidth), -1.0f / ((float)ms_iHeight), 1.0f); D3DXMatrixScaling(&m_matBuildingTransparent, 1.0f / ((float)ms_iWidth), -1.0f / ((float)ms_iHeight), 1.0f);
m_matBuildingTransparent._41 = 0.5f; m_matBuildingTransparent._41 = 0.5f;
m_matBuildingTransparent._42 = 0.5f; m_matBuildingTransparent._42 = 0.5f;
NANOEND
return true; return true;
} }

10
src/MilesLib/Stdafx.h
View File

@ -16,14 +16,4 @@
//{{AFX_INSERT_LOCATION}} //{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line. // Microsoft Visual C++ will insert additional declarations immediately before the previous line.
// Armadillo nanomite protection
#if !defined(NANOBEGIN) && !defined(NANOEND)
#ifdef _DEBUG
#define NANOBEGIN
#define NANOEND
#else
#include <armadillo/SecuredSections.h>
#endif
#endif
#endif #endif

3
src/PRTerrainLib/TextureSet.cpp
View File

@ -24,7 +24,6 @@ void CTextureSet::Create()
bool CTextureSet::Load(const char * c_szTextureSetFileName, float fTerrainTexCoordBase) bool CTextureSet::Load(const char * c_szTextureSetFileName, float fTerrainTexCoordBase)
{ {
NANOBEGIN
Clear(); Clear();
CTokenVectorMap stTokenVectorMap; CTokenVectorMap stTokenVectorMap;
@ -91,7 +90,7 @@ bool CTextureSet::Load(const char * c_szTextureSetFileName, float fTerrainTexCoo
} }
m_stFileName.assign(c_szTextureSetFileName); m_stFileName.assign(c_szTextureSetFileName);
NANOEND
return true; return true;
} }

6
src/ScriptLib/PythonLauncher.cpp
View File

@ -114,7 +114,6 @@ void CPythonLauncher::SetTraceFunc(int (*pFunc)(PyObject * obj, PyFrameObject *
bool CPythonLauncher::Create(const char* c_szProgramName) bool CPythonLauncher::Create(const char* c_szProgramName)
{ {
NANOBEGIN
Py_SetProgramName((char*)c_szProgramName); Py_SetProgramName((char*)c_szProgramName);
#ifdef _DEBUG #ifdef _DEBUG
PyEval_SetTrace(TraceFunc, NULL); PyEval_SetTrace(TraceFunc, NULL);
@ -138,13 +137,11 @@ bool CPythonLauncher::Create(const char* c_szProgramName)
if (!RunLine("import sys")) if (!RunLine("import sys"))
return false; return false;
NANOEND
return true; return true;
} }
bool CPythonLauncher::RunCompiledFile(const char* c_szFileName) bool CPythonLauncher::RunCompiledFile(const char* c_szFileName)
{ {
NANOBEGIN
FILE * fp = fopen(c_szFileName, "rb"); FILE * fp = fopen(c_szFileName, "rb");
if (!fp) if (!fp)
@ -191,14 +188,12 @@ bool CPythonLauncher::RunCompiledFile(const char* c_szFileName)
if (Py_FlushLine()) if (Py_FlushLine())
PyErr_Clear(); PyErr_Clear();
NANOEND
return true; return true;
} }
bool CPythonLauncher::RunMemoryTextFile(const char* c_szFileName, std::shared_ptr<std::vector<char>> fileData) bool CPythonLauncher::RunMemoryTextFile(const char* c_szFileName, std::shared_ptr<std::vector<char>> fileData)
{ {
NANOBEGIN
std::string stConvFileData; std::string stConvFileData;
stConvFileData.reserve(fileData->size()); stConvFileData.reserve(fileData->size());
stConvFileData+="exec(compile('''"; stConvFileData+="exec(compile('''";
@ -219,7 +214,6 @@ bool CPythonLauncher::RunMemoryTextFile(const char* c_szFileName, std::shared_pt
stConvFileData+= "'exec'))"; stConvFileData+= "'exec'))";
const CHAR* c_pcConvFileData=stConvFileData.c_str(); const CHAR* c_pcConvFileData=stConvFileData.c_str();
NANOEND
return RunLine(c_pcConvFileData); return RunLine(c_pcConvFileData);
} }

2
src/SphereLib/spherepack.cpp
View File

@ -19,7 +19,6 @@ int DrawCircle(int locx, int locy, int radius, int color);
SpherePackFactory::SpherePackFactory(int maxspheres, float rootsize, float leafsize, float gravy) SpherePackFactory::SpherePackFactory(int maxspheres, float rootsize, float leafsize, float gravy)
{ {
NANOBEGIN
maxspheres *= 4; // include room for both trees, the root node and leaf node tree, and the superspheres maxspheres *= 4; // include room for both trees, the root node and leaf node tree, and the superspheres
mMaxRootSize = rootsize; mMaxRootSize = rootsize;
mMaxLeafSize = leafsize; mMaxLeafSize = leafsize;
@ -61,7 +60,6 @@ SpherePackFactory::SpherePackFactory(int maxspheres, float rootsize, float leafs
mColors[11] = 0x0080FFFF; mColors[11] = 0x0080FFFF;
#endif #endif
NANOEND
} }
SpherePackFactory::~SpherePackFactory(void) SpherePackFactory::~SpherePackFactory(void)

2
src/UserInterface/Locale.cpp
View File

@ -25,7 +25,6 @@ int MULTI_LOCALE_CODE = 1252;
void LocaleService_LoadConfig(const char* fileName) void LocaleService_LoadConfig(const char* fileName)
{ {
NANOBEGIN
FILE* fp = fopen(fileName, "rt"); FILE* fp = fopen(fileName, "rt");
if (fp) if (fp)
@ -44,7 +43,6 @@ void LocaleService_LoadConfig(const char* fileName)
} }
fclose(fp); fclose(fp);
} }
NANOEND
} }
unsigned LocaleService_GetLastExp(int level) unsigned LocaleService_GetLastExp(int level)

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
{ {

4
src/UserInterface/PythonApplication.cpp
View File

@ -978,7 +978,6 @@ void CPythonApplication::Loop()
// SUPPORT_NEW_KOREA_SERVER // SUPPORT_NEW_KOREA_SERVER
bool LoadLocaleData(const char* localePath) bool LoadLocaleData(const char* localePath)
{ {
NANOBEGIN
CPythonNonPlayer& rkNPCMgr = CPythonNonPlayer::Instance(); CPythonNonPlayer& rkNPCMgr = CPythonNonPlayer::Instance();
CItemManager& rkItemMgr = CItemManager::Instance(); CItemManager& rkItemMgr = CItemManager::Instance();
CPythonSkill& rkSkillMgr = CPythonSkill::Instance(); CPythonSkill& rkSkillMgr = CPythonSkill::Instance();
@ -1055,7 +1054,6 @@ bool LoadLocaleData(const char* localePath)
} }
} }
NANOEND
return true; return true;
} }
// END_OF_SUPPORT_NEW_KOREA_SERVER // END_OF_SUPPORT_NEW_KOREA_SERVER
@ -1070,7 +1068,6 @@ unsigned __GetWindowMode(bool windowed)
bool CPythonApplication::Create(PyObject * poSelf, const char * c_szName, int width, int height, int Windowed) bool CPythonApplication::Create(PyObject * poSelf, const char * c_szName, int width, int height, int Windowed)
{ {
NANOBEGIN
Windowed = CPythonSystem::Instance().IsWindowed() ? 1 : 0; Windowed = CPythonSystem::Instance().IsWindowed() ? 1 : 0;
bool bAnotherWindow = false; bool bAnotherWindow = false;
@ -1135,7 +1132,6 @@ bool CPythonApplication::Create(PyObject * poSelf, const char * c_szName, int wi
} }
} }
NANOEND
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

2
src/UserInterface/PythonApplicationCursor.cpp
View File

@ -4,7 +4,6 @@
bool CPythonApplication::CreateCursors() bool CPythonApplication::CreateCursors()
{ {
NANOBEGIN
m_bCursorVisible = TRUE; m_bCursorVisible = TRUE;
m_bLiarCursorOn = false; m_bLiarCursorOn = false;
@ -41,7 +40,6 @@ bool CPythonApplication::CreateCursors()
m_CursorHandleMap.insert(TCursorHandleMap::value_type(i, hCursor)); m_CursorHandleMap.insert(TCursorHandleMap::value_type(i, hCursor));
} }
NANOEND
return true; return true;
} }

4
src/UserInterface/PythonApplicationLogo.cpp
View File

@ -197,8 +197,8 @@ void CPythonApplication::OnLogoRender()
{ {
if(!m_pLogoTex->IsEmpty() && !m_bLogoError && true == bInitializedLogo) if(!m_pLogoTex->IsEmpty() && !m_bLogoError && true == bInitializedLogo)
{ {
STATEMANAGER.SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR); STATEMANAGER.SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
STATEMANAGER.SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR); STATEMANAGER.SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_ANISOTROPIC);
m_pLogoTex->SetTextureStage(0); m_pLogoTex->SetTextureStage(0);
CPythonGraphic::instance().RenderTextureBox(m_nLeft, m_nTop, m_nRight, m_nBottom, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f); CPythonGraphic::instance().RenderTextureBox(m_nLeft, m_nTop, m_nRight, m_nBottom, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f);
} }

8
src/UserInterface/PythonMiniMap.cpp
View File

@ -265,8 +265,8 @@ void CPythonMiniMap::Render(float fScreenX, float fScreenY)
} }
STATEMANAGER.SaveSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_POINT); STATEMANAGER.SaveSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_POINT);
STATEMANAGER.SaveSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT); STATEMANAGER.SaveSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
STATEMANAGER.SaveSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT); STATEMANAGER.SaveSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_ANISOTROPIC);
STATEMANAGER.SaveSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP); STATEMANAGER.SaveSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
STATEMANAGER.SaveSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP); STATEMANAGER.SaveSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
@ -431,8 +431,8 @@ void CPythonMiniMap::Render(float fScreenX, float fScreenY)
STATEMANAGER.RestoreSamplerState(0, D3DSAMP_MINFILTER); STATEMANAGER.RestoreSamplerState(0, D3DSAMP_MINFILTER);
STATEMANAGER.RestoreSamplerState(0, D3DSAMP_MAGFILTER); STATEMANAGER.RestoreSamplerState(0, D3DSAMP_MAGFILTER);
STATEMANAGER.SaveSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR); STATEMANAGER.SaveSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
STATEMANAGER.SaveSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR); STATEMANAGER.SaveSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_ANISOTROPIC);
// 캐릭터 마크 // 캐릭터 마크
CInstanceBase * pkInst = CPythonCharacterManager::Instance().GetMainInstancePtr(); CInstanceBase * pkInst = CPythonCharacterManager::Instance().GetMainInstancePtr();

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);
*/
}

7
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));
} }
}; };
@ -768,7 +763,6 @@ DWORD CPythonNetworkStream::GetEmpireID()
void CPythonNetworkStream::__ClearSelectCharacterData() void CPythonNetworkStream::__ClearSelectCharacterData()
{ {
NANOBEGIN
memset(&m_akSimplePlayerInfo, 0, sizeof(m_akSimplePlayerInfo)); memset(&m_akSimplePlayerInfo, 0, sizeof(m_akSimplePlayerInfo));
for (int i = 0; i < PLAYER_PER_ACCOUNT4; ++i) for (int i = 0; i < PLAYER_PER_ACCOUNT4; ++i)
@ -776,7 +770,6 @@ void CPythonNetworkStream::__ClearSelectCharacterData()
m_adwGuildID[i] = 0; m_adwGuildID[i] = 0;
m_astrGuildName[i] = ""; m_astrGuildName[i] = "";
} }
NANOEND
} }
void CPythonNetworkStream::__DirectEnterMode_Initialize() void CPythonNetworkStream::__DirectEnterMode_Initialize()

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 },

11
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;
@ -1087,7 +1079,6 @@ bool CPythonNetworkStream::SendMessengerRemovePacket(const char * c_szKey, const
bool CPythonNetworkStream::SendCharacterStatePacket(const TPixelPosition& c_rkPPosDst, float fDstRot, UINT eFunc, UINT uArg) bool CPythonNetworkStream::SendCharacterStatePacket(const TPixelPosition& c_rkPPosDst, float fDstRot, UINT eFunc, UINT uArg)
{ {
NANOBEGIN
if (!__CanActMainInstance()) if (!__CanActMainInstance())
return true; return true;
@ -1121,7 +1112,7 @@ bool CPythonNetworkStream::SendCharacterStatePacket(const TPixelPosition& c_rkPP
kStatePacket.bArg); kStatePacket.bArg);
return false; return false;
} }
NANOEND
return SendSequence(); return SendSequence();
} }

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();

6
src/UserInterface/UserInterface.cpp
View File

@ -205,7 +205,6 @@ int Setup(LPSTR lpCmdLine); // Internal function forward
bool PackInitialize(const std::string& packFolder) bool PackInitialize(const std::string& packFolder)
{ {
NANOBEGIN
if (_access(packFolder.c_str(), 0) != 0) if (_access(packFolder.c_str(), 0) != 0)
return true; return true;
@ -278,7 +277,6 @@ bool PackInitialize(const std::string& packFolder)
} }
} }
NANOEND
return true; return true;
} }
@ -292,7 +290,6 @@ bool RunMainScript(CPythonLauncher& pyLauncher, const char* lpCmdLine)
initgrpText(); initgrpText();
initwndMgr(); initwndMgr();
///////////////////////////////////////////// /////////////////////////////////////////////
initudp();
initapp(); initapp();
initsystem(); initsystem();
initchr(); initchr();
@ -320,8 +317,6 @@ bool RunMainScript(CPythonLauncher& pyLauncher, const char* lpCmdLine)
initguild(); initguild();
initServerStateChecker(); initServerStateChecker();
NANOBEGIN
// RegisterDebugFlag // RegisterDebugFlag
{ {
std::string stRegisterDebugFlag; std::string stRegisterDebugFlag;
@ -393,7 +388,6 @@ bool RunMainScript(CPythonLauncher& pyLauncher, const char* lpCmdLine)
} }
} }
NANOEND
return true; return true;
} }

8
src/UserInterface/UserInterface.rc
View File

@ -126,8 +126,8 @@ IDI_METIN2 ICON "metin2.ico"
// //
VS_VERSION_INFO VERSIONINFO VS_VERSION_INFO VERSIONINFO
FILEVERSION 0,4,0,0 FILEVERSION 0,4,1,0
PRODUCTVERSION 0,4,0,0 PRODUCTVERSION 0,4,1,0
FILEFLAGSMASK 0x17L FILEFLAGSMASK 0x17L
#ifdef _DEBUG #ifdef _DEBUG
FILEFLAGS 0x1L FILEFLAGS 0x1L
@ -144,12 +144,12 @@ BEGIN
BEGIN BEGIN
VALUE "CompanyName", "The Old Metin2 Project" VALUE "CompanyName", "The Old Metin2 Project"
VALUE "FileDescription", "The Metin2 Client" VALUE "FileDescription", "The Metin2 Client"
VALUE "FileVersion", "0.4.0.0" VALUE "FileVersion", "0.4.1.0"
VALUE "InternalName", "Metin2Client" VALUE "InternalName", "Metin2Client"
VALUE "LegalCopyright", "Copyright (C) 2022-2025" VALUE "LegalCopyright", "Copyright (C) 2022-2025"
VALUE "OriginalFilename", "Metin2.exe" VALUE "OriginalFilename", "Metin2.exe"
VALUE "ProductName", "Metin2Client" VALUE "ProductName", "Metin2Client"
VALUE "ProductVersion", "0.4.0.0" VALUE "ProductVersion", "0.4.1.0"
END END
END END
BLOCK "VarFileInfo" BLOCK "VarFileInfo"

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>