port: complete 100% logic layer, eliminate pending dir, and unify client_main on port route
- Completed batch 4-f (Messenger, Guild, GuildMark), 4-g (PythonSystem, systemSetting), 4-h (PythonSoundManagerModule, MilesLib CSoundManager) - Ported UserInterface/Locale.cpp, EterLocale/Japanese.cpp, EterLib/PathStack, EterLib/NetDatagram* UDP suite - Modularized PythonApplication into Camera and Event handlers aligning with 40250 signatures - Completely removed extension/src/platform/pending/ directory - Logic layer reached 100.0% completion (3338/3338 functions, 0 TODO, 0 DIVERGENT) with empty port-map queue - Removed legacy AppFlow route and fallback from project/client_main.gd, switching main loop unconditionally to native port route - Verified 15/15 port.login_flow integration steps and 19/19 port_gate suites passing
This commit is contained in:
shen
@@ -0,0 +1,546 @@
|
||||
#include "StdAfx.h"
|
||||
#include "GuildMarkDownloader.h"
|
||||
#include "PythonCharacterManager.h"
|
||||
#include "Packet.h"
|
||||
#include "Test.h"
|
||||
|
||||
// MARK_BUG_FIX
|
||||
struct SMarkIndex
|
||||
{
|
||||
WORD guild_id;
|
||||
WORD mark_id;
|
||||
};
|
||||
|
||||
// END_OFMARK_BUG_FIX
|
||||
|
||||
CGuildMarkDownloader::CGuildMarkDownloader()
|
||||
{
|
||||
SetRecvBufferSize(640*1024);
|
||||
SetSendBufferSize(1024);
|
||||
__Initialize();
|
||||
}
|
||||
|
||||
CGuildMarkDownloader::~CGuildMarkDownloader()
|
||||
{
|
||||
__OfflineState_Set();
|
||||
}
|
||||
|
||||
bool CGuildMarkDownloader::Connect(const CNetworkAddress& c_rkNetAddr, DWORD dwHandle, DWORD dwRandomKey)
|
||||
{
|
||||
__OfflineState_Set();
|
||||
|
||||
m_dwHandle=dwHandle;
|
||||
m_dwRandomKey=dwRandomKey;
|
||||
m_dwTodo=TODO_RECV_MARK;
|
||||
return CNetworkStream::Connect(c_rkNetAddr);
|
||||
}
|
||||
|
||||
bool CGuildMarkDownloader::ConnectToRecvSymbol(const CNetworkAddress& c_rkNetAddr, DWORD dwHandle, DWORD dwRandomKey, const std::vector<DWORD> & c_rkVec_dwGuildID)
|
||||
{
|
||||
__OfflineState_Set();
|
||||
|
||||
m_dwHandle=dwHandle;
|
||||
m_dwRandomKey=dwRandomKey;
|
||||
m_dwTodo=TODO_RECV_SYMBOL;
|
||||
m_kVec_dwGuildID = c_rkVec_dwGuildID;
|
||||
return CNetworkStream::Connect(c_rkNetAddr);
|
||||
}
|
||||
|
||||
void CGuildMarkDownloader::Process()
|
||||
{
|
||||
CNetworkStream::Process();
|
||||
|
||||
if (!__StateProcess())
|
||||
{
|
||||
__OfflineState_Set();
|
||||
Disconnect();
|
||||
}
|
||||
}
|
||||
|
||||
void CGuildMarkDownloader::OnConnectFailure()
|
||||
{
|
||||
__OfflineState_Set();
|
||||
}
|
||||
|
||||
void CGuildMarkDownloader::OnConnectSuccess()
|
||||
{
|
||||
__LoginState_Set();
|
||||
}
|
||||
|
||||
void CGuildMarkDownloader::OnRemoteDisconnect()
|
||||
{
|
||||
__OfflineState_Set();
|
||||
}
|
||||
|
||||
void CGuildMarkDownloader::OnDisconnect()
|
||||
{
|
||||
__OfflineState_Set();
|
||||
}
|
||||
|
||||
void CGuildMarkDownloader::__Initialize()
|
||||
{
|
||||
m_eState=STATE_OFFLINE;
|
||||
m_pkMarkMgr=NULL;
|
||||
m_currentRequestingImageIndex=0;
|
||||
m_dwBlockIndex=0;
|
||||
m_dwBlockDataPos=0;
|
||||
m_dwBlockDataSize=0;
|
||||
|
||||
m_dwHandle=0;
|
||||
m_dwRandomKey=0;
|
||||
m_dwTodo=TODO_RECV_NONE;
|
||||
m_kVec_dwGuildID.clear();
|
||||
}
|
||||
|
||||
bool CGuildMarkDownloader::__StateProcess()
|
||||
{
|
||||
switch (m_eState)
|
||||
{
|
||||
case STATE_LOGIN:
|
||||
return __LoginState_Process();
|
||||
break;
|
||||
case STATE_COMPLETE:
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void CGuildMarkDownloader::__OfflineState_Set()
|
||||
{
|
||||
__Initialize();
|
||||
}
|
||||
|
||||
void CGuildMarkDownloader::__CompleteState_Set()
|
||||
{
|
||||
m_eState = STATE_COMPLETE;
|
||||
CPythonCharacterManager::instance().RefreshAllGuildMark();
|
||||
}
|
||||
|
||||
void CGuildMarkDownloader::__LoginState_Set()
|
||||
{
|
||||
m_eState = STATE_LOGIN;
|
||||
}
|
||||
|
||||
bool CGuildMarkDownloader::__LoginState_Process()
|
||||
{
|
||||
BYTE header;
|
||||
|
||||
if (!Peek(sizeof(BYTE), &header))
|
||||
return true;
|
||||
|
||||
if (IsSecurityMode())
|
||||
{
|
||||
if (0 == header)
|
||||
{
|
||||
if (!Recv(sizeof(header), &header))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
UINT needPacketSize = __GetPacketSize(header);
|
||||
|
||||
if (!needPacketSize)
|
||||
return false;
|
||||
|
||||
if (!Peek(needPacketSize))
|
||||
return true;
|
||||
|
||||
__DispatchPacket(header);
|
||||
return true;
|
||||
}
|
||||
|
||||
// MARK_BUG_FIX
|
||||
UINT CGuildMarkDownloader::__GetPacketSize(UINT header)
|
||||
{
|
||||
switch (header)
|
||||
{
|
||||
case HEADER_GC_PHASE:
|
||||
return sizeof(TPacketGCPhase);
|
||||
case HEADER_GC_HANDSHAKE:
|
||||
return sizeof(TPacketGCHandshake);
|
||||
case HEADER_GC_PING:
|
||||
return sizeof(TPacketGCPing);
|
||||
case HEADER_GC_MARK_IDXLIST:
|
||||
return sizeof(TPacketGCMarkIDXList);
|
||||
case HEADER_GC_MARK_BLOCK:
|
||||
return sizeof(TPacketGCMarkBlock);
|
||||
case HEADER_GC_GUILD_SYMBOL_DATA:
|
||||
return sizeof(TPacketGCGuildSymbolData);
|
||||
case HEADER_GC_MARK_DIFF_DATA: // 사용하지 않음
|
||||
return sizeof(BYTE);
|
||||
#ifdef _IMPROVED_PACKET_ENCRYPTION_
|
||||
case HEADER_GC_KEY_AGREEMENT:
|
||||
return sizeof(TPacketKeyAgreement);
|
||||
case HEADER_GC_KEY_AGREEMENT_COMPLETED:
|
||||
return sizeof(TPacketKeyAgreementCompleted);
|
||||
|
||||
#endif
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool CGuildMarkDownloader::__DispatchPacket(UINT header)
|
||||
{
|
||||
switch (header)
|
||||
{
|
||||
case HEADER_GC_PHASE:
|
||||
return __LoginState_RecvPhase();
|
||||
case HEADER_GC_HANDSHAKE:
|
||||
return __LoginState_RecvHandshake();
|
||||
case HEADER_GC_PING:
|
||||
return __LoginState_RecvPing();
|
||||
case HEADER_GC_MARK_IDXLIST:
|
||||
return __LoginState_RecvMarkIndex();
|
||||
case HEADER_GC_MARK_BLOCK:
|
||||
return __LoginState_RecvMarkBlock();
|
||||
case HEADER_GC_GUILD_SYMBOL_DATA:
|
||||
return __LoginState_RecvSymbolData();
|
||||
case HEADER_GC_MARK_DIFF_DATA: // 사용하지 않음
|
||||
return true;
|
||||
#ifdef _IMPROVED_PACKET_ENCRYPTION_
|
||||
case HEADER_GC_KEY_AGREEMENT:
|
||||
return __LoginState_RecvKeyAgreement();
|
||||
case HEADER_GC_KEY_AGREEMENT_COMPLETED:
|
||||
return __LoginState_RecvKeyAgreementCompleted();
|
||||
#endif
|
||||
}
|
||||
return false;
|
||||
}
|
||||
// END_OF_MARK_BUG_FIX
|
||||
|
||||
bool CGuildMarkDownloader::__LoginState_RecvHandshake()
|
||||
{
|
||||
TPacketGCHandshake kPacketHandshake;
|
||||
if (!Recv(sizeof(kPacketHandshake), &kPacketHandshake))
|
||||
return false;
|
||||
|
||||
TPacketCGMarkLogin kPacketMarkLogin;
|
||||
|
||||
kPacketMarkLogin.header = HEADER_CG_MARK_LOGIN;
|
||||
kPacketMarkLogin.handle = m_dwHandle;
|
||||
kPacketMarkLogin.random_key = m_dwRandomKey;
|
||||
|
||||
if (!Send(sizeof(kPacketMarkLogin), &kPacketMarkLogin))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CGuildMarkDownloader::__LoginState_RecvPing()
|
||||
{
|
||||
TPacketGCPing kPacketPing;
|
||||
|
||||
if (!Recv(sizeof(kPacketPing), &kPacketPing))
|
||||
return false;
|
||||
|
||||
TPacketCGPong kPacketPong;
|
||||
kPacketPong.bHeader = HEADER_CG_PONG;
|
||||
|
||||
if (!Send(sizeof(TPacketCGPong), &kPacketPong))
|
||||
return false;
|
||||
|
||||
if (IsSecurityMode())
|
||||
return SendSequence();
|
||||
else
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CGuildMarkDownloader::__LoginState_RecvPhase()
|
||||
{
|
||||
TPacketGCPhase kPacketPhase;
|
||||
|
||||
if (!Recv(sizeof(kPacketPhase), &kPacketPhase))
|
||||
return false;
|
||||
|
||||
if (kPacketPhase.phase == PHASE_LOGIN)
|
||||
{
|
||||
#ifndef _IMPROVED_PACKET_ENCRYPTION_
|
||||
const char* key = LocaleService_GetSecurityKey();
|
||||
SetSecurityMode(true, key);
|
||||
#endif
|
||||
|
||||
switch (m_dwTodo)
|
||||
{
|
||||
case TODO_RECV_NONE:
|
||||
{
|
||||
assert(!"CGuildMarkDownloader::__LoginState_RecvPhase - Todo type is none");
|
||||
break;
|
||||
}
|
||||
case TODO_RECV_MARK:
|
||||
{
|
||||
// MARK_BUG_FIX
|
||||
if (!__SendMarkIDXList())
|
||||
return false;
|
||||
// END_OF_MARK_BUG_FIX
|
||||
break;
|
||||
}
|
||||
case TODO_RECV_SYMBOL:
|
||||
{
|
||||
if (!__SendSymbolCRCList())
|
||||
return false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// MARK_BUG_FIX
|
||||
bool CGuildMarkDownloader::__SendMarkIDXList()
|
||||
{
|
||||
TPacketCGMarkIDXList kPacketMarkIDXList;
|
||||
kPacketMarkIDXList.header = HEADER_CG_MARK_IDXLIST;
|
||||
if (!Send(sizeof(kPacketMarkIDXList), &kPacketMarkIDXList))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CGuildMarkDownloader::__LoginState_RecvMarkIndex()
|
||||
{
|
||||
TPacketGCMarkIDXList kPacketMarkIndex;
|
||||
|
||||
if (!Peek(sizeof(kPacketMarkIndex), &kPacketMarkIndex))
|
||||
return false;
|
||||
|
||||
//DWORD bufSize = sizeof(WORD) * 2 * kPacketMarkIndex.count;
|
||||
|
||||
if (!Peek(kPacketMarkIndex.bufSize))
|
||||
return false;
|
||||
|
||||
Recv(sizeof(kPacketMarkIndex));
|
||||
|
||||
WORD guildID, markID;
|
||||
|
||||
for (DWORD i = 0; i < kPacketMarkIndex.count; ++i)
|
||||
{
|
||||
Recv(sizeof(WORD), &guildID);
|
||||
Recv(sizeof(WORD), &markID);
|
||||
|
||||
// 길드ID -> 마크ID 인덱스 등록
|
||||
CGuildMarkManager::Instance().AddMarkIDByGuildID(guildID, markID);
|
||||
}
|
||||
|
||||
// 모든 마크 이미지 파일을 로드한다. (파일이 없으면 만들어짐)
|
||||
CGuildMarkManager::Instance().LoadMarkImages();
|
||||
|
||||
m_currentRequestingImageIndex = 0;
|
||||
__SendMarkCRCList();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CGuildMarkDownloader::__SendMarkCRCList()
|
||||
{
|
||||
TPacketCGMarkCRCList kPacketMarkCRCList;
|
||||
|
||||
if (!CGuildMarkManager::Instance().GetBlockCRCList(m_currentRequestingImageIndex, kPacketMarkCRCList.crclist))
|
||||
__CompleteState_Set();
|
||||
else
|
||||
{
|
||||
kPacketMarkCRCList.header = HEADER_CG_MARK_CRCLIST;
|
||||
kPacketMarkCRCList.imgIdx = m_currentRequestingImageIndex;
|
||||
++m_currentRequestingImageIndex;
|
||||
|
||||
if (!Send(sizeof(kPacketMarkCRCList), &kPacketMarkCRCList))
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CGuildMarkDownloader::__LoginState_RecvMarkBlock()
|
||||
{
|
||||
TPacketGCMarkBlock kPacket;
|
||||
|
||||
if (!Peek(sizeof(kPacket), &kPacket))
|
||||
return false;
|
||||
|
||||
if (!Peek(kPacket.bufSize))
|
||||
return false;
|
||||
|
||||
Recv(sizeof(kPacket));
|
||||
|
||||
BYTE posBlock;
|
||||
DWORD compSize;
|
||||
char compBuf[SGuildMarkBlock::MAX_COMP_SIZE];
|
||||
|
||||
for (DWORD i = 0; i < kPacket.count; ++i)
|
||||
{
|
||||
Recv(sizeof(BYTE), &posBlock);
|
||||
Recv(sizeof(DWORD), &compSize);
|
||||
|
||||
if (compSize > SGuildMarkBlock::MAX_COMP_SIZE)
|
||||
{
|
||||
TraceError("RecvMarkBlock: data corrupted");
|
||||
Recv(compSize);
|
||||
}
|
||||
else
|
||||
{
|
||||
Recv(compSize, compBuf);
|
||||
// 압축된 이미지를 실제로 저장한다. CRC등 여러가지 정보가 함께 빌드된다.
|
||||
CGuildMarkManager::Instance().SaveBlockFromCompressedData(kPacket.imgIdx, posBlock, (const BYTE *) compBuf, compSize);
|
||||
}
|
||||
}
|
||||
|
||||
if (kPacket.count > 0)
|
||||
{
|
||||
// 마크 이미지 저장
|
||||
CGuildMarkManager::Instance().SaveMarkImage(kPacket.imgIdx);
|
||||
|
||||
// 리소스 리로딩 (재접속을 안해도 본인것은 잘 보이게 함)
|
||||
std::string imagePath;
|
||||
|
||||
if (CGuildMarkManager::Instance().GetMarkImageFilename(kPacket.imgIdx, imagePath))
|
||||
{
|
||||
CResource * pResource = CResourceManager::Instance().GetResourcePointer(imagePath.c_str());
|
||||
if (pResource->IsType(CGraphicImage::Type()))
|
||||
{
|
||||
CGraphicImage* pkGrpImg=static_cast<CGraphicImage*>(pResource);
|
||||
pkGrpImg->Reload();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 더 요청할 것이 있으면 요청하고 아니면 이미지를 저장하고 종료
|
||||
if (m_currentRequestingImageIndex < CGuildMarkManager::Instance().GetMarkImageCount())
|
||||
__SendMarkCRCList();
|
||||
else
|
||||
__CompleteState_Set();
|
||||
|
||||
return true;
|
||||
}
|
||||
// END_OF_MARK_BUG_FIX
|
||||
|
||||
#ifdef _IMPROVED_PACKET_ENCRYPTION_
|
||||
bool CGuildMarkDownloader::__LoginState_RecvKeyAgreement()
|
||||
{
|
||||
TPacketKeyAgreement packet;
|
||||
if (!Recv(sizeof(packet), &packet))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
Tracenf("KEY_AGREEMENT RECV %u", packet.wDataLength);
|
||||
|
||||
TPacketKeyAgreement packetToSend;
|
||||
size_t dataLength = TPacketKeyAgreement::MAX_DATA_LEN;
|
||||
size_t agreedLength = Prepare(packetToSend.data, &dataLength);
|
||||
if (agreedLength == 0)
|
||||
{
|
||||
// 초기화 실패
|
||||
Disconnect();
|
||||
return false;
|
||||
}
|
||||
assert(dataLength <= TPacketKeyAgreement::MAX_DATA_LEN);
|
||||
|
||||
if (Activate(packet.wAgreedLength, packet.data, packet.wDataLength))
|
||||
{
|
||||
// Key agreement 성공, 응답 전송
|
||||
packetToSend.bHeader = HEADER_CG_KEY_AGREEMENT;
|
||||
packetToSend.wAgreedLength = (WORD)agreedLength;
|
||||
packetToSend.wDataLength = (WORD)dataLength;
|
||||
|
||||
if (!Send(sizeof(packetToSend), &packetToSend))
|
||||
{
|
||||
Tracen(" CAccountConnector::__AuthState_RecvKeyAgreement - SendKeyAgreement Error");
|
||||
return false;
|
||||
}
|
||||
Tracenf("KEY_AGREEMENT SEND %u", packetToSend.wDataLength);
|
||||
}
|
||||
else
|
||||
{
|
||||
// 키 협상 실패
|
||||
Disconnect();
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CGuildMarkDownloader::__LoginState_RecvKeyAgreementCompleted()
|
||||
{
|
||||
TPacketKeyAgreementCompleted packet;
|
||||
if (!Recv(sizeof(packet), &packet))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
Tracenf("KEY_AGREEMENT_COMPLETED RECV");
|
||||
|
||||
ActivateCipher();
|
||||
|
||||
return true;
|
||||
}
|
||||
#endif // _IMPROVED_PACKET_ENCRYPTION_
|
||||
|
||||
bool CGuildMarkDownloader::__SendSymbolCRCList()
|
||||
{
|
||||
for (DWORD i=0; i<m_kVec_dwGuildID.size(); ++i)
|
||||
{
|
||||
TPacketCGSymbolCRC kSymbolCRCPacket;
|
||||
kSymbolCRCPacket.header = HEADER_CG_GUILD_SYMBOL_CRC;
|
||||
kSymbolCRCPacket.dwGuildID = m_kVec_dwGuildID[i];
|
||||
|
||||
std::string strFileName = GetGuildSymbolFileName(m_kVec_dwGuildID[i]);
|
||||
kSymbolCRCPacket.dwCRC = GetFileCRC32(strFileName.c_str());
|
||||
kSymbolCRCPacket.dwSize = GetFileSize(strFileName.c_str());
|
||||
#ifdef _DEBUG
|
||||
printf("__SendSymbolCRCList [GuildID:%d / CRC:%u]\n", m_kVec_dwGuildID[i], kSymbolCRCPacket.dwCRC);
|
||||
#endif
|
||||
if (!Send(sizeof(kSymbolCRCPacket), &kSymbolCRCPacket))
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CGuildMarkDownloader::__LoginState_RecvSymbolData()
|
||||
{
|
||||
TPacketGCBlankDynamic packet;
|
||||
if (!Peek(sizeof(TPacketGCBlankDynamic), &packet))
|
||||
return true;
|
||||
|
||||
#ifdef _DEBUG
|
||||
printf("__LoginState_RecvSymbolData [%d/%d]\n", GetRecvBufferSize(), packet.size);
|
||||
#endif
|
||||
if (packet.size > GetRecvBufferSize())
|
||||
return true;
|
||||
|
||||
//////////////////////////////////////////////////////////////
|
||||
|
||||
TPacketGCGuildSymbolData kPacketSymbolData;
|
||||
if (!Recv(sizeof(kPacketSymbolData), &kPacketSymbolData))
|
||||
return false;
|
||||
|
||||
WORD wDataSize = kPacketSymbolData.size - sizeof(kPacketSymbolData);
|
||||
DWORD dwGuildID = kPacketSymbolData.guild_id;
|
||||
BYTE * pbyBuf = new BYTE [wDataSize];
|
||||
|
||||
if (!Recv(wDataSize, pbyBuf))
|
||||
{
|
||||
delete[] pbyBuf;
|
||||
return false;
|
||||
}
|
||||
|
||||
MyCreateDirectory(g_strGuildSymbolPathName.c_str());
|
||||
|
||||
std::string strFileName = GetGuildSymbolFileName(dwGuildID);
|
||||
|
||||
FILE * File = fopen(strFileName.c_str(), "wb");
|
||||
if (!File)
|
||||
{
|
||||
delete[] pbyBuf;
|
||||
return false;
|
||||
}
|
||||
fwrite(pbyBuf, wDataSize, 1, File);
|
||||
fclose(File);
|
||||
|
||||
#ifdef _DEBUG
|
||||
printf("__LoginState_RecvSymbolData(filename:%s, datasize:%d, guildid:%d)\n", strFileName.c_str(), wDataSize, dwGuildID);
|
||||
#endif
|
||||
|
||||
delete[] pbyBuf;
|
||||
return true;
|
||||
}
|
||||
@@ -0,0 +1,482 @@
|
||||
#include "StdAfx.h"
|
||||
#include "GuildMarkUploader.h"
|
||||
#include "Packet.h"
|
||||
#include "Test.h"
|
||||
|
||||
#ifdef __VTUNE__
|
||||
#else
|
||||
|
||||
CGuildMarkUploader::CGuildMarkUploader()
|
||||
: m_pbySymbolBuf(NULL)
|
||||
{
|
||||
SetRecvBufferSize(1024);
|
||||
SetSendBufferSize(1024);
|
||||
__Inialize();
|
||||
}
|
||||
|
||||
CGuildMarkUploader::~CGuildMarkUploader()
|
||||
{
|
||||
__OfflineState_Set();
|
||||
}
|
||||
|
||||
void CGuildMarkUploader::Disconnect()
|
||||
{
|
||||
__OfflineState_Set();
|
||||
}
|
||||
|
||||
bool CGuildMarkUploader::IsCompleteUploading()
|
||||
{
|
||||
return STATE_OFFLINE == m_eState;
|
||||
}
|
||||
|
||||
bool CGuildMarkUploader::__Save(const char* c_szFileName)
|
||||
{
|
||||
/* 업로더에서 저장하지 않아야 함;
|
||||
ILuint uImg;
|
||||
ilGenImages(1, &uImg);
|
||||
ilBindImage(uImg);
|
||||
ilEnable(IL_FILE_OVERWRITE);
|
||||
ilEnable(IL_ORIGIN_SET);
|
||||
ilOriginFunc(IL_ORIGIN_UPPER_LEFT);
|
||||
|
||||
if (!ilLoad(IL_TYPE_UNKNOWN, (const ILstring)c_szFileName))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if (ilGetInteger(IL_IMAGE_WIDTH) != CGuildMarkImage::WIDTH)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if (ilGetInteger(IL_IMAGE_HEIGHT) != CGuildMarkImage::HEIGHT)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
ilConvertImage(IL_BGRA, IL_BYTE);
|
||||
|
||||
UINT uColCount = CGuildMarkImage::MARK_COL_COUNT;
|
||||
UINT uCol = m_dwGuildID % uColCount;
|
||||
UINT uRow = m_dwGuildID / uColCount;
|
||||
|
||||
ilSetPixels(uCol*SGuildMark::WIDTH, uRow*SGuildMark::HEIGHT, 0, SGuildMark::WIDTH, SGuildMark::HEIGHT, 1, IL_BGRA, IL_BYTE, (ILvoid*)m_kMark.m_apxBuf);
|
||||
|
||||
ilSave(IL_TGA, (ILstring)c_szFileName);
|
||||
|
||||
ilDeleteImages(1, &uImg);
|
||||
*/
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CGuildMarkUploader::__Load(const char* c_szFileName, UINT* peError)
|
||||
{
|
||||
ILuint uImg;
|
||||
ilGenImages(1, &uImg);
|
||||
ilBindImage(uImg);
|
||||
ilEnable(IL_ORIGIN_SET);
|
||||
ilOriginFunc(IL_ORIGIN_UPPER_LEFT);
|
||||
|
||||
if (!ilLoad(IL_TYPE_UNKNOWN, (const ILstring)c_szFileName))
|
||||
{
|
||||
*peError=ERROR_LOAD;
|
||||
return false;
|
||||
}
|
||||
|
||||
if (ilGetInteger(IL_IMAGE_WIDTH)!=SGuildMark::WIDTH)
|
||||
{
|
||||
*peError=ERROR_WIDTH;
|
||||
return false;
|
||||
}
|
||||
|
||||
if (ilGetInteger(IL_IMAGE_HEIGHT)!=SGuildMark::HEIGHT)
|
||||
{
|
||||
*peError=ERROR_HEIGHT;
|
||||
return false;
|
||||
}
|
||||
|
||||
ilConvertImage(IL_BGRA, IL_BYTE);
|
||||
|
||||
ilCopyPixels(0, 0, 0, SGuildMark::WIDTH, SGuildMark::HEIGHT, 1, IL_BGRA, IL_BYTE, (ILvoid*)m_kMark.m_apxBuf);
|
||||
|
||||
ilDeleteImages(1, &uImg);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CGuildMarkUploader::__LoadSymbol(const char* c_szFileName, UINT* peError)
|
||||
{
|
||||
// For Check Image
|
||||
ILuint uImg;
|
||||
ilGenImages(1, &uImg);
|
||||
ilBindImage(uImg);
|
||||
ilEnable(IL_ORIGIN_SET);
|
||||
ilOriginFunc(IL_ORIGIN_UPPER_LEFT);
|
||||
if (!ilLoad(IL_TYPE_UNKNOWN, (const ILstring)c_szFileName))
|
||||
{
|
||||
*peError=ERROR_LOAD;
|
||||
return false;
|
||||
}
|
||||
if (ilGetInteger(IL_IMAGE_WIDTH) != 64)
|
||||
{
|
||||
*peError=ERROR_WIDTH;
|
||||
return false;
|
||||
}
|
||||
if (ilGetInteger(IL_IMAGE_HEIGHT) != 128)
|
||||
{
|
||||
*peError=ERROR_HEIGHT;
|
||||
return false;
|
||||
}
|
||||
ilDeleteImages(1, &uImg);
|
||||
ilShutDown();
|
||||
|
||||
/////
|
||||
|
||||
FILE * file = fopen(c_szFileName, "rb");
|
||||
if (!file)
|
||||
{
|
||||
*peError=ERROR_LOAD;
|
||||
}
|
||||
|
||||
fseek(file, 0, SEEK_END);
|
||||
m_dwSymbolBufSize = ftell(file);
|
||||
fseek(file, 0, SEEK_SET);
|
||||
|
||||
m_pbySymbolBuf = new BYTE [m_dwSymbolBufSize];
|
||||
fread(m_pbySymbolBuf, m_dwSymbolBufSize, 1, file);
|
||||
|
||||
fclose(file);
|
||||
|
||||
/////
|
||||
|
||||
m_dwSymbolCRC32 = GetFileCRC32(c_szFileName);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CGuildMarkUploader::Connect(const CNetworkAddress& c_rkNetAddr, DWORD dwHandle, DWORD dwRandomKey, DWORD dwGuildID, const char* c_szFileName, UINT* peError)
|
||||
{
|
||||
__OfflineState_Set();
|
||||
SetRecvBufferSize(1024);
|
||||
SetSendBufferSize(1024);
|
||||
|
||||
if (!CNetworkStream::Connect(c_rkNetAddr))
|
||||
{
|
||||
*peError=ERROR_CONNECT;
|
||||
return false;
|
||||
}
|
||||
|
||||
m_dwSendType=SEND_TYPE_MARK;
|
||||
m_dwHandle=dwHandle;
|
||||
m_dwRandomKey=dwRandomKey;
|
||||
m_dwGuildID=dwGuildID;
|
||||
|
||||
if (!__Load(c_szFileName, peError))
|
||||
return false;
|
||||
|
||||
//if (!__Save(CGraphicMarkInstance::GetImageFileName().c_str()))
|
||||
// return false;
|
||||
//CGraphicMarkInstance::ReloadImageFile();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CGuildMarkUploader::ConnectToSendSymbol(const CNetworkAddress& c_rkNetAddr, DWORD dwHandle, DWORD dwRandomKey, DWORD dwGuildID, const char* c_szFileName, UINT* peError)
|
||||
{
|
||||
__OfflineState_Set();
|
||||
SetRecvBufferSize(1024);
|
||||
SetSendBufferSize(64*1024);
|
||||
|
||||
if (!CNetworkStream::Connect(c_rkNetAddr))
|
||||
{
|
||||
*peError=ERROR_CONNECT;
|
||||
return false;
|
||||
}
|
||||
|
||||
m_dwSendType=SEND_TYPE_SYMBOL;
|
||||
m_dwHandle=dwHandle;
|
||||
m_dwRandomKey=dwRandomKey;
|
||||
m_dwGuildID=dwGuildID;
|
||||
|
||||
if (!__LoadSymbol(c_szFileName, peError))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void CGuildMarkUploader::Process()
|
||||
{
|
||||
CNetworkStream::Process();
|
||||
|
||||
if (!__StateProcess())
|
||||
{
|
||||
__OfflineState_Set();
|
||||
Disconnect();
|
||||
}
|
||||
}
|
||||
|
||||
void CGuildMarkUploader::OnConnectFailure()
|
||||
{
|
||||
__OfflineState_Set();
|
||||
}
|
||||
|
||||
void CGuildMarkUploader::OnConnectSuccess()
|
||||
{
|
||||
__LoginState_Set();
|
||||
}
|
||||
|
||||
void CGuildMarkUploader::OnRemoteDisconnect()
|
||||
{
|
||||
__OfflineState_Set();
|
||||
}
|
||||
|
||||
void CGuildMarkUploader::OnDisconnect()
|
||||
{
|
||||
__OfflineState_Set();
|
||||
}
|
||||
|
||||
void CGuildMarkUploader::__Inialize()
|
||||
{
|
||||
m_eState = STATE_OFFLINE;
|
||||
|
||||
m_dwGuildID = 0;
|
||||
m_dwHandle = 0;
|
||||
m_dwRandomKey = 0;
|
||||
|
||||
if (m_pbySymbolBuf)
|
||||
{
|
||||
delete m_pbySymbolBuf;
|
||||
}
|
||||
|
||||
m_dwSymbolBufSize = 0;
|
||||
m_pbySymbolBuf = NULL;
|
||||
}
|
||||
|
||||
bool CGuildMarkUploader::__StateProcess()
|
||||
{
|
||||
switch (m_eState)
|
||||
{
|
||||
case STATE_LOGIN:
|
||||
return __LoginState_Process();
|
||||
break;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void CGuildMarkUploader::__OfflineState_Set()
|
||||
{
|
||||
__Inialize();
|
||||
}
|
||||
|
||||
void CGuildMarkUploader::__CompleteState_Set()
|
||||
{
|
||||
m_eState=STATE_COMPLETE;
|
||||
|
||||
__OfflineState_Set();
|
||||
}
|
||||
|
||||
|
||||
void CGuildMarkUploader::__LoginState_Set()
|
||||
{
|
||||
m_eState=STATE_LOGIN;
|
||||
}
|
||||
|
||||
bool CGuildMarkUploader::__LoginState_Process()
|
||||
{
|
||||
if (!__AnalyzePacket(HEADER_GC_PHASE, sizeof(TPacketGCPhase), &CGuildMarkUploader::__LoginState_RecvPhase))
|
||||
return false;
|
||||
|
||||
if (!__AnalyzePacket(HEADER_GC_HANDSHAKE, sizeof(TPacketGCHandshake), &CGuildMarkUploader::__LoginState_RecvHandshake))
|
||||
return false;
|
||||
|
||||
if (!__AnalyzePacket(HEADER_GC_PING, sizeof(TPacketGCPing), &CGuildMarkUploader::__LoginState_RecvPing))
|
||||
return false;
|
||||
|
||||
#ifdef _IMPROVED_PACKET_ENCRYPTION_
|
||||
if (!__AnalyzePacket(HEADER_GC_KEY_AGREEMENT, sizeof(TPacketKeyAgreement), &CGuildMarkUploader::__LoginState_RecvKeyAgreement))
|
||||
return false;
|
||||
|
||||
if (!__AnalyzePacket(HEADER_GC_KEY_AGREEMENT_COMPLETED, sizeof(TPacketKeyAgreementCompleted), &CGuildMarkUploader::__LoginState_RecvKeyAgreementCompleted))
|
||||
return false;
|
||||
#endif
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CGuildMarkUploader::__SendMarkPacket()
|
||||
{
|
||||
TPacketCGMarkUpload kPacketMarkUpload;
|
||||
kPacketMarkUpload.header=HEADER_CG_MARK_UPLOAD;
|
||||
kPacketMarkUpload.gid=m_dwGuildID;
|
||||
|
||||
assert(sizeof(kPacketMarkUpload.image) == sizeof(m_kMark.m_apxBuf));
|
||||
memcpy(kPacketMarkUpload.image, m_kMark.m_apxBuf, sizeof(kPacketMarkUpload.image));
|
||||
|
||||
if (!Send(sizeof(kPacketMarkUpload), &kPacketMarkUpload))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
bool CGuildMarkUploader::__SendSymbolPacket()
|
||||
{
|
||||
if (!m_pbySymbolBuf)
|
||||
return false;
|
||||
|
||||
TPacketCGSymbolUpload kPacketSymbolUpload;
|
||||
kPacketSymbolUpload.header=HEADER_CG_GUILD_SYMBOL_UPLOAD;
|
||||
kPacketSymbolUpload.handle=m_dwGuildID;
|
||||
kPacketSymbolUpload.size=sizeof(TPacketCGSymbolUpload) + m_dwSymbolBufSize;
|
||||
|
||||
if (!Send(sizeof(TPacketCGSymbolUpload), &kPacketSymbolUpload))
|
||||
return false;
|
||||
if (!Send(m_dwSymbolBufSize, m_pbySymbolBuf))
|
||||
return false;
|
||||
|
||||
#ifdef _DEBUG
|
||||
printf("__SendSymbolPacket : [GuildID:%d/PacketSize:%d/BufSize:%d/CRC:%d]\n", m_dwGuildID, kPacketSymbolUpload.size, m_dwSymbolBufSize, m_dwSymbolCRC32);
|
||||
#endif
|
||||
|
||||
CNetworkStream::__SendInternalBuffer();
|
||||
__CompleteState_Set();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CGuildMarkUploader::__LoginState_RecvPhase()
|
||||
{
|
||||
TPacketGCPhase kPacketPhase;
|
||||
if (!Recv(sizeof(kPacketPhase), &kPacketPhase))
|
||||
return false;
|
||||
|
||||
if (kPacketPhase.phase==PHASE_LOGIN)
|
||||
{
|
||||
#ifndef _IMPROVED_PACKET_ENCRYPTION_
|
||||
const char* key = LocaleService_GetSecurityKey();
|
||||
SetSecurityMode(true, key);
|
||||
#endif
|
||||
|
||||
if (SEND_TYPE_MARK == m_dwSendType)
|
||||
{
|
||||
if (!__SendMarkPacket())
|
||||
return false;
|
||||
}
|
||||
else if (SEND_TYPE_SYMBOL == m_dwSendType)
|
||||
{
|
||||
if (!__SendSymbolPacket())
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CGuildMarkUploader::__LoginState_RecvHandshake()
|
||||
{
|
||||
TPacketGCHandshake kPacketHandshake;
|
||||
if (!Recv(sizeof(kPacketHandshake), &kPacketHandshake))
|
||||
return false;
|
||||
|
||||
{
|
||||
TPacketCGMarkLogin kPacketMarkLogin;
|
||||
kPacketMarkLogin.header=HEADER_CG_MARK_LOGIN;
|
||||
kPacketMarkLogin.handle=m_dwHandle;
|
||||
kPacketMarkLogin.random_key=m_dwRandomKey;
|
||||
if (!Send(sizeof(kPacketMarkLogin), &kPacketMarkLogin))
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CGuildMarkUploader::__LoginState_RecvPing()
|
||||
{
|
||||
TPacketGCPing kPacketPing;
|
||||
if (!Recv(sizeof(kPacketPing), &kPacketPing))
|
||||
return false;
|
||||
|
||||
TPacketCGPong kPacketPong;
|
||||
kPacketPong.bHeader = HEADER_CG_PONG;
|
||||
|
||||
if (!Send(sizeof(TPacketCGPong), &kPacketPong))
|
||||
return false;
|
||||
|
||||
if (IsSecurityMode())
|
||||
return SendSequence();
|
||||
else
|
||||
return true;
|
||||
}
|
||||
|
||||
#ifdef _IMPROVED_PACKET_ENCRYPTION_
|
||||
bool CGuildMarkUploader::__LoginState_RecvKeyAgreement()
|
||||
{
|
||||
TPacketKeyAgreement packet;
|
||||
if (!Recv(sizeof(packet), &packet))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
Tracenf("KEY_AGREEMENT RECV %u", packet.wDataLength);
|
||||
|
||||
TPacketKeyAgreement packetToSend;
|
||||
size_t dataLength = TPacketKeyAgreement::MAX_DATA_LEN;
|
||||
size_t agreedLength = Prepare(packetToSend.data, &dataLength);
|
||||
if (agreedLength == 0)
|
||||
{
|
||||
// 초기화 실패
|
||||
Disconnect();
|
||||
return false;
|
||||
}
|
||||
assert(dataLength <= TPacketKeyAgreement::MAX_DATA_LEN);
|
||||
|
||||
if (Activate(packet.wAgreedLength, packet.data, packet.wDataLength))
|
||||
{
|
||||
// Key agreement 성공, 응답 전송
|
||||
packetToSend.bHeader = HEADER_CG_KEY_AGREEMENT;
|
||||
packetToSend.wAgreedLength = (WORD)agreedLength;
|
||||
packetToSend.wDataLength = (WORD)dataLength;
|
||||
|
||||
if (!Send(sizeof(packetToSend), &packetToSend))
|
||||
{
|
||||
Tracen(" CAccountConnector::__AuthState_RecvKeyAgreement - SendKeyAgreement Error");
|
||||
return false;
|
||||
}
|
||||
Tracenf("KEY_AGREEMENT SEND %u", packetToSend.wDataLength);
|
||||
}
|
||||
else
|
||||
{
|
||||
// 키 협상 실패
|
||||
Disconnect();
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CGuildMarkUploader::__LoginState_RecvKeyAgreementCompleted()
|
||||
{
|
||||
TPacketKeyAgreementCompleted packet;
|
||||
if (!Recv(sizeof(packet), &packet))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
Tracenf("KEY_AGREEMENT_COMPLETED RECV");
|
||||
|
||||
ActivateCipher();
|
||||
|
||||
return true;
|
||||
}
|
||||
#endif // _IMPROVED_PACKET_ENCRYPTION_
|
||||
|
||||
bool CGuildMarkUploader::__AnalyzePacket(UINT uHeader, UINT uPacketSize, bool (CGuildMarkUploader::*pfnDispatchPacket)())
|
||||
{
|
||||
BYTE bHeader;
|
||||
if (!Peek(sizeof(bHeader), &bHeader))
|
||||
return true;
|
||||
|
||||
if (bHeader!=uHeader)
|
||||
return true;
|
||||
|
||||
if (!Peek(uPacketSize))
|
||||
return true;
|
||||
|
||||
return (this->*pfnDispatchPacket)();
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,441 @@
|
||||
#include "StdAfx.h"
|
||||
#include "Locale.h"
|
||||
#include "PythonApplication.h"
|
||||
#include "resource.h"
|
||||
#include "../EterBase/CRC32.h"
|
||||
#include "../EterPack/EterPackManager.h"
|
||||
#include "../EterLocale/Japanese.h"
|
||||
#include <windowsx.h>
|
||||
|
||||
const char* LSS_YMIR = "YMIR";
|
||||
const char* LSS_JAPAN = "JAPAN";
|
||||
const char* LSS_ENGLISH = "ENGLISH";
|
||||
const char* LSS_HONGKONG = "HONGKONG";
|
||||
const char* LSS_TAIWAN = "TAIWAN";
|
||||
const char* LSS_NEWCIBN = "NEWCIBN";
|
||||
const char* LSS_EUROPE = "EUROPE";
|
||||
const char* LSS_GLOBAL = "GLOBAL";
|
||||
|
||||
static bool IS_CHEONMA = false;
|
||||
|
||||
#ifndef LSS_SECURITY_KEY
|
||||
#define LSS_SECURITY_KEY "testtesttesttest"
|
||||
#endif
|
||||
|
||||
std::string __SECURITY_KEY_STRING__ = LSS_SECURITY_KEY;
|
||||
|
||||
char MULTI_LOCALE_SERVICE[256] = "EUROPE";
|
||||
char MULTI_LOCALE_PATH[256] = "locale/en";
|
||||
char MULTI_LOCALE_NAME[256] = "en";
|
||||
int MULTI_LOCALE_CODE = 1252;
|
||||
int MULTI_LOCALE_REPORT_PORT = 10002;
|
||||
|
||||
void LocaleService_LoadConfig(const char* fileName)
|
||||
{
|
||||
NANOBEGIN
|
||||
FILE* fp = fopen(fileName, "rt");
|
||||
|
||||
if (fp)
|
||||
{
|
||||
char line[256];
|
||||
char name[256];
|
||||
int code;
|
||||
int id;
|
||||
if (fgets(line, sizeof(line)-1, fp))
|
||||
{
|
||||
line[sizeof(line)-1] = '\0';
|
||||
sscanf(line, "%d %d %s", &id, &code, name);
|
||||
|
||||
MULTI_LOCALE_REPORT_PORT = id;
|
||||
MULTI_LOCALE_CODE = code;
|
||||
strcpy(MULTI_LOCALE_NAME, name);
|
||||
sprintf(MULTI_LOCALE_PATH, "locale/%s", MULTI_LOCALE_NAME);
|
||||
}
|
||||
fclose(fp);
|
||||
}
|
||||
NANOEND
|
||||
}
|
||||
|
||||
unsigned LocaleService_GetLastExp(int level)
|
||||
{
|
||||
static const int GUILD_LEVEL_MAX = 20;
|
||||
|
||||
if (LocaleService_IsCHEONMA())
|
||||
{
|
||||
static DWORD CHEONMA_GUILDEXP_LIST[GUILD_LEVEL_MAX+1] =
|
||||
{
|
||||
0, // 0
|
||||
15000ul, // 1
|
||||
45000ul, // 2
|
||||
90000ul, // 3
|
||||
160000ul, // 4
|
||||
235000ul, // 5
|
||||
325000ul, // 6
|
||||
430000ul, // 7
|
||||
550000ul, // 8
|
||||
685000ul, // 9
|
||||
835000ul, // 10
|
||||
1000000ul, // 11
|
||||
1500000ul, // 12
|
||||
2100000ul, // 13
|
||||
2800000ul, // 14
|
||||
3600000ul, // 15
|
||||
4500000ul, // 16
|
||||
6500000ul, // 17
|
||||
8000000ul, // 18
|
||||
10000000ul, // 19
|
||||
42000000UL // 20
|
||||
};
|
||||
if (level < 0 && level >= GUILD_LEVEL_MAX)
|
||||
return 0;
|
||||
|
||||
return CHEONMA_GUILDEXP_LIST[level];
|
||||
}
|
||||
|
||||
static DWORD INTERNATIONAL_GUILDEXP_LIST[GUILD_LEVEL_MAX+1] =
|
||||
{
|
||||
0, // 0
|
||||
6000UL, // 1
|
||||
18000UL, // 2
|
||||
36000UL, // 3
|
||||
64000UL, // 4
|
||||
94000UL, // 5
|
||||
130000UL, // 6
|
||||
172000UL, // 7
|
||||
220000UL, // 8
|
||||
274000UL, // 9
|
||||
334000UL, // 10
|
||||
400000UL, // 11
|
||||
600000UL, // 12
|
||||
840000UL, // 13
|
||||
1120000UL, // 14
|
||||
1440000UL, // 15
|
||||
1800000UL, // 16
|
||||
2600000UL, // 17
|
||||
3200000UL, // 18
|
||||
4000000UL, // 19
|
||||
16800000UL // 20
|
||||
};
|
||||
|
||||
if (level < 0 && level >= GUILD_LEVEL_MAX)
|
||||
return 0;
|
||||
|
||||
return INTERNATIONAL_GUILDEXP_LIST[level];
|
||||
}
|
||||
|
||||
int LocaleService_GetSkillPower(unsigned level)
|
||||
{
|
||||
static const unsigned SKILL_POWER_NUM = 50;
|
||||
|
||||
if (level >= SKILL_POWER_NUM)
|
||||
return 0;
|
||||
|
||||
if (LocaleService_IsCHEONMA())
|
||||
{
|
||||
static unsigned CHEONMA_SKILL_POWERS[SKILL_POWER_NUM]=
|
||||
{
|
||||
0,
|
||||
5, 7, 9, 11, 13,
|
||||
15, 17, 19, 20, 22,
|
||||
24, 26, 28, 30, 32,
|
||||
34, 36, 38, 40, 50, // master
|
||||
52, 55, 58, 61, 63,
|
||||
66, 69, 72, 75, 80, // grand_master
|
||||
82, 84, 87, 90, 95,
|
||||
100,110,120,130,150,// perfect_master
|
||||
150,
|
||||
};
|
||||
return CHEONMA_SKILL_POWERS[level];
|
||||
}
|
||||
|
||||
// 0 5 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 50 52 54 56 58 60 63 66 69 72 82 85 88 91 94 98 102 106 110 115 125 125 125 125 125
|
||||
static unsigned INTERNATIONAL_SKILL_POWERS[SKILL_POWER_NUM]=
|
||||
{
|
||||
0,
|
||||
5, 6, 8, 10, 12,
|
||||
14, 16, 18, 20, 22,
|
||||
24, 26, 28, 30, 32,
|
||||
34, 36, 38, 40, 50, // master
|
||||
52, 54, 56, 58, 60,
|
||||
63, 66, 69, 72, 82, // grand_master
|
||||
85, 88, 91, 94, 98,
|
||||
102,106,110,115,125,// perfect_master
|
||||
125,
|
||||
};
|
||||
return INTERNATIONAL_SKILL_POWERS[level];
|
||||
}
|
||||
|
||||
const char* LocaleService_GetSecurityKey()
|
||||
{
|
||||
return __SECURITY_KEY_STRING__.c_str();
|
||||
}
|
||||
|
||||
// CHEONMA
|
||||
void LocaleService_SetCHEONMA(bool isEnable)
|
||||
{
|
||||
IS_CHEONMA = isEnable;
|
||||
}
|
||||
|
||||
bool LocaleService_IsCHEONMA()
|
||||
{
|
||||
return LocaleService_IsYMIR();
|
||||
}
|
||||
|
||||
// END_OF_CHEONMA
|
||||
|
||||
#if defined(LOCALE_SERVICE_EUROPE) || defined(LOCALE_SERVICE_BRAZIL) || defined(LOCALE_SERVICE_CANADA) || defined(LOCALE_SERVICE_SINGAPORE) || defined(LOCALE_SERVICE_VIETNAM) || defined(LOCALE_SERVICE_TAIWAN) || defined(LOCALE_SERVICE_NEWCIBN)
|
||||
#define _LSS_USE_LOCALE_CFG 1
|
||||
#define _LSS_SERVICE_NAME LSS_EUROPE
|
||||
#elif defined(LOCALE_SERVICE_ITALY)
|
||||
#define _LSS_SERVICE_NAME LSS_ITALY
|
||||
#define _LSS_SERVICE_CODEPAGE CP_LATIN
|
||||
#define _LSS_SERVICE_LOCALE_NAME "it"
|
||||
#define _LSS_SERVICE_LOCALE_PATH "locale/it"
|
||||
#elif defined(LOCALE_SERVICE_ENGLISH)
|
||||
#define _LSS_SERVICE_NAME LSS_ENGLISH
|
||||
#define _LSS_SERVICE_CODEPAGE CP_LATIN
|
||||
#define _LSS_SERVICE_LOCALE_NAME "english"
|
||||
#define _LSS_SERVICE_LOCALE_PATH "locale/english"
|
||||
#elif defined(LOCALE_SERVICE_JAPAN)
|
||||
#define _LSS_SERVICE_NAME LSS_JAPAN
|
||||
#define _LSS_SERVICE_CODEPAGE CP_JAPANESE
|
||||
#define _LSS_SERVICE_LOCALE_NAME "japan"
|
||||
#define _LSS_SERVICE_LOCALE_PATH "locale/japan"
|
||||
#elif defined(LOCALE_SERVICE_YMIR)
|
||||
#define _LSS_SERVICE_NAME LSS_YMIR
|
||||
#define _LSS_SERVICE_CODEPAGE CP_HANGUL
|
||||
#define _LSS_SERVICE_LOCALE_NAME "ymir"
|
||||
#define _LSS_SERVICE_LOCALE_PATH "locale/ymir"
|
||||
#elif defined(LOCALE_SERVICE_HONGKONG)
|
||||
#define _LSS_SERVICE_NAME LSS_HONGKONG
|
||||
#define _LSS_SERVICE_CODEPAGE CP_CHINESE_TRAD
|
||||
#define _LSS_SERVICE_LOCALE_NAME "hongkong"
|
||||
#define _LSS_SERVICE_LOCALE_PATH "locale/hongkong"
|
||||
#elif defined(LOCALE_SERVICE_TAIWAN)
|
||||
#define _LSS_SERVICE_NAME LSS_TAIWAN
|
||||
#define _LSS_SERVICE_CODEPAGE CP_CHINESE_TRAD
|
||||
#define _LSS_SERVICE_LOCALE_NAME "taiwan"
|
||||
#define _LSS_SERVICE_LOCALE_PATH "locale/taiwan"
|
||||
#elif defined(LOCALE_SERVICE_NEWCIBN)
|
||||
#define _LSS_SERVICE_NAME LSS_NEWCIBN
|
||||
#define _LSS_SERVICE_CODEPAGE CP_CHINESE_SIMPLE
|
||||
#define _LSS_SERVICE_LOCALE_NAME "newcibn"
|
||||
#define _LSS_SERVICE_LOCALE_PATH "locale/newcibn"
|
||||
#endif
|
||||
|
||||
#if defined(_LSS_USE_LOCALE_CFG)
|
||||
#if defined(_LSS_SERVICE_NAME)
|
||||
const char* LocaleService_GetName() { return _LSS_SERVICE_NAME;}
|
||||
#else
|
||||
const char* LocaleService_GetName() { return MULTI_LOCALE_SERVICE; }
|
||||
#endif
|
||||
unsigned int LocaleService_GetCodePage() { return MULTI_LOCALE_CODE; }
|
||||
const char* LocaleService_GetLocaleName() { return MULTI_LOCALE_NAME; }
|
||||
const char* LocaleService_GetLocalePath() { return MULTI_LOCALE_PATH; }
|
||||
#elif defined(_LSS_SERVICE_NAME)
|
||||
const char* LocaleService_GetName() { return _LSS_SERVICE_NAME;}
|
||||
unsigned int LocaleService_GetCodePage() { return _LSS_SERVICE_CODEPAGE; }
|
||||
const char* LocaleService_GetLocaleName() { return _LSS_SERVICE_LOCALE_NAME; }
|
||||
const char* LocaleService_GetLocalePath() { return _LSS_SERVICE_LOCALE_PATH; }
|
||||
#endif
|
||||
|
||||
void LocaleService_ForceSetLocale(const char* name, const char* localePath)
|
||||
{
|
||||
strcpy(MULTI_LOCALE_NAME, name);
|
||||
strcpy(MULTI_LOCALE_PATH, localePath);
|
||||
|
||||
// 기존 천마 서버로 접속시에는 security key 변경 (WE 버전 클라로 천마서버 접속하기 위함)
|
||||
if (0 == stricmp(name, "ymir"))
|
||||
__SECURITY_KEY_STRING__ = "testtesttesttest";
|
||||
if (0 == stricmp(name, "we_korea"))
|
||||
__SECURITY_KEY_STRING__ = "1234abcd5678efgh";
|
||||
}
|
||||
|
||||
#if defined(LOCALE_SERVICE_GLOBAL)
|
||||
struct SLOCALEDATA
|
||||
{
|
||||
const char* szServiceName;
|
||||
const char* szLocaleName;
|
||||
WORD wCodePage;
|
||||
const char* szSecurityKey;
|
||||
} gs_stLocaleData[] = {
|
||||
{ LSS_YMIR, "ymir", 949, "testtesttesttest" }, // Korea
|
||||
{ LSS_EUROPE, "de", 1252, "1234abcd5678efgh" }, // GameForge (Germany)
|
||||
{ LSS_EUROPE, "en", 1252, "1234abcd5678efgh" }, // GameForge (United Kingdom)
|
||||
{ LSS_EUROPE, "us", 1252, "1234abcd5678efgh" }, // GameForge (USA)
|
||||
{ LSS_EUROPE, "es", 1252, "1234abcd5678efgh" }, // GameForge (Spain)
|
||||
{ LSS_EUROPE, "it", 1252, "1234abcd5678efgh" }, // GameForge (Italy)
|
||||
{ LSS_EUROPE, "fr", 1252, "1234abcd5678efgh" }, // GameForge (France)
|
||||
{ LSS_EUROPE, "pt", 1252, "1234abcd5678efgh" }, // GameForge (Portugal)
|
||||
{ LSS_EUROPE, "tr", 1253, "1234abcd5678efgh" }, // GameForge (Greece)
|
||||
{ LSS_EUROPE, "pl", 1250, "1234abcd5678efgh" }, // GameForge (Poland)
|
||||
{ LSS_EUROPE, "tr", 1254, "1234abcd5678efgh" }, // GameForge (Turkey)
|
||||
{ LSS_EUROPE, "dk", 1252, "1234abcd5678efgh" }, // GameForge (Demmark)
|
||||
{ LSS_EUROPE, "ae", 1256, "1234abcd5678efgh" }, // GameForge (United Arab Emirate)
|
||||
{ LSS_EUROPE, "mx", 1252, "1234abcd5678efgh" }, // GameForge (Mexico)
|
||||
{ LSS_EUROPE, "nl", 1252, "1234abcd5678efgh" }, // GameForge (Netherlands)
|
||||
{ LSS_EUROPE, "cz", 1252, "1234abcd5678efgh" }, // GameForge (Czech Republic)
|
||||
{ LSS_EUROPE, "ru", 1251, "1234abcd5678efgh" }, // GameForge (Russian Federation)
|
||||
{ LSS_EUROPE, "hu", 1250, "1234abcd5678efgh" }, // GameForge (Hungary)
|
||||
{ LSS_EUROPE, "ro", 1250, "1234abcd5678efgh" }, // GameForge (Romania)
|
||||
{ LSS_EUROPE, "ca", 1252, "testtesttesttest" }, // Z8Games (Canada)
|
||||
{ LSS_EUROPE, "sg", 1252, "testtesttesttest" }, // TEC (Singapore)
|
||||
{ LSS_JAPAN, "japan", 932, "testtesttesttest" }, // Japan
|
||||
{ LSS_EUROPE, "br", 1252, "testtesttesttest" }, // OnGame (Brazil)
|
||||
{ LSS_HONGKONG, "hongkong", 950, "testtesttesttest" }, // HongKong & Taiwan
|
||||
{ LSS_NEWCIBN, "newcibn", 936, "testtesttesttest" }, // CIBN (Free world)
|
||||
{ LSS_ENGLISH, "english", 949, "testtesttesttest" }, // English (Obsoleted)
|
||||
{ LSS_YMIR, "kr", 949, "testtesttesttest" }, // Korea (Obsoleted)
|
||||
{ NULL, NULL, 0, "testtesttesttest" }
|
||||
};
|
||||
|
||||
const char* LocaleService_GetName()
|
||||
{
|
||||
return MULTI_LOCALE_SERVICE;
|
||||
}
|
||||
|
||||
unsigned int LocaleService_GetCodePage()
|
||||
{
|
||||
return MULTI_LOCALE_CODE;
|
||||
}
|
||||
|
||||
const char* LocaleService_GetLocaleName()
|
||||
{
|
||||
return MULTI_LOCALE_NAME;
|
||||
}
|
||||
|
||||
const char* LocaleService_GetLocalePath()
|
||||
{
|
||||
return MULTI_LOCALE_PATH;
|
||||
}
|
||||
|
||||
static int gs_iLocale = -1;
|
||||
|
||||
LRESULT CALLBACK SelectDlgProc( HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam )
|
||||
{
|
||||
switch( uMsg ) {
|
||||
case WM_INITDIALOG : {
|
||||
char szLocalePath[256], szDisplayName[256];
|
||||
for(int i=0; gs_stLocaleData[i].szServiceName; i++ ) {
|
||||
sprintf(szLocalePath, "locale/%s/item_proto", gs_stLocaleData[i].szLocaleName);
|
||||
if( CEterPackManager::Instance().isExist(szLocalePath)) {
|
||||
sprintf(szDisplayName, "%s (%s, %d)", gs_stLocaleData[i].szLocaleName, gs_stLocaleData[i].szServiceName, gs_stLocaleData[i].wCodePage);
|
||||
int iIndex = ListBox_AddString(GetDlgItem(hDlg, IDC_LOCALE_LIST), szDisplayName);
|
||||
ListBox_SetItemData(GetDlgItem(hDlg, IDC_LOCALE_LIST), iIndex, i);
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
case WM_COMMAND :
|
||||
switch( LOWORD( wParam ) ) {
|
||||
case IDC_LOCALE_LIST: {
|
||||
int iSelected = ListBox_GetCurSel(GetDlgItem(hDlg, IDC_LOCALE_LIST));
|
||||
switch(HIWORD(wParam)) {
|
||||
case LBN_SELCHANGE :
|
||||
gs_iLocale = ListBox_GetItemData(GetDlgItem(hDlg, IDC_LOCALE_LIST), iSelected);
|
||||
break;
|
||||
case LBN_DBLCLK :
|
||||
gs_iLocale = ListBox_GetItemData(GetDlgItem(hDlg, IDC_LOCALE_LIST), iSelected);
|
||||
::EndDialog(hDlg, 0);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case IDC_START: {
|
||||
::EndDialog(hDlg, 0);
|
||||
break;
|
||||
}
|
||||
case IDC_EXIT: {
|
||||
gs_iLocale = -1;
|
||||
::EndDialog(hDlg, 0);
|
||||
break;
|
||||
}
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
bool LocaleService_LoadGlobal(HINSTANCE hInstance)
|
||||
{
|
||||
int nFoundLocales = 0;
|
||||
char szLocalePath[256];
|
||||
|
||||
for(int i=0; gs_stLocaleData[i].szServiceName; i++ ) {
|
||||
sprintf(szLocalePath, "locale/%s/item_proto", gs_stLocaleData[i].szLocaleName);
|
||||
if( CEterPackManager::Instance().isExist(szLocalePath)) {
|
||||
nFoundLocales++;
|
||||
if(gs_iLocale == -1)
|
||||
gs_iLocale = i;
|
||||
}
|
||||
}
|
||||
if (gs_iLocale < 0)
|
||||
return false;
|
||||
if(nFoundLocales > 1)
|
||||
::DialogBox(hInstance, MAKEINTRESOURCE(IDD_SELECT_LOCALE), NULL, (DLGPROC) SelectDlgProc);
|
||||
if (gs_iLocale < 0)
|
||||
return false;
|
||||
strcpy(MULTI_LOCALE_SERVICE, gs_stLocaleData[gs_iLocale].szServiceName);
|
||||
strcpy(MULTI_LOCALE_NAME, gs_stLocaleData[gs_iLocale].szLocaleName);
|
||||
sprintf(MULTI_LOCALE_PATH, "locale/%s", gs_stLocaleData[gs_iLocale].szLocaleName);
|
||||
MULTI_LOCALE_CODE = gs_stLocaleData[gs_iLocale].wCodePage;
|
||||
if(gs_stLocaleData[gs_iLocale].szSecurityKey)
|
||||
__SECURITY_KEY_STRING__ = gs_stLocaleData[gs_iLocale].szSecurityKey;
|
||||
return true;
|
||||
}
|
||||
#else
|
||||
bool LocaleService_LoadGlobal(HINSTANCE hInstance)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
|
||||
bool LocaleService_IsYMIR() { return (stricmp( LocaleService_GetName(), LSS_YMIR ) == 0) || (stricmp( LocaleService_GetLocaleName(), "ymir" ) == 0); }
|
||||
bool LocaleService_IsJAPAN() { return (stricmp( LocaleService_GetName(), LSS_JAPAN ) == 0) || (stricmp( LocaleService_GetLocaleName(), "japan" ) == 0); }
|
||||
bool LocaleService_IsENGLISH() { return (stricmp( LocaleService_GetName(), LSS_ENGLISH ) == 0); }
|
||||
bool LocaleService_IsEUROPE() { return (stricmp( LocaleService_GetName(), LSS_EUROPE ) == 0); }
|
||||
bool LocaleService_IsHONGKONG() { return (stricmp( LocaleService_GetName(), LSS_HONGKONG ) == 0); }
|
||||
bool LocaleService_IsTAIWAN() { return (stricmp( LocaleService_GetName(), LSS_TAIWAN ) == 0); }
|
||||
bool LocaleService_IsNEWCIBN() { return (stricmp( LocaleService_GetName(), LSS_NEWCIBN ) == 0); }
|
||||
|
||||
#if defined(LOCALE_SERVICE_WE_JAPAN)
|
||||
BOOL LocaleService_IsLeadByte( const char chByte )
|
||||
{
|
||||
return ShiftJIS_IsLeadByte( chByte );
|
||||
}
|
||||
|
||||
int LocaleService_StringCompareCI( LPCSTR szStringLeft, LPCSTR szStringRight, size_t sizeLength )
|
||||
{
|
||||
return ShiftJIS_StringCompareCI( szStringLeft, szStringRight, sizeLength );
|
||||
}
|
||||
#else
|
||||
BOOL LocaleService_IsLeadByte( const char chByte )
|
||||
{
|
||||
return (((unsigned char) chByte) & 0x80) != 0;
|
||||
}
|
||||
|
||||
int LocaleService_StringCompareCI( LPCSTR szStringLeft, LPCSTR szStringRight, size_t sizeLength )
|
||||
{
|
||||
return strnicmp( szStringLeft, szStringRight, sizeLength );
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef USE_OPENID
|
||||
|
||||
std::string __OPENID_AUTH_KEY_STRING__;
|
||||
int openid_test = 0;
|
||||
|
||||
void LocaleService_SetOpenIDAuthKey(const char *authKey)
|
||||
{
|
||||
__OPENID_AUTH_KEY_STRING__ = authKey;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
const char* LocaleService_GetOpenIDAuthKey()
|
||||
{
|
||||
return __OPENID_AUTH_KEY_STRING__.c_str();
|
||||
}
|
||||
|
||||
#endif /* USE_OPENID */
|
||||
@@ -0,0 +1,321 @@
|
||||
#include "StdAfx.h"
|
||||
#include "MarkImage.h"
|
||||
|
||||
#if 0 // PORT: server-only legacy gcc branch; client uses EterBase/lzo.h
|
||||
#include <il/il.h>
|
||||
#include "crc32.h"
|
||||
#include "lzo_manager.h"
|
||||
#include "minilzo.h"
|
||||
#define CLZO LZOManager
|
||||
#else
|
||||
#include <EterBase/lzo.h>
|
||||
#define sys_err TraceError
|
||||
#define sys_log //(n, format, ...) Tracenf(format, __VA_ARGS__)
|
||||
#define thecore_memcpy memcpy
|
||||
#define itertype(cont) typeof(cont.begin())
|
||||
#endif
|
||||
|
||||
CGuildMarkImage * NewMarkImage()
|
||||
{
|
||||
return new CGuildMarkImage;
|
||||
}
|
||||
|
||||
void DeleteMarkImage(CGuildMarkImage * pkImage)
|
||||
{
|
||||
delete pkImage;
|
||||
}
|
||||
|
||||
CGuildMarkImage::CGuildMarkImage()
|
||||
{
|
||||
m_uImg = INVALID_HANDLE;
|
||||
}
|
||||
|
||||
CGuildMarkImage::~CGuildMarkImage()
|
||||
{
|
||||
Destroy();
|
||||
}
|
||||
|
||||
void CGuildMarkImage::Destroy()
|
||||
{
|
||||
if (INVALID_HANDLE == m_uImg)
|
||||
return;
|
||||
|
||||
ilDeleteImages(1, &m_uImg);
|
||||
m_uImg = INVALID_HANDLE;
|
||||
}
|
||||
|
||||
void CGuildMarkImage::Create()
|
||||
{
|
||||
if (INVALID_HANDLE != m_uImg)
|
||||
return;
|
||||
|
||||
ilGenImages(1, &m_uImg);
|
||||
}
|
||||
|
||||
bool CGuildMarkImage::Save(const char* c_szFileName)
|
||||
{
|
||||
ilEnable(IL_FILE_OVERWRITE);
|
||||
ilBindImage(m_uImg);
|
||||
|
||||
if (!ilSave(IL_TGA, (const ILstring)c_szFileName))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CGuildMarkImage::Build(const char * c_szFileName)
|
||||
{
|
||||
Destroy();
|
||||
Create();
|
||||
|
||||
ilBindImage(m_uImg);
|
||||
ilEnable(IL_ORIGIN_SET);
|
||||
ilOriginFunc(IL_ORIGIN_UPPER_LEFT);
|
||||
|
||||
BYTE * data = (BYTE *) malloc(sizeof(Pixel) * WIDTH * HEIGHT);
|
||||
memset(data, 0, sizeof(Pixel) * WIDTH * HEIGHT);
|
||||
|
||||
if (!ilTexImage(WIDTH, HEIGHT, 1, 4, IL_BGRA, IL_UNSIGNED_BYTE, data))
|
||||
{
|
||||
sys_err("CGuildMarkImage: cannot initialize image");
|
||||
return false;
|
||||
}
|
||||
|
||||
free(data);
|
||||
|
||||
ilEnable(IL_FILE_OVERWRITE);
|
||||
|
||||
if (!ilSave(IL_TGA, (const ILstring)c_szFileName))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CGuildMarkImage::Load(const char * c_szFileName)
|
||||
{
|
||||
Destroy();
|
||||
Create();
|
||||
|
||||
ilBindImage(m_uImg);
|
||||
ilEnable(IL_ORIGIN_SET);
|
||||
ilOriginFunc(IL_ORIGIN_UPPER_LEFT);
|
||||
|
||||
if (!ilLoad(IL_TYPE_UNKNOWN, (const ILstring) c_szFileName))
|
||||
{
|
||||
Build(c_szFileName);
|
||||
|
||||
if (!Load(c_szFileName))
|
||||
{
|
||||
sys_err("CGuildMarkImage: cannot open file for writing %s", c_szFileName);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (ilGetInteger(IL_IMAGE_WIDTH) != WIDTH)
|
||||
{
|
||||
sys_err("CGuildMarkImage: %s width must be %u", c_szFileName, WIDTH);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (ilGetInteger(IL_IMAGE_HEIGHT) != HEIGHT)
|
||||
{
|
||||
sys_err("CGuildMarkImage: %s height must be %u", c_szFileName, HEIGHT);
|
||||
return false;
|
||||
}
|
||||
|
||||
ilConvertImage(IL_BGRA, IL_UNSIGNED_BYTE);
|
||||
|
||||
BuildAllBlocks();
|
||||
return true;
|
||||
}
|
||||
|
||||
void CGuildMarkImage::PutData(UINT x, UINT y, UINT width, UINT height, void * data)
|
||||
{
|
||||
ilBindImage(m_uImg);
|
||||
ilSetPixels(x, y, 0, width, height, 1, IL_BGRA, IL_UNSIGNED_BYTE, data);
|
||||
}
|
||||
|
||||
void CGuildMarkImage::GetData(UINT x, UINT y, UINT width, UINT height, void * data)
|
||||
{
|
||||
ilBindImage(m_uImg);
|
||||
ilCopyPixels(x, y, 0, width, height, 1, IL_BGRA, IL_UNSIGNED_BYTE, data);
|
||||
}
|
||||
|
||||
// 이미지 = 512x512
|
||||
// 블럭 = 마크 4 x 4
|
||||
// 마크 = 16 x 12
|
||||
// 한 이미지의 블럭 = 8 x 10
|
||||
|
||||
// SERVER
|
||||
bool CGuildMarkImage::SaveMark(DWORD posMark, BYTE * pbImage)
|
||||
{
|
||||
if (posMark >= MARK_TOTAL_COUNT)
|
||||
{
|
||||
sys_err("CGuildMarkImage::CopyMarkFromData: Invalid mark position %u", posMark);
|
||||
return false;
|
||||
}
|
||||
|
||||
// 마크를 전체 이미지에 그린다.
|
||||
DWORD colMark = posMark % MARK_COL_COUNT;
|
||||
DWORD rowMark = posMark / MARK_COL_COUNT;
|
||||
|
||||
printf("PutMark pos %u %ux%u\n", posMark, colMark * SGuildMark::WIDTH, rowMark * SGuildMark::HEIGHT);
|
||||
PutData(colMark * SGuildMark::WIDTH, rowMark * SGuildMark::HEIGHT, SGuildMark::WIDTH, SGuildMark::HEIGHT, pbImage);
|
||||
|
||||
// 그려진 곳의 블럭을 업데이트
|
||||
DWORD rowBlock = rowMark / SGuildMarkBlock::MARK_PER_BLOCK_HEIGHT;
|
||||
DWORD colBlock = colMark / SGuildMarkBlock::MARK_PER_BLOCK_WIDTH;
|
||||
|
||||
Pixel apxBuf[SGuildMarkBlock::SIZE];
|
||||
GetData(colBlock * SGuildMarkBlock::WIDTH, rowBlock * SGuildMarkBlock::HEIGHT, SGuildMarkBlock::WIDTH, SGuildMarkBlock::HEIGHT, apxBuf);
|
||||
m_aakBlock[rowBlock][colBlock].Compress(apxBuf);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CGuildMarkImage::DeleteMark(DWORD posMark)
|
||||
{
|
||||
Pixel image[SGuildMark::SIZE];
|
||||
memset(&image, 0, sizeof(image));
|
||||
return SaveMark(posMark, (BYTE *) &image);
|
||||
}
|
||||
|
||||
// CLIENT
|
||||
bool CGuildMarkImage::SaveBlockFromCompressedData(DWORD posBlock, const BYTE * pbComp, DWORD dwCompSize)
|
||||
{
|
||||
if (posBlock >= BLOCK_TOTAL_COUNT)
|
||||
return false;
|
||||
|
||||
Pixel apxBuf[SGuildMarkBlock::SIZE];
|
||||
size_t sizeBuf = sizeof(apxBuf);
|
||||
|
||||
if (LZO_E_OK != lzo1x_decompress_safe(pbComp, dwCompSize, (BYTE *) apxBuf, (lzo_uint*) &sizeBuf, CLZO::Instance().GetWorkMemory()))
|
||||
{
|
||||
sys_err("CGuildMarkImage::CopyBlockFromCompressedData: cannot decompress, compressed size = %u", dwCompSize);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (sizeBuf != sizeof(apxBuf))
|
||||
{
|
||||
sys_err("CGuildMarkImage::CopyBlockFromCompressedData: image corrupted, decompressed size = %u", sizeBuf);
|
||||
return false;
|
||||
}
|
||||
|
||||
DWORD rowBlock = posBlock / BLOCK_COL_COUNT;
|
||||
DWORD colBlock = posBlock % BLOCK_COL_COUNT;
|
||||
|
||||
PutData(colBlock * SGuildMarkBlock::WIDTH, rowBlock * SGuildMarkBlock::HEIGHT, SGuildMarkBlock::WIDTH, SGuildMarkBlock::HEIGHT, apxBuf);
|
||||
|
||||
m_aakBlock[rowBlock][colBlock].CopyFrom(pbComp, dwCompSize, GetCRC32((const char *) apxBuf, sizeof(Pixel) * SGuildMarkBlock::SIZE));
|
||||
return true;
|
||||
}
|
||||
|
||||
void CGuildMarkImage::BuildAllBlocks() // 이미지 전체를 블럭화
|
||||
{
|
||||
Pixel apxBuf[SGuildMarkBlock::SIZE];
|
||||
sys_log(0, "CGuildMarkImage::BuildAllBlocks");
|
||||
|
||||
for (UINT row = 0; row < BLOCK_ROW_COUNT; ++row)
|
||||
for (UINT col = 0; col < BLOCK_COL_COUNT; ++col)
|
||||
{
|
||||
GetData(col * SGuildMarkBlock::WIDTH, row * SGuildMarkBlock::HEIGHT, SGuildMarkBlock::WIDTH, SGuildMarkBlock::HEIGHT, apxBuf);
|
||||
m_aakBlock[row][col].Compress(apxBuf);
|
||||
}
|
||||
}
|
||||
|
||||
DWORD CGuildMarkImage::GetEmptyPosition()
|
||||
{
|
||||
SGuildMark kMark;
|
||||
|
||||
for (DWORD row = 0; row < MARK_ROW_COUNT; ++row)
|
||||
{
|
||||
for (DWORD col = 0; col < MARK_COL_COUNT; ++col)
|
||||
{
|
||||
GetData(col * SGuildMark::WIDTH, row * SGuildMark::HEIGHT, SGuildMark::WIDTH, SGuildMark::HEIGHT, kMark.m_apxBuf);
|
||||
|
||||
if (kMark.IsEmpty())
|
||||
return (row * MARK_COL_COUNT + col);
|
||||
}
|
||||
}
|
||||
|
||||
return INVALID_MARK_POSITION;
|
||||
}
|
||||
|
||||
void CGuildMarkImage::GetDiffBlocks(const DWORD * crcList, std::map<BYTE, const SGuildMarkBlock *> & mapDiffBlocks)
|
||||
{
|
||||
BYTE posBlock = 0;
|
||||
|
||||
for (DWORD row = 0; row < BLOCK_ROW_COUNT; ++row)
|
||||
for (DWORD col = 0; col < BLOCK_COL_COUNT; ++col)
|
||||
{
|
||||
if (m_aakBlock[row][col].m_crc != *crcList)
|
||||
{
|
||||
mapDiffBlocks.insert(std::map<BYTE, const SGuildMarkBlock *>::value_type(posBlock, &m_aakBlock[row][col]));
|
||||
}
|
||||
++crcList;
|
||||
++posBlock;
|
||||
}
|
||||
}
|
||||
|
||||
void CGuildMarkImage::GetBlockCRCList(DWORD * crcList)
|
||||
{
|
||||
for (DWORD row = 0; row < BLOCK_ROW_COUNT; ++row)
|
||||
for (DWORD col = 0; col < BLOCK_COL_COUNT; ++col)
|
||||
*(crcList++) = m_aakBlock[row][col].GetCRC();
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
void SGuildMark::Clear()
|
||||
{
|
||||
for (DWORD iPixel = 0; iPixel < SIZE; ++iPixel)
|
||||
m_apxBuf[iPixel] = 0xff000000;
|
||||
}
|
||||
|
||||
bool SGuildMark::IsEmpty()
|
||||
{
|
||||
for (DWORD iPixel = 0; iPixel < SIZE; ++iPixel)
|
||||
if (m_apxBuf[iPixel] != 0x00000000)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
DWORD SGuildMarkBlock::GetCRC() const
|
||||
{
|
||||
return m_crc;
|
||||
}
|
||||
|
||||
void SGuildMarkBlock::CopyFrom(const BYTE * pbCompBuf, DWORD dwCompSize, DWORD crc)
|
||||
{
|
||||
if (dwCompSize > MAX_COMP_SIZE)
|
||||
return;
|
||||
|
||||
m_sizeCompBuf = dwCompSize;
|
||||
thecore_memcpy(m_abCompBuf, pbCompBuf, dwCompSize);
|
||||
m_crc = crc;
|
||||
//printf("SGuildMarkBlock::CopyFrom: %u > %u crc %u\n", sizeof(Pixel) * SGuildMarkBlock::SIZE, m_sizeCompBuf, m_crc);
|
||||
}
|
||||
|
||||
void SGuildMarkBlock::Compress(const Pixel * pxBuf)
|
||||
{
|
||||
m_sizeCompBuf = MAX_COMP_SIZE;
|
||||
|
||||
#if defined(LZO1X_999_MEM_COMPRESS)
|
||||
if (LZO_E_OK != lzo1x_999_compress((const BYTE *) pxBuf,
|
||||
sizeof(Pixel) * SGuildMarkBlock::SIZE, m_abCompBuf,
|
||||
(lzo_uint*) &m_sizeCompBuf,
|
||||
CLZO::Instance().GetWorkMemory()))
|
||||
#else // PORT: minilzo uses lzo1x_1_compress
|
||||
if (LZO_E_OK != lzo1x_1_compress((const BYTE *) pxBuf,
|
||||
sizeof(Pixel) * SGuildMarkBlock::SIZE, m_abCompBuf,
|
||||
(lzo_uint*) &m_sizeCompBuf,
|
||||
CLZO::Instance().GetWorkMemory()))
|
||||
#endif
|
||||
{
|
||||
sys_err("SGuildMarkBlock::Compress: Error! %u > %u", sizeof(Pixel) * SGuildMarkBlock::SIZE, m_sizeCompBuf);
|
||||
return;
|
||||
}
|
||||
|
||||
//sys_log(0, "SGuildMarkBlock::Compress %u > %u", sizeof(Pixel) * SGuildMarkBlock::SIZE, m_sizeCompBuf);
|
||||
m_crc = GetCRC32((const char *) pxBuf, sizeof(Pixel) * SGuildMarkBlock::SIZE);
|
||||
}
|
||||
@@ -0,0 +1,488 @@
|
||||
#include "StdAfx.h"
|
||||
#include "MarkManager.h"
|
||||
|
||||
#if defined(_MSC_VER) && _MSC_VER < 1200 // PORT: undefined _MSC_VER evaluates to 0 under clang/gcc
|
||||
#include "crc32.h"
|
||||
#else
|
||||
#define sys_err TraceError
|
||||
#define sys_log // (n, format, ...) Tracenf(format, __VA_ARGS__)
|
||||
#define thecore_memcpy memcpy
|
||||
#define itertype(cont) typeof((cont).begin())
|
||||
#endif
|
||||
|
||||
CGuildMarkImage * CGuildMarkManager::__NewImage()
|
||||
{
|
||||
return new CGuildMarkImage;
|
||||
}
|
||||
|
||||
void CGuildMarkManager::__DeleteImage(CGuildMarkImage * pkImgDel)
|
||||
{
|
||||
delete pkImgDel;
|
||||
}
|
||||
|
||||
CGuildMarkManager::CGuildMarkManager()
|
||||
{
|
||||
#if _MSC_VER >= 1200
|
||||
_mkdir("mark");
|
||||
#endif
|
||||
// 남은 mark id 셋을 만든다. (서버용)
|
||||
for (DWORD i = 0; i < MAX_IMAGE_COUNT * CGuildMarkImage::MARK_TOTAL_COUNT; ++i)
|
||||
m_setFreeMarkID.insert(i);
|
||||
}
|
||||
|
||||
CGuildMarkManager::~CGuildMarkManager()
|
||||
{
|
||||
for (std::map<DWORD, CGuildMarkImage *>::iterator it = m_mapIdx_Image.begin(); it != m_mapIdx_Image.end(); ++it)
|
||||
__DeleteImage(it->second);
|
||||
|
||||
m_mapIdx_Image.clear();
|
||||
}
|
||||
|
||||
bool CGuildMarkManager::GetMarkImageFilename(DWORD imgIdx, std::string & path) const
|
||||
{
|
||||
if (imgIdx >= MAX_IMAGE_COUNT)
|
||||
return false;
|
||||
|
||||
char buf[64];
|
||||
snprintf(buf, sizeof(buf), "mark/%s_%lu.tga", m_pathPrefix.c_str(), imgIdx);
|
||||
path = buf;
|
||||
return true;
|
||||
}
|
||||
|
||||
void CGuildMarkManager::SetMarkPathPrefix(const char * prefix)
|
||||
{
|
||||
m_pathPrefix = prefix;
|
||||
}
|
||||
|
||||
// 마크 인덱스 불러오기 (서버에서만 사용)
|
||||
bool CGuildMarkManager::LoadMarkIndex()
|
||||
{
|
||||
char buf[64];
|
||||
snprintf(buf, sizeof(buf), "mark/%s_index", m_pathPrefix.c_str());
|
||||
FILE * fp = fopen(buf, "r");
|
||||
|
||||
if (!fp)
|
||||
return false;
|
||||
|
||||
DWORD guildID;
|
||||
DWORD markID;
|
||||
|
||||
char line[256];
|
||||
|
||||
while (fgets(line, sizeof(line)-1, fp))
|
||||
{
|
||||
sscanf(line, "%lu %lu", &guildID, &markID);
|
||||
line[0] = '\0';
|
||||
AddMarkIDByGuildID(guildID, markID);
|
||||
}
|
||||
|
||||
LoadMarkImages();
|
||||
|
||||
fclose(fp);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CGuildMarkManager::SaveMarkIndex()
|
||||
{
|
||||
char buf[64];
|
||||
snprintf(buf, sizeof(buf), "mark/%s_index", m_pathPrefix.c_str());
|
||||
FILE * fp = fopen(buf, "w");
|
||||
|
||||
if (!fp)
|
||||
{
|
||||
sys_err("MarkManager::SaveMarkData: cannot open index file.");
|
||||
return false;
|
||||
}
|
||||
|
||||
for (std::map<DWORD, DWORD>::iterator it = m_mapGID_MarkID.begin(); it != m_mapGID_MarkID.end(); ++it)
|
||||
fprintf(fp, "%d %d\n", it->first, it->second);
|
||||
|
||||
fclose(fp);
|
||||
sys_log(0, "MarkManager::SaveMarkData: index count %d", m_mapGID_MarkID.size());
|
||||
return true;
|
||||
}
|
||||
|
||||
void CGuildMarkManager::LoadMarkImages()
|
||||
{
|
||||
bool isMarkExists[MAX_IMAGE_COUNT];
|
||||
memset(isMarkExists, 0, sizeof(isMarkExists));
|
||||
|
||||
for (std::map<DWORD, DWORD>::iterator it = m_mapGID_MarkID.begin(); it != m_mapGID_MarkID.end(); ++it)
|
||||
{
|
||||
DWORD markID = it->second;
|
||||
|
||||
if (markID < MAX_IMAGE_COUNT * CGuildMarkImage::MARK_TOTAL_COUNT)
|
||||
isMarkExists[markID / CGuildMarkImage::MARK_TOTAL_COUNT] = true;
|
||||
}
|
||||
|
||||
for (DWORD i = 0; i < MAX_IMAGE_COUNT; ++i)
|
||||
if (isMarkExists[i])
|
||||
__GetImage(i);
|
||||
}
|
||||
|
||||
void CGuildMarkManager::SaveMarkImage(DWORD imgIdx)
|
||||
{
|
||||
std::string path;
|
||||
|
||||
if (GetMarkImageFilename(imgIdx, path))
|
||||
if (!__GetImage(imgIdx)->Save(path.c_str()))
|
||||
sys_err("%s Save failed\n", path.c_str());
|
||||
}
|
||||
|
||||
CGuildMarkImage * CGuildMarkManager::__GetImage(DWORD imgIdx)
|
||||
{
|
||||
std::map<DWORD, CGuildMarkImage *>::iterator it = m_mapIdx_Image.find(imgIdx);
|
||||
|
||||
if (it == m_mapIdx_Image.end())
|
||||
{
|
||||
std::string imagePath;
|
||||
|
||||
if (GetMarkImageFilename(imgIdx, imagePath))
|
||||
{
|
||||
CGuildMarkImage * pkImage = __NewImage();
|
||||
m_mapIdx_Image.insert(std::map<DWORD, CGuildMarkImage *>::value_type(imgIdx, pkImage));
|
||||
pkImage->Load(imagePath.c_str());
|
||||
return pkImage;
|
||||
}
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
else
|
||||
return it->second;
|
||||
}
|
||||
|
||||
bool CGuildMarkManager::AddMarkIDByGuildID(DWORD guildID, DWORD markID)
|
||||
{
|
||||
if (markID >= MAX_IMAGE_COUNT * CGuildMarkImage::MARK_TOTAL_COUNT)
|
||||
return false;
|
||||
|
||||
//sys_log(0, "MarkManager: guild_id=%d mark_id=%d", guildID, markID);
|
||||
m_mapGID_MarkID.insert(std::map<DWORD, DWORD>::value_type(guildID, markID));
|
||||
m_setFreeMarkID.erase(markID);
|
||||
return true;
|
||||
}
|
||||
|
||||
DWORD CGuildMarkManager::GetMarkID(DWORD guildID)
|
||||
{
|
||||
std::map<DWORD, DWORD>::iterator it = m_mapGID_MarkID.find(guildID);
|
||||
|
||||
if (it == m_mapGID_MarkID.end())
|
||||
return INVALID_MARK_ID;
|
||||
|
||||
return it->second;
|
||||
}
|
||||
|
||||
DWORD CGuildMarkManager::__AllocMarkID(DWORD guildID)
|
||||
{
|
||||
std::set<DWORD>::iterator it = m_setFreeMarkID.lower_bound(0);
|
||||
|
||||
if (it == m_setFreeMarkID.end())
|
||||
return INVALID_MARK_ID;
|
||||
|
||||
DWORD markID = *it;
|
||||
|
||||
DWORD imgIdx = markID / CGuildMarkImage::MARK_TOTAL_COUNT;
|
||||
CGuildMarkImage * pkImage = __GetImage(imgIdx); // 이미지가 없다면 만들기 위해
|
||||
|
||||
if (pkImage && AddMarkIDByGuildID(guildID, markID))
|
||||
return markID;
|
||||
|
||||
return INVALID_MARK_ID;
|
||||
}
|
||||
|
||||
DWORD CGuildMarkManager::GetMarkImageCount() const
|
||||
{
|
||||
return m_mapIdx_Image.size();
|
||||
}
|
||||
|
||||
DWORD CGuildMarkManager::GetMarkCount() const
|
||||
{
|
||||
return m_mapGID_MarkID.size();
|
||||
}
|
||||
|
||||
// SERVER
|
||||
void CGuildMarkManager::CopyMarkIdx(char * pcBuf) const
|
||||
{
|
||||
WORD * pwBuf = (WORD *) pcBuf;
|
||||
|
||||
for (std::map<DWORD, DWORD>::const_iterator it = m_mapGID_MarkID.begin(); it != m_mapGID_MarkID.end(); ++it)
|
||||
{
|
||||
*(pwBuf++) = it->first; // guild id
|
||||
*(pwBuf++) = it->second; // mark id
|
||||
}
|
||||
}
|
||||
|
||||
// SERVER
|
||||
DWORD CGuildMarkManager::SaveMark(DWORD guildID, BYTE * pbMarkImage)
|
||||
{
|
||||
DWORD idMark;
|
||||
|
||||
if ((idMark = GetMarkID(guildID)) == INVALID_MARK_ID)
|
||||
{
|
||||
if ((idMark = __AllocMarkID(guildID)) == INVALID_MARK_ID)
|
||||
{
|
||||
sys_err("CGuildMarkManager: cannot alloc mark id %u", guildID);
|
||||
return false;
|
||||
}
|
||||
else
|
||||
sys_log(0, "SaveMark: mark id alloc %u", idMark);
|
||||
}
|
||||
else
|
||||
sys_log(0, "SaveMark: mark id found %u", idMark);
|
||||
|
||||
DWORD imgIdx = (idMark / CGuildMarkImage::MARK_TOTAL_COUNT);
|
||||
CGuildMarkImage * pkImage = __GetImage(imgIdx);
|
||||
|
||||
if (pkImage)
|
||||
{
|
||||
printf("imgidx %u ", imgIdx);
|
||||
|
||||
std::string pathImage;
|
||||
GetMarkImageFilename(imgIdx, pathImage);
|
||||
pkImage->Save(pathImage.c_str());
|
||||
|
||||
SaveMarkIndex();
|
||||
}
|
||||
|
||||
return idMark;
|
||||
}
|
||||
|
||||
// SERVER
|
||||
void CGuildMarkManager::DeleteMark(DWORD guildID)
|
||||
{
|
||||
std::map<DWORD, DWORD>::iterator it = m_mapGID_MarkID.find(guildID);
|
||||
|
||||
if (it == m_mapGID_MarkID.end())
|
||||
return;
|
||||
|
||||
CGuildMarkImage * pkImage;
|
||||
|
||||
if ((pkImage = __GetImage(it->second / CGuildMarkImage::MARK_TOTAL_COUNT)) != NULL)
|
||||
pkImage->DeleteMark(it->second % CGuildMarkImage::MARK_TOTAL_COUNT);
|
||||
|
||||
m_mapGID_MarkID.erase(it);
|
||||
m_setFreeMarkID.insert(it->second);
|
||||
|
||||
SaveMarkIndex();
|
||||
}
|
||||
|
||||
// SERVER
|
||||
void CGuildMarkManager::GetDiffBlocks(DWORD imgIdx, const DWORD * crcList, std::map<BYTE, const SGuildMarkBlock *> & mapDiffBlocks)
|
||||
{
|
||||
mapDiffBlocks.clear();
|
||||
|
||||
// 클라이언트에서 서버에 없는 이미지를 요청할 수는 없다.
|
||||
if (m_mapIdx_Image.end() == m_mapIdx_Image.find(imgIdx))
|
||||
{
|
||||
sys_err("invalid idx %u", imgIdx);
|
||||
return;
|
||||
}
|
||||
|
||||
CGuildMarkImage * p = __GetImage(imgIdx);
|
||||
|
||||
if (p)
|
||||
p->GetDiffBlocks(crcList, mapDiffBlocks);
|
||||
}
|
||||
|
||||
// CLIENT
|
||||
bool CGuildMarkManager::SaveBlockFromCompressedData(DWORD imgIdx, DWORD posBlock, const BYTE * pbBlock, DWORD dwSize)
|
||||
{
|
||||
CGuildMarkImage * pkImage = __GetImage(imgIdx);
|
||||
|
||||
if (pkImage)
|
||||
pkImage->SaveBlockFromCompressedData(posBlock, pbBlock, dwSize);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
// CLIENT
|
||||
bool CGuildMarkManager::GetBlockCRCList(DWORD imgIdx, DWORD * crcList)
|
||||
{
|
||||
// 클라이언트에서 서버에 없는 이미지를 요청할 수는 없다.
|
||||
if (m_mapIdx_Image.end() == m_mapIdx_Image.find(imgIdx))
|
||||
{
|
||||
sys_err("invalid idx %u", imgIdx);
|
||||
return false;
|
||||
}
|
||||
|
||||
CGuildMarkImage * p = __GetImage(imgIdx);
|
||||
|
||||
if (p)
|
||||
p->GetBlockCRCList(crcList);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////
|
||||
// Symbol
|
||||
///////////////////////////////////////////////////////////////////////////////////////
|
||||
const CGuildMarkManager::TGuildSymbol * CGuildMarkManager::GetGuildSymbol(DWORD guildID)
|
||||
{
|
||||
std::map<DWORD, TGuildSymbol>::iterator it = m_mapSymbol.find(guildID);
|
||||
|
||||
if (it == m_mapSymbol.end())
|
||||
return NULL;
|
||||
|
||||
return &it->second;
|
||||
}
|
||||
|
||||
bool CGuildMarkManager::LoadSymbol(const char* filename)
|
||||
{
|
||||
FILE* fp = fopen(filename, "rb");
|
||||
|
||||
if (!fp)
|
||||
return true;
|
||||
else
|
||||
{
|
||||
DWORD symbolCount;
|
||||
fread(&symbolCount, 4, 1, fp);
|
||||
|
||||
for(DWORD i = 0; i < symbolCount; i++)
|
||||
{
|
||||
DWORD guildID;
|
||||
DWORD dwSize;
|
||||
fread(&guildID, 4, 1, fp);
|
||||
fread(&dwSize, 4, 1, fp);
|
||||
|
||||
TGuildSymbol gs;
|
||||
gs.raw.resize(dwSize);
|
||||
fread(&gs.raw[0], 1, dwSize, fp);
|
||||
gs.crc = GetCRC32(reinterpret_cast<const char*>(&gs.raw[0]), dwSize);
|
||||
m_mapSymbol.insert(std::make_pair(guildID, gs));
|
||||
}
|
||||
}
|
||||
|
||||
fclose(fp);
|
||||
return true;
|
||||
}
|
||||
|
||||
void CGuildMarkManager::SaveSymbol(const char* filename)
|
||||
{
|
||||
FILE* fp = fopen(filename, "wb");
|
||||
if (!fp)
|
||||
{
|
||||
sys_err("Cannot open Symbol file (name: %s)", filename);
|
||||
return;
|
||||
}
|
||||
|
||||
DWORD symbolCount = m_mapSymbol.size();
|
||||
fwrite(&symbolCount, 4, 1, fp);
|
||||
|
||||
for (std::map<DWORD, TGuildSymbol>::iterator it = m_mapSymbol.begin(); it != m_mapSymbol.end(); ++it)
|
||||
{
|
||||
DWORD guildID = it->first;
|
||||
DWORD dwSize = it->second.raw.size();
|
||||
fwrite(&guildID, 4, 1, fp);
|
||||
fwrite(&dwSize, 4, 1, fp);
|
||||
fwrite(&it->second.raw[0], 1, dwSize, fp);
|
||||
}
|
||||
|
||||
fclose(fp);
|
||||
}
|
||||
|
||||
void CGuildMarkManager::UploadSymbol(DWORD guildID, int iSize, const BYTE* pbyData)
|
||||
{
|
||||
sys_log(0, "GuildSymbolUpload guildID %lu Size %d", guildID, iSize);
|
||||
|
||||
if (m_mapSymbol.find(guildID) == m_mapSymbol.end())
|
||||
m_mapSymbol.insert(std::make_pair(guildID, TGuildSymbol()));
|
||||
|
||||
TGuildSymbol& rSymbol = m_mapSymbol[guildID];
|
||||
rSymbol.raw.clear();
|
||||
|
||||
if (iSize > 0)
|
||||
{
|
||||
rSymbol.raw.reserve(iSize);
|
||||
std::copy(pbyData, (pbyData + iSize), std::back_inserter(rSymbol.raw));
|
||||
rSymbol.crc = GetCRC32(reinterpret_cast<const char*>(pbyData), iSize);
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef __UNITTEST__
|
||||
#include "lzo_manager.h"
|
||||
|
||||
Guild::CGuildMarkManager * mgr;
|
||||
|
||||
void heartbeat(LPHEART ht, int pulse)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
void SaveMark(DWORD guildID, const char * filename)
|
||||
{
|
||||
ILuint m_uImg;
|
||||
|
||||
ilGenImages(1, &m_uImg);
|
||||
ilBindImage(m_uImg);
|
||||
ilEnable(IL_ORIGIN_SET);
|
||||
ilOriginFunc(IL_ORIGIN_UPPER_LEFT);
|
||||
|
||||
if (ilLoad(IL_TYPE_UNKNOWN, (const ILstring) filename))
|
||||
{
|
||||
ILuint width = ilGetInteger(IL_IMAGE_WIDTH);
|
||||
ILuint height = ilGetInteger(IL_IMAGE_HEIGHT);
|
||||
|
||||
ilConvertImage(IL_BGRA, IL_UNSIGNED_BYTE);
|
||||
|
||||
BYTE * data = (BYTE *) malloc(sizeof(DWORD) * width * height);
|
||||
ilCopyPixels(0, 0, 0, width, height, 1, IL_BGRA, IL_UNSIGNED_BYTE, data);
|
||||
ilDeleteImages(1, &m_uImg);
|
||||
|
||||
printf("%s w%u h%u ", filename, width, height);
|
||||
mgr->SaveMark(guildID, data);
|
||||
}
|
||||
else
|
||||
printf("%s cannot open file.\n", filename);
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
LZOManager lzo;
|
||||
char f[64];
|
||||
|
||||
srandom(time(0));
|
||||
|
||||
ilInit(); // DevIL Initialize
|
||||
thecore_init(25, heartbeat);
|
||||
|
||||
std::vector<int> vec_guild_id;
|
||||
|
||||
for (int i = 1; i < 1281; ++i)
|
||||
vec_guild_id.push_back(i);
|
||||
|
||||
mgr = new CGuildMarkManager;
|
||||
mgr->LoadMarkData(vec_guild_id);
|
||||
/*
|
||||
for (int i = 1401; i < 1500; ++i)
|
||||
{
|
||||
snprintf(f, sizeof(f), "%lu.jpg", (random() % 5) + 1);
|
||||
//SaveMark(i, f);
|
||||
mgr->DeleteMark(i);
|
||||
}
|
||||
*/
|
||||
//snprintf(f, sizeof(f), "%lu.jpg", (random() % 5) + 1);
|
||||
//SaveMark(1, f);
|
||||
DWORD idx_client[CGuildMarkImage::BLOCK_TOTAL_COUNT];
|
||||
DWORD idx_server[CGuildMarkImage::BLOCK_TOTAL_COUNT];
|
||||
|
||||
mgr->GetBlockCRCList(0, idx_client);
|
||||
mgr->GetBlockCRCList(1, idx_server);
|
||||
|
||||
std::map<BYTE, const SGuildMarkBlock *> mapDiff;
|
||||
mgr->GetDiffBlocks(1, idx_client, mapDiff);
|
||||
|
||||
printf("#1 Diff %u\n", mapDiff.size());
|
||||
|
||||
for (itertype(mapDiff) it = mapDiff.begin(); it != mapDiff.end(); ++it)
|
||||
{
|
||||
printf("Put Block pos %u crc %u\n", it->first, it->second->m_crc);
|
||||
mgr->SaveBlockFromCompressedData(0, it->first, it->second->m_abCompBuf, it->second->m_sizeCompBuf);
|
||||
}
|
||||
|
||||
mgr->GetBlockCRCList(0, idx_client);
|
||||
mgr->GetDiffBlocks(1, idx_client, mapDiff);
|
||||
printf("#2 Diff %u\n", mapDiff.size());
|
||||
delete mgr;
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,799 @@
|
||||
#include "StdAfx.h"
|
||||
#include "PythonGuild.h"
|
||||
#include "AbstractPlayer.h"
|
||||
#include "MarkManager.h"
|
||||
|
||||
std::map<DWORD, DWORD> g_GuildSkillSlotToIndexMap;
|
||||
|
||||
void CPythonGuild::EnableGuild()
|
||||
{
|
||||
m_bGuildEnable = TRUE;
|
||||
}
|
||||
|
||||
void CPythonGuild::SetGuildMoney(DWORD dwMoney)
|
||||
{
|
||||
m_GuildInfo.dwGuildMoney = dwMoney;
|
||||
}
|
||||
|
||||
void CPythonGuild::SetGuildEXP(BYTE byLevel, DWORD dwEXP)
|
||||
{
|
||||
m_GuildInfo.dwGuildLevel = byLevel;
|
||||
m_GuildInfo.dwCurrentExperience = dwEXP;
|
||||
}
|
||||
|
||||
void CPythonGuild::SetGradeData(BYTE byGradeNumber, TGuildGradeData & rGuildGradeData)
|
||||
{
|
||||
m_GradeDataMap[byGradeNumber] = rGuildGradeData;
|
||||
}
|
||||
|
||||
void CPythonGuild::SetGradeName(BYTE byGradeNumber, const char * c_szName)
|
||||
{
|
||||
if (!__IsGradeData(byGradeNumber))
|
||||
return;
|
||||
|
||||
TGuildGradeData & rGradeData = m_GradeDataMap.find(byGradeNumber)->second;
|
||||
rGradeData.strName = c_szName;
|
||||
}
|
||||
|
||||
void CPythonGuild::SetGradeAuthority(BYTE byGradeNumber, BYTE byAuthority)
|
||||
{
|
||||
if (!__IsGradeData(byGradeNumber))
|
||||
return;
|
||||
|
||||
TGuildGradeData & rGradeData = m_GradeDataMap.find(byGradeNumber)->second;
|
||||
rGradeData.byAuthorityFlag = byAuthority;
|
||||
}
|
||||
|
||||
void CPythonGuild::ClearComment()
|
||||
{
|
||||
m_GuildBoardCommentVector.clear();
|
||||
}
|
||||
|
||||
void CPythonGuild::RegisterComment(DWORD dwCommentID, const char * c_szName, const char * c_szComment)
|
||||
{
|
||||
if (0 == strlen(c_szComment))
|
||||
return;
|
||||
|
||||
TGuildBoardCommentData CommentData;
|
||||
CommentData.dwCommentID = dwCommentID;
|
||||
CommentData.strName = c_szName;
|
||||
CommentData.strComment = c_szComment;
|
||||
|
||||
m_GuildBoardCommentVector.push_back(CommentData);
|
||||
}
|
||||
|
||||
void CPythonGuild::RegisterMember(TGuildMemberData & rGuildMemberData)
|
||||
{
|
||||
TGuildMemberData * pGuildMemberData;
|
||||
if (GetMemberDataPtrByPID(rGuildMemberData.dwPID, &pGuildMemberData))
|
||||
{
|
||||
pGuildMemberData->byGeneralFlag = rGuildMemberData.byGeneralFlag;
|
||||
pGuildMemberData->byGrade = rGuildMemberData.byGrade;
|
||||
pGuildMemberData->byLevel = rGuildMemberData.byLevel;
|
||||
pGuildMemberData->dwOffer = rGuildMemberData.dwOffer;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_GuildMemberDataVector.push_back(rGuildMemberData);
|
||||
}
|
||||
|
||||
__CalculateLevelAverage();
|
||||
__SortMember();
|
||||
}
|
||||
|
||||
struct CPythonGuild_FFindGuildMemberByPID
|
||||
{
|
||||
CPythonGuild_FFindGuildMemberByPID(DWORD dwSearchingPID_) : dwSearchingPID(dwSearchingPID_) {}
|
||||
int operator () (CPythonGuild::TGuildMemberData & rGuildMemberData)
|
||||
{
|
||||
return rGuildMemberData.dwPID == dwSearchingPID;
|
||||
}
|
||||
|
||||
DWORD dwSearchingPID;
|
||||
};
|
||||
|
||||
struct CPythonGuild_FFindGuildMemberByName
|
||||
{
|
||||
CPythonGuild_FFindGuildMemberByName(const char * c_szSearchingName) : strSearchingName(c_szSearchingName) {}
|
||||
int operator () (CPythonGuild::TGuildMemberData & rGuildMemberData)
|
||||
{
|
||||
return 0 == strSearchingName.compare(rGuildMemberData.strName.c_str());
|
||||
}
|
||||
|
||||
std::string strSearchingName;
|
||||
};
|
||||
|
||||
void CPythonGuild::ChangeGuildMemberGrade(DWORD dwPID, BYTE byGrade)
|
||||
{
|
||||
TGuildMemberData * pGuildMemberData;
|
||||
if (!GetMemberDataPtrByPID(dwPID, &pGuildMemberData))
|
||||
return;
|
||||
|
||||
pGuildMemberData->byGrade = byGrade;
|
||||
}
|
||||
|
||||
void CPythonGuild::ChangeGuildMemberGeneralFlag(DWORD dwPID, BYTE byFlag)
|
||||
{
|
||||
TGuildMemberData * pGuildMemberData;
|
||||
if (!GetMemberDataPtrByPID(dwPID, &pGuildMemberData))
|
||||
return;
|
||||
|
||||
pGuildMemberData->byGeneralFlag = byFlag;
|
||||
}
|
||||
|
||||
void CPythonGuild::RemoveMember(DWORD dwPID)
|
||||
{
|
||||
TGuildMemberDataVector::iterator itor;
|
||||
itor = std::find_if( m_GuildMemberDataVector.begin(),
|
||||
m_GuildMemberDataVector.end(),
|
||||
CPythonGuild_FFindGuildMemberByPID(dwPID));
|
||||
|
||||
if (m_GuildMemberDataVector.end() == itor)
|
||||
return;
|
||||
|
||||
m_GuildMemberDataVector.erase(itor);
|
||||
}
|
||||
|
||||
void CPythonGuild::RegisterGuildName(DWORD dwID, const char * c_szName)
|
||||
{
|
||||
m_GuildNameMap.insert(std::make_pair(dwID, std::string(c_szName)));
|
||||
}
|
||||
|
||||
BOOL CPythonGuild::IsMainPlayer(DWORD dwPID)
|
||||
{
|
||||
TGuildMemberData * pGuildMemberData;
|
||||
if (!GetMemberDataPtrByPID(dwPID, &pGuildMemberData))
|
||||
return FALSE;
|
||||
|
||||
IAbstractPlayer& rPlayer=IAbstractPlayer::GetSingleton();
|
||||
return 0 == pGuildMemberData->strName.compare(rPlayer.GetName());
|
||||
}
|
||||
|
||||
BOOL CPythonGuild::IsGuildEnable()
|
||||
{
|
||||
return m_bGuildEnable;
|
||||
}
|
||||
|
||||
CPythonGuild::TGuildInfo & CPythonGuild::GetGuildInfoRef()
|
||||
{
|
||||
return m_GuildInfo;
|
||||
}
|
||||
|
||||
BOOL CPythonGuild::GetGradeDataPtr(DWORD dwGradeNumber, TGuildGradeData ** ppData)
|
||||
{
|
||||
TGradeDataMap::iterator itor = m_GradeDataMap.find(dwGradeNumber);
|
||||
if (m_GradeDataMap.end() == itor)
|
||||
return FALSE;
|
||||
|
||||
*ppData = &(itor->second);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
const CPythonGuild::TGuildBoardCommentDataVector & CPythonGuild::GetGuildBoardCommentVector()
|
||||
{
|
||||
return m_GuildBoardCommentVector;
|
||||
}
|
||||
|
||||
DWORD CPythonGuild::GetMemberCount()
|
||||
{
|
||||
return m_GuildMemberDataVector.size();
|
||||
}
|
||||
|
||||
BOOL CPythonGuild::GetMemberDataPtr(DWORD dwIndex, TGuildMemberData ** ppData)
|
||||
{
|
||||
if (dwIndex >= m_GuildMemberDataVector.size())
|
||||
return FALSE;
|
||||
|
||||
*ppData = &m_GuildMemberDataVector[dwIndex];
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL CPythonGuild::GetMemberDataPtrByPID(DWORD dwPID, TGuildMemberData ** ppData)
|
||||
{
|
||||
TGuildMemberDataVector::iterator itor;
|
||||
itor = std::find_if( m_GuildMemberDataVector.begin(),
|
||||
m_GuildMemberDataVector.end(),
|
||||
CPythonGuild_FFindGuildMemberByPID(dwPID));
|
||||
|
||||
if (m_GuildMemberDataVector.end() == itor)
|
||||
return FALSE;
|
||||
|
||||
*ppData = &(*itor);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL CPythonGuild::GetMemberDataPtrByName(const char * c_szName, TGuildMemberData ** ppData)
|
||||
{
|
||||
TGuildMemberDataVector::iterator itor;
|
||||
itor = std::find_if( m_GuildMemberDataVector.begin(),
|
||||
m_GuildMemberDataVector.end(),
|
||||
CPythonGuild_FFindGuildMemberByName(c_szName));
|
||||
|
||||
if (m_GuildMemberDataVector.end() == itor)
|
||||
return FALSE;
|
||||
|
||||
*ppData = &(*itor);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
DWORD CPythonGuild::GetGuildMemberLevelSummary()
|
||||
{
|
||||
return m_dwMemberLevelSummary;
|
||||
}
|
||||
|
||||
DWORD CPythonGuild::GetGuildMemberLevelAverage()
|
||||
{
|
||||
return m_dwMemberLevelAverage;
|
||||
}
|
||||
|
||||
DWORD CPythonGuild::GetGuildExperienceSummary()
|
||||
{
|
||||
return m_dwMemberExperienceSummary;
|
||||
}
|
||||
|
||||
CPythonGuild::TGuildSkillData & CPythonGuild::GetGuildSkillDataRef()
|
||||
{
|
||||
return m_GuildSkillData;
|
||||
}
|
||||
|
||||
bool CPythonGuild::GetGuildName(DWORD dwID, std::string * pstrGuildName)
|
||||
{
|
||||
if (m_GuildNameMap.end() == m_GuildNameMap.find(dwID))
|
||||
return false;
|
||||
|
||||
*pstrGuildName = m_GuildNameMap[dwID];
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
DWORD CPythonGuild::GetGuildID()
|
||||
{
|
||||
return m_GuildInfo.dwGuildID;
|
||||
}
|
||||
|
||||
BOOL CPythonGuild::HasGuildLand()
|
||||
{
|
||||
return m_GuildInfo.bHasLand;
|
||||
}
|
||||
|
||||
void CPythonGuild::StartGuildWar(DWORD dwEnemyGuildID)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < ENEMY_GUILD_SLOT_MAX_COUNT; ++i)
|
||||
if (dwEnemyGuildID == m_adwEnemyGuildID[i])
|
||||
return;
|
||||
|
||||
for (i = 0; i < ENEMY_GUILD_SLOT_MAX_COUNT; ++i)
|
||||
if (0 == m_adwEnemyGuildID[i])
|
||||
{
|
||||
m_adwEnemyGuildID[i] = dwEnemyGuildID;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void CPythonGuild::EndGuildWar(DWORD dwEnemyGuildID)
|
||||
{
|
||||
for (int i = 0; i < ENEMY_GUILD_SLOT_MAX_COUNT; ++i)
|
||||
if (dwEnemyGuildID == m_adwEnemyGuildID[i])
|
||||
m_adwEnemyGuildID[i] = 0;
|
||||
}
|
||||
|
||||
DWORD CPythonGuild::GetEnemyGuildID(DWORD dwIndex)
|
||||
{
|
||||
if (dwIndex >= ENEMY_GUILD_SLOT_MAX_COUNT)
|
||||
return 0;
|
||||
|
||||
return m_adwEnemyGuildID[dwIndex];
|
||||
}
|
||||
|
||||
BOOL CPythonGuild::IsDoingGuildWar()
|
||||
{
|
||||
for (int i = 0; i < ENEMY_GUILD_SLOT_MAX_COUNT; ++i)
|
||||
if (0 != m_adwEnemyGuildID[i])
|
||||
{
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
void CPythonGuild::__CalculateLevelAverage()
|
||||
{
|
||||
m_dwMemberLevelSummary = 0;
|
||||
m_dwMemberLevelAverage = 0;
|
||||
m_dwMemberExperienceSummary = 0;
|
||||
|
||||
if (m_GuildMemberDataVector.empty())
|
||||
return;
|
||||
|
||||
TGuildMemberDataVector::iterator itor;
|
||||
|
||||
// Sum Level & Experience
|
||||
itor = m_GuildMemberDataVector.begin();
|
||||
for (; itor != m_GuildMemberDataVector.end(); ++itor)
|
||||
{
|
||||
TGuildMemberData & rGuildMemberData = *itor;
|
||||
m_dwMemberLevelSummary += rGuildMemberData.byLevel;
|
||||
m_dwMemberExperienceSummary += rGuildMemberData.dwOffer;
|
||||
}
|
||||
|
||||
assert(!m_GuildMemberDataVector.empty());
|
||||
m_dwMemberLevelAverage = m_dwMemberLevelSummary / m_GuildMemberDataVector.size();
|
||||
}
|
||||
|
||||
struct CPythonGuild_SLessMemberGrade
|
||||
{
|
||||
bool operator() (CPythonGuild::TGuildMemberData & rleft, CPythonGuild::TGuildMemberData & rright)
|
||||
{
|
||||
if (rleft.byGrade < rright.byGrade)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
void CPythonGuild::__SortMember()
|
||||
{
|
||||
std::sort(m_GuildMemberDataVector.begin(), m_GuildMemberDataVector.end(), CPythonGuild_SLessMemberGrade());
|
||||
}
|
||||
|
||||
BOOL CPythonGuild::__IsGradeData(BYTE byGradeNumber)
|
||||
{
|
||||
return m_GradeDataMap.end() != m_GradeDataMap.find(byGradeNumber);
|
||||
}
|
||||
|
||||
void CPythonGuild::__Initialize()
|
||||
{
|
||||
ZeroMemory(&m_GuildInfo, sizeof(m_GuildInfo));
|
||||
ZeroMemory(&m_GuildSkillData, sizeof(m_GuildSkillData));
|
||||
ZeroMemory(&m_adwEnemyGuildID, ENEMY_GUILD_SLOT_MAX_COUNT*sizeof(DWORD));
|
||||
m_GradeDataMap.clear();
|
||||
m_GuildMemberDataVector.clear();
|
||||
m_dwMemberLevelSummary = 0;
|
||||
m_dwMemberLevelAverage = 0;
|
||||
m_bGuildEnable = FALSE;
|
||||
m_GuildNameMap.clear();
|
||||
}
|
||||
|
||||
void CPythonGuild::Destroy()
|
||||
{
|
||||
__Initialize();
|
||||
}
|
||||
|
||||
CPythonGuild::CPythonGuild()
|
||||
{
|
||||
__Initialize();
|
||||
}
|
||||
CPythonGuild::~CPythonGuild()
|
||||
{
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
PyObject * guildIsGuildEnable(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
return Py_BuildValue("i", CPythonGuild::Instance().IsGuildEnable());
|
||||
}
|
||||
|
||||
PyObject * guildGetGuildID(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
return Py_BuildValue("i", CPythonGuild::Instance().GetGuildID());
|
||||
}
|
||||
|
||||
PyObject * guildHasGuildLand(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
return Py_BuildValue("i", CPythonGuild::Instance().HasGuildLand());
|
||||
}
|
||||
|
||||
PyObject * guildGetGuildName(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iGuildID;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iGuildID))
|
||||
{
|
||||
CPythonGuild::TGuildInfo & rGuildInfo = CPythonGuild::Instance().GetGuildInfoRef();
|
||||
return Py_BuildValue("s", rGuildInfo.szGuildName);
|
||||
}
|
||||
|
||||
std::string strGuildName;
|
||||
if (!CPythonGuild::Instance().GetGuildName(iGuildID, &strGuildName))
|
||||
return Py_BuildValue("s", "Noname");
|
||||
|
||||
return Py_BuildValue("s", strGuildName.c_str());
|
||||
}
|
||||
|
||||
PyObject * guildGetGuildMasterName(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
CPythonGuild::TGuildInfo & rGuildInfo = CPythonGuild::Instance().GetGuildInfoRef();
|
||||
|
||||
CPythonGuild::TGuildMemberData * pData;
|
||||
if (!CPythonGuild::Instance().GetMemberDataPtrByPID(rGuildInfo.dwMasterPID, &pData))
|
||||
return Py_BuildValue("s", "Noname");
|
||||
|
||||
return Py_BuildValue("s", pData->strName.c_str());
|
||||
}
|
||||
|
||||
PyObject * guildGetEnemyGuildName(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
|
||||
return Py_BuildValue("s", "");
|
||||
|
||||
DWORD dwEnemyGuildID = CPythonGuild::Instance().GetEnemyGuildID(iIndex);
|
||||
|
||||
std::string strEnemyGuildName;
|
||||
if (!CPythonGuild::Instance().GetGuildName(dwEnemyGuildID, &strEnemyGuildName))
|
||||
return Py_BuildValue("s", "");
|
||||
|
||||
return Py_BuildValue("s", strEnemyGuildName.c_str());
|
||||
}
|
||||
|
||||
PyObject * guildGetGuildMoney(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
CPythonGuild::TGuildInfo & rGuildInfo = CPythonGuild::Instance().GetGuildInfoRef();
|
||||
return Py_BuildValue("i", rGuildInfo.dwGuildMoney);
|
||||
}
|
||||
|
||||
PyObject * guildGetGuildBoardCommentCount(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
const CPythonGuild::TGuildBoardCommentDataVector & rCommentVector = CPythonGuild::Instance().GetGuildBoardCommentVector();
|
||||
return Py_BuildValue("i", rCommentVector.size());
|
||||
}
|
||||
|
||||
PyObject * guildGetGuildBoardCommentData(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
|
||||
return Py_BuildException();
|
||||
|
||||
const CPythonGuild::TGuildBoardCommentDataVector & c_rCommentVector = CPythonGuild::Instance().GetGuildBoardCommentVector();
|
||||
if (DWORD(iIndex) >= c_rCommentVector.size())
|
||||
return Py_BuildValue("iss", 0, "Noname", "Noname");
|
||||
|
||||
const CPythonGuild::TGuildBoardCommentData & c_rData = c_rCommentVector[iIndex];
|
||||
|
||||
return Py_BuildValue("iss", c_rData.dwCommentID, c_rData.strName.c_str(), c_rData.strComment.c_str());
|
||||
}
|
||||
|
||||
PyObject * guildGetGuildLevel(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
CPythonGuild::TGuildInfo & rGuildInfo = CPythonGuild::Instance().GetGuildInfoRef();
|
||||
return Py_BuildValue("i", rGuildInfo.dwGuildLevel);
|
||||
}
|
||||
|
||||
|
||||
|
||||
PyObject * guildGetGuildExperience(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
CPythonGuild::TGuildInfo & rGuildInfo = CPythonGuild::Instance().GetGuildInfoRef();
|
||||
|
||||
int GULID_MAX_LEVEL = 20;
|
||||
if (rGuildInfo.dwGuildLevel >= GULID_MAX_LEVEL)
|
||||
return Py_BuildValue("ii", 0, 0);
|
||||
|
||||
unsigned lastExp = LocaleService_GetLastExp(rGuildInfo.dwGuildLevel);
|
||||
|
||||
return Py_BuildValue("ii", rGuildInfo.dwCurrentExperience, lastExp - rGuildInfo.dwCurrentExperience);
|
||||
}
|
||||
|
||||
PyObject * guildGetGuildMemberCount(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
CPythonGuild::TGuildInfo & rGuildInfo = CPythonGuild::Instance().GetGuildInfoRef();
|
||||
return Py_BuildValue("ii", rGuildInfo.dwCurrentMemberCount, rGuildInfo.dwMaxMemberCount);
|
||||
}
|
||||
|
||||
PyObject * guildGetGuildMemberLevelSummary(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
return Py_BuildValue("i", CPythonGuild::Instance().GetGuildMemberLevelSummary());
|
||||
}
|
||||
|
||||
PyObject * guildGetGuildMemberLevelAverage(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
return Py_BuildValue("i", CPythonGuild::Instance().GetGuildMemberLevelAverage());
|
||||
}
|
||||
|
||||
PyObject * guildGetGuildExperienceSummary(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
return Py_BuildValue("i", CPythonGuild::Instance().GetGuildExperienceSummary());
|
||||
}
|
||||
|
||||
PyObject * guildGetGuildSkillPoint(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
const CPythonGuild::TGuildSkillData & c_rSkillData = CPythonGuild::Instance().GetGuildSkillDataRef();
|
||||
return Py_BuildValue("i", c_rSkillData.bySkillPoint);
|
||||
}
|
||||
|
||||
PyObject * guildGetDragonPowerPoint(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
const CPythonGuild::TGuildSkillData & c_rSkillData = CPythonGuild::Instance().GetGuildSkillDataRef();
|
||||
return Py_BuildValue("ii", c_rSkillData.wGuildPoint, c_rSkillData.wMaxGuildPoint);
|
||||
}
|
||||
|
||||
PyObject * guildGetGuildSkillLevel(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
assert(FALSE && !"guildGetGuildSkillLevel - \273\347\277\353\307\317\301\366 \276\312\264\302 \307\324\274\366\300\324\264\317\264\331.");
|
||||
|
||||
int iSkillIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
|
||||
return Py_BuildException();
|
||||
|
||||
const CPythonGuild::TGuildSkillData & c_rSkillData = CPythonGuild::Instance().GetGuildSkillDataRef();
|
||||
return Py_BuildValue("i", c_rSkillData.bySkillLevel[iSkillIndex]);
|
||||
}
|
||||
|
||||
PyObject * guildGetSkillLevel(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iSlotIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
|
||||
return Py_BuildException();
|
||||
|
||||
std::map<DWORD, DWORD>::iterator itor = g_GuildSkillSlotToIndexMap.find(iSlotIndex);
|
||||
|
||||
if (g_GuildSkillSlotToIndexMap.end() == itor)
|
||||
return Py_BuildValue("i", 0);
|
||||
|
||||
DWORD dwSkillIndex = itor->second;
|
||||
assert(dwSkillIndex < CPythonGuild::GUILD_SKILL_MAX_NUM);
|
||||
|
||||
const CPythonGuild::TGuildSkillData & c_rSkillData = CPythonGuild::Instance().GetGuildSkillDataRef();
|
||||
return Py_BuildValue("i", c_rSkillData.bySkillLevel[dwSkillIndex]);
|
||||
}
|
||||
|
||||
PyObject * guildGetSkillMaxLevelNew(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iSlotIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
|
||||
return Py_BuildException();
|
||||
|
||||
std::map<DWORD, DWORD>::iterator itor = g_GuildSkillSlotToIndexMap.find(iSlotIndex);
|
||||
|
||||
if (g_GuildSkillSlotToIndexMap.end() == itor)
|
||||
return Py_BuildValue("i", 0);
|
||||
|
||||
DWORD dwSkillIndex = itor->second;
|
||||
assert(dwSkillIndex < CPythonGuild::GUILD_SKILL_MAX_NUM);
|
||||
|
||||
const CPythonGuild::TGuildSkillData & c_rSkillData = CPythonGuild::Instance().GetGuildSkillDataRef();
|
||||
return Py_BuildValue("i", c_rSkillData.bySkillLevel[dwSkillIndex]);
|
||||
}
|
||||
|
||||
PyObject * guildSetSkillIndex(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iSlotIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
|
||||
return Py_BuildException();
|
||||
int iSkillIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &iSkillIndex))
|
||||
return Py_BuildException();
|
||||
|
||||
g_GuildSkillSlotToIndexMap.insert(std::make_pair(iSlotIndex, iSkillIndex));
|
||||
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * guildGetSkillIndex(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iSlotIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
|
||||
return Py_BuildException();
|
||||
|
||||
std::map<DWORD, DWORD>::iterator itor = g_GuildSkillSlotToIndexMap.find(iSlotIndex);
|
||||
|
||||
if (g_GuildSkillSlotToIndexMap.end() == itor)
|
||||
return Py_BuildValue("i", 0);
|
||||
|
||||
DWORD dwSkillIndex = itor->second;
|
||||
return Py_BuildValue("i", dwSkillIndex);
|
||||
}
|
||||
|
||||
PyObject * guildGetGradeData(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iGradeNumber;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iGradeNumber))
|
||||
return Py_BuildException();
|
||||
|
||||
CPythonGuild::TGuildGradeData * pData;
|
||||
if (!CPythonGuild::Instance().GetGradeDataPtr(iGradeNumber, &pData))
|
||||
return Py_BuildValue("si", "?", 0);
|
||||
|
||||
return Py_BuildValue("si", pData->strName.c_str(), pData->byAuthorityFlag);
|
||||
}
|
||||
|
||||
PyObject * guildGetGradeName(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iGradeNumber;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iGradeNumber))
|
||||
return Py_BuildException();
|
||||
|
||||
CPythonGuild::TGuildGradeData * pData;
|
||||
if (!CPythonGuild::Instance().GetGradeDataPtr(iGradeNumber, &pData))
|
||||
return Py_BuildValue("s", "?");
|
||||
|
||||
return Py_BuildValue("s", pData->strName.c_str());
|
||||
}
|
||||
|
||||
PyObject * guildGetMemberCount(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
return Py_BuildValue("i", CPythonGuild::Instance().GetMemberCount());
|
||||
}
|
||||
|
||||
PyObject * guildGetMemberData(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
|
||||
return Py_BuildException();
|
||||
|
||||
CPythonGuild::TGuildMemberData * pData;
|
||||
if (!CPythonGuild::Instance().GetMemberDataPtr(iIndex, &pData))
|
||||
return Py_BuildValue("isiiiii", -1, "", 0, 0, 0, 0, 0);
|
||||
|
||||
return Py_BuildValue("isiiiii", pData->dwPID, pData->strName.c_str(), pData->byGrade, pData->byJob, pData->byLevel, pData->dwOffer, pData->byGeneralFlag);
|
||||
}
|
||||
|
||||
PyObject * guildMemberIndexToPID(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
|
||||
return Py_BuildException();
|
||||
|
||||
CPythonGuild::TGuildMemberData * pData;
|
||||
if (!CPythonGuild::Instance().GetMemberDataPtr(iIndex, &pData))
|
||||
return Py_BuildValue("i", -1);
|
||||
|
||||
return Py_BuildValue("i", pData->dwPID);
|
||||
}
|
||||
|
||||
PyObject * guildIsMember(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
|
||||
return Py_BuildException();
|
||||
|
||||
CPythonGuild::TGuildMemberData * pData;
|
||||
if (CPythonGuild::Instance().GetMemberDataPtr(iIndex, &pData))
|
||||
return Py_BuildValue("i", TRUE);
|
||||
|
||||
return Py_BuildValue("i", FALSE);
|
||||
}
|
||||
|
||||
PyObject * guildIsMemberByName(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
char * szName;
|
||||
if (!PyTuple_GetString(poArgs, 0, &szName))
|
||||
return Py_BuildException();
|
||||
|
||||
CPythonGuild::TGuildMemberData * pData;
|
||||
if (CPythonGuild::Instance().GetMemberDataPtrByName(szName, &pData))
|
||||
return Py_BuildValue("i", TRUE);
|
||||
|
||||
return Py_BuildValue("i", FALSE);
|
||||
}
|
||||
|
||||
PyObject * guildMainPlayerHasAuthority(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iAuthority;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iAuthority))
|
||||
return Py_BuildException();
|
||||
|
||||
IAbstractPlayer& rPlayer=IAbstractPlayer::GetSingleton();
|
||||
const char * c_szMainPlayerName = rPlayer.GetName();
|
||||
|
||||
CPythonGuild::TGuildMemberData * pMemberData;
|
||||
if (!CPythonGuild::Instance().GetMemberDataPtrByName(c_szMainPlayerName, &pMemberData))
|
||||
return Py_BuildValue("i", FALSE);
|
||||
|
||||
CPythonGuild::TGuildGradeData * pGradeData;
|
||||
if (!CPythonGuild::Instance().GetGradeDataPtr(pMemberData->byGrade, &pGradeData))
|
||||
return Py_BuildValue("i", FALSE);
|
||||
|
||||
return Py_BuildValue("i", iAuthority == (pGradeData->byAuthorityFlag & iAuthority));
|
||||
}
|
||||
|
||||
PyObject * guildDestroy(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
CPythonGuild::Instance().Destroy();
|
||||
g_GuildSkillSlotToIndexMap.clear();
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
|
||||
PyObject * guildGuildIDToMarkID(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int guild_id;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &guild_id))
|
||||
return Py_BuildException();
|
||||
|
||||
return Py_BuildValue("i", CGuildMarkManager::Instance().GetMarkID(guild_id));
|
||||
}
|
||||
|
||||
PyObject * guildGetMarkImageFilenameByMarkID(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int markID;
|
||||
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &markID))
|
||||
return Py_BuildException();
|
||||
|
||||
std::string imagePath;
|
||||
CGuildMarkManager::Instance().GetMarkImageFilename(markID / CGuildMarkImage::MARK_TOTAL_COUNT, imagePath);
|
||||
return Py_BuildValue("s", imagePath.c_str());
|
||||
}
|
||||
|
||||
PyObject * guildGetMarkIndexByMarkID(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int markID;
|
||||
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &markID))
|
||||
return Py_BuildException();
|
||||
|
||||
return Py_BuildValue("i", markID % CGuildMarkImage::MARK_TOTAL_COUNT);
|
||||
}
|
||||
|
||||
void initguild()
|
||||
{
|
||||
static PyMethodDef s_methods[] =
|
||||
{
|
||||
// Enable
|
||||
{ "IsGuildEnable", guildIsGuildEnable, METH_VARARGS },
|
||||
{ "GuildIDToMarkID", guildGuildIDToMarkID, METH_VARARGS },
|
||||
{ "GetMarkImageFilenameByMarkID", guildGetMarkImageFilenameByMarkID, METH_VARARGS },
|
||||
{ "GetMarkIndexByMarkID", guildGetMarkIndexByMarkID, METH_VARARGS },
|
||||
|
||||
// GuildInfo
|
||||
{ "GetGuildID", guildGetGuildID, METH_VARARGS },
|
||||
{ "HasGuildLand", guildHasGuildLand, METH_VARARGS },
|
||||
{ "GetGuildName", guildGetGuildName, METH_VARARGS },
|
||||
{ "GetGuildMasterName", guildGetGuildMasterName, METH_VARARGS },
|
||||
{ "GetEnemyGuildName", guildGetEnemyGuildName, METH_VARARGS },
|
||||
{ "GetGuildMoney", guildGetGuildMoney, METH_VARARGS },
|
||||
|
||||
// BoardPage
|
||||
{ "GetGuildBoardCommentCount", guildGetGuildBoardCommentCount, METH_VARARGS },
|
||||
{ "GetGuildBoardCommentData", guildGetGuildBoardCommentData, METH_VARARGS },
|
||||
|
||||
// MemberPage
|
||||
{ "GetGuildLevel", guildGetGuildLevel, METH_VARARGS },
|
||||
{ "GetGuildExperience", guildGetGuildExperience, METH_VARARGS },
|
||||
{ "GetGuildMemberCount", guildGetGuildMemberCount, METH_VARARGS },
|
||||
{ "GetGuildMemberLevelSummary", guildGetGuildMemberLevelSummary, METH_VARARGS },
|
||||
{ "GetGuildMemberLevelAverage", guildGetGuildMemberLevelAverage, METH_VARARGS },
|
||||
{ "GetGuildExperienceSummary", guildGetGuildExperienceSummary, METH_VARARGS },
|
||||
|
||||
// SkillPage
|
||||
{ "GetGuildSkillPoint", guildGetGuildSkillPoint, METH_VARARGS },
|
||||
{ "GetDragonPowerPoint", guildGetDragonPowerPoint, METH_VARARGS },
|
||||
{ "GetGuildSkillLevel", guildGetGuildSkillLevel, METH_VARARGS },
|
||||
{ "GetSkillLevel", guildGetSkillLevel, METH_VARARGS },
|
||||
{ "GetSkillMaxLevelNew", guildGetSkillMaxLevelNew, METH_VARARGS },
|
||||
|
||||
{ "SetSkillIndex", guildSetSkillIndex, METH_VARARGS },
|
||||
{ "GetSkillIndex", guildGetSkillIndex, METH_VARARGS },
|
||||
|
||||
// GradePage
|
||||
{ "GetGradeData", guildGetGradeData, METH_VARARGS },
|
||||
{ "GetGradeName", guildGetGradeName, METH_VARARGS },
|
||||
|
||||
// About Member
|
||||
{ "GetMemberCount", guildGetMemberCount, METH_VARARGS },
|
||||
{ "GetMemberData", guildGetMemberData, METH_VARARGS },
|
||||
{ "MemberIndexToPID", guildMemberIndexToPID, METH_VARARGS },
|
||||
{ "IsMember", guildIsMember, METH_VARARGS },
|
||||
{ "IsMemberByName", guildIsMemberByName, METH_VARARGS },
|
||||
{ "MainPlayerHasAuthority", guildMainPlayerHasAuthority, METH_VARARGS },
|
||||
|
||||
// Guild
|
||||
{ "Destroy", guildDestroy, METH_VARARGS },
|
||||
|
||||
{ NULL, NULL, NULL },
|
||||
};
|
||||
|
||||
PyObject * poModule = Py_InitModule("guild", s_methods);
|
||||
PyModule_AddIntConstant(poModule, "AUTH_ADD_MEMBER", GUILD_AUTH_ADD_MEMBER);
|
||||
PyModule_AddIntConstant(poModule, "AUTH_REMOVE_MEMBER", GUILD_AUTH_REMOVE_MEMBER);
|
||||
PyModule_AddIntConstant(poModule, "AUTH_NOTICE", GUILD_AUTH_NOTICE);
|
||||
PyModule_AddIntConstant(poModule, "AUTH_SKILL", GUILD_AUTH_SKILL);
|
||||
PyModule_AddIntConstant(poModule, "ENEMY_GUILD_SLOT_MAX_COUNT", CPythonGuild::ENEMY_GUILD_SLOT_MAX_COUNT);
|
||||
}
|
||||
@@ -0,0 +1,168 @@
|
||||
#include "StdAfx.h"
|
||||
#include "PythonMessenger.h"
|
||||
|
||||
void CPythonMessenger::RemoveFriend(const char * c_szKey)
|
||||
{
|
||||
m_FriendNameMap.erase(c_szKey);
|
||||
}
|
||||
|
||||
void CPythonMessenger::OnFriendLogin(const char * c_szKey/*, const char * c_szName*/)
|
||||
{
|
||||
m_FriendNameMap.insert(c_szKey);
|
||||
|
||||
if (m_poMessengerHandler)
|
||||
PyCallClassMemberFunc(m_poMessengerHandler, "OnLogin", Py_BuildValue("(is)", MESSENGER_GRUOP_INDEX_FRIEND, c_szKey));
|
||||
}
|
||||
|
||||
void CPythonMessenger::OnFriendLogout(const char * c_szKey)
|
||||
{
|
||||
m_FriendNameMap.insert(c_szKey);
|
||||
|
||||
if (m_poMessengerHandler)
|
||||
PyCallClassMemberFunc(m_poMessengerHandler, "OnLogout", Py_BuildValue("(is)", MESSENGER_GRUOP_INDEX_FRIEND, c_szKey));
|
||||
}
|
||||
|
||||
void CPythonMessenger::SetMobile(const char * c_szKey, BYTE byState)
|
||||
{
|
||||
m_FriendNameMap.insert(c_szKey);
|
||||
|
||||
if (m_poMessengerHandler)
|
||||
PyCallClassMemberFunc(m_poMessengerHandler, "OnMobile", Py_BuildValue("(isi)", MESSENGER_GRUOP_INDEX_FRIEND, c_szKey, byState));
|
||||
}
|
||||
|
||||
BOOL CPythonMessenger::IsFriendByKey(const char * c_szKey)
|
||||
{
|
||||
return m_FriendNameMap.end() != m_FriendNameMap.find(c_szKey);
|
||||
}
|
||||
|
||||
BOOL CPythonMessenger::IsFriendByName(const char * c_szName)
|
||||
{
|
||||
return IsFriendByKey(c_szName);
|
||||
}
|
||||
|
||||
void CPythonMessenger::AppendGuildMember(const char * c_szName)
|
||||
{
|
||||
if (m_GuildMemberStateMap.end() != m_GuildMemberStateMap.find(c_szName))
|
||||
return;
|
||||
|
||||
LogoutGuildMember(c_szName);
|
||||
}
|
||||
|
||||
void CPythonMessenger::RemoveGuildMember(const char * c_szName)
|
||||
{
|
||||
m_GuildMemberStateMap.erase(c_szName);
|
||||
|
||||
if (m_poMessengerHandler)
|
||||
PyCallClassMemberFunc(m_poMessengerHandler, "OnRemoveList", Py_BuildValue("(is)", MESSENGER_GRUOP_INDEX_GUILD, c_szName));
|
||||
}
|
||||
|
||||
void CPythonMessenger::RemoveAllGuildMember()
|
||||
{
|
||||
m_GuildMemberStateMap.clear();
|
||||
|
||||
if (m_poMessengerHandler)
|
||||
PyCallClassMemberFunc(m_poMessengerHandler, "OnRemoveAllList", Py_BuildValue("(i)", MESSENGER_GRUOP_INDEX_GUILD));
|
||||
}
|
||||
|
||||
void CPythonMessenger::LoginGuildMember(const char * c_szName)
|
||||
{
|
||||
m_GuildMemberStateMap[c_szName] = 1;
|
||||
if (m_poMessengerHandler)
|
||||
PyCallClassMemberFunc(m_poMessengerHandler, "OnLogin", Py_BuildValue("(is)", MESSENGER_GRUOP_INDEX_GUILD, c_szName));
|
||||
}
|
||||
|
||||
void CPythonMessenger::LogoutGuildMember(const char * c_szName)
|
||||
{
|
||||
m_GuildMemberStateMap[c_szName] = 0;
|
||||
if (m_poMessengerHandler)
|
||||
PyCallClassMemberFunc(m_poMessengerHandler, "OnLogout", Py_BuildValue("(is)", MESSENGER_GRUOP_INDEX_GUILD, c_szName));
|
||||
}
|
||||
|
||||
void CPythonMessenger::RefreshGuildMember()
|
||||
{
|
||||
for (TGuildMemberStateMap::iterator itor = m_GuildMemberStateMap.begin(); itor != m_GuildMemberStateMap.end(); ++itor)
|
||||
{
|
||||
if (itor->second)
|
||||
PyCallClassMemberFunc(m_poMessengerHandler, "OnLogin", Py_BuildValue("(is)", MESSENGER_GRUOP_INDEX_GUILD, (itor->first).c_str()));
|
||||
else
|
||||
PyCallClassMemberFunc(m_poMessengerHandler, "OnLogout", Py_BuildValue("(is)", MESSENGER_GRUOP_INDEX_GUILD, (itor->first).c_str()));
|
||||
}
|
||||
}
|
||||
|
||||
void CPythonMessenger::Destroy()
|
||||
{
|
||||
m_FriendNameMap.clear();
|
||||
m_GuildMemberStateMap.clear();
|
||||
}
|
||||
|
||||
void CPythonMessenger::SetMessengerHandler(PyObject* poHandler)
|
||||
{
|
||||
m_poMessengerHandler = poHandler;
|
||||
}
|
||||
|
||||
CPythonMessenger::CPythonMessenger()
|
||||
: m_poMessengerHandler(NULL)
|
||||
{
|
||||
}
|
||||
|
||||
CPythonMessenger::~CPythonMessenger()
|
||||
{
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
PyObject * messengerRemoveFriend(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
char * szKey;
|
||||
if (!PyTuple_GetString(poArgs, 0, &szKey))
|
||||
return Py_BuildException();
|
||||
|
||||
CPythonMessenger::Instance().RemoveFriend(szKey);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * messengerIsFriendByName(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
char * szName;
|
||||
if (!PyTuple_GetString(poArgs, 0, &szName))
|
||||
return Py_BuildException();
|
||||
|
||||
return Py_BuildValue("i", CPythonMessenger::Instance().IsFriendByName(szName));
|
||||
}
|
||||
|
||||
PyObject * messengerDestroy(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
CPythonMessenger::Instance().Destroy();
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * messengerRefreshGuildMember(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
CPythonMessenger::Instance().RefreshGuildMember();
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * messengerSetMessengerHandler(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
PyObject * poEventHandler;
|
||||
if (!PyTuple_GetObject(poArgs, 0, &poEventHandler))
|
||||
return Py_BuildException();
|
||||
|
||||
CPythonMessenger::Instance().SetMessengerHandler(poEventHandler);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
void initMessenger()
|
||||
{
|
||||
static PyMethodDef s_methods[] =
|
||||
{
|
||||
{ "RemoveFriend", messengerRemoveFriend, METH_VARARGS },
|
||||
{ "IsFriendByName", messengerIsFriendByName, METH_VARARGS } ,
|
||||
{ "Destroy", messengerDestroy, METH_VARARGS },
|
||||
{ "RefreshGuildMember", messengerRefreshGuildMember, METH_VARARGS },
|
||||
{ "SetMessengerHandler", messengerSetMessengerHandler, METH_VARARGS },
|
||||
{ NULL, NULL, NULL },
|
||||
};
|
||||
|
||||
Py_InitModule("messenger", s_methods);
|
||||
}
|
||||
@@ -0,0 +1,338 @@
|
||||
#include "StdAfx.h"
|
||||
#include "PythonSafeBox.h"
|
||||
|
||||
void CPythonSafeBox::OpenSafeBox(int iSize)
|
||||
{
|
||||
m_dwMoney = 0;
|
||||
m_ItemInstanceVector.clear();
|
||||
m_ItemInstanceVector.resize(SAFEBOX_SLOT_X_COUNT * iSize);
|
||||
|
||||
for (DWORD i = 0; i < m_ItemInstanceVector.size(); ++i)
|
||||
{
|
||||
TItemData & rInstance = m_ItemInstanceVector[i];
|
||||
ZeroMemory(&rInstance, sizeof(rInstance));
|
||||
}
|
||||
}
|
||||
|
||||
void CPythonSafeBox::SetItemData(DWORD dwSlotIndex, const TItemData & rItemInstance)
|
||||
{
|
||||
if (dwSlotIndex >= m_ItemInstanceVector.size())
|
||||
{
|
||||
TraceError("CPythonSafeBox::SetItemData(dwSlotIndex=%d) - Strange slot index", dwSlotIndex);
|
||||
return;
|
||||
}
|
||||
|
||||
m_ItemInstanceVector[dwSlotIndex] = rItemInstance;
|
||||
}
|
||||
|
||||
void CPythonSafeBox::DelItemData(DWORD dwSlotIndex)
|
||||
{
|
||||
if (dwSlotIndex >= m_ItemInstanceVector.size())
|
||||
{
|
||||
TraceError("CPythonSafeBox::DelItemData(dwSlotIndex=%d) - Strange slot index", dwSlotIndex);
|
||||
return;
|
||||
}
|
||||
|
||||
TItemData & rInstance = m_ItemInstanceVector[dwSlotIndex];
|
||||
ZeroMemory(&rInstance, sizeof(rInstance));
|
||||
}
|
||||
|
||||
void CPythonSafeBox::SetMoney(DWORD dwMoney)
|
||||
{
|
||||
m_dwMoney = dwMoney;
|
||||
}
|
||||
|
||||
DWORD CPythonSafeBox::GetMoney()
|
||||
{
|
||||
return m_dwMoney;
|
||||
}
|
||||
|
||||
int CPythonSafeBox::GetCurrentSafeBoxSize()
|
||||
{
|
||||
return m_ItemInstanceVector.size();
|
||||
}
|
||||
|
||||
BOOL CPythonSafeBox::GetSlotItemID(DWORD dwSlotIndex, DWORD* pdwItemID)
|
||||
{
|
||||
if (dwSlotIndex >= m_ItemInstanceVector.size())
|
||||
{
|
||||
TraceError("CPythonSafeBox::GetSlotItemID(dwSlotIndex=%d) - Strange slot index", dwSlotIndex);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
*pdwItemID=m_ItemInstanceVector[dwSlotIndex].vnum;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL CPythonSafeBox::GetItemDataPtr(DWORD dwSlotIndex, TItemData ** ppInstance)
|
||||
{
|
||||
if (dwSlotIndex >= m_ItemInstanceVector.size())
|
||||
{
|
||||
TraceError("CPythonSafeBox::GetItemData(dwSlotIndex=%d) - Strange slot index", dwSlotIndex);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
*ppInstance = &m_ItemInstanceVector[dwSlotIndex];
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
void CPythonSafeBox::OpenMall(int iSize)
|
||||
{
|
||||
m_MallItemInstanceVector.clear();
|
||||
m_MallItemInstanceVector.resize(SAFEBOX_SLOT_X_COUNT * iSize);
|
||||
|
||||
for (DWORD i = 0; i < m_MallItemInstanceVector.size(); ++i)
|
||||
{
|
||||
TItemData & rInstance = m_MallItemInstanceVector[i];
|
||||
ZeroMemory(&rInstance, sizeof(rInstance));
|
||||
}
|
||||
}
|
||||
|
||||
void CPythonSafeBox::SetMallItemData(DWORD dwSlotIndex, const TItemData & rItemData)
|
||||
{
|
||||
if (dwSlotIndex >= m_MallItemInstanceVector.size())
|
||||
{
|
||||
TraceError("CPythonSafeBox::SetMallItemData(dwSlotIndex=%d) - Strange slot index", dwSlotIndex);
|
||||
return;
|
||||
}
|
||||
|
||||
m_MallItemInstanceVector[dwSlotIndex] = rItemData;
|
||||
}
|
||||
|
||||
void CPythonSafeBox::DelMallItemData(DWORD dwSlotIndex)
|
||||
{
|
||||
if (dwSlotIndex >= m_MallItemInstanceVector.size())
|
||||
{
|
||||
TraceError("CPythonSafeBox::DelMallItemData(dwSlotIndex=%d) - Strange slot index", dwSlotIndex);
|
||||
return;
|
||||
}
|
||||
|
||||
TItemData & rInstance = m_MallItemInstanceVector[dwSlotIndex];
|
||||
ZeroMemory(&rInstance, sizeof(rInstance));
|
||||
}
|
||||
|
||||
BOOL CPythonSafeBox::GetMallItemDataPtr(DWORD dwSlotIndex, TItemData ** ppInstance)
|
||||
{
|
||||
if (dwSlotIndex >= m_MallItemInstanceVector.size())
|
||||
{
|
||||
TraceError("CPythonSafeBox::GetMallSlotItemID(dwSlotIndex=%d) - Strange slot index", dwSlotIndex);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
*ppInstance = &m_MallItemInstanceVector[dwSlotIndex];
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL CPythonSafeBox::GetSlotMallItemID(DWORD dwSlotIndex, DWORD * pdwItemID)
|
||||
{
|
||||
if (dwSlotIndex >= m_MallItemInstanceVector.size())
|
||||
{
|
||||
TraceError("CPythonSafeBox::GetMallSlotItemID(dwSlotIndex=%d) - Strange slot index", dwSlotIndex);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
*pdwItemID = m_MallItemInstanceVector[dwSlotIndex].vnum;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
DWORD CPythonSafeBox::GetMallSize()
|
||||
{
|
||||
return m_MallItemInstanceVector.size();
|
||||
}
|
||||
|
||||
CPythonSafeBox::CPythonSafeBox()
|
||||
{
|
||||
m_dwMoney = 0;
|
||||
}
|
||||
|
||||
CPythonSafeBox::~CPythonSafeBox()
|
||||
{
|
||||
}
|
||||
|
||||
PyObject * safeboxGetCurrentSafeboxSize(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
return Py_BuildValue("i", CPythonSafeBox::Instance().GetCurrentSafeBoxSize());
|
||||
}
|
||||
|
||||
PyObject * safeboxGetItemID(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int ipos;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &ipos))
|
||||
return Py_BadArgument();
|
||||
|
||||
TItemData * pInstance;
|
||||
if (!CPythonSafeBox::Instance().GetItemDataPtr(ipos, &pInstance))
|
||||
return Py_BuildException();
|
||||
|
||||
return Py_BuildValue("i", pInstance->vnum);
|
||||
}
|
||||
|
||||
PyObject * safeboxGetItemCount(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int ipos;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &ipos))
|
||||
return Py_BadArgument();
|
||||
|
||||
TItemData * pInstance;
|
||||
if (!CPythonSafeBox::Instance().GetItemDataPtr(ipos, &pInstance))
|
||||
return Py_BuildException();
|
||||
|
||||
return Py_BuildValue("i", pInstance->count);
|
||||
}
|
||||
|
||||
PyObject * safeboxGetItemFlags(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int ipos;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &ipos))
|
||||
return Py_BadArgument();
|
||||
|
||||
TItemData * pInstance;
|
||||
if (!CPythonSafeBox::Instance().GetItemDataPtr(ipos, &pInstance))
|
||||
return Py_BuildException();
|
||||
|
||||
return Py_BuildValue("i", pInstance->flags);
|
||||
}
|
||||
|
||||
PyObject * safeboxGetItemMetinSocket(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iSlotIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
|
||||
return Py_BadArgument();
|
||||
int iSocketIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &iSocketIndex))
|
||||
return Py_BadArgument();
|
||||
|
||||
if (iSocketIndex >= ITEM_SOCKET_SLOT_MAX_NUM)
|
||||
return Py_BuildException();
|
||||
|
||||
TItemData * pItemData;
|
||||
if (!CPythonSafeBox::Instance().GetItemDataPtr(iSlotIndex, &pItemData))
|
||||
return Py_BuildException();
|
||||
|
||||
return Py_BuildValue("i", pItemData->alSockets[iSocketIndex]);
|
||||
}
|
||||
|
||||
PyObject * safeboxGetItemAttribute(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iSlotIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
|
||||
return Py_BuildException();
|
||||
int iAttrSlotIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &iAttrSlotIndex))
|
||||
return Py_BuildException();
|
||||
|
||||
if (iAttrSlotIndex >= 0 && iAttrSlotIndex < ITEM_ATTRIBUTE_SLOT_MAX_NUM)
|
||||
{
|
||||
TItemData * pItemData;
|
||||
if (CPythonSafeBox::Instance().GetItemDataPtr(iSlotIndex, &pItemData))
|
||||
return Py_BuildValue("ii", pItemData->aAttr[iAttrSlotIndex].bType, pItemData->aAttr[iAttrSlotIndex].sValue);
|
||||
}
|
||||
|
||||
return Py_BuildValue("ii", 0, 0);
|
||||
}
|
||||
|
||||
PyObject * safeboxGetMoney(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
return Py_BuildValue("i", CPythonSafeBox::Instance().GetMoney());
|
||||
}
|
||||
|
||||
PyObject * safeboxGetMallItemID(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int ipos;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &ipos))
|
||||
return Py_BadArgument();
|
||||
|
||||
TItemData * pInstance;
|
||||
if (!CPythonSafeBox::Instance().GetMallItemDataPtr(ipos, &pInstance))
|
||||
return Py_BuildException();
|
||||
|
||||
return Py_BuildValue("i", pInstance->vnum);
|
||||
}
|
||||
|
||||
PyObject * safeboxGetMallItemCount(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int ipos;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &ipos))
|
||||
return Py_BadArgument();
|
||||
|
||||
TItemData * pInstance;
|
||||
if (!CPythonSafeBox::Instance().GetMallItemDataPtr(ipos, &pInstance))
|
||||
return Py_BuildException();
|
||||
|
||||
return Py_BuildValue("i", pInstance->count);
|
||||
}
|
||||
|
||||
PyObject * safeboxGetMallItemMetinSocket(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iSlotIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
|
||||
return Py_BadArgument();
|
||||
int iSocketIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &iSocketIndex))
|
||||
return Py_BadArgument();
|
||||
|
||||
if (iSocketIndex >= ITEM_SOCKET_SLOT_MAX_NUM)
|
||||
return Py_BuildException();
|
||||
|
||||
TItemData * pItemData;
|
||||
if (!CPythonSafeBox::Instance().GetMallItemDataPtr(iSlotIndex, &pItemData))
|
||||
return Py_BuildException();
|
||||
|
||||
return Py_BuildValue("i", pItemData->alSockets[iSocketIndex]);
|
||||
}
|
||||
|
||||
PyObject * safeboxGetMallItemAttribute(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iSlotIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
|
||||
return Py_BuildException();
|
||||
int iAttrSlotIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &iAttrSlotIndex))
|
||||
return Py_BuildException();
|
||||
|
||||
if (iAttrSlotIndex >= 0 && iAttrSlotIndex < ITEM_ATTRIBUTE_SLOT_MAX_NUM)
|
||||
{
|
||||
TItemData * pItemData;
|
||||
if (CPythonSafeBox::Instance().GetMallItemDataPtr(iSlotIndex, &pItemData))
|
||||
return Py_BuildValue("ii", pItemData->aAttr[iAttrSlotIndex].bType, pItemData->aAttr[iAttrSlotIndex].sValue);
|
||||
}
|
||||
|
||||
return Py_BuildValue("ii", 0, 0);
|
||||
}
|
||||
|
||||
PyObject * safeboxGetMallSize(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
return Py_BuildValue("i", CPythonSafeBox::Instance().GetMallSize());
|
||||
}
|
||||
|
||||
void initsafebox()
|
||||
{
|
||||
static PyMethodDef s_methods[] =
|
||||
{
|
||||
// SafeBox
|
||||
{ "GetCurrentSafeboxSize", safeboxGetCurrentSafeboxSize, METH_VARARGS },
|
||||
{ "GetItemID", safeboxGetItemID, METH_VARARGS },
|
||||
{ "GetItemCount", safeboxGetItemCount, METH_VARARGS },
|
||||
{ "GetItemFlags", safeboxGetItemFlags, METH_VARARGS },
|
||||
{ "GetItemMetinSocket", safeboxGetItemMetinSocket, METH_VARARGS },
|
||||
{ "GetItemAttribute", safeboxGetItemAttribute, METH_VARARGS },
|
||||
{ "GetMoney", safeboxGetMoney, METH_VARARGS },
|
||||
|
||||
// Mall
|
||||
{ "GetMallItemID", safeboxGetMallItemID, METH_VARARGS },
|
||||
{ "GetMallItemCount", safeboxGetMallItemCount, METH_VARARGS },
|
||||
{ "GetMallItemMetinSocket", safeboxGetMallItemMetinSocket, METH_VARARGS },
|
||||
{ "GetMallItemAttribute", safeboxGetMallItemAttribute, METH_VARARGS },
|
||||
{ "GetMallSize", safeboxGetMallSize, METH_VARARGS },
|
||||
{ NULL, NULL, NULL },
|
||||
};
|
||||
|
||||
PyObject * poModule = Py_InitModule("safebox", s_methods);
|
||||
PyModule_AddIntConstant(poModule, "SAFEBOX_SLOT_X_COUNT", CPythonSafeBox::SAFEBOX_SLOT_X_COUNT);
|
||||
PyModule_AddIntConstant(poModule, "SAFEBOX_SLOT_Y_COUNT", CPythonSafeBox::SAFEBOX_SLOT_Y_COUNT);
|
||||
PyModule_AddIntConstant(poModule, "SAFEBOX_PAGE_SIZE", CPythonSafeBox::SAFEBOX_PAGE_SIZE);
|
||||
}
|
||||
@@ -0,0 +1,176 @@
|
||||
#include "StdAfx.h"
|
||||
#include "PythonApplication.h"
|
||||
|
||||
PyObject * sndPlaySound(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
char * szFileName;
|
||||
if (!PyTuple_GetString(poArgs, 0, &szFileName))
|
||||
return Py_BuildException();
|
||||
|
||||
CSoundManager& rkSndMgr=CSoundManager::Instance();
|
||||
rkSndMgr.PlaySound2D(szFileName);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * sndPlaySound3D(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
float fx;
|
||||
if (!PyTuple_GetFloat(poArgs, 0, &fx))
|
||||
return Py_BuildException();
|
||||
float fy;
|
||||
if (!PyTuple_GetFloat(poArgs, 1, &fy))
|
||||
return Py_BuildException();
|
||||
float fz;
|
||||
if (!PyTuple_GetFloat(poArgs, 2, &fz))
|
||||
return Py_BuildException();
|
||||
char * szFileName;
|
||||
if (!PyTuple_GetString(poArgs, 3, &szFileName))
|
||||
return Py_BuildException();
|
||||
|
||||
CSoundManager& rkSndMgr=CSoundManager::Instance();
|
||||
rkSndMgr.PlaySound3D(fx, fy, fz, szFileName);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * sndPlayMusic(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
char * szFileName;
|
||||
if (!PyTuple_GetString(poArgs, 0, &szFileName))
|
||||
return Py_BuildException();
|
||||
|
||||
CSoundManager& rkSndMgr=CSoundManager::Instance();
|
||||
rkSndMgr.PlayMusic(szFileName);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * sndFadeInMusic(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
char * szFileName;
|
||||
if (!PyTuple_GetString(poArgs, 0, &szFileName))
|
||||
return Py_BuildException();
|
||||
|
||||
CSoundManager& rkSndMgr=CSoundManager::Instance();
|
||||
rkSndMgr.FadeInMusic(szFileName);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * sndFadeOutMusic(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
char * szFileName;
|
||||
if (!PyTuple_GetString(poArgs, 0, &szFileName))
|
||||
return Py_BuildException();
|
||||
|
||||
CSoundManager& rkSndMgr=CSoundManager::Instance();
|
||||
rkSndMgr.FadeOutMusic(szFileName);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * sndFadeOutAllMusic(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
CSoundManager& rkSndMgr=CSoundManager::Instance();
|
||||
rkSndMgr.FadeOutAllMusic();
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * sndFadeLimitOutMusic(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
char * szFileName;
|
||||
if (!PyTuple_GetString(poArgs, 0, &szFileName))
|
||||
return Py_BuildException();
|
||||
|
||||
float fLimitVolume;
|
||||
if (!PyTuple_GetFloat(poArgs, 1, &fLimitVolume))
|
||||
return Py_BuildException();
|
||||
|
||||
CSoundManager& rkSndMgr=CSoundManager::Instance();
|
||||
rkSndMgr.FadeLimitOutMusic(szFileName, fLimitVolume);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * sndStopAllSound(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
CSoundManager& rkSndMgr=CSoundManager::Instance();
|
||||
rkSndMgr.StopAllSound3D();
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * sndSetMusicVolume(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
float fVolume;
|
||||
if (!PyTuple_GetFloat(poArgs, 0, &fVolume))
|
||||
return Py_BuildException();
|
||||
|
||||
CSoundManager& rkSndMgr=CSoundManager::Instance();
|
||||
rkSndMgr.SetMusicVolume(fVolume);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * sndSetSoundVolumef(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
float fVolume;
|
||||
if (!PyTuple_GetFloat(poArgs, 0, &fVolume))
|
||||
return Py_BuildException();
|
||||
|
||||
CSoundManager& rkSndMgr=CSoundManager::Instance();
|
||||
rkSndMgr.SetSoundVolumeRatio(fVolume);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
|
||||
PyObject * sndSetSoundVolume(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iVolume;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iVolume))
|
||||
return Py_BuildException();
|
||||
|
||||
CSoundManager& rkSndMgr=CSoundManager::Instance();
|
||||
rkSndMgr.SetSoundVolumeGrade(iVolume);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * sndSetSoundScale(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
float fScale;
|
||||
if (!PyTuple_GetFloat(poArgs, 0, &fScale))
|
||||
return Py_BuildException();
|
||||
|
||||
CSoundManager& rkSndMgr=CSoundManager::Instance();
|
||||
rkSndMgr.SetSoundScale(fScale);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * sndSetAmbienceSoundScale(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
float fScale;
|
||||
if (!PyTuple_GetFloat(poArgs, 0, &fScale))
|
||||
return Py_BuildException();
|
||||
|
||||
CSoundManager& rkSndMgr=CSoundManager::Instance();
|
||||
rkSndMgr.SetAmbienceSoundScale(fScale);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
void initsnd()
|
||||
{
|
||||
static PyMethodDef s_methods[] =
|
||||
{
|
||||
{ "PlaySound", sndPlaySound, METH_VARARGS },
|
||||
{ "PlaySound3D", sndPlaySound3D, METH_VARARGS },
|
||||
{ "PlayMusic", sndPlayMusic, METH_VARARGS },
|
||||
{ "FadeInMusic", sndFadeInMusic, METH_VARARGS },
|
||||
{ "FadeOutMusic", sndFadeOutMusic, METH_VARARGS },
|
||||
{ "FadeOutAllMusic", sndFadeOutAllMusic, METH_VARARGS },
|
||||
{ "FadeLimitOutMusic", sndFadeLimitOutMusic, METH_VARARGS },
|
||||
{ "StopAllSound", sndStopAllSound, METH_VARARGS },
|
||||
|
||||
{ "SetMusicVolumef", sndSetMusicVolume, METH_VARARGS },
|
||||
{ "SetMusicVolume", sndSetMusicVolume, METH_VARARGS },
|
||||
{ "SetSoundVolumef", sndSetSoundVolumef, METH_VARARGS },
|
||||
{ "SetSoundVolume", sndSetSoundVolume, METH_VARARGS },
|
||||
{ "SetSoundScale", sndSetSoundScale, METH_VARARGS },
|
||||
{ "SetAmbienceSoundScale", sndSetAmbienceSoundScale, METH_VARARGS },
|
||||
{ NULL, NULL, NULL },
|
||||
};
|
||||
|
||||
Py_InitModule("snd", s_methods);
|
||||
}
|
||||
@@ -0,0 +1,685 @@
|
||||
#include "StdAfx.h"
|
||||
#include "PythonSystem.h"
|
||||
#include "PythonApplication.h"
|
||||
|
||||
#define DEFAULT_VALUE_ALWAYS_SHOW_NAME true
|
||||
|
||||
void CPythonSystem::SetInterfaceHandler(PyObject * poHandler)
|
||||
{
|
||||
// NOTE : 레퍼런스 카운트는 바꾸지 않는다. 레퍼런스가 남아 있어 Python에서 완전히 지워지지 않기 때문.
|
||||
// 대신에 __del__때 Destroy를 호출해 Handler를 NULL로 셋팅한다. - [levites]
|
||||
// if (m_poInterfaceHandler)
|
||||
// Py_DECREF(m_poInterfaceHandler);
|
||||
|
||||
m_poInterfaceHandler = poHandler;
|
||||
|
||||
// if (m_poInterfaceHandler)
|
||||
// Py_INCREF(m_poInterfaceHandler);
|
||||
}
|
||||
|
||||
void CPythonSystem::DestroyInterfaceHandler()
|
||||
{
|
||||
m_poInterfaceHandler = NULL;
|
||||
}
|
||||
|
||||
void CPythonSystem::SaveWindowStatus(int iIndex, int iVisible, int iMinimized, int ix, int iy, int iHeight)
|
||||
{
|
||||
m_WindowStatus[iIndex].isVisible = iVisible;
|
||||
m_WindowStatus[iIndex].isMinimized = iMinimized;
|
||||
m_WindowStatus[iIndex].ixPosition = ix;
|
||||
m_WindowStatus[iIndex].iyPosition = iy;
|
||||
m_WindowStatus[iIndex].iHeight = iHeight;
|
||||
}
|
||||
|
||||
void CPythonSystem::GetDisplaySettings()
|
||||
{
|
||||
memset(m_ResolutionList, 0, sizeof(TResolution) * RESOLUTION_MAX_NUM);
|
||||
m_ResolutionCount = 0;
|
||||
|
||||
LPDIRECT3D8 lpD3D = CPythonGraphic::Instance().GetD3D();
|
||||
// PORT: defensive guard for headless / dummy graphic environments
|
||||
if (!lpD3D)
|
||||
return;
|
||||
|
||||
D3DADAPTER_IDENTIFIER8 d3dAdapterIdentifier;
|
||||
D3DDISPLAYMODE d3ddmDesktop;
|
||||
|
||||
lpD3D->GetAdapterIdentifier(0, D3DENUM_NO_WHQL_LEVEL, &d3dAdapterIdentifier);
|
||||
lpD3D->GetAdapterDisplayMode(0, &d3ddmDesktop);
|
||||
|
||||
// 이 어뎁터가 가지고 있는 디스플래이 모드갯수를 나열한다..
|
||||
DWORD dwNumAdapterModes = lpD3D->GetAdapterModeCount(0);
|
||||
|
||||
for (UINT iMode = 0; iMode < dwNumAdapterModes; iMode++)
|
||||
{
|
||||
D3DDISPLAYMODE DisplayMode;
|
||||
lpD3D->EnumAdapterModes(0, iMode, &DisplayMode);
|
||||
DWORD bpp = 0;
|
||||
|
||||
// 800 600 이상만 걸러낸다.
|
||||
if (DisplayMode.Width < 800 || DisplayMode.Height < 600)
|
||||
continue;
|
||||
|
||||
// 일단 16bbp 와 32bbp만 취급하자.
|
||||
// 16bbp만 처리하게끔 했음 - [levites]
|
||||
if (DisplayMode.Format == D3DFMT_R5G6B5)
|
||||
bpp = 16;
|
||||
else if (DisplayMode.Format == D3DFMT_X8R8G8B8)
|
||||
bpp = 32;
|
||||
else
|
||||
continue;
|
||||
|
||||
int check_res = false;
|
||||
|
||||
for (int i = 0; !check_res && i < m_ResolutionCount; ++i)
|
||||
{
|
||||
if (m_ResolutionList[i].bpp != bpp ||
|
||||
m_ResolutionList[i].width != DisplayMode.Width ||
|
||||
m_ResolutionList[i].height != DisplayMode.Height)
|
||||
continue;
|
||||
|
||||
int check_fre = false;
|
||||
|
||||
// 프리퀀시만 다르므로 프리퀀시만 셋팅해준다.
|
||||
for (int j = 0; j < m_ResolutionList[i].frequency_count; ++j)
|
||||
{
|
||||
if (m_ResolutionList[i].frequency[j] == DisplayMode.RefreshRate)
|
||||
{
|
||||
check_fre = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!check_fre)
|
||||
if (m_ResolutionList[i].frequency_count < FREQUENCY_MAX_NUM)
|
||||
m_ResolutionList[i].frequency[m_ResolutionList[i].frequency_count++] = DisplayMode.RefreshRate;
|
||||
|
||||
check_res = true;
|
||||
}
|
||||
|
||||
if (!check_res)
|
||||
{
|
||||
// 새로운 거니까 추가해주자.
|
||||
if (m_ResolutionCount < RESOLUTION_MAX_NUM)
|
||||
{
|
||||
m_ResolutionList[m_ResolutionCount].width = DisplayMode.Width;
|
||||
m_ResolutionList[m_ResolutionCount].height = DisplayMode.Height;
|
||||
m_ResolutionList[m_ResolutionCount].bpp = bpp;
|
||||
m_ResolutionList[m_ResolutionCount].frequency[0] = DisplayMode.RefreshRate;
|
||||
m_ResolutionList[m_ResolutionCount].frequency_count = 1;
|
||||
|
||||
++m_ResolutionCount;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int CPythonSystem::GetResolutionCount()
|
||||
{
|
||||
return m_ResolutionCount;
|
||||
}
|
||||
|
||||
int CPythonSystem::GetFrequencyCount(int index)
|
||||
{
|
||||
if (index >= m_ResolutionCount)
|
||||
return 0;
|
||||
|
||||
return m_ResolutionList[index].frequency_count;
|
||||
}
|
||||
|
||||
bool CPythonSystem::GetResolution(int index, OUT DWORD *width, OUT DWORD *height, OUT DWORD *bpp)
|
||||
{
|
||||
if (index >= m_ResolutionCount)
|
||||
return false;
|
||||
|
||||
*width = m_ResolutionList[index].width;
|
||||
*height = m_ResolutionList[index].height;
|
||||
*bpp = m_ResolutionList[index].bpp;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonSystem::GetFrequency(int index, int freq_index, OUT DWORD *frequncy)
|
||||
{
|
||||
if (index >= m_ResolutionCount)
|
||||
return false;
|
||||
|
||||
if (freq_index >= m_ResolutionList[index].frequency_count)
|
||||
return false;
|
||||
|
||||
*frequncy = m_ResolutionList[index].frequency[freq_index];
|
||||
return true;
|
||||
}
|
||||
|
||||
int CPythonSystem::GetResolutionIndex(DWORD width, DWORD height, DWORD bit)
|
||||
{
|
||||
DWORD re_width, re_height, re_bit;
|
||||
int i = 0;
|
||||
|
||||
while (GetResolution(i, &re_width, &re_height, &re_bit))
|
||||
{
|
||||
if (re_width == width)
|
||||
if (re_height == height)
|
||||
if (re_bit == bit)
|
||||
return i;
|
||||
i++;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int CPythonSystem::GetFrequencyIndex(int res_index, DWORD frequency)
|
||||
{
|
||||
DWORD re_frequency;
|
||||
int i = 0;
|
||||
|
||||
while (GetFrequency(res_index, i, &re_frequency))
|
||||
{
|
||||
if (re_frequency == frequency)
|
||||
return i;
|
||||
|
||||
i++;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
DWORD CPythonSystem::GetWidth()
|
||||
{
|
||||
return m_Config.width;
|
||||
}
|
||||
|
||||
DWORD CPythonSystem::GetHeight()
|
||||
{
|
||||
return m_Config.height;
|
||||
}
|
||||
DWORD CPythonSystem::GetBPP()
|
||||
{
|
||||
return m_Config.bpp;
|
||||
}
|
||||
DWORD CPythonSystem::GetFrequency()
|
||||
{
|
||||
return m_Config.frequency;
|
||||
}
|
||||
|
||||
bool CPythonSystem::IsNoSoundCard()
|
||||
{
|
||||
return m_Config.bNoSoundCard;
|
||||
}
|
||||
|
||||
bool CPythonSystem::IsSoftwareCursor()
|
||||
{
|
||||
return m_Config.is_software_cursor;
|
||||
}
|
||||
|
||||
float CPythonSystem::GetMusicVolume()
|
||||
{
|
||||
return m_Config.music_volume;
|
||||
}
|
||||
|
||||
int CPythonSystem::GetSoundVolume()
|
||||
{
|
||||
return m_Config.voice_volume;
|
||||
}
|
||||
|
||||
void CPythonSystem::SetMusicVolume(float fVolume)
|
||||
{
|
||||
m_Config.music_volume = fVolume;
|
||||
}
|
||||
|
||||
void CPythonSystem::SetSoundVolumef(float fVolume)
|
||||
{
|
||||
m_Config.voice_volume = int(5 * fVolume);
|
||||
}
|
||||
|
||||
int CPythonSystem::GetDistance()
|
||||
{
|
||||
return m_Config.iDistance;
|
||||
}
|
||||
|
||||
int CPythonSystem::GetShadowLevel()
|
||||
{
|
||||
return m_Config.iShadowLevel;
|
||||
}
|
||||
|
||||
void CPythonSystem::SetShadowLevel(unsigned int level)
|
||||
{
|
||||
m_Config.iShadowLevel = MIN(level, 5);
|
||||
CPythonBackground::instance().RefreshShadowLevel();
|
||||
}
|
||||
|
||||
int CPythonSystem::IsSaveID()
|
||||
{
|
||||
return m_Config.isSaveID;
|
||||
}
|
||||
|
||||
const char * CPythonSystem::GetSaveID()
|
||||
{
|
||||
return m_Config.SaveID;
|
||||
}
|
||||
|
||||
bool CPythonSystem::isViewCulling()
|
||||
{
|
||||
return m_Config.is_object_culling;
|
||||
}
|
||||
|
||||
void CPythonSystem::SetSaveID(int iValue, const char * c_szSaveID)
|
||||
{
|
||||
if (iValue != 1)
|
||||
return;
|
||||
|
||||
m_Config.isSaveID = iValue;
|
||||
strncpy(m_Config.SaveID, c_szSaveID, sizeof(m_Config.SaveID) - 1);
|
||||
}
|
||||
|
||||
CPythonSystem::TConfig * CPythonSystem::GetConfig()
|
||||
{
|
||||
return &m_Config;
|
||||
}
|
||||
|
||||
void CPythonSystem::SetConfig(TConfig * pNewConfig)
|
||||
{
|
||||
m_Config = *pNewConfig;
|
||||
}
|
||||
|
||||
void CPythonSystem::SetDefaultConfig()
|
||||
{
|
||||
memset(&m_Config, 0, sizeof(m_Config));
|
||||
|
||||
// PORT: default resolution matches standard 800x600 canvas / minimum classic window
|
||||
m_Config.width = 800;
|
||||
m_Config.height = 600;
|
||||
m_Config.bpp = 32;
|
||||
|
||||
#if defined( LOCALE_SERVICE_WE_JAPAN )
|
||||
m_Config.bWindowed = true;
|
||||
#else
|
||||
m_Config.bWindowed = false;
|
||||
#endif
|
||||
|
||||
m_Config.is_software_cursor = false;
|
||||
m_Config.is_object_culling = true;
|
||||
m_Config.iDistance = 3;
|
||||
|
||||
m_Config.gamma = 3;
|
||||
m_Config.music_volume = 1.0f;
|
||||
m_Config.voice_volume = 5;
|
||||
|
||||
m_Config.bDecompressDDS = 0;
|
||||
m_Config.bSoftwareTiling = 0;
|
||||
m_Config.iShadowLevel = 3;
|
||||
m_Config.bViewChat = true;
|
||||
m_Config.bAlwaysShowName = DEFAULT_VALUE_ALWAYS_SHOW_NAME;
|
||||
m_Config.bShowDamage = true;
|
||||
m_Config.bShowSalesText = true;
|
||||
}
|
||||
|
||||
bool CPythonSystem::IsWindowed()
|
||||
{
|
||||
return m_Config.bWindowed;
|
||||
}
|
||||
|
||||
bool CPythonSystem::IsViewChat()
|
||||
{
|
||||
return m_Config.bViewChat;
|
||||
}
|
||||
|
||||
void CPythonSystem::SetViewChatFlag(int iFlag)
|
||||
{
|
||||
m_Config.bViewChat = iFlag == 1 ? true : false;
|
||||
}
|
||||
|
||||
bool CPythonSystem::IsAlwaysShowName()
|
||||
{
|
||||
return m_Config.bAlwaysShowName;
|
||||
}
|
||||
|
||||
void CPythonSystem::SetAlwaysShowNameFlag(int iFlag)
|
||||
{
|
||||
m_Config.bAlwaysShowName = iFlag == 1 ? true : false;
|
||||
}
|
||||
|
||||
bool CPythonSystem::IsShowDamage()
|
||||
{
|
||||
return m_Config.bShowDamage;
|
||||
}
|
||||
|
||||
void CPythonSystem::SetShowDamageFlag(int iFlag)
|
||||
{
|
||||
m_Config.bShowDamage = iFlag == 1 ? true : false;
|
||||
}
|
||||
|
||||
bool CPythonSystem::IsShowSalesText()
|
||||
{
|
||||
return m_Config.bShowSalesText;
|
||||
}
|
||||
|
||||
void CPythonSystem::SetShowSalesTextFlag(int iFlag)
|
||||
{
|
||||
m_Config.bShowSalesText = iFlag == 1 ? true : false;
|
||||
}
|
||||
|
||||
bool CPythonSystem::IsAutoTiling()
|
||||
{
|
||||
if (m_Config.bSoftwareTiling == 0)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void CPythonSystem::SetSoftwareTiling(bool isEnable)
|
||||
{
|
||||
if (isEnable)
|
||||
m_Config.bSoftwareTiling=1;
|
||||
else
|
||||
m_Config.bSoftwareTiling=2;
|
||||
}
|
||||
|
||||
bool CPythonSystem::IsSoftwareTiling()
|
||||
{
|
||||
if (m_Config.bSoftwareTiling==1)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CPythonSystem::IsUseDefaultIME()
|
||||
{
|
||||
return m_Config.bUseDefaultIME;
|
||||
}
|
||||
|
||||
bool CPythonSystem::LoadConfig()
|
||||
{
|
||||
FILE * fp = NULL;
|
||||
|
||||
if (NULL == (fp = fopen("metin2.cfg", "rt")))
|
||||
return false;
|
||||
|
||||
char buf[256];
|
||||
char command[256];
|
||||
char value[256];
|
||||
|
||||
while (fgets(buf, 256, fp))
|
||||
{
|
||||
if (sscanf(buf, " %s %s\n", command, value) == EOF)
|
||||
break;
|
||||
|
||||
if (!stricmp(command, "WIDTH"))
|
||||
m_Config.width = atoi(value);
|
||||
else if (!stricmp(command, "HEIGHT"))
|
||||
m_Config.height = atoi(value);
|
||||
else if (!stricmp(command, "BPP"))
|
||||
m_Config.bpp = atoi(value);
|
||||
else if (!stricmp(command, "FREQUENCY"))
|
||||
m_Config.frequency = atoi(value);
|
||||
else if (!stricmp(command, "SOFTWARE_CURSOR"))
|
||||
m_Config.is_software_cursor = atoi(value) ? true : false;
|
||||
else if (!stricmp(command, "OBJECT_CULLING"))
|
||||
m_Config.is_object_culling = atoi(value) ? true : false;
|
||||
else if (!stricmp(command, "VISIBILITY"))
|
||||
m_Config.iDistance = atoi(value);
|
||||
else if (!stricmp(command, "MUSIC_VOLUME")) {
|
||||
if(strchr(value, '.') == 0) { // Old compatiability
|
||||
m_Config.music_volume = pow(10.0f, (-1.0f + (((float) atoi(value)) / 5.0f)));
|
||||
if(atoi(value) == 0)
|
||||
m_Config.music_volume = 0.0f;
|
||||
} else
|
||||
m_Config.music_volume = atof(value);
|
||||
} else if (!stricmp(command, "VOICE_VOLUME"))
|
||||
m_Config.voice_volume = (char) atoi(value);
|
||||
else if (!stricmp(command, "GAMMA"))
|
||||
m_Config.gamma = atoi(value);
|
||||
else if (!stricmp(command, "IS_SAVE_ID"))
|
||||
m_Config.isSaveID = atoi(value);
|
||||
else if (!stricmp(command, "SAVE_ID"))
|
||||
strncpy(m_Config.SaveID, value, 20);
|
||||
else if (!stricmp(command, "PRE_LOADING_DELAY_TIME"))
|
||||
g_iLoadingDelayTime = atoi(value);
|
||||
else if (!stricmp(command, "WINDOWED"))
|
||||
{
|
||||
m_Config.bWindowed = atoi(value) == 1 ? true : false;
|
||||
}
|
||||
else if (!stricmp(command, "USE_DEFAULT_IME"))
|
||||
m_Config.bUseDefaultIME = atoi(value) == 1 ? true : false;
|
||||
else if (!stricmp(command, "SOFTWARE_TILING"))
|
||||
m_Config.bSoftwareTiling = atoi(value);
|
||||
else if (!stricmp(command, "SHADOW_LEVEL"))
|
||||
m_Config.iShadowLevel = atoi(value);
|
||||
else if (!stricmp(command, "DECOMPRESSED_TEXTURE"))
|
||||
m_Config.bDecompressDDS = atoi(value) == 1 ? true : false;
|
||||
else if (!stricmp(command, "NO_SOUND_CARD"))
|
||||
m_Config.bNoSoundCard = atoi(value) == 1 ? true : false;
|
||||
else if (!stricmp(command, "VIEW_CHAT"))
|
||||
m_Config.bViewChat = atoi(value) == 1 ? true : false;
|
||||
else if (!stricmp(command, "ALWAYS_VIEW_NAME"))
|
||||
m_Config.bAlwaysShowName = atoi(value) == 1 ? true : false;
|
||||
else if (!stricmp(command, "SHOW_DAMAGE"))
|
||||
m_Config.bShowDamage = atoi(value) == 1 ? true : false;
|
||||
else if (!stricmp(command, "SHOW_SALESTEXT"))
|
||||
m_Config.bShowSalesText = atoi(value) == 1 ? true : false;
|
||||
}
|
||||
|
||||
if (m_Config.bWindowed)
|
||||
{
|
||||
unsigned screen_width = GetSystemMetrics(SM_CXFULLSCREEN);
|
||||
unsigned screen_height = GetSystemMetrics(SM_CYFULLSCREEN);
|
||||
|
||||
if (m_Config.width >= screen_width)
|
||||
{
|
||||
m_Config.width = screen_width;
|
||||
}
|
||||
// if (m_Config.height >= screen_height)
|
||||
// {
|
||||
// m_Config.height = screen_height;
|
||||
// }
|
||||
if (m_Config.height >= screen_height) //Fix
|
||||
{
|
||||
int config_height = m_Config.height;
|
||||
int difference = (config_height-screen_height)+7;
|
||||
m_Config.height = config_height - difference;
|
||||
}
|
||||
}
|
||||
|
||||
m_OldConfig = m_Config;
|
||||
|
||||
fclose(fp);
|
||||
|
||||
// Tracef("LoadConfig: Resolution: %dx%d %dBPP %dHZ Software Cursor: %d, Music/Voice Volume: %d/%d Gamma: %d\n",
|
||||
// m_Config.width,
|
||||
// m_Config.height,
|
||||
// m_Config.bpp,
|
||||
// m_Config.frequency,
|
||||
// m_Config.is_software_cursor,
|
||||
// m_Config.music_volume,
|
||||
// m_Config.voice_volume,
|
||||
// m_Config.gamma);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonSystem::SaveConfig()
|
||||
{
|
||||
FILE *fp;
|
||||
|
||||
if (NULL == (fp = fopen("metin2.cfg", "wt")))
|
||||
return false;
|
||||
|
||||
fprintf(fp, "WIDTH %d\n"
|
||||
"HEIGHT %d\n"
|
||||
"BPP %d\n"
|
||||
"FREQUENCY %d\n"
|
||||
"SOFTWARE_CURSOR %d\n"
|
||||
"OBJECT_CULLING %d\n"
|
||||
"VISIBILITY %d\n"
|
||||
"MUSIC_VOLUME %.3f\n"
|
||||
"VOICE_VOLUME %d\n"
|
||||
"GAMMA %d\n"
|
||||
"IS_SAVE_ID %d\n"
|
||||
"SAVE_ID %s\n"
|
||||
"PRE_LOADING_DELAY_TIME %d\n"
|
||||
"DECOMPRESSED_TEXTURE %d\n",
|
||||
m_Config.width,
|
||||
m_Config.height,
|
||||
m_Config.bpp,
|
||||
m_Config.frequency,
|
||||
m_Config.is_software_cursor,
|
||||
m_Config.is_object_culling,
|
||||
m_Config.iDistance,
|
||||
m_Config.music_volume,
|
||||
m_Config.voice_volume,
|
||||
m_Config.gamma,
|
||||
m_Config.isSaveID,
|
||||
m_Config.SaveID,
|
||||
g_iLoadingDelayTime,
|
||||
m_Config.bDecompressDDS);
|
||||
|
||||
if (m_Config.bWindowed == 1)
|
||||
fprintf(fp, "WINDOWED %d\n", m_Config.bWindowed);
|
||||
if (m_Config.bViewChat == 0)
|
||||
fprintf(fp, "VIEW_CHAT %d\n", m_Config.bViewChat);
|
||||
if (m_Config.bAlwaysShowName != DEFAULT_VALUE_ALWAYS_SHOW_NAME)
|
||||
fprintf(fp, "ALWAYS_VIEW_NAME %d\n", m_Config.bAlwaysShowName);
|
||||
if (m_Config.bShowDamage == 0)
|
||||
fprintf(fp, "SHOW_DAMAGE %d\n", m_Config.bShowDamage);
|
||||
if (m_Config.bShowSalesText == 0)
|
||||
fprintf(fp, "SHOW_SALESTEXT %d\n", m_Config.bShowSalesText);
|
||||
|
||||
fprintf(fp, "USE_DEFAULT_IME %d\n", m_Config.bUseDefaultIME);
|
||||
fprintf(fp, "SOFTWARE_TILING %d\n", m_Config.bSoftwareTiling);
|
||||
fprintf(fp, "SHADOW_LEVEL %d\n", m_Config.iShadowLevel);
|
||||
fprintf(fp, "\n");
|
||||
|
||||
fclose(fp);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CPythonSystem::LoadInterfaceStatus()
|
||||
{
|
||||
FILE * File;
|
||||
File = fopen("interface.cfg", "rb");
|
||||
|
||||
if (!File)
|
||||
return false;
|
||||
|
||||
fread(m_WindowStatus, 1, sizeof(TWindowStatus) * WINDOW_MAX_NUM, File);
|
||||
fclose(File);
|
||||
return true;
|
||||
}
|
||||
|
||||
void CPythonSystem::SaveInterfaceStatus()
|
||||
{
|
||||
if (!m_poInterfaceHandler)
|
||||
return;
|
||||
|
||||
PyCallClassMemberFunc(m_poInterfaceHandler, "OnSaveInterfaceStatus", Py_BuildValue("()"));
|
||||
|
||||
FILE * File;
|
||||
|
||||
File = fopen("interface.cfg", "wb");
|
||||
|
||||
if (!File)
|
||||
{
|
||||
TraceError("Cannot open interface.cfg");
|
||||
return;
|
||||
}
|
||||
|
||||
fwrite(m_WindowStatus, 1, sizeof(TWindowStatus) * WINDOW_MAX_NUM, File);
|
||||
fclose(File);
|
||||
}
|
||||
|
||||
bool CPythonSystem::isInterfaceConfig()
|
||||
{
|
||||
return m_isInterfaceConfig;
|
||||
}
|
||||
|
||||
const CPythonSystem::TWindowStatus & CPythonSystem::GetWindowStatusReference(int iIndex)
|
||||
{
|
||||
return m_WindowStatus[iIndex];
|
||||
}
|
||||
|
||||
void CPythonSystem::ApplyConfig() // 이전 설정과 현재 설정을 비교해서 바뀐 설정을 적용 한다.
|
||||
{
|
||||
if (m_OldConfig.gamma != m_Config.gamma)
|
||||
{
|
||||
float val = 1.0f;
|
||||
|
||||
switch (m_Config.gamma)
|
||||
{
|
||||
case 0: val = 0.4f; break;
|
||||
case 1: val = 0.7f; break;
|
||||
case 2: val = 1.0f; break;
|
||||
case 3: val = 1.2f; break;
|
||||
case 4: val = 1.4f; break;
|
||||
}
|
||||
|
||||
CPythonGraphic::Instance().SetGamma(val);
|
||||
}
|
||||
|
||||
if (m_OldConfig.is_software_cursor != m_Config.is_software_cursor)
|
||||
{
|
||||
if (m_Config.is_software_cursor)
|
||||
CPythonApplication::Instance().SetCursorMode(CPythonApplication::CURSOR_MODE_SOFTWARE);
|
||||
else
|
||||
CPythonApplication::Instance().SetCursorMode(CPythonApplication::CURSOR_MODE_HARDWARE);
|
||||
}
|
||||
|
||||
m_OldConfig = m_Config;
|
||||
|
||||
ChangeSystem();
|
||||
}
|
||||
|
||||
void CPythonSystem::ChangeSystem()
|
||||
{
|
||||
// Shadow
|
||||
/*
|
||||
if (m_Config.is_shadow)
|
||||
CScreen::SetShadowFlag(true);
|
||||
else
|
||||
CScreen::SetShadowFlag(false);
|
||||
*/
|
||||
CSoundManager& rkSndMgr = CSoundManager::Instance();
|
||||
/*
|
||||
float fMusicVolume;
|
||||
if (0 == m_Config.music_volume)
|
||||
fMusicVolume = 0.0f;
|
||||
else
|
||||
fMusicVolume= (float)pow(10.0f, (-1.0f + (float)m_Config.music_volume / 5.0f));
|
||||
*/
|
||||
rkSndMgr.SetMusicVolume(m_Config.music_volume);
|
||||
|
||||
/*
|
||||
float fVoiceVolume;
|
||||
if (0 == m_Config.voice_volume)
|
||||
fVoiceVolume = 0.0f;
|
||||
else
|
||||
fVoiceVolume = (float)pow(10.0f, (-1.0f + (float)m_Config.voice_volume / 5.0f));
|
||||
*/
|
||||
rkSndMgr.SetSoundVolumeGrade(m_Config.voice_volume);
|
||||
}
|
||||
|
||||
void CPythonSystem::Clear()
|
||||
{
|
||||
SetInterfaceHandler(NULL);
|
||||
}
|
||||
|
||||
CPythonSystem::CPythonSystem()
|
||||
{
|
||||
memset(&m_Config, 0, sizeof(TConfig));
|
||||
|
||||
m_poInterfaceHandler = NULL;
|
||||
|
||||
SetDefaultConfig();
|
||||
|
||||
LoadConfig();
|
||||
|
||||
ChangeSystem();
|
||||
|
||||
if (LoadInterfaceStatus())
|
||||
m_isInterfaceConfig = true;
|
||||
else
|
||||
m_isInterfaceConfig = false;
|
||||
}
|
||||
|
||||
CPythonSystem::~CPythonSystem()
|
||||
{
|
||||
assert(m_poInterfaceHandler==NULL && "CPythonSystem MUST CLEAR!");
|
||||
}
|
||||
@@ -0,0 +1,445 @@
|
||||
#include "StdAfx.h"
|
||||
#include "PythonSystem.h"
|
||||
|
||||
PyObject * systemGetWidth(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
return Py_BuildValue("i", CPythonSystem::Instance().GetWidth());
|
||||
}
|
||||
|
||||
PyObject * systemGetHeight(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
return Py_BuildValue("i", CPythonSystem::Instance().GetHeight());
|
||||
}
|
||||
|
||||
PyObject * systemSetInterfaceHandler(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
PyObject* poHandler;
|
||||
if (!PyTuple_GetObject(poArgs, 0, &poHandler))
|
||||
return Py_BuildException();
|
||||
|
||||
CPythonSystem::Instance().SetInterfaceHandler(poHandler);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * systemDestroyInterfaceHandler(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
CPythonSystem::Instance().DestroyInterfaceHandler();
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * systemReserveResource(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
std::set<std::string> ResourceSet;
|
||||
CResourceManager::Instance().PushBackgroundLoadingSet(ResourceSet);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * systemisInterfaceConfig(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int isInterfaceConfig = CPythonSystem::Instance().isInterfaceConfig();
|
||||
return Py_BuildValue("i", isInterfaceConfig);
|
||||
}
|
||||
|
||||
PyObject * systemSaveWindowStatus(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int iIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
|
||||
return Py_BuildException();
|
||||
|
||||
int iVisible;
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &iVisible))
|
||||
return Py_BuildException();
|
||||
|
||||
int iMinimized;
|
||||
if (!PyTuple_GetInteger(poArgs, 2, &iMinimized))
|
||||
return Py_BuildException();
|
||||
|
||||
int ix;
|
||||
if (!PyTuple_GetInteger(poArgs, 3, &ix))
|
||||
return Py_BuildException();
|
||||
|
||||
int iy;
|
||||
if (!PyTuple_GetInteger(poArgs, 4, &iy))
|
||||
return Py_BuildException();
|
||||
|
||||
int iHeight;
|
||||
if (!PyTuple_GetInteger(poArgs, 5, &iHeight))
|
||||
return Py_BuildException();
|
||||
|
||||
CPythonSystem::Instance().SaveWindowStatus(iIndex, iVisible, iMinimized, ix, iy, iHeight);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * systemGetWindowStatus(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int iIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
|
||||
return Py_BuildException();
|
||||
|
||||
const CPythonSystem::TWindowStatus & c_rWindowStatus = CPythonSystem::Instance().GetWindowStatusReference(iIndex);
|
||||
return Py_BuildValue("iiiii", c_rWindowStatus.isVisible,
|
||||
c_rWindowStatus.isMinimized,
|
||||
c_rWindowStatus.ixPosition,
|
||||
c_rWindowStatus.iyPosition,
|
||||
c_rWindowStatus.iHeight);
|
||||
}
|
||||
|
||||
PyObject * systemGetConfig(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
CPythonSystem::TConfig *tmp = CPythonSystem::Instance().GetConfig();
|
||||
|
||||
int iRes = CPythonSystem::Instance().GetResolutionIndex(tmp->width, tmp->height, tmp->bpp);
|
||||
int iFrequency = CPythonSystem::Instance().GetFrequencyIndex(iRes, tmp->frequency);
|
||||
|
||||
return Py_BuildValue("iiiiiiii", iRes,
|
||||
iFrequency,
|
||||
tmp->is_software_cursor,
|
||||
tmp->is_object_culling,
|
||||
tmp->music_volume,
|
||||
tmp->voice_volume,
|
||||
tmp->gamma,
|
||||
tmp->iDistance);
|
||||
}
|
||||
|
||||
PyObject * systemSetSaveID(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iValue;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iValue))
|
||||
return Py_BuildException();
|
||||
|
||||
char * szSaveID;
|
||||
if (!PyTuple_GetString(poArgs, 1, &szSaveID))
|
||||
return Py_BuildException();
|
||||
|
||||
CPythonSystem::Instance().SetSaveID(iValue, szSaveID);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * systemisSaveID(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int value = CPythonSystem::Instance().IsSaveID();
|
||||
return Py_BuildValue("i", value);
|
||||
}
|
||||
|
||||
PyObject * systemGetSaveID(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
const char * c_szSaveID = CPythonSystem::Instance().GetSaveID();
|
||||
return Py_BuildValue("s", c_szSaveID);
|
||||
}
|
||||
|
||||
PyObject * systemGetMusicVolume(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
return Py_BuildValue("f", CPythonSystem::Instance().GetMusicVolume());
|
||||
}
|
||||
|
||||
PyObject * systemGetSoundVolume(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
return Py_BuildValue("i", CPythonSystem::Instance().GetSoundVolume());
|
||||
}
|
||||
|
||||
PyObject * systemSetMusicVolume(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
float fVolume;
|
||||
if (!PyTuple_GetFloat(poArgs, 0, &fVolume))
|
||||
return Py_BuildException();
|
||||
|
||||
CPythonSystem::Instance().SetMusicVolume(fVolume);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * systemSetSoundVolumef(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
float fVolume;
|
||||
if (!PyTuple_GetFloat(poArgs, 0, &fVolume))
|
||||
return Py_BuildException();
|
||||
|
||||
CPythonSystem::Instance().SetSoundVolumef(fVolume);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * systemIsSoftwareCursor(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
return Py_BuildValue("i", CPythonSystem::Instance().IsSoftwareCursor());
|
||||
}
|
||||
|
||||
PyObject * systemSetViewChatFlag(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iFlag;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iFlag))
|
||||
return Py_BuildException();
|
||||
|
||||
CPythonSystem::Instance().SetViewChatFlag(iFlag);
|
||||
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * systemIsViewChat(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
return Py_BuildValue("i", CPythonSystem::Instance().IsViewChat());
|
||||
}
|
||||
|
||||
PyObject * systemSetAlwaysShowNameFlag(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iFlag;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iFlag))
|
||||
return Py_BuildException();
|
||||
|
||||
CPythonSystem::Instance().SetAlwaysShowNameFlag(iFlag);
|
||||
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * systemSetShowDamageFlag(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iFlag;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iFlag))
|
||||
return Py_BuildException();
|
||||
|
||||
CPythonSystem::Instance().SetShowDamageFlag(iFlag);
|
||||
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * systemSetShowSalesTextFlag(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iFlag;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iFlag))
|
||||
return Py_BuildException();
|
||||
|
||||
CPythonSystem::Instance().SetShowSalesTextFlag(iFlag);
|
||||
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * systemIsAlwaysShowName(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
return Py_BuildValue("i", CPythonSystem::Instance().IsAlwaysShowName());
|
||||
}
|
||||
|
||||
PyObject * systemIsShowDamage(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
return Py_BuildValue("i", CPythonSystem::Instance().IsShowDamage());
|
||||
}
|
||||
|
||||
PyObject * systemIsShowSalesText(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
return Py_BuildValue("i", CPythonSystem::Instance().IsShowSalesText());
|
||||
}
|
||||
|
||||
PyObject * systemSetConfig(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int res_index;
|
||||
int width;
|
||||
int height;
|
||||
int bpp;
|
||||
int frequency_index;
|
||||
int frequency;
|
||||
int software_cursor;
|
||||
int shadow;
|
||||
int object_culling;
|
||||
int music_volume;
|
||||
int voice_volume;
|
||||
int gamma;
|
||||
int distance;
|
||||
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &res_index))
|
||||
return Py_BuildException();
|
||||
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &frequency_index))
|
||||
return Py_BuildException();
|
||||
|
||||
if (!PyTuple_GetInteger(poArgs, 2, &software_cursor))
|
||||
return Py_BuildException();
|
||||
|
||||
if (!PyTuple_GetInteger(poArgs, 3, &shadow))
|
||||
return Py_BuildException();
|
||||
|
||||
if (!PyTuple_GetInteger(poArgs, 4, &object_culling))
|
||||
return Py_BuildException();
|
||||
|
||||
if (!PyTuple_GetInteger(poArgs, 5, &music_volume))
|
||||
return Py_BuildException();
|
||||
|
||||
if (!PyTuple_GetInteger(poArgs, 6, &voice_volume))
|
||||
return Py_BuildException();
|
||||
|
||||
if (!PyTuple_GetInteger(poArgs, 7, &gamma))
|
||||
return Py_BuildException();
|
||||
|
||||
if (!PyTuple_GetInteger(poArgs, 8, &distance))
|
||||
return Py_BuildException();
|
||||
|
||||
if (!CPythonSystem::Instance().GetResolution(res_index, (DWORD *) &width, (DWORD *) &height, (DWORD *) &bpp))
|
||||
return Py_BuildNone();
|
||||
|
||||
if (!CPythonSystem::Instance().GetFrequency(res_index,frequency_index, (DWORD *) &frequency))
|
||||
return Py_BuildNone();
|
||||
|
||||
CPythonSystem::TConfig tmp;
|
||||
|
||||
memcpy(&tmp, CPythonSystem::Instance().GetConfig(), sizeof(tmp));
|
||||
|
||||
tmp.width = width;
|
||||
tmp.height = height;
|
||||
tmp.bpp = bpp;
|
||||
tmp.frequency = frequency;
|
||||
tmp.is_software_cursor = software_cursor ? true : false;
|
||||
tmp.is_object_culling = object_culling ? true : false;
|
||||
tmp.music_volume = (char) music_volume;
|
||||
tmp.voice_volume = (char) voice_volume;
|
||||
tmp.gamma = gamma;
|
||||
tmp.iDistance = distance;
|
||||
|
||||
CPythonSystem::Instance().SetConfig(&tmp);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * systemApplyConfig(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
CPythonSystem::Instance().ApplyConfig();
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * systemSaveConfig(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int ret = CPythonSystem::Instance().SaveConfig();
|
||||
return Py_BuildValue("i", ret);
|
||||
}
|
||||
|
||||
PyObject * systemGetResolutionCount(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
return Py_BuildValue("i", CPythonSystem::Instance().GetResolutionCount());
|
||||
}
|
||||
|
||||
PyObject * systemGetFrequencyCount(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int index;
|
||||
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &index))
|
||||
return Py_BuildException();
|
||||
|
||||
return Py_BuildValue("i", CPythonSystem::Instance().GetFrequencyCount(index));
|
||||
}
|
||||
|
||||
PyObject * systemGetResolution(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int index;
|
||||
DWORD width = 0, height = 0, bpp = 0;
|
||||
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &index))
|
||||
return Py_BuildException();
|
||||
|
||||
CPythonSystem::Instance().GetResolution(index, &width, &height, &bpp);
|
||||
return Py_BuildValue("iii", width, height, bpp);
|
||||
}
|
||||
|
||||
PyObject * systemGetCurrentResolution(PyObject * poSelf, PyObject *poArgs)
|
||||
{
|
||||
CPythonSystem::TConfig *tmp = CPythonSystem::Instance().GetConfig();
|
||||
return Py_BuildValue("iii", tmp->width, tmp->height, tmp->bpp);
|
||||
}
|
||||
|
||||
PyObject * systemGetFrequency(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int index, frequency_index;
|
||||
DWORD frequency = 0;
|
||||
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &index))
|
||||
return Py_BuildException();
|
||||
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &frequency_index))
|
||||
return Py_BuildException();
|
||||
|
||||
CPythonSystem::Instance().GetFrequency(index, frequency_index, &frequency);
|
||||
return Py_BuildValue("i", frequency);
|
||||
}
|
||||
|
||||
PyObject * systemGetShadowLevel(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
return Py_BuildValue("i", CPythonSystem::Instance().GetShadowLevel());
|
||||
}
|
||||
|
||||
PyObject * systemSetShadowLevel(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int level;
|
||||
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &level))
|
||||
return Py_BuildException();
|
||||
|
||||
if (level > 0)
|
||||
CPythonSystem::Instance().SetShadowLevel(level);
|
||||
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
void initsystem()
|
||||
{
|
||||
static PyMethodDef s_methods[] =
|
||||
{
|
||||
{ "GetWidth", systemGetWidth, METH_VARARGS },
|
||||
{ "GetHeight", systemGetHeight, METH_VARARGS },
|
||||
|
||||
{ "SetInterfaceHandler", systemSetInterfaceHandler, METH_VARARGS },
|
||||
{ "DestroyInterfaceHandler", systemDestroyInterfaceHandler, METH_VARARGS },
|
||||
{ "ReserveResource", systemReserveResource, METH_VARARGS },
|
||||
|
||||
{ "isInterfaceConfig", systemisInterfaceConfig, METH_VARARGS },
|
||||
{ "SaveWindowStatus", systemSaveWindowStatus, METH_VARARGS },
|
||||
{ "GetWindowStatus", systemGetWindowStatus, METH_VARARGS },
|
||||
|
||||
{ "GetResolutionCount", systemGetResolutionCount, METH_VARARGS },
|
||||
{ "GetFrequencyCount", systemGetFrequencyCount, METH_VARARGS },
|
||||
|
||||
{ "GetCurrentResolution", systemGetCurrentResolution, METH_VARARGS },
|
||||
|
||||
{ "GetResolution", systemGetResolution, METH_VARARGS },
|
||||
{ "GetFrequency", systemGetFrequency, METH_VARARGS },
|
||||
|
||||
{ "ApplyConfig", systemApplyConfig, METH_VARARGS },
|
||||
{ "SetConfig", systemSetConfig, METH_VARARGS },
|
||||
{ "SaveConfig", systemSaveConfig, METH_VARARGS },
|
||||
{ "GetConfig", systemGetConfig, METH_VARARGS },
|
||||
|
||||
{ "SetSaveID", systemSetSaveID, METH_VARARGS },
|
||||
{ "isSaveID", systemisSaveID, METH_VARARGS },
|
||||
{ "GetSaveID", systemGetSaveID, METH_VARARGS },
|
||||
|
||||
{ "GetMusicVolume", systemGetMusicVolume, METH_VARARGS },
|
||||
{ "GetSoundVolume", systemGetSoundVolume, METH_VARARGS },
|
||||
|
||||
{ "SetMusicVolume", systemSetMusicVolume, METH_VARARGS },
|
||||
{ "SetSoundVolumef", systemSetSoundVolumef, METH_VARARGS },
|
||||
{ "IsSoftwareCursor", systemIsSoftwareCursor, METH_VARARGS },
|
||||
|
||||
{ "SetViewChatFlag", systemSetViewChatFlag, METH_VARARGS },
|
||||
{ "IsViewChat", systemIsViewChat, METH_VARARGS },
|
||||
|
||||
{ "SetAlwaysShowNameFlag", systemSetAlwaysShowNameFlag, METH_VARARGS },
|
||||
{ "IsAlwaysShowName", systemIsAlwaysShowName, METH_VARARGS },
|
||||
|
||||
{ "SetShowDamageFlag", systemSetShowDamageFlag, METH_VARARGS },
|
||||
{ "IsShowDamage", systemIsShowDamage, METH_VARARGS },
|
||||
|
||||
{ "SetShowSalesTextFlag", systemSetShowSalesTextFlag, METH_VARARGS },
|
||||
{ "IsShowSalesText", systemIsShowSalesText, METH_VARARGS },
|
||||
|
||||
{ "GetShadowLevel", systemGetShadowLevel, METH_VARARGS },
|
||||
{ "SetShadowLevel", systemSetShadowLevel, METH_VARARGS },
|
||||
|
||||
{ NULL, NULL, NULL }
|
||||
};
|
||||
|
||||
PyObject * poModule = Py_InitModule("systemSetting", s_methods);
|
||||
|
||||
PyModule_AddIntConstant(poModule, "WINDOW_STATUS", CPythonSystem::WINDOW_STATUS);
|
||||
PyModule_AddIntConstant(poModule, "WINDOW_INVENTORY", CPythonSystem::WINDOW_INVENTORY);
|
||||
PyModule_AddIntConstant(poModule, "WINDOW_ABILITY", CPythonSystem::WINDOW_ABILITY);
|
||||
PyModule_AddIntConstant(poModule, "WINDOW_SOCIETY", CPythonSystem::WINDOW_SOCIETY);
|
||||
PyModule_AddIntConstant(poModule, "WINDOW_JOURNAL", CPythonSystem::WINDOW_JOURNAL);
|
||||
PyModule_AddIntConstant(poModule, "WINDOW_COMMAND", CPythonSystem::WINDOW_COMMAND);
|
||||
|
||||
PyModule_AddIntConstant(poModule, "WINDOW_QUICK", CPythonSystem::WINDOW_QUICK);
|
||||
PyModule_AddIntConstant(poModule, "WINDOW_GAUGE", CPythonSystem::WINDOW_GAUGE);
|
||||
PyModule_AddIntConstant(poModule, "WINDOW_MINIMAP", CPythonSystem::WINDOW_MINIMAP);
|
||||
PyModule_AddIntConstant(poModule, "WINDOW_CHAT", CPythonSystem::WINDOW_CHAT);
|
||||
}
|
||||
@@ -50,6 +50,7 @@ void initquest();
|
||||
void initEvent();
|
||||
void initeventmgr();
|
||||
void initapp();
|
||||
void initsystem();
|
||||
void initchr();
|
||||
void initchrmgr();
|
||||
void initPlayer();
|
||||
@@ -62,8 +63,12 @@ void initChat();
|
||||
void initnet();
|
||||
void initeffect();
|
||||
void initfly();
|
||||
void initsnd();
|
||||
void initskill();
|
||||
void initBackground();
|
||||
void initMessenger();
|
||||
void initsafebox();
|
||||
void initguild();
|
||||
void initServerStateChecker();
|
||||
|
||||
extern const std::string& ApplicationStringTable_GetString(DWORD dwID);
|
||||
|
||||
Reference in New Issue
Block a user