metin2/client
metin2/client
2
0
Fork 6
Code Issues 10 Pull Requests Packages Projects Releases Wiki Activity

Used antialiasing filter, removed unused code #21

Merged
Exynox merged 4 commits from nightly into master 2025-04-13 16:48:58 +03:00
Conversation 0 Commits 4 Files Changed 35 +114 -776
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.SetTCPRecvBufferSize(128*1024)
net.SetTCPSendBufferSize(4096)
net.SetUDPRecvBufferSize(4096)
self.id=""
self.pwd=""
@ -261,8 +260,6 @@ class MainStream(object):
else:
net.ConnectTCP(self.addr, self.port)
#net.ConnectUDP(IP, Port)
def SetConnectInfo(self, addr, port, account_addr=0, account_port=0):
self.addr = addr
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
VS_VERSION_INFO VERSIONINFO
FILEVERSION 0,4,0,0
PRODUCTVERSION 0,4,0,0
FILEVERSION 0,4,1,0
PRODUCTVERSION 0,4,1,0
FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
FILEFLAGS METIN2_DEBUG
FILEOS VOS__WINDOWS32
@ -29,12 +29,12 @@ BEGIN
BEGIN
VALUE "CompanyName", "The Old Metin2 Project"
VALUE "FileDescription", METIN2_COMPONENT_DESCRIPTION
VALUE "FileVersion", "0.4.0.0"
VALUE "FileVersion", "0.4.1.0"
VALUE "InternalName", METIN2_COMPONENT_INTERNALNAME
VALUE "LegalCopyright", "Copyright (C) 2022-2025"
VALUE "OriginalFilename", METIN2_COMPONENT_FILENAME
VALUE "ProductName", "Metin2Config"
VALUE "ProductVersion", "0.4.0.0"
VALUE "ProductVersion", "0.4.1.0"
END
END

10
src/EterBase/StdAfx.h
View File

@ -40,16 +40,6 @@
#define atoi _atoi64
#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 "filename.h"
#include "ServiceDefs.h"

24
src/EterBase/Timer.cpp
View File

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

2
src/EterGrnLib/LODController.cpp
View File

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

10
src/EterGrnLib/StdAfx.h
View File

@ -10,13 +10,3 @@
#include "../eterBase/Stl.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)
{
NANOBEGIN
if (ms_lpKeyboard)
return true;
@ -82,7 +80,6 @@ bool CInputKeyboard::InitializeKeyboard(HWND hWnd)
ms_lpKeyboard->Acquire();
NANOEND
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[0xfc] = "HEADER_GC_HANDSHAKE_OK";
stringList[0xfd] = "HEADER_GC_PHASE";
stringList[0xfe] = "HEADER_GC_BINDUDP";
stringList[0xff] = "HEADER_GC_HANDSHAKE";
}
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_WORLD, &ms_matIdentity);
STATEMANAGER.SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_NONE);
STATEMANAGER.SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_NONE);
STATEMANAGER.SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
STATEMANAGER.SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
STATEMANAGER.SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_ANISOTROPIC);
STATEMANAGER.SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
STATEMANAGER.SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
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)
{
NANOBEGIN
Destroy();
m_strFilename = c_szFilename;
@ -278,7 +277,6 @@ bool CFlyingData::LoadScriptFile(const char* c_szFilename)
}
}
NANOEND
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)
{
NANOBEGIN
CTokenVectorMap 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);
m_matBuildingTransparent._41 = 0.5f;
m_matBuildingTransparent._42 = 0.5f;
NANOEND
return true;
}

10
src/MilesLib/Stdafx.h
View File

@ -16,14 +16,4 @@
//{{AFX_INSERT_LOCATION}}
// 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

3
src/PRTerrainLib/TextureSet.cpp
View File

@ -24,7 +24,6 @@ void CTextureSet::Create()
bool CTextureSet::Load(const char * c_szTextureSetFileName, float fTerrainTexCoordBase)
{
NANOBEGIN
Clear();
CTokenVectorMap stTokenVectorMap;
@ -91,7 +90,7 @@ bool CTextureSet::Load(const char * c_szTextureSetFileName, float fTerrainTexCoo
}
m_stFileName.assign(c_szTextureSetFileName);
NANOEND
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)
{
NANOBEGIN
Py_SetProgramName((char*)c_szProgramName);
#ifdef _DEBUG
PyEval_SetTrace(TraceFunc, NULL);
@ -138,13 +137,11 @@ bool CPythonLauncher::Create(const char* c_szProgramName)
if (!RunLine("import sys"))
return false;
NANOEND
return true;
}
bool CPythonLauncher::RunCompiledFile(const char* c_szFileName)
{
NANOBEGIN
FILE * fp = fopen(c_szFileName, "rb");
if (!fp)
@ -191,14 +188,12 @@ bool CPythonLauncher::RunCompiledFile(const char* c_szFileName)
if (Py_FlushLine())
PyErr_Clear();
NANOEND
return true;
}
bool CPythonLauncher::RunMemoryTextFile(const char* c_szFileName, std::shared_ptr<std::vector<char>> fileData)
{
NANOBEGIN
std::string stConvFileData;
stConvFileData.reserve(fileData->size());
stConvFileData+="exec(compile('''";
@ -219,7 +214,6 @@ bool CPythonLauncher::RunMemoryTextFile(const char* c_szFileName, std::shared_pt
stConvFileData+= "'exec'))";
const CHAR* c_pcConvFileData=stConvFileData.c_str();
NANOEND
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)
{
NANOBEGIN
maxspheres *= 4; // include room for both trees, the root node and leaf node tree, and the superspheres
mMaxRootSize = rootsize;
mMaxLeafSize = leafsize;
@ -61,7 +60,6 @@ SpherePackFactory::SpherePackFactory(int maxspheres, float rootsize, float leafs
mColors[11] = 0x0080FFFF;
#endif
NANOEND
}
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)
{
NANOBEGIN
FILE* fp = fopen(fileName, "rt");
if (fp)
@ -44,7 +43,6 @@ void LocaleService_LoadConfig(const char* fileName)
}
fclose(fp);
}
NANOEND
}
unsigned LocaleService_GetLastExp(int level)

24
src/UserInterface/Packet.h
View File

@ -339,9 +339,6 @@ enum
// END_OF_AUTOBAN
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
#ifdef __AUCTION__
@ -354,7 +351,6 @@ enum
HEADER_GC_HANDSHAKE_OK = 0xfc, // 252
HEADER_GC_PHASE = 0xfd, // 253
HEADER_GC_BINDUDP = 0xfe, // 254
HEADER_GC_HANDSHAKE = 0xff, // 255
/////////////////////////////////////////////////
@ -1149,13 +1145,6 @@ typedef struct packet_header_handshake
LONG lDelta;
} TPacketGCHandshake;
typedef struct packet_header_bindudp
{
BYTE header;
DWORD addr;
WORD port;
} TPacketGCBindUDP;
typedef struct packet_header_dynamic_size
{
BYTE header;
@ -2620,19 +2609,6 @@ typedef struct packet_state
TPixelPosition kPPos;
} 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
typedef struct packet_autoban_quiz
{

178
src/UserInterface/PythonApplication.cpp
View File

@ -978,8 +978,7 @@ void CPythonApplication::Loop()
// SUPPORT_NEW_KOREA_SERVER
bool LoadLocaleData(const char* localePath)
{
NANOBEGIN
CPythonNonPlayer& rkNPCMgr = CPythonNonPlayer::Instance();
CPythonNonPlayer& rkNPCMgr = CPythonNonPlayer::Instance();
CItemManager& rkItemMgr = CItemManager::Instance();
CPythonSkill& rkSkillMgr = CPythonSkill::Instance();
CPythonNetworkStream& rkNetStream = CPythonNetworkStream::Instance();
@ -1055,8 +1054,7 @@ bool LoadLocaleData(const char* localePath)
}
}
NANOEND
return true;
return true;
}
// END_OF_SUPPORT_NEW_KOREA_SERVER
@ -1070,8 +1068,7 @@ unsigned __GetWindowMode(bool 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;
@ -1135,115 +1132,114 @@ bool CPythonApplication::Create(PyObject * poSelf, const char * c_szName, int wi
}
}
NANOEND
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Cursor
if (!CreateCursors())
// Cursor
if (!CreateCursors())
{
//PyErr_SetString(PyExc_RuntimeError, "CMSWindow::Cursors Create Error");
TraceError("CMSWindow::Cursors Create Error");
SET_EXCEPTION("CREATE_CURSOR");
return false;
}
if (!m_pySystem.IsNoSoundCard())
{
// Sound
if (!m_SoundManager.Create())
{
//PyErr_SetString(PyExc_RuntimeError, "CMSWindow::Cursors Create Error");
TraceError("CMSWindow::Cursors Create Error");
SET_EXCEPTION("CREATE_CURSOR");
return false;
// NOTE : 중국측의 요청으로 생략
// LogBox(ApplicationStringTable_GetStringz(IDS_WARN_NO_SOUND_DEVICE));
}
}
if (!m_pySystem.IsNoSoundCard())
extern bool GRAPHICS_CAPS_SOFTWARE_TILING;
if (!m_pySystem.IsAutoTiling())
GRAPHICS_CAPS_SOFTWARE_TILING = m_pySystem.IsSoftwareTiling();
// Device
if (!CreateDevice(m_pySystem.GetWidth(), m_pySystem.GetHeight(), Windowed, m_pySystem.GetBPP(), m_pySystem.GetFrequency()))
return false;
GrannyCreateSharedDeformBuffer();
if (m_pySystem.IsAutoTiling())
{
if (m_grpDevice.IsFastTNL())
{
// Sound
if (!m_SoundManager.Create())
{
// NOTE : 중국측의 요청으로 생략
// LogBox(ApplicationStringTable_GetStringz(IDS_WARN_NO_SOUND_DEVICE));
}
}
extern bool GRAPHICS_CAPS_SOFTWARE_TILING;
if (!m_pySystem.IsAutoTiling())
GRAPHICS_CAPS_SOFTWARE_TILING = m_pySystem.IsSoftwareTiling();
// Device
if (!CreateDevice(m_pySystem.GetWidth(), m_pySystem.GetHeight(), Windowed, m_pySystem.GetBPP(), m_pySystem.GetFrequency()))
return false;
GrannyCreateSharedDeformBuffer();
if (m_pySystem.IsAutoTiling())
{
if (m_grpDevice.IsFastTNL())
{
m_pyBackground.ReserveSoftwareTilingEnable(false);
}
else
{
m_pyBackground.ReserveSoftwareTilingEnable(true);
}
m_pyBackground.ReserveSoftwareTilingEnable(false);
}
else
{
m_pyBackground.ReserveSoftwareTilingEnable(m_pySystem.IsSoftwareTiling());
m_pyBackground.ReserveSoftwareTilingEnable(true);
}
}
else
{
m_pyBackground.ReserveSoftwareTilingEnable(m_pySystem.IsSoftwareTiling());
}
SetVisibleMode(true);
SetVisibleMode(true);
if (m_isWindowFullScreenEnable) //m_pySystem.IsUseDefaultIME() && !m_pySystem.IsWindowed())
{
SetWindowPos(GetWindowHandle(), HWND_TOP, 0, 0, width, height, SWP_SHOWWINDOW);
}
if (m_isWindowFullScreenEnable) //m_pySystem.IsUseDefaultIME() && !m_pySystem.IsWindowed())
{
SetWindowPos(GetWindowHandle(), HWND_TOP, 0, 0, width, height, SWP_SHOWWINDOW);
}
if (!InitializeKeyboard(GetWindowHandle()))
return false;
if (!InitializeKeyboard(GetWindowHandle()))
return false;
m_pySystem.GetDisplaySettings();
m_pySystem.GetDisplaySettings();
// Mouse
if (m_pySystem.IsSoftwareCursor())
SetCursorMode(CURSOR_MODE_SOFTWARE);
else
SetCursorMode(CURSOR_MODE_HARDWARE);
// Mouse
if (m_pySystem.IsSoftwareCursor())
SetCursorMode(CURSOR_MODE_SOFTWARE);
else
SetCursorMode(CURSOR_MODE_HARDWARE);
// Network
if (!m_netDevice.Create())
{
//PyErr_SetString(PyExc_RuntimeError, "NetDevice::Create failed");
TraceError("NetDevice::Create failed");
SET_EXCEPTION("CREATE_NETWORK");
return false;
}
// Network
if (!m_netDevice.Create())
{
//PyErr_SetString(PyExc_RuntimeError, "NetDevice::Create failed");
TraceError("NetDevice::Create failed");
SET_EXCEPTION("CREATE_NETWORK");
return false;
}
if (!m_grpDevice.IsFastTNL())
CGrannyLODController::SetMinLODMode(true);
if (!m_grpDevice.IsFastTNL())
CGrannyLODController::SetMinLODMode(true);
m_pyItem.Create();
m_pyItem.Create();
// Other Modules
DefaultFont_Startup();
// Other Modules
DefaultFont_Startup();
CPythonIME::Instance().Create(GetWindowHandle());
CPythonIME::Instance().SetText("", 0);
CPythonTextTail::Instance().Initialize();
CPythonIME::Instance().Create(GetWindowHandle());
CPythonIME::Instance().SetText("", 0);
CPythonTextTail::Instance().Initialize();
// Light Manager
m_LightManager.Initialize();
// Light Manager
m_LightManager.Initialize();
CGraphicImageInstance::CreateSystem(32);
CGraphicImageInstance::CreateSystem(32);
// 백업
STICKYKEYS sStickKeys;
memset(&sStickKeys, 0, sizeof(sStickKeys));
sStickKeys.cbSize = sizeof(sStickKeys);
SystemParametersInfo( SPI_GETSTICKYKEYS, sizeof(sStickKeys), &sStickKeys, 0 );
m_dwStickyKeysFlag = sStickKeys.dwFlags;
// 백업
STICKYKEYS sStickKeys;
memset(&sStickKeys, 0, sizeof(sStickKeys));
sStickKeys.cbSize = sizeof(sStickKeys);
SystemParametersInfo( SPI_GETSTICKYKEYS, sizeof(sStickKeys), &sStickKeys, 0 );
m_dwStickyKeysFlag = sStickKeys.dwFlags;
// 설정
sStickKeys.dwFlags &= ~(SKF_AVAILABLE|SKF_HOTKEYACTIVE);
SystemParametersInfo( SPI_SETSTICKYKEYS, sizeof(sStickKeys), &sStickKeys, 0 );
// 설정
sStickKeys.dwFlags &= ~(SKF_AVAILABLE|SKF_HOTKEYACTIVE);
SystemParametersInfo( SPI_SETSTICKYKEYS, sizeof(sStickKeys), &sStickKeys, 0 );
// SphereMap
CGrannyMaterial::CreateSphereMap(0, "d:/ymir work/special/spheremap.jpg");
CGrannyMaterial::CreateSphereMap(1, "d:/ymir work/special/spheremap01.jpg");
return true;
// SphereMap
CGrannyMaterial::CreateSphereMap(0, "d:/ymir work/special/spheremap.jpg");
CGrannyMaterial::CreateSphereMap(1, "d:/ymir work/special/spheremap01.jpg");
return true;
}
void CPythonApplication::SetGlobalCenterPosition(LONG x, LONG y)

2
src/UserInterface/PythonApplicationCursor.cpp
View File

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

4
src/UserInterface/PythonApplicationLogo.cpp
View File

@ -197,8 +197,8 @@ void CPythonApplication::OnLogoRender()
{
if(!m_pLogoTex->IsEmpty() && !m_bLogoError && true == bInitializedLogo)
{
STATEMANAGER.SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
STATEMANAGER.SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
STATEMANAGER.SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
STATEMANAGER.SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_ANISOTROPIC);
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);
}

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_MINFILTER, D3DTEXF_POINT);
STATEMANAGER.SaveSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
STATEMANAGER.SaveSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
STATEMANAGER.SaveSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_ANISOTROPIC);
STATEMANAGER.SaveSamplerState(0, D3DSAMP_ADDRESSU, 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_MAGFILTER);
STATEMANAGER.SaveSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
STATEMANAGER.SaveSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
STATEMANAGER.SaveSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
STATEMANAGER.SaveSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_ANISOTROPIC);
// 캐릭터 마크
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_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_CREATE_FLY, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCreateFly), 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_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_DRAGON_SOUL_REFINE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDragonSoulRefine), STATIC_SIZE_PACKET));
}
};
@ -768,7 +763,6 @@ DWORD CPythonNetworkStream::GetEmpireID()
void CPythonNetworkStream::__ClearSelectCharacterData()
{
NANOBEGIN
memset(&m_akSimplePlayerInfo, 0, sizeof(m_akSimplePlayerInfo));
for (int i = 0; i < PLAYER_PER_ACCOUNT4; ++i)
@ -776,7 +770,6 @@ void CPythonNetworkStream::__ClearSelectCharacterData()
m_adwGuildID[i] = 0;
m_astrGuildName[i] = "";
}
NANOEND
}
void CPythonNetworkStream::__DirectEnterMode_Initialize()

4
src/UserInterface/PythonNetworkStream.h
View File

@ -546,10 +546,6 @@ class CPythonNetworkStream : public CNetworkStream, public CSingleton<CPythonNet
// Channel
bool RecvChannelPacket();
//Security
bool RecvHSCheckRequest();
bool RecvXTrapVerifyRequest();
protected:
// 이모티콘
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();
}
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;
@ -330,19 +320,6 @@ PyObject* netConnectTCP(PyObject* poSelf, PyObject* poArgs)
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;
@ -1736,14 +1713,12 @@ void initnet()
{ "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 },
{ "SendLoginPacket", netSendLoginPacket, METH_VARARGS },

11
src/UserInterface/PythonNetworkStreamPhaseGame.cpp
View File

@ -591,14 +591,6 @@ void CPythonNetworkStream::GamePhase()
return;
break;
case HEADER_GC_HS_REQUEST:
ret = RecvHSCheckRequest();
break;
case HEADER_GC_XTRAP_CS1_REQUEST:
ret = RecvXTrapVerifyRequest();
break;
case HEADER_GC_SPECIFIC_EFFECT:
ret = RecvSpecificEffect();
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)
{
NANOBEGIN
if (!__CanActMainInstance())
return true;
@ -1121,7 +1112,7 @@ bool CPythonNetworkStream::SendCharacterStatePacket(const TPixelPosition& c_rkPP
kStatePacket.bArg);
return false;
}
NANOEND
return SendSequence();
}

48
src/UserInterface/PythonNetworkStreamPhaseHandShake.cpp
View File

@ -19,17 +19,6 @@ void CPythonNetworkStream::HandShakePhase()
return;
break;
case HEADER_GC_BINDUDP:
{
TPacketGCBindUDP BindUDP;
if (!Recv(sizeof(TPacketGCBindUDP), &BindUDP))
return;
return;
}
break;
case HEADER_GC_HANDSHAKE:
{
if (!Recv(sizeof(TPacketGCHandshake), &m_HandshakeData))
@ -134,40 +123,3 @@ bool CPythonNetworkStream::RecvHandshakeOKPacket()
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
};
void initudp();
void initapp();
void initime();
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)
{
NANOBEGIN
if (_access(packFolder.c_str(), 0) != 0)
return true;
@ -278,7 +277,6 @@ bool PackInitialize(const std::string& packFolder)
}
}
NANOEND
return true;
}
@ -292,7 +290,6 @@ bool RunMainScript(CPythonLauncher& pyLauncher, const char* lpCmdLine)
initgrpText();
initwndMgr();
/////////////////////////////////////////////
initudp();
initapp();
initsystem();
initchr();
@ -320,8 +317,6 @@ bool RunMainScript(CPythonLauncher& pyLauncher, const char* lpCmdLine)
initguild();
initServerStateChecker();
NANOBEGIN
// RegisterDebugFlag
{
std::string stRegisterDebugFlag;
@ -393,7 +388,6 @@ bool RunMainScript(CPythonLauncher& pyLauncher, const char* lpCmdLine)
}
}
NANOEND
return true;
}

8
src/UserInterface/UserInterface.rc
View File

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

3
src/UserInterface/UserInterface.vcxproj
View File

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

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

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