4428 lines
116 KiB
C++
4428 lines
116 KiB
C++
#include "StdAfx.h"
|
||
#include "PythonNetworkStream.h"
|
||
#include "Packet.h"
|
||
|
||
#include "PythonGuild.h"
|
||
#include "PythonCharacterManager.h"
|
||
#include "PythonPlayer.h"
|
||
#include "PythonBackground.h"
|
||
#include "PythonMiniMap.h"
|
||
#include "PythonTextTail.h"
|
||
#include "PythonItem.h"
|
||
#include "PythonChat.h"
|
||
#include "PythonShop.h"
|
||
#include "PythonExchange.h"
|
||
#include "PythonQuest.h"
|
||
#include "PythonEventManager.h"
|
||
#include "PythonMessenger.h"
|
||
#include "PythonApplication.h"
|
||
|
||
#include "../EterPack/EterPackManager.h"
|
||
#include "../gamelib/ItemManager.h"
|
||
|
||
#include "AbstractApplication.h"
|
||
#include "AbstractCharacterManager.h"
|
||
#include "InstanceBase.h"
|
||
|
||
#include "ProcessCRC.h"
|
||
|
||
BOOL gs_bEmpireLanuageEnable = TRUE;
|
||
|
||
void CPythonNetworkStream::__RefreshAlignmentWindow()
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshAlignment", Py_BuildValue("()"));
|
||
}
|
||
|
||
void CPythonNetworkStream::__RefreshTargetBoardByVID(DWORD dwVID)
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshTargetBoardByVID", Py_BuildValue("(i)", dwVID));
|
||
}
|
||
|
||
void CPythonNetworkStream::__RefreshTargetBoardByName(const char * c_szName)
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshTargetBoardByName", Py_BuildValue("(s)", c_szName));
|
||
}
|
||
|
||
void CPythonNetworkStream::__RefreshTargetBoard()
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshTargetBoard", Py_BuildValue("()"));
|
||
}
|
||
|
||
void CPythonNetworkStream::__RefreshGuildWindowGradePage()
|
||
{
|
||
m_isRefreshGuildWndGradePage=true;
|
||
}
|
||
|
||
void CPythonNetworkStream::__RefreshGuildWindowSkillPage()
|
||
{
|
||
m_isRefreshGuildWndSkillPage=true;
|
||
}
|
||
|
||
void CPythonNetworkStream::__RefreshGuildWindowMemberPageGradeComboBox()
|
||
{
|
||
m_isRefreshGuildWndMemberPageGradeComboBox=true;
|
||
}
|
||
|
||
void CPythonNetworkStream::__RefreshGuildWindowMemberPage()
|
||
{
|
||
m_isRefreshGuildWndMemberPage=true;
|
||
}
|
||
|
||
void CPythonNetworkStream::__RefreshGuildWindowBoardPage()
|
||
{
|
||
m_isRefreshGuildWndBoardPage=true;
|
||
}
|
||
|
||
void CPythonNetworkStream::__RefreshGuildWindowInfoPage()
|
||
{
|
||
m_isRefreshGuildWndInfoPage=true;
|
||
}
|
||
|
||
void CPythonNetworkStream::__RefreshMessengerWindow()
|
||
{
|
||
m_isRefreshMessengerWnd=true;
|
||
}
|
||
|
||
void CPythonNetworkStream::__RefreshSafeboxWindow()
|
||
{
|
||
m_isRefreshSafeboxWnd=true;
|
||
}
|
||
|
||
void CPythonNetworkStream::__RefreshMallWindow()
|
||
{
|
||
m_isRefreshMallWnd=true;
|
||
}
|
||
|
||
void CPythonNetworkStream::__RefreshSkillWindow()
|
||
{
|
||
m_isRefreshSkillWnd=true;
|
||
}
|
||
|
||
void CPythonNetworkStream::__RefreshExchangeWindow()
|
||
{
|
||
m_isRefreshExchangeWnd=true;
|
||
}
|
||
|
||
void CPythonNetworkStream::__RefreshStatus()
|
||
{
|
||
m_isRefreshStatus=true;
|
||
}
|
||
|
||
void CPythonNetworkStream::__RefreshCharacterWindow()
|
||
{
|
||
m_isRefreshCharacterWnd=true;
|
||
}
|
||
|
||
void CPythonNetworkStream::__RefreshInventoryWindow()
|
||
{
|
||
m_isRefreshInventoryWnd=true;
|
||
}
|
||
|
||
void CPythonNetworkStream::__RefreshEquipmentWindow()
|
||
{
|
||
m_isRefreshEquipmentWnd=true;
|
||
}
|
||
|
||
void CPythonNetworkStream::__SetGuildID(DWORD id)
|
||
{
|
||
if (m_dwGuildID != id)
|
||
{
|
||
m_dwGuildID = id;
|
||
IAbstractPlayer& rkPlayer = IAbstractPlayer::GetSingleton();
|
||
|
||
for (int i = 0; i < PLAYER_PER_ACCOUNT4; ++i)
|
||
if (!strncmp(m_akSimplePlayerInfo[i].szName, rkPlayer.GetName(), CHARACTER_NAME_MAX_LEN))
|
||
{
|
||
m_adwGuildID[i] = id;
|
||
|
||
std::string guildName;
|
||
if (CPythonGuild::Instance().GetGuildName(id, &guildName))
|
||
{
|
||
m_astrGuildName[i] = guildName;
|
||
}
|
||
else
|
||
{
|
||
m_astrGuildName[i] = "";
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
struct PERF_PacketInfo
|
||
{
|
||
DWORD dwCount;
|
||
DWORD dwTime;
|
||
|
||
PERF_PacketInfo()
|
||
{
|
||
dwCount=0;
|
||
dwTime=0;
|
||
}
|
||
};
|
||
|
||
|
||
#ifdef __PERFORMANCE_CHECK__
|
||
|
||
class PERF_PacketTimeAnalyzer
|
||
{
|
||
public:
|
||
~PERF_PacketTimeAnalyzer()
|
||
{
|
||
FILE* fp=fopen("perf_dispatch_packet_result.txt", "w");
|
||
|
||
for (std::map<DWORD, PERF_PacketInfo>::iterator i=m_kMap_kPacketInfo.begin(); i!=m_kMap_kPacketInfo.end(); ++i)
|
||
{
|
||
if (i->second.dwTime>0)
|
||
fprintf(fp, "header %d: count %d, time %d, tpc %d\n", i->first, i->second.dwCount, i->second.dwTime, i->second.dwTime/i->second.dwCount);
|
||
}
|
||
fclose(fp);
|
||
}
|
||
|
||
public:
|
||
std::map<DWORD, PERF_PacketInfo> m_kMap_kPacketInfo;
|
||
};
|
||
|
||
PERF_PacketTimeAnalyzer gs_kPacketTimeAnalyzer;
|
||
|
||
#endif
|
||
|
||
// Game Phase ---------------------------------------------------------------------------
|
||
void CPythonNetworkStream::GamePhase()
|
||
{
|
||
if (!m_kQue_stHack.empty())
|
||
{
|
||
__SendHack(m_kQue_stHack.front().c_str());
|
||
m_kQue_stHack.pop_front();
|
||
}
|
||
|
||
TPacketHeader header = 0;
|
||
bool ret = true;
|
||
|
||
#ifdef __PERFORMANCE_CHECK__
|
||
DWORD timeBeginDispatch=timeGetTime();
|
||
|
||
static std::map<DWORD, PERF_PacketInfo> kMap_kPacketInfo;
|
||
kMap_kPacketInfo.clear();
|
||
#endif
|
||
|
||
const DWORD MAX_RECV_COUNT = 4;
|
||
const DWORD SAFE_RECV_BUFSIZE = 8192;
|
||
DWORD dwRecvCount = 0;
|
||
|
||
while (ret)
|
||
{
|
||
if(dwRecvCount++ >= MAX_RECV_COUNT-1 && GetRecvBufferSize() < SAFE_RECV_BUFSIZE
|
||
&& m_strPhase == "Game") //phase_game <20><> <20>ƴϾ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>찡 <20>ִ<EFBFBD>.
|
||
break;
|
||
|
||
if (!CheckPacket(&header))
|
||
break;
|
||
|
||
#ifdef __PERFORMANCE_CHECK__
|
||
DWORD timeBeginPacket=timeGetTime();
|
||
#endif
|
||
|
||
switch (header)
|
||
{
|
||
case HEADER_GC_OBSERVER_ADD:
|
||
ret = RecvObserverAddPacket();
|
||
break;
|
||
case HEADER_GC_OBSERVER_REMOVE:
|
||
ret = RecvObserverRemovePacket();
|
||
break;
|
||
case HEADER_GC_OBSERVER_MOVE:
|
||
ret = RecvObserverMovePacket();
|
||
break;
|
||
case HEADER_GC_WARP:
|
||
ret = RecvWarpPacket();
|
||
break;
|
||
|
||
case HEADER_GC_PHASE:
|
||
ret = RecvPhasePacket();
|
||
return; // <20><><EFBFBD>߿<EFBFBD> Phase <20><> <20>ٲ<EFBFBD><D9B2><EFBFBD> <20>ϴ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> GamePhase Ż<><C5BB> - [levites]
|
||
break;
|
||
|
||
case HEADER_GC_PVP:
|
||
ret = RecvPVPPacket();
|
||
break;
|
||
|
||
case HEADER_GC_DUEL_START:
|
||
ret = RecvDuelStartPacket();
|
||
break;
|
||
|
||
case HEADER_GC_CHARACTER_ADD:
|
||
ret = RecvCharacterAppendPacket();
|
||
break;
|
||
|
||
case HEADER_GC_CHAR_ADDITIONAL_INFO:
|
||
ret = RecvCharacterAdditionalInfo();
|
||
break;
|
||
|
||
case HEADER_GC_CHARACTER_ADD2:
|
||
ret = RecvCharacterAppendPacketNew();
|
||
break;
|
||
|
||
case HEADER_GC_CHARACTER_UPDATE:
|
||
ret = RecvCharacterUpdatePacket();
|
||
break;
|
||
|
||
case HEADER_GC_CHARACTER_UPDATE2:
|
||
ret = RecvCharacterUpdatePacketNew();
|
||
break;
|
||
|
||
case HEADER_GC_CHARACTER_DEL:
|
||
ret = RecvCharacterDeletePacket();
|
||
break;
|
||
|
||
case HEADER_GC_CHAT:
|
||
ret = RecvChatPacket();
|
||
break;
|
||
|
||
case HEADER_GC_SYNC_POSITION:
|
||
ret = RecvSyncPositionPacket();
|
||
break;
|
||
|
||
case HEADER_GC_OWNERSHIP:
|
||
ret = RecvOwnerShipPacket();
|
||
break;
|
||
|
||
case HEADER_GC_WHISPER:
|
||
ret = RecvWhisperPacket();
|
||
break;
|
||
|
||
case HEADER_GC_CHARACTER_MOVE:
|
||
ret = RecvCharacterMovePacket();
|
||
break;
|
||
|
||
// Position
|
||
case HEADER_GC_CHARACTER_POSITION:
|
||
ret = RecvCharacterPositionPacket();
|
||
break;
|
||
|
||
// Battle Packet
|
||
case HEADER_GC_STUN:
|
||
ret = RecvStunPacket();
|
||
break;
|
||
|
||
case HEADER_GC_DEAD:
|
||
ret = RecvDeadPacket();
|
||
break;
|
||
|
||
case HEADER_GC_PLAYER_POINT_CHANGE:
|
||
ret = RecvPointChange();
|
||
break;
|
||
|
||
// item packet.
|
||
case HEADER_GC_ITEM_SET:
|
||
ret = RecvItemSetPacket();
|
||
break;
|
||
|
||
case HEADER_GC_ITEM_SET2:
|
||
ret = RecvItemSetPacket2();
|
||
break;
|
||
|
||
case HEADER_GC_ITEM_USE:
|
||
ret = RecvItemUsePacket();
|
||
break;
|
||
|
||
case HEADER_GC_ITEM_UPDATE:
|
||
ret = RecvItemUpdatePacket();
|
||
break;
|
||
|
||
case HEADER_GC_ITEM_GROUND_ADD:
|
||
ret = RecvItemGroundAddPacket();
|
||
break;
|
||
|
||
case HEADER_GC_ITEM_GROUND_DEL:
|
||
ret = RecvItemGroundDelPacket();
|
||
break;
|
||
|
||
case HEADER_GC_ITEM_OWNERSHIP:
|
||
ret = RecvItemOwnership();
|
||
break;
|
||
|
||
case HEADER_GC_QUICKSLOT_ADD:
|
||
ret = RecvQuickSlotAddPacket();
|
||
break;
|
||
|
||
case HEADER_GC_QUICKSLOT_DEL:
|
||
ret = RecvQuickSlotDelPacket();
|
||
break;
|
||
|
||
case HEADER_GC_QUICKSLOT_SWAP:
|
||
ret = RecvQuickSlotMovePacket();
|
||
break;
|
||
|
||
case HEADER_GC_MOTION:
|
||
ret = RecvMotionPacket();
|
||
break;
|
||
|
||
case HEADER_GC_SHOP:
|
||
ret = RecvShopPacket();
|
||
break;
|
||
|
||
case HEADER_GC_SHOP_SIGN:
|
||
ret = RecvShopSignPacket();
|
||
break;
|
||
|
||
case HEADER_GC_EXCHANGE:
|
||
ret = RecvExchangePacket();
|
||
break;
|
||
|
||
case HEADER_GC_QUEST_INFO:
|
||
ret = RecvQuestInfoPacket();
|
||
break;
|
||
|
||
case HEADER_GC_REQUEST_MAKE_GUILD:
|
||
ret = RecvRequestMakeGuild();
|
||
break;
|
||
|
||
case HEADER_GC_PING:
|
||
ret = RecvPingPacket();
|
||
break;
|
||
|
||
case HEADER_GC_SCRIPT:
|
||
ret = RecvScriptPacket();
|
||
break;
|
||
|
||
case HEADER_GC_QUEST_CONFIRM:
|
||
ret = RecvQuestConfirmPacket();
|
||
break;
|
||
|
||
case HEADER_GC_TARGET:
|
||
ret = RecvTargetPacket();
|
||
break;
|
||
|
||
case HEADER_GC_DAMAGE_INFO:
|
||
ret = RecvDamageInfoPacket();
|
||
break;
|
||
|
||
case HEADER_GC_MOUNT:
|
||
ret = RecvMountPacket();
|
||
break;
|
||
|
||
case HEADER_GC_CHANGE_SPEED:
|
||
ret = RecvChangeSpeedPacket();
|
||
break;
|
||
|
||
case HEADER_GC_PLAYER_POINTS:
|
||
ret = __RecvPlayerPoints();
|
||
break;
|
||
|
||
case HEADER_GC_CREATE_FLY:
|
||
ret = RecvCreateFlyPacket();
|
||
break;
|
||
|
||
case HEADER_GC_FLY_TARGETING:
|
||
ret = RecvFlyTargetingPacket();
|
||
break;
|
||
|
||
case HEADER_GC_ADD_FLY_TARGETING:
|
||
ret = RecvAddFlyTargetingPacket();
|
||
break;
|
||
|
||
case HEADER_GC_SKILL_LEVEL:
|
||
ret = RecvSkillLevel();
|
||
break;
|
||
|
||
case HEADER_GC_SKILL_LEVEL_NEW:
|
||
ret = RecvSkillLevelNew();
|
||
break;
|
||
|
||
case HEADER_GC_MESSENGER:
|
||
ret = RecvMessenger();
|
||
break;
|
||
|
||
case HEADER_GC_GUILD:
|
||
ret = RecvGuild();
|
||
break;
|
||
|
||
case HEADER_GC_PARTY_INVITE:
|
||
ret = RecvPartyInvite();
|
||
break;
|
||
|
||
case HEADER_GC_PARTY_ADD:
|
||
ret = RecvPartyAdd();
|
||
break;
|
||
|
||
case HEADER_GC_PARTY_UPDATE:
|
||
ret = RecvPartyUpdate();
|
||
break;
|
||
|
||
case HEADER_GC_PARTY_REMOVE:
|
||
ret = RecvPartyRemove();
|
||
break;
|
||
|
||
case HEADER_GC_PARTY_LINK:
|
||
ret = RecvPartyLink();
|
||
break;
|
||
|
||
case HEADER_GC_PARTY_UNLINK:
|
||
ret = RecvPartyUnlink();
|
||
break;
|
||
|
||
case HEADER_GC_PARTY_PARAMETER:
|
||
ret = RecvPartyParameter();
|
||
break;
|
||
|
||
case HEADER_GC_SAFEBOX_SET:
|
||
ret = RecvSafeBoxSetPacket();
|
||
break;
|
||
|
||
case HEADER_GC_SAFEBOX_DEL:
|
||
ret = RecvSafeBoxDelPacket();
|
||
break;
|
||
|
||
case HEADER_GC_SAFEBOX_WRONG_PASSWORD:
|
||
ret = RecvSafeBoxWrongPasswordPacket();
|
||
break;
|
||
|
||
case HEADER_GC_SAFEBOX_SIZE:
|
||
ret = RecvSafeBoxSizePacket();
|
||
break;
|
||
|
||
case HEADER_GC_SAFEBOX_MONEY_CHANGE:
|
||
ret = RecvSafeBoxMoneyChangePacket();
|
||
break;
|
||
|
||
case HEADER_GC_FISHING:
|
||
ret = RecvFishing();
|
||
break;
|
||
|
||
case HEADER_GC_DUNGEON:
|
||
ret = RecvDungeon();
|
||
break;
|
||
|
||
case HEADER_GC_TIME:
|
||
ret = RecvTimePacket();
|
||
break;
|
||
|
||
case HEADER_GC_WALK_MODE:
|
||
ret = RecvWalkModePacket();
|
||
break;
|
||
|
||
case HEADER_GC_CHANGE_SKILL_GROUP:
|
||
ret = RecvChangeSkillGroupPacket();
|
||
break;
|
||
|
||
case HEADER_GC_REFINE_INFORMATION:
|
||
ret = RecvRefineInformationPacket();
|
||
break;
|
||
|
||
case HEADER_GC_REFINE_INFORMATION_NEW:
|
||
ret = RecvRefineInformationPacketNew();
|
||
break;
|
||
|
||
case HEADER_GC_SEPCIAL_EFFECT:
|
||
ret = RecvSpecialEffect();
|
||
break;
|
||
|
||
case HEADER_GC_NPC_POSITION:
|
||
ret = RecvNPCList();
|
||
break;
|
||
|
||
case HEADER_GC_CHANNEL:
|
||
ret = RecvChannelPacket();
|
||
break;
|
||
|
||
case HEADER_GC_VIEW_EQUIP:
|
||
ret = RecvViewEquipPacket();
|
||
break;
|
||
|
||
case HEADER_GC_LAND_LIST:
|
||
ret = RecvLandPacket();
|
||
break;
|
||
|
||
//case HEADER_GC_TARGET_CREATE:
|
||
// ret = RecvTargetCreatePacket();
|
||
// break;
|
||
|
||
case HEADER_GC_TARGET_CREATE_NEW:
|
||
ret = RecvTargetCreatePacketNew();
|
||
break;
|
||
|
||
case HEADER_GC_TARGET_UPDATE:
|
||
ret = RecvTargetUpdatePacket();
|
||
break;
|
||
|
||
case HEADER_GC_TARGET_DELETE:
|
||
ret = RecvTargetDeletePacket();
|
||
break;
|
||
|
||
case HEADER_GC_AFFECT_ADD:
|
||
ret = RecvAffectAddPacket();
|
||
break;
|
||
|
||
case HEADER_GC_AFFECT_REMOVE:
|
||
ret = RecvAffectRemovePacket();
|
||
break;
|
||
|
||
case HEADER_GC_MALL_OPEN:
|
||
ret = RecvMallOpenPacket();
|
||
break;
|
||
|
||
case HEADER_GC_MALL_SET:
|
||
ret = RecvMallItemSetPacket();
|
||
break;
|
||
|
||
case HEADER_GC_MALL_DEL:
|
||
ret = RecvMallItemDelPacket();
|
||
break;
|
||
|
||
case HEADER_GC_LOVER_INFO:
|
||
ret = RecvLoverInfoPacket();
|
||
break;
|
||
|
||
case HEADER_GC_LOVE_POINT_UPDATE:
|
||
ret = RecvLovePointUpdatePacket();
|
||
break;
|
||
|
||
case HEADER_GC_DIG_MOTION:
|
||
ret = RecvDigMotionPacket();
|
||
break;
|
||
|
||
case HEADER_GC_HANDSHAKE:
|
||
RecvHandshakePacket();
|
||
return;
|
||
break;
|
||
|
||
case HEADER_GC_HANDSHAKE_OK:
|
||
RecvHandshakeOKPacket();
|
||
return;
|
||
break;
|
||
|
||
case HEADER_GC_HYBRIDCRYPT_KEYS:
|
||
RecvHybridCryptKeyPacket();
|
||
return;
|
||
break;
|
||
|
||
case HEADER_GC_HYBRIDCRYPT_SDB:
|
||
RecvHybridCryptSDBPacket();
|
||
return;
|
||
break;
|
||
|
||
case HEADER_GC_HS_REQUEST:
|
||
ret = RecvHSCheckRequest();
|
||
break;
|
||
|
||
case HEADER_GC_XTRAP_CS1_REQUEST:
|
||
ret = RecvXTrapVerifyRequest();
|
||
break;
|
||
|
||
case HEADER_GC_SPECIFIC_EFFECT:
|
||
ret = RecvSpecificEffect();
|
||
break;
|
||
|
||
case HEADER_GC_DRAGON_SOUL_REFINE:
|
||
ret = RecvDragonSoulRefine();
|
||
break;
|
||
|
||
default:
|
||
ret = RecvDefaultPacket(header);
|
||
break;
|
||
}
|
||
#ifdef __PERFORMANCE_CHECK__
|
||
DWORD timeEndPacket=timeGetTime();
|
||
|
||
{
|
||
PERF_PacketInfo& rkPacketInfo=kMap_kPacketInfo[header];
|
||
rkPacketInfo.dwCount++;
|
||
rkPacketInfo.dwTime+=timeEndPacket-timeBeginPacket;
|
||
}
|
||
|
||
{
|
||
PERF_PacketInfo& rkPacketInfo=gs_kPacketTimeAnalyzer.m_kMap_kPacketInfo[header];
|
||
rkPacketInfo.dwCount++;
|
||
rkPacketInfo.dwTime+=timeEndPacket-timeBeginPacket;
|
||
}
|
||
#endif
|
||
}
|
||
|
||
#ifdef __PERFORMANCE_CHECK__
|
||
DWORD timeEndDispatch=timeGetTime();
|
||
|
||
if (timeEndDispatch-timeBeginDispatch>2)
|
||
{
|
||
static FILE* fp=fopen("perf_dispatch_packet.txt", "w");
|
||
|
||
fprintf(fp, "delay %d\n", timeEndDispatch-timeBeginDispatch);
|
||
for (std::map<DWORD, PERF_PacketInfo>::iterator i=kMap_kPacketInfo.begin(); i!=kMap_kPacketInfo.end(); ++i)
|
||
{
|
||
if (i->second.dwTime>0)
|
||
fprintf(fp, "header %d: count %d, time %d\n", i->first, i->second.dwCount, i->second.dwTime);
|
||
}
|
||
fputs("=====================================================\n", fp);
|
||
fflush(fp);
|
||
}
|
||
#endif
|
||
|
||
if (!ret)
|
||
RecvErrorPacket(header);
|
||
|
||
static DWORD s_nextRefreshTime = ELTimer_GetMSec();
|
||
|
||
DWORD curTime = ELTimer_GetMSec();
|
||
if (s_nextRefreshTime > curTime)
|
||
return;
|
||
|
||
|
||
|
||
if (m_isRefreshCharacterWnd)
|
||
{
|
||
m_isRefreshCharacterWnd=false;
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshCharacter", Py_BuildValue("()"));
|
||
s_nextRefreshTime = curTime + 300;
|
||
}
|
||
|
||
if (m_isRefreshEquipmentWnd)
|
||
{
|
||
m_isRefreshEquipmentWnd=false;
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshEquipment", Py_BuildValue("()"));
|
||
s_nextRefreshTime = curTime + 300;
|
||
}
|
||
|
||
if (m_isRefreshInventoryWnd)
|
||
{
|
||
m_isRefreshInventoryWnd=false;
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshInventory", Py_BuildValue("()"));
|
||
s_nextRefreshTime = curTime + 300;
|
||
}
|
||
|
||
if (m_isRefreshExchangeWnd)
|
||
{
|
||
m_isRefreshExchangeWnd=false;
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshExchange", Py_BuildValue("()"));
|
||
s_nextRefreshTime = curTime + 300;
|
||
}
|
||
|
||
if (m_isRefreshSkillWnd)
|
||
{
|
||
m_isRefreshSkillWnd=false;
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshSkill", Py_BuildValue("()"));
|
||
s_nextRefreshTime = curTime + 300;
|
||
}
|
||
|
||
if (m_isRefreshSafeboxWnd)
|
||
{
|
||
m_isRefreshSafeboxWnd=false;
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshSafebox", Py_BuildValue("()"));
|
||
s_nextRefreshTime = curTime + 300;
|
||
}
|
||
|
||
if (m_isRefreshMallWnd)
|
||
{
|
||
m_isRefreshMallWnd=false;
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshMall", Py_BuildValue("()"));
|
||
s_nextRefreshTime = curTime + 300;
|
||
}
|
||
|
||
if (m_isRefreshStatus)
|
||
{
|
||
m_isRefreshStatus=false;
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshStatus", Py_BuildValue("()"));
|
||
s_nextRefreshTime = curTime + 300;
|
||
}
|
||
|
||
if (m_isRefreshMessengerWnd)
|
||
{
|
||
m_isRefreshMessengerWnd=false;
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshMessenger", Py_BuildValue("()"));
|
||
s_nextRefreshTime = curTime + 300;
|
||
}
|
||
|
||
if (m_isRefreshGuildWndInfoPage)
|
||
{
|
||
m_isRefreshGuildWndInfoPage=false;
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildInfoPage", Py_BuildValue("()"));
|
||
s_nextRefreshTime = curTime + 300;
|
||
}
|
||
|
||
if (m_isRefreshGuildWndBoardPage)
|
||
{
|
||
m_isRefreshGuildWndBoardPage=false;
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildBoardPage", Py_BuildValue("()"));
|
||
s_nextRefreshTime = curTime + 300;
|
||
}
|
||
|
||
if (m_isRefreshGuildWndMemberPage)
|
||
{
|
||
m_isRefreshGuildWndMemberPage=false;
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildMemberPage", Py_BuildValue("()"));
|
||
s_nextRefreshTime = curTime + 300;
|
||
}
|
||
|
||
if (m_isRefreshGuildWndMemberPageGradeComboBox)
|
||
{
|
||
m_isRefreshGuildWndMemberPageGradeComboBox=false;
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildMemberPageGradeComboBox", Py_BuildValue("()"));
|
||
s_nextRefreshTime = curTime + 300;
|
||
}
|
||
|
||
if (m_isRefreshGuildWndSkillPage)
|
||
{
|
||
m_isRefreshGuildWndSkillPage=false;
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildSkillPage", Py_BuildValue("()"));
|
||
s_nextRefreshTime = curTime + 300;
|
||
}
|
||
|
||
if (m_isRefreshGuildWndGradePage)
|
||
{
|
||
m_isRefreshGuildWndGradePage=false;
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildGradePage", Py_BuildValue("()"));
|
||
s_nextRefreshTime = curTime + 300;
|
||
}
|
||
}
|
||
|
||
void CPythonNetworkStream::__InitializeGamePhase()
|
||
{
|
||
__ServerTimeSync_Initialize();
|
||
|
||
m_isRefreshStatus=false;
|
||
m_isRefreshCharacterWnd=false;
|
||
m_isRefreshEquipmentWnd=false;
|
||
m_isRefreshInventoryWnd=false;
|
||
m_isRefreshExchangeWnd=false;
|
||
m_isRefreshSkillWnd=false;
|
||
m_isRefreshSafeboxWnd=false;
|
||
m_isRefreshMallWnd=false;
|
||
m_isRefreshMessengerWnd=false;
|
||
m_isRefreshGuildWndInfoPage=false;
|
||
m_isRefreshGuildWndBoardPage=false;
|
||
m_isRefreshGuildWndMemberPage=false;
|
||
m_isRefreshGuildWndMemberPageGradeComboBox=false;
|
||
m_isRefreshGuildWndSkillPage=false;
|
||
m_isRefreshGuildWndGradePage=false;
|
||
|
||
m_EmoticonStringVector.clear();
|
||
|
||
m_pInstTarget = NULL;
|
||
}
|
||
|
||
void CPythonNetworkStream::Warp(LONG lGlobalX, LONG lGlobalY)
|
||
{
|
||
CPythonBackground& rkBgMgr=CPythonBackground::Instance();
|
||
rkBgMgr.Destroy();
|
||
rkBgMgr.Create();
|
||
rkBgMgr.Warp(lGlobalX, lGlobalY);
|
||
//rkBgMgr.SetShadowLevel(CPythonBackground::SHADOW_ALL);
|
||
rkBgMgr.RefreshShadowLevel();
|
||
|
||
// NOTE : Warp <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> CenterPosition<6F><6E> Height<68><74> 0<>̱<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ī<><EFBFBD><DEB6><EFBFBD> <20><><EFBFBD>ٴڿ<D9B4> <20><><EFBFBD><EFBFBD><EFBFBD>ְ<EFBFBD> <20><>
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD>϶<EFBFBD><CFB6><EFBFBD><EFBFBD><EFBFBD> Height<68><74> <20><><EFBFBD><EFBFBD> <20>DZ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>̹Ƿ<CCB9> <20><><EFBFBD><EFBFBD> <20>̵<EFBFBD><CCB5>ϸ<EFBFBD> Position<6F><6E> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ѹ<EFBFBD>
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ش<EFBFBD> - [levites]
|
||
LONG lLocalX = lGlobalX;
|
||
LONG lLocalY = lGlobalY;
|
||
__GlobalPositionToLocalPosition(lLocalX, lLocalY);
|
||
float fHeight = CPythonBackground::Instance().GetHeight(float(lLocalX), float(lLocalY));
|
||
|
||
IAbstractApplication& rkApp=IAbstractApplication::GetSingleton();
|
||
rkApp.SetCenterPosition(float(lLocalX), float(lLocalY), fHeight);
|
||
|
||
__ShowMapName(lLocalX, lLocalY);
|
||
}
|
||
|
||
void CPythonNetworkStream::__ShowMapName(LONG lLocalX, LONG lLocalY)
|
||
{
|
||
const std::string & c_rstrMapFileName = CPythonBackground::Instance().GetWarpMapName();
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ShowMapName", Py_BuildValue("(sii)", c_rstrMapFileName.c_str(), lLocalX, lLocalY));
|
||
}
|
||
|
||
void CPythonNetworkStream::__LeaveGamePhase()
|
||
{
|
||
CInstanceBase::ClearPVPKeySystem();
|
||
|
||
__ClearNetworkActorManager();
|
||
|
||
m_bComboSkillFlag = FALSE;
|
||
|
||
IAbstractCharacterManager& rkChrMgr=IAbstractCharacterManager::GetSingleton();
|
||
rkChrMgr.Destroy();
|
||
|
||
CPythonItem& rkItemMgr=CPythonItem::Instance();
|
||
rkItemMgr.Destroy();
|
||
}
|
||
|
||
void CPythonNetworkStream::SetGamePhase()
|
||
{
|
||
if ("Game"!=m_strPhase)
|
||
m_phaseLeaveFunc.Run();
|
||
|
||
Tracen("");
|
||
Tracen("## Network - Game Phase ##");
|
||
Tracen("");
|
||
|
||
m_strPhase = "Game";
|
||
|
||
m_dwChangingPhaseTime = ELTimer_GetMSec();
|
||
m_phaseProcessFunc.Set(this, &CPythonNetworkStream::GamePhase);
|
||
m_phaseLeaveFunc.Set(this, &CPythonNetworkStream::__LeaveGamePhase);
|
||
|
||
// Main Character <20><><EFBFBD><EFBFBD>O
|
||
|
||
IAbstractPlayer & rkPlayer = IAbstractPlayer::GetSingleton();
|
||
rkPlayer.SetMainCharacterIndex(GetMainActorVID());
|
||
|
||
__RefreshStatus();
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvObserverAddPacket()
|
||
{
|
||
TPacketGCObserverAdd kObserverAddPacket;
|
||
if (!Recv(sizeof(kObserverAddPacket), &kObserverAddPacket))
|
||
return false;
|
||
|
||
CPythonMiniMap::Instance().AddObserver(
|
||
kObserverAddPacket.vid,
|
||
kObserverAddPacket.x*100.0f,
|
||
kObserverAddPacket.y*100.0f);
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvObserverRemovePacket()
|
||
{
|
||
TPacketGCObserverAdd kObserverRemovePacket;
|
||
if (!Recv(sizeof(kObserverRemovePacket), &kObserverRemovePacket))
|
||
return false;
|
||
|
||
CPythonMiniMap::Instance().RemoveObserver(
|
||
kObserverRemovePacket.vid
|
||
);
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvObserverMovePacket()
|
||
{
|
||
TPacketGCObserverMove kObserverMovePacket;
|
||
if (!Recv(sizeof(kObserverMovePacket), &kObserverMovePacket))
|
||
return false;
|
||
|
||
CPythonMiniMap::Instance().MoveObserver(
|
||
kObserverMovePacket.vid,
|
||
kObserverMovePacket.x*100.0f,
|
||
kObserverMovePacket.y*100.0f);
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
bool CPythonNetworkStream::RecvWarpPacket()
|
||
{
|
||
TPacketGCWarp kWarpPacket;
|
||
|
||
if (!Recv(sizeof(kWarpPacket), &kWarpPacket))
|
||
return false;
|
||
|
||
__DirectEnterMode_Set(m_dwSelectedCharacterIndex);
|
||
|
||
CNetworkStream::Connect((DWORD)kWarpPacket.lAddr, kWarpPacket.wPort);
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvDuelStartPacket()
|
||
{
|
||
TPacketGCDuelStart kDuelStartPacket;
|
||
if (!Recv(sizeof(kDuelStartPacket), &kDuelStartPacket))
|
||
return false;
|
||
|
||
DWORD count = (kDuelStartPacket.wSize - sizeof(kDuelStartPacket))/sizeof(DWORD);
|
||
|
||
CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
|
||
|
||
CInstanceBase* pkInstMain=rkChrMgr.GetMainInstancePtr();
|
||
if (!pkInstMain)
|
||
{
|
||
TraceError("CPythonNetworkStream::RecvDuelStartPacket - MainCharacter is NULL");
|
||
return false;
|
||
}
|
||
DWORD dwVIDSrc = pkInstMain->GetVirtualID();
|
||
DWORD dwVIDDest;
|
||
|
||
for ( DWORD i = 0; i < count; i++)
|
||
{
|
||
Recv(sizeof(dwVIDDest),&dwVIDDest);
|
||
CInstanceBase::InsertDUELKey(dwVIDSrc,dwVIDDest);
|
||
}
|
||
|
||
if(count == 0)
|
||
pkInstMain->SetDuelMode(CInstanceBase::DUEL_CANNOTATTACK);
|
||
else
|
||
pkInstMain->SetDuelMode(CInstanceBase::DUEL_START);
|
||
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "CloseTargetBoard", Py_BuildValue("()"));
|
||
|
||
rkChrMgr.RefreshAllPCTextTail();
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvPVPPacket()
|
||
{
|
||
TPacketGCPVP kPVPPacket;
|
||
if (!Recv(sizeof(kPVPPacket), &kPVPPacket))
|
||
return false;
|
||
|
||
CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
|
||
CPythonPlayer & rkPlayer = CPythonPlayer::Instance();
|
||
|
||
switch (kPVPPacket.bMode)
|
||
{
|
||
case PVP_MODE_AGREE:
|
||
rkChrMgr.RemovePVPKey(kPVPPacket.dwVIDSrc, kPVPPacket.dwVIDDst);
|
||
|
||
// <20><><EFBFBD>밡 <20><>(Dst)<29><><EFBFBD><EFBFBD> <20><><EFBFBD>Ǹ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
if (rkPlayer.IsMainCharacterIndex(kPVPPacket.dwVIDDst))
|
||
rkPlayer.RememberChallengeInstance(kPVPPacket.dwVIDSrc);
|
||
|
||
// <20><><EFBFBD>뿡<EFBFBD><EBBFA1> <20><><EFBFBD>Ǹ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>ȿ<EFBFBD><C8BF><EFBFBD> <20><><EFBFBD><EFBFBD> <20>Ҵ<EFBFBD>
|
||
if (rkPlayer.IsMainCharacterIndex(kPVPPacket.dwVIDSrc))
|
||
rkPlayer.RememberCantFightInstance(kPVPPacket.dwVIDDst);
|
||
break;
|
||
case PVP_MODE_REVENGE:
|
||
{
|
||
rkChrMgr.RemovePVPKey(kPVPPacket.dwVIDSrc, kPVPPacket.dwVIDDst);
|
||
|
||
DWORD dwKiller = kPVPPacket.dwVIDSrc;
|
||
DWORD dwVictim = kPVPPacket.dwVIDDst;
|
||
|
||
// <20><>(victim)<29><> <20><><EFBFBD>뿡<EFBFBD><EBBFA1> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
if (rkPlayer.IsMainCharacterIndex(dwVictim))
|
||
rkPlayer.RememberRevengeInstance(dwKiller);
|
||
|
||
// <20><><EFBFBD><EFBFBD>(victim)<29><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD> <20><><EFBFBD>ȿ<EFBFBD><C8BF><EFBFBD> <20><><EFBFBD><EFBFBD> <20>Ҵ<EFBFBD>
|
||
if (rkPlayer.IsMainCharacterIndex(dwKiller))
|
||
rkPlayer.RememberCantFightInstance(dwVictim);
|
||
break;
|
||
}
|
||
|
||
case PVP_MODE_FIGHT:
|
||
rkChrMgr.InsertPVPKey(kPVPPacket.dwVIDSrc, kPVPPacket.dwVIDDst);
|
||
rkPlayer.ForgetInstance(kPVPPacket.dwVIDSrc);
|
||
rkPlayer.ForgetInstance(kPVPPacket.dwVIDDst);
|
||
break;
|
||
case PVP_MODE_NONE:
|
||
rkChrMgr.RemovePVPKey(kPVPPacket.dwVIDSrc, kPVPPacket.dwVIDDst);
|
||
rkPlayer.ForgetInstance(kPVPPacket.dwVIDSrc);
|
||
rkPlayer.ForgetInstance(kPVPPacket.dwVIDDst);
|
||
break;
|
||
}
|
||
|
||
// NOTE : PVP <20><><EFBFBD>۽<EFBFBD> TargetBoard <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20>մϴ<D5B4>.
|
||
__RefreshTargetBoardByVID(kPVPPacket.dwVIDSrc);
|
||
__RefreshTargetBoardByVID(kPVPPacket.dwVIDDst);
|
||
|
||
return true;
|
||
}
|
||
|
||
// DELETEME
|
||
/*
|
||
void CPythonNetworkStream::__SendWarpPacket()
|
||
{
|
||
TPacketCGWarp kWarpPacket;
|
||
kWarpPacket.bHeader=HEADER_GC_WARP;
|
||
if (!Send(sizeof(kWarpPacket), &kWarpPacket))
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
*/
|
||
void CPythonNetworkStream::NotifyHack(const char* c_szMsg)
|
||
{
|
||
if (!m_kQue_stHack.empty())
|
||
if (c_szMsg==m_kQue_stHack.back())
|
||
return;
|
||
|
||
m_kQue_stHack.push_back(c_szMsg);
|
||
}
|
||
|
||
bool CPythonNetworkStream::__SendHack(const char* c_szMsg)
|
||
{
|
||
Tracen(c_szMsg);
|
||
|
||
TPacketCGHack kPacketHack;
|
||
kPacketHack.bHeader=HEADER_CG_HACK;
|
||
strncpy(kPacketHack.szBuf, c_szMsg, sizeof(kPacketHack.szBuf)-1);
|
||
|
||
if (!Send(sizeof(kPacketHack), &kPacketHack))
|
||
return false;
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendMessengerAddByVIDPacket(DWORD vid)
|
||
{
|
||
TPacketCGMessenger packet;
|
||
packet.header = HEADER_CG_MESSENGER;
|
||
packet.subheader = MESSENGER_SUBHEADER_CG_ADD_BY_VID;
|
||
if (!Send(sizeof(packet), &packet))
|
||
return false;
|
||
if (!Send(sizeof(vid), &vid))
|
||
return false;
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendMessengerAddByNamePacket(const char * c_szName)
|
||
{
|
||
TPacketCGMessenger packet;
|
||
packet.header = HEADER_CG_MESSENGER;
|
||
packet.subheader = MESSENGER_SUBHEADER_CG_ADD_BY_NAME;
|
||
if (!Send(sizeof(packet), &packet))
|
||
return false;
|
||
char szName[CHARACTER_NAME_MAX_LEN];
|
||
strncpy(szName, c_szName, CHARACTER_NAME_MAX_LEN-1);
|
||
szName[CHARACTER_NAME_MAX_LEN-1] = '\0'; // #720: <20><EFBFBD><DEBD><EFBFBD> <20≯<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>÷ο<C3B7> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
|
||
|
||
if (!Send(sizeof(szName), &szName))
|
||
return false;
|
||
Tracef(" SendMessengerAddByNamePacket : %s\n", c_szName);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendMessengerRemovePacket(const char * c_szKey, const char * c_szName)
|
||
{
|
||
TPacketCGMessenger packet;
|
||
packet.header = HEADER_CG_MESSENGER;
|
||
packet.subheader = MESSENGER_SUBHEADER_CG_REMOVE;
|
||
if (!Send(sizeof(packet), &packet))
|
||
return false;
|
||
char szKey[CHARACTER_NAME_MAX_LEN];
|
||
strncpy(szKey, c_szKey, CHARACTER_NAME_MAX_LEN-1);
|
||
if (!Send(sizeof(szKey), &szKey))
|
||
return false;
|
||
__RefreshTargetBoardByName(c_szName);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendCharacterStatePacket(const TPixelPosition& c_rkPPosDst, float fDstRot, UINT eFunc, UINT uArg)
|
||
{
|
||
NANOBEGIN
|
||
if (!__CanActMainInstance())
|
||
return true;
|
||
|
||
if (fDstRot < 0.0f)
|
||
fDstRot = 360 + fDstRot;
|
||
else if (fDstRot > 360.0f)
|
||
fDstRot = fmodf(fDstRot, 360.0f);
|
||
|
||
// TODO: <20><><EFBFBD>߿<EFBFBD> <20><>Ŷ<EFBFBD≯<EFBFBD><CCB8><EFBFBD> <20>ٲ<EFBFBD><D9B2><EFBFBD>
|
||
TPacketCGMove kStatePacket;
|
||
kStatePacket.bHeader = HEADER_CG_CHARACTER_MOVE;
|
||
kStatePacket.bFunc = eFunc;
|
||
kStatePacket.bArg = uArg;
|
||
kStatePacket.bRot = fDstRot/5.0f;
|
||
kStatePacket.lX = long(c_rkPPosDst.x);
|
||
kStatePacket.lY = long(c_rkPPosDst.y);
|
||
kStatePacket.dwTime = ELTimer_GetServerMSec();
|
||
|
||
assert(kStatePacket.lX >= 0 && kStatePacket.lX < 204800);
|
||
|
||
__LocalPositionToGlobalPosition(kStatePacket.lX, kStatePacket.lY);
|
||
|
||
if (!Send(sizeof(kStatePacket), &kStatePacket))
|
||
{
|
||
Tracenf("CPythonNetworkStream::SendCharacterStatePacket(dwCmdTime=%u, fDstPos=(%f, %f), fDstRot=%f, eFunc=%d uArg=%d) - PACKET SEND ERROR",
|
||
kStatePacket.dwTime,
|
||
float(kStatePacket.lX),
|
||
float(kStatePacket.lY),
|
||
fDstRot,
|
||
kStatePacket.bFunc,
|
||
kStatePacket.bArg);
|
||
return false;
|
||
}
|
||
NANOEND
|
||
return SendSequence();
|
||
}
|
||
|
||
// NOTE : SlotIndex<65><78> <20>ӽ<EFBFBD>
|
||
bool CPythonNetworkStream::SendUseSkillPacket(DWORD dwSkillIndex, DWORD dwTargetVID)
|
||
{
|
||
TPacketCGUseSkill UseSkillPacket;
|
||
UseSkillPacket.bHeader = HEADER_CG_USE_SKILL;
|
||
UseSkillPacket.dwVnum = dwSkillIndex;
|
||
UseSkillPacket.dwTargetVID = dwTargetVID;
|
||
if (!Send(sizeof(TPacketCGUseSkill), &UseSkillPacket))
|
||
{
|
||
Tracen("CPythonNetworkStream::SendUseSkillPacket - SEND PACKET ERROR");
|
||
return false;
|
||
}
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendChatPacket(const char * c_szChat, BYTE byType)
|
||
{
|
||
if (strlen(c_szChat) == 0)
|
||
return true;
|
||
|
||
if (strlen(c_szChat) >= 512)
|
||
return true;
|
||
|
||
if (c_szChat[0] == '/')
|
||
{
|
||
if (1 == strlen(c_szChat))
|
||
{
|
||
if (!m_strLastCommand.empty())
|
||
c_szChat = m_strLastCommand.c_str();
|
||
}
|
||
else
|
||
{
|
||
m_strLastCommand = c_szChat;
|
||
}
|
||
}
|
||
|
||
if (ClientCommand(c_szChat))
|
||
return true;
|
||
|
||
int iTextLen = strlen(c_szChat) + 1;
|
||
TPacketCGChat ChatPacket;
|
||
ChatPacket.header = HEADER_CG_CHAT;
|
||
ChatPacket.length = sizeof(ChatPacket) + iTextLen;
|
||
ChatPacket.type = byType;
|
||
|
||
if (!Send(sizeof(ChatPacket), &ChatPacket))
|
||
return false;
|
||
|
||
if (!Send(iTextLen, c_szChat))
|
||
return false;
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////
|
||
// Emoticon
|
||
void CPythonNetworkStream::RegisterEmoticonString(const char * pcEmoticonString)
|
||
{
|
||
if (m_EmoticonStringVector.size() >= CInstanceBase::EMOTICON_NUM)
|
||
{
|
||
TraceError("Can't register emoticon string... vector is full (size:%d)", m_EmoticonStringVector.size() );
|
||
return;
|
||
}
|
||
m_EmoticonStringVector.push_back(pcEmoticonString);
|
||
}
|
||
|
||
bool CPythonNetworkStream::ParseEmoticon(const char * pChatMsg, DWORD * pdwEmoticon)
|
||
{
|
||
for (DWORD dwEmoticonIndex = 0; dwEmoticonIndex < m_EmoticonStringVector.size() ; ++dwEmoticonIndex)
|
||
{
|
||
if (strlen(pChatMsg) > m_EmoticonStringVector[dwEmoticonIndex].size())
|
||
continue;
|
||
|
||
const char * pcFind = strstr(pChatMsg, m_EmoticonStringVector[dwEmoticonIndex].c_str());
|
||
|
||
if (pcFind != pChatMsg)
|
||
continue;
|
||
|
||
*pdwEmoticon = dwEmoticonIndex;
|
||
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
// Emoticon
|
||
//////////////////////////////////////////////////////////////////////////
|
||
|
||
void CPythonNetworkStream::__ConvertEmpireText(DWORD dwEmpireID, char* szText)
|
||
{
|
||
if (dwEmpireID<1 || dwEmpireID>3)
|
||
return;
|
||
|
||
UINT uHanPos;
|
||
|
||
STextConvertTable& rkTextConvTable=m_aTextConvTable[dwEmpireID-1];
|
||
|
||
BYTE* pbText=(BYTE*)szText;
|
||
while (*pbText)
|
||
{
|
||
if (*pbText & 0x80)
|
||
{
|
||
if (pbText[0]>=0xb0 && pbText[0]<=0xc8 && pbText[1]>=0xa1 && pbText[1]<=0xfe)
|
||
{
|
||
uHanPos=(pbText[0]-0xb0)*(0xfe-0xa1+1)+(pbText[1]-0xa1);
|
||
pbText[0]=rkTextConvTable.aacHan[uHanPos][0];
|
||
pbText[1]=rkTextConvTable.aacHan[uHanPos][1];
|
||
}
|
||
pbText+=2;
|
||
}
|
||
else
|
||
{
|
||
if (*pbText>='a' && *pbText<='z')
|
||
{
|
||
*pbText=rkTextConvTable.acLower[*pbText-'a'];
|
||
}
|
||
else if (*pbText>='A' && *pbText<='Z')
|
||
{
|
||
*pbText=rkTextConvTable.acUpper[*pbText-'A'];
|
||
}
|
||
pbText++;
|
||
}
|
||
}
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvChatPacket()
|
||
{
|
||
TPacketGCChat kChat;
|
||
char buf[1024 + 1];
|
||
char line[1024 + 1];
|
||
|
||
if (!Recv(sizeof(kChat), &kChat))
|
||
return false;
|
||
|
||
UINT uChatSize=kChat.size - sizeof(kChat);
|
||
|
||
if (!Recv(uChatSize, buf))
|
||
return false;
|
||
|
||
buf[uChatSize]='\0';
|
||
|
||
// <20><><EFBFBD><EFBFBD> <20>ƶ<EFBFBD> <20><><EFBFBD><EFBFBD> ó<><C3B3>
|
||
// "<22≯<EFBFBD>: <20><><EFBFBD><EFBFBD>" <20>Է<EFBFBD><D4B7><EFBFBD> "<22><><EFBFBD><EFBFBD>: <20≯<EFBFBD>" <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϱ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><>(0x08)<29><> <20><><EFBFBD><EFBFBD>
|
||
// <20><><EFBFBD><EFBFBD> <20>ƶ<EFBFBD><C6B6><EFBFBD> <20><>ȣ<EFBFBD><C8A3> ó<><C3B3><EFBFBD><EFBFBD> (<28><><EFBFBD><EFBFBD>1) : (<28><><EFBFBD><EFBFBD>2) <20><> <20>ԷµǾ (<28><><EFBFBD><EFBFBD>2) : (<28><><EFBFBD><EFBFBD>1) <20><> <20><><EFBFBD><EFBFBD><EFBFBD>ϰ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
if (LocaleService_IsEUROPE() && GetDefaultCodePage() == 1256)
|
||
{
|
||
char * p = strchr(buf, ':');
|
||
if (p && p[1] == ' ')
|
||
p[1] = 0x08;
|
||
}
|
||
|
||
if (kChat.type >= CHAT_TYPE_MAX_NUM)
|
||
return true;
|
||
|
||
if (CHAT_TYPE_COMMAND == kChat.type)
|
||
{
|
||
ServerCommand(buf);
|
||
return true;
|
||
}
|
||
|
||
if (kChat.dwVID != 0)
|
||
{
|
||
CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
|
||
CInstanceBase * pkInstChatter = rkChrMgr.GetInstancePtr(kChat.dwVID);
|
||
if (NULL == pkInstChatter)
|
||
return true;
|
||
|
||
switch (kChat.type)
|
||
{
|
||
case CHAT_TYPE_TALKING: /* <20>׳<EFBFBD> ä<><C3A4> */
|
||
case CHAT_TYPE_PARTY: /* <20><>Ƽ<EFBFBD><C6BC> */
|
||
case CHAT_TYPE_GUILD: /* <20><><EFBFBD>帻 */
|
||
case CHAT_TYPE_SHOUT: /* <20><>ġ<EFBFBD><C4A1> */
|
||
case CHAT_TYPE_WHISPER: // <20><><EFBFBD><EFBFBD><EFBFBD>ʹ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ʴ<EFBFBD> Only Client Enum
|
||
{
|
||
char * p = strchr(buf, ':');
|
||
|
||
if (p)
|
||
p += 2;
|
||
else
|
||
p = buf;
|
||
|
||
DWORD dwEmoticon;
|
||
|
||
if (ParseEmoticon(p, &dwEmoticon))
|
||
{
|
||
pkInstChatter->SetEmoticon(dwEmoticon);
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
if (gs_bEmpireLanuageEnable)
|
||
{
|
||
CInstanceBase* pkInstMain=rkChrMgr.GetMainInstancePtr();
|
||
if (pkInstMain)
|
||
if (!pkInstMain->IsSameEmpire(*pkInstChatter))
|
||
__ConvertEmpireText(pkInstChatter->GetEmpireID(), p);
|
||
}
|
||
|
||
if (m_isEnableChatInsultFilter)
|
||
{
|
||
if (false == pkInstChatter->IsNPC() && false == pkInstChatter->IsEnemy())
|
||
{
|
||
__FilterInsult(p, strlen(p));
|
||
}
|
||
}
|
||
|
||
_snprintf(line, sizeof(line), "%s", p);
|
||
}
|
||
}
|
||
break;
|
||
case CHAT_TYPE_COMMAND: /* <20><><EFBFBD><EFBFBD> */
|
||
case CHAT_TYPE_INFO: /* <20><><EFBFBD><EFBFBD> (<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD>ġ<EFBFBD><C4A1> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>. <20><>) */
|
||
case CHAT_TYPE_NOTICE: /* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
|
||
case CHAT_TYPE_BIG_NOTICE:
|
||
case CHAT_TYPE_MAX_NUM:
|
||
default:
|
||
_snprintf(line, sizeof(line), "%s", buf);
|
||
break;
|
||
}
|
||
|
||
if (CHAT_TYPE_SHOUT != kChat.type)
|
||
{
|
||
CPythonTextTail::Instance().RegisterChatTail(kChat.dwVID, line);
|
||
}
|
||
|
||
if (pkInstChatter->IsPC())
|
||
CPythonChat::Instance().AppendChat(kChat.type, buf);
|
||
}
|
||
else
|
||
{
|
||
if (CHAT_TYPE_NOTICE == kChat.type)
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_SetTipMessage", Py_BuildValue("(s)", buf));
|
||
}
|
||
else if (CHAT_TYPE_BIG_NOTICE == kChat.type)
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_SetBigMessage", Py_BuildValue("(s)", buf));
|
||
}
|
||
else if (CHAT_TYPE_SHOUT == kChat.type)
|
||
{
|
||
char * p = strchr(buf, ':');
|
||
|
||
if (p)
|
||
{
|
||
if (m_isEnableChatInsultFilter)
|
||
__FilterInsult(p, strlen(p));
|
||
}
|
||
}
|
||
|
||
CPythonChat::Instance().AppendChat(kChat.type, buf);
|
||
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvWhisperPacket()
|
||
{
|
||
TPacketGCWhisper whisperPacket;
|
||
char buf[512 + 1];
|
||
|
||
if (!Recv(sizeof(whisperPacket), &whisperPacket))
|
||
return false;
|
||
|
||
assert(whisperPacket.wSize - sizeof(whisperPacket) < 512);
|
||
|
||
if (!Recv(whisperPacket.wSize - sizeof(whisperPacket), &buf))
|
||
return false;
|
||
|
||
buf[whisperPacket.wSize - sizeof(whisperPacket)] = '\0';
|
||
|
||
static char line[256];
|
||
if (CPythonChat::WHISPER_TYPE_CHAT == whisperPacket.bType || CPythonChat::WHISPER_TYPE_GM == whisperPacket.bType)
|
||
{
|
||
_snprintf(line, sizeof(line), "%s : %s", whisperPacket.szNameFrom, buf);
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnRecvWhisper", Py_BuildValue("(iss)", (int) whisperPacket.bType, whisperPacket.szNameFrom, line));
|
||
}
|
||
else if (CPythonChat::WHISPER_TYPE_SYSTEM == whisperPacket.bType || CPythonChat::WHISPER_TYPE_ERROR == whisperPacket.bType)
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnRecvWhisperSystemMessage", Py_BuildValue("(iss)", (int) whisperPacket.bType, whisperPacket.szNameFrom, buf));
|
||
}
|
||
else
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnRecvWhisperError", Py_BuildValue("(iss)", (int) whisperPacket.bType, whisperPacket.szNameFrom, buf));
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendWhisperPacket(const char * name, const char * c_szChat)
|
||
{
|
||
if (strlen(c_szChat) >= 255)
|
||
return true;
|
||
|
||
int iTextLen = strlen(c_szChat) + 1;
|
||
TPacketCGWhisper WhisperPacket;
|
||
WhisperPacket.bHeader = HEADER_CG_WHISPER;
|
||
WhisperPacket.wSize = sizeof(WhisperPacket) + iTextLen;
|
||
|
||
strncpy(WhisperPacket.szNameTo, name, sizeof(WhisperPacket.szNameTo) - 1);
|
||
|
||
if (!Send(sizeof(WhisperPacket), &WhisperPacket))
|
||
return false;
|
||
|
||
if (!Send(iTextLen, c_szChat))
|
||
return false;
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendMobileMessagePacket(const char * name, const char * c_szChat)
|
||
{
|
||
int iTextLen = strlen(c_szChat) + 1;
|
||
TPacketCGSMS SMSPacket;
|
||
SMSPacket.bHeader = HEADER_CG_SMS;
|
||
SMSPacket.wSize = sizeof(SMSPacket) + iTextLen;
|
||
|
||
strncpy(SMSPacket.szNameTo, name, sizeof(SMSPacket.szNameTo) - 1);
|
||
|
||
if (!Send(sizeof(SMSPacket), &SMSPacket))
|
||
return false;
|
||
|
||
if (!Send(iTextLen, c_szChat))
|
||
return false;
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvPointChange()
|
||
{
|
||
TPacketGCPointChange PointChange;
|
||
|
||
if (!Recv(sizeof(TPacketGCPointChange), &PointChange))
|
||
{
|
||
Tracen("Recv Point Change Packet Error");
|
||
return false;
|
||
}
|
||
|
||
CPythonCharacterManager& rkChrMgr = CPythonCharacterManager::Instance();
|
||
rkChrMgr.ShowPointEffect(PointChange.Type, PointChange.dwVID);
|
||
|
||
CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetMainInstancePtr();
|
||
|
||
// <20>ڽ<EFBFBD><DABD><EFBFBD> Point<6E><74> <20><><EFBFBD><EFBFBD><EFBFBD>Ǿ<EFBFBD><C7BE><EFBFBD> <20><><EFBFBD><EFBFBD>..
|
||
if (pInstance)
|
||
if (PointChange.dwVID == pInstance->GetVirtualID())
|
||
{
|
||
CPythonPlayer & rkPlayer = CPythonPlayer::Instance();
|
||
rkPlayer.SetStatus(PointChange.Type, PointChange.value);
|
||
|
||
switch (PointChange.Type)
|
||
{
|
||
case POINT_STAT_RESET_COUNT:
|
||
__RefreshStatus();
|
||
break;
|
||
case POINT_LEVEL:
|
||
case POINT_ST:
|
||
case POINT_DX:
|
||
case POINT_HT:
|
||
case POINT_IQ:
|
||
__RefreshStatus();
|
||
__RefreshSkillWindow();
|
||
break;
|
||
case POINT_SKILL:
|
||
case POINT_SUB_SKILL:
|
||
case POINT_HORSE_SKILL:
|
||
__RefreshSkillWindow();
|
||
break;
|
||
case POINT_ENERGY:
|
||
if (PointChange.value == 0)
|
||
{
|
||
rkPlayer.SetStatus(POINT_ENERGY_END_TIME, 0);
|
||
}
|
||
__RefreshStatus();
|
||
break;
|
||
default:
|
||
__RefreshStatus();
|
||
break;
|
||
}
|
||
|
||
if (POINT_GOLD == PointChange.Type)
|
||
{
|
||
if (PointChange.amount > 0)
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnPickMoney", Py_BuildValue("(i)", PointChange.amount));
|
||
}
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvStunPacket()
|
||
{
|
||
TPacketGCStun StunPacket;
|
||
|
||
if (!Recv(sizeof(StunPacket), &StunPacket))
|
||
{
|
||
Tracen("CPythonNetworkStream::RecvStunPacket Error");
|
||
return false;
|
||
}
|
||
|
||
//Tracef("RecvStunPacket %d\n", StunPacket.vid);
|
||
|
||
CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
|
||
CInstanceBase * pkInstSel = rkChrMgr.GetInstancePtr(StunPacket.vid);
|
||
|
||
if (pkInstSel)
|
||
{
|
||
if (CPythonCharacterManager::Instance().GetMainInstancePtr()==pkInstSel)
|
||
pkInstSel->Die();
|
||
else
|
||
pkInstSel->Stun();
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvDeadPacket()
|
||
{
|
||
TPacketGCDead DeadPacket;
|
||
if (!Recv(sizeof(DeadPacket), &DeadPacket))
|
||
{
|
||
Tracen("CPythonNetworkStream::RecvDeadPacket Error");
|
||
return false;
|
||
}
|
||
|
||
CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
|
||
CInstanceBase * pkChrInstSel = rkChrMgr.GetInstancePtr(DeadPacket.vid);
|
||
if (pkChrInstSel)
|
||
{
|
||
CInstanceBase* pkInstMain=rkChrMgr.GetMainInstancePtr();
|
||
if (pkInstMain==pkChrInstSel)
|
||
{
|
||
Tracenf("<EFBFBD><EFBFBD><EFBFBD>ΰ<EFBFBD> <20><><EFBFBD><EFBFBD>");
|
||
if (false == pkInstMain->GetDuelMode())
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnGameOver", Py_BuildValue("()"));
|
||
}
|
||
CPythonPlayer::Instance().NotifyDeadMainCharacter();
|
||
}
|
||
|
||
pkChrInstSel->Die();
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendCharacterPositionPacket(BYTE iPosition)
|
||
{
|
||
TPacketCGPosition PositionPacket;
|
||
|
||
PositionPacket.header = HEADER_CG_CHARACTER_POSITION;
|
||
PositionPacket.position = iPosition;
|
||
|
||
if (!Send(sizeof(TPacketCGPosition), &PositionPacket))
|
||
{
|
||
Tracen("Send Character Position Packet Error");
|
||
return false;
|
||
}
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendOnClickPacket(DWORD vid)
|
||
{
|
||
TPacketCGOnClick OnClickPacket;
|
||
OnClickPacket.header = HEADER_CG_ON_CLICK;
|
||
OnClickPacket.vid = vid;
|
||
|
||
if (!Send(sizeof(OnClickPacket), &OnClickPacket))
|
||
{
|
||
Tracen("Send On_Click Packet Error");
|
||
return false;
|
||
}
|
||
|
||
Tracef("SendOnClickPacket\n");
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvCharacterPositionPacket()
|
||
{
|
||
TPacketGCPosition PositionPacket;
|
||
|
||
if (!Recv(sizeof(TPacketGCPosition), &PositionPacket))
|
||
return false;
|
||
|
||
CInstanceBase * pChrInstance = CPythonCharacterManager::Instance().GetInstancePtr(PositionPacket.vid);
|
||
|
||
if (!pChrInstance)
|
||
return true;
|
||
|
||
//pChrInstance->UpdatePosition(PositionPacket.position);
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvMotionPacket()
|
||
{
|
||
TPacketGCMotion MotionPacket;
|
||
|
||
if (!Recv(sizeof(TPacketGCMotion), &MotionPacket))
|
||
return false;
|
||
|
||
CInstanceBase * pMainInstance = CPythonCharacterManager::Instance().GetInstancePtr(MotionPacket.vid);
|
||
CInstanceBase * pVictimInstance = NULL;
|
||
|
||
if (0 != MotionPacket.victim_vid)
|
||
pVictimInstance = CPythonCharacterManager::Instance().GetInstancePtr(MotionPacket.victim_vid);
|
||
|
||
if (!pMainInstance)
|
||
return false;
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvShopPacket()
|
||
{
|
||
std::vector<char> vecBuffer;
|
||
vecBuffer.clear();
|
||
|
||
TPacketGCShop packet_shop;
|
||
if (!Recv(sizeof(packet_shop), &packet_shop))
|
||
return false;
|
||
|
||
int iSize = packet_shop.size - sizeof(packet_shop);
|
||
if (iSize > 0)
|
||
{
|
||
vecBuffer.resize(iSize);
|
||
if (!Recv(iSize, &vecBuffer[0]))
|
||
return false;
|
||
}
|
||
|
||
switch (packet_shop.subheader)
|
||
{
|
||
case SHOP_SUBHEADER_GC_START:
|
||
{
|
||
CPythonShop::Instance().Clear();
|
||
|
||
DWORD dwVID = *(DWORD *)&vecBuffer[0];
|
||
|
||
TPacketGCShopStart * pShopStartPacket = (TPacketGCShopStart *)&vecBuffer[4];
|
||
for (BYTE iItemIndex = 0; iItemIndex < SHOP_HOST_ITEM_MAX_NUM; ++iItemIndex)
|
||
{
|
||
CPythonShop::Instance().SetItemData(iItemIndex, pShopStartPacket->items[iItemIndex]);
|
||
}
|
||
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartShop", Py_BuildValue("(i)", dwVID));
|
||
}
|
||
break;
|
||
|
||
case SHOP_SUBHEADER_GC_START_EX:
|
||
{
|
||
CPythonShop::Instance().Clear();
|
||
|
||
TPacketGCShopStartEx * pShopStartPacket = (TPacketGCShopStartEx *)&vecBuffer[0];
|
||
size_t read_point = sizeof(TPacketGCShopStartEx);
|
||
|
||
DWORD dwVID = pShopStartPacket->owner_vid;
|
||
BYTE shop_tab_count = pShopStartPacket->shop_tab_count;
|
||
|
||
CPythonShop::instance().SetTabCount(shop_tab_count);
|
||
|
||
for (size_t i = 0; i < shop_tab_count; i++)
|
||
{
|
||
TPacketGCShopStartEx::TSubPacketShopTab* pPackTab = (TPacketGCShopStartEx::TSubPacketShopTab*)&vecBuffer[read_point];
|
||
read_point += sizeof(TPacketGCShopStartEx::TSubPacketShopTab);
|
||
|
||
CPythonShop::instance().SetTabCoinType(i, pPackTab->coin_type);
|
||
CPythonShop::instance().SetTabName(i, pPackTab->name);
|
||
|
||
struct packet_shop_item* item = &pPackTab->items[0];
|
||
|
||
for (BYTE j = 0; j < SHOP_HOST_ITEM_MAX_NUM; j++)
|
||
{
|
||
TShopItemData* itemData = (item + j);
|
||
CPythonShop::Instance().SetItemData(i, j, *itemData);
|
||
}
|
||
}
|
||
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartShop", Py_BuildValue("(i)", dwVID));
|
||
}
|
||
break;
|
||
|
||
|
||
case SHOP_SUBHEADER_GC_END:
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "EndShop", Py_BuildValue("()"));
|
||
break;
|
||
|
||
case SHOP_SUBHEADER_GC_UPDATE_ITEM:
|
||
{
|
||
TPacketGCShopUpdateItem * pShopUpdateItemPacket = (TPacketGCShopUpdateItem *)&vecBuffer[0];
|
||
CPythonShop::Instance().SetItemData(pShopUpdateItemPacket->pos, pShopUpdateItemPacket->item);
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshShop", Py_BuildValue("()"));
|
||
}
|
||
break;
|
||
|
||
case SHOP_SUBHEADER_GC_UPDATE_PRICE:
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetShopSellingPrice", Py_BuildValue("(i)", *(int *)&vecBuffer[0]));
|
||
break;
|
||
|
||
case SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY:
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "NOT_ENOUGH_MONEY"));
|
||
break;
|
||
|
||
case SHOP_SUBHEADER_GC_NOT_ENOUGH_MONEY_EX:
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "NOT_ENOUGH_MONEY_EX"));
|
||
break;
|
||
|
||
case SHOP_SUBHEADER_GC_SOLDOUT:
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "SOLDOUT"));
|
||
break;
|
||
|
||
case SHOP_SUBHEADER_GC_INVENTORY_FULL:
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "INVENTORY_FULL"));
|
||
break;
|
||
|
||
case SHOP_SUBHEADER_GC_INVALID_POS:
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "INVALID_POS"));
|
||
break;
|
||
|
||
default:
|
||
TraceError("CPythonNetworkStream::RecvShopPacket: Unknown subheader\n");
|
||
break;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvExchangePacket()
|
||
{
|
||
TPacketGCExchange exchange_packet;
|
||
|
||
if (!Recv(sizeof(exchange_packet), &exchange_packet))
|
||
return false;
|
||
|
||
switch (exchange_packet.subheader)
|
||
{
|
||
case EXCHANGE_SUBHEADER_GC_START:
|
||
CPythonExchange::Instance().Clear();
|
||
CPythonExchange::Instance().Start();
|
||
CPythonExchange::Instance().SetSelfName(CPythonPlayer::Instance().GetName());
|
||
|
||
{
|
||
CInstanceBase * pCharacterInstance = CPythonCharacterManager::Instance().GetInstancePtr(exchange_packet.arg1);
|
||
|
||
if (pCharacterInstance)
|
||
CPythonExchange::Instance().SetTargetName(pCharacterInstance->GetNameString());
|
||
}
|
||
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartExchange", Py_BuildValue("()"));
|
||
break;
|
||
|
||
case EXCHANGE_SUBHEADER_GC_ITEM_ADD:
|
||
if (exchange_packet.is_me)
|
||
{
|
||
int iSlotIndex = exchange_packet.arg2.cell;
|
||
CPythonExchange::Instance().SetItemToSelf(iSlotIndex, exchange_packet.arg1, (BYTE) exchange_packet.arg3);
|
||
for (int i = 0; i < ITEM_SOCKET_SLOT_MAX_NUM; ++i)
|
||
CPythonExchange::Instance().SetItemMetinSocketToSelf(iSlotIndex, i, exchange_packet.alValues[i]);
|
||
for (int j = 0; j < ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++j)
|
||
CPythonExchange::Instance().SetItemAttributeToSelf(iSlotIndex, j, exchange_packet.aAttr[j].bType, exchange_packet.aAttr[j].sValue);
|
||
}
|
||
else
|
||
{
|
||
int iSlotIndex = exchange_packet.arg2.cell;
|
||
CPythonExchange::Instance().SetItemToTarget(iSlotIndex, exchange_packet.arg1, (BYTE) exchange_packet.arg3);
|
||
for (int i = 0; i < ITEM_SOCKET_SLOT_MAX_NUM; ++i)
|
||
CPythonExchange::Instance().SetItemMetinSocketToTarget(iSlotIndex, i, exchange_packet.alValues[i]);
|
||
for (int j = 0; j < ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++j)
|
||
CPythonExchange::Instance().SetItemAttributeToTarget(iSlotIndex, j, exchange_packet.aAttr[j].bType, exchange_packet.aAttr[j].sValue);
|
||
}
|
||
|
||
__RefreshExchangeWindow();
|
||
__RefreshInventoryWindow();
|
||
break;
|
||
|
||
case EXCHANGE_SUBHEADER_GC_ITEM_DEL:
|
||
if (exchange_packet.is_me)
|
||
{
|
||
CPythonExchange::Instance().DelItemOfSelf((BYTE) exchange_packet.arg1);
|
||
}
|
||
else
|
||
{
|
||
CPythonExchange::Instance().DelItemOfTarget((BYTE) exchange_packet.arg1);
|
||
}
|
||
__RefreshExchangeWindow();
|
||
__RefreshInventoryWindow();
|
||
break;
|
||
|
||
case EXCHANGE_SUBHEADER_GC_ELK_ADD:
|
||
if (exchange_packet.is_me)
|
||
CPythonExchange::Instance().SetElkToSelf(exchange_packet.arg1);
|
||
else
|
||
CPythonExchange::Instance().SetElkToTarget(exchange_packet.arg1);
|
||
|
||
__RefreshExchangeWindow();
|
||
break;
|
||
|
||
case EXCHANGE_SUBHEADER_GC_ACCEPT:
|
||
if (exchange_packet.is_me)
|
||
{
|
||
CPythonExchange::Instance().SetAcceptToSelf((BYTE) exchange_packet.arg1);
|
||
}
|
||
else
|
||
{
|
||
CPythonExchange::Instance().SetAcceptToTarget((BYTE) exchange_packet.arg1);
|
||
}
|
||
__RefreshExchangeWindow();
|
||
break;
|
||
|
||
case EXCHANGE_SUBHEADER_GC_END:
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "EndExchange", Py_BuildValue("()"));
|
||
__RefreshInventoryWindow();
|
||
CPythonExchange::Instance().End();
|
||
break;
|
||
|
||
case EXCHANGE_SUBHEADER_GC_ALREADY:
|
||
Tracef("trade_already");
|
||
break;
|
||
|
||
case EXCHANGE_SUBHEADER_GC_LESS_ELK:
|
||
Tracef("trade_less_elk");
|
||
break;
|
||
};
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvQuestInfoPacket()
|
||
{
|
||
TPacketGCQuestInfo QuestInfo;
|
||
|
||
if (!Peek(sizeof(TPacketGCQuestInfo), &QuestInfo))
|
||
{
|
||
Tracen("Recv Quest Info Packet Error #1");
|
||
return false;
|
||
}
|
||
|
||
if (!Peek(QuestInfo.size))
|
||
{
|
||
Tracen("Recv Quest Info Packet Error #2");
|
||
return false;
|
||
}
|
||
|
||
Recv(sizeof(TPacketGCQuestInfo));
|
||
|
||
const BYTE & c_rFlag = QuestInfo.flag;
|
||
|
||
enum
|
||
{
|
||
QUEST_PACKET_TYPE_NONE,
|
||
QUEST_PACKET_TYPE_BEGIN,
|
||
QUEST_PACKET_TYPE_UPDATE,
|
||
QUEST_PACKET_TYPE_END,
|
||
};
|
||
|
||
BYTE byQuestPacketType = QUEST_PACKET_TYPE_NONE;
|
||
|
||
if (0 != (c_rFlag & QUEST_SEND_IS_BEGIN))
|
||
{
|
||
BYTE isBegin;
|
||
if (!Recv(sizeof(isBegin), &isBegin))
|
||
return false;
|
||
|
||
if (isBegin)
|
||
byQuestPacketType = QUEST_PACKET_TYPE_BEGIN;
|
||
else
|
||
byQuestPacketType = QUEST_PACKET_TYPE_END;
|
||
}
|
||
else
|
||
{
|
||
byQuestPacketType = QUEST_PACKET_TYPE_UPDATE;
|
||
}
|
||
|
||
// Recv Data Start
|
||
char szTitle[30 + 1] = "";
|
||
char szClockName[16 + 1] = "";
|
||
int iClockValue = 0;
|
||
char szCounterName[16 + 1] = "";
|
||
int iCounterValue = 0;
|
||
char szIconFileName[24 + 1] = "";
|
||
|
||
if (0 != (c_rFlag & QUEST_SEND_TITLE))
|
||
{
|
||
if (!Recv(sizeof(szTitle), &szTitle))
|
||
return false;
|
||
|
||
szTitle[30]='\0';
|
||
}
|
||
if (0 != (c_rFlag & QUEST_SEND_CLOCK_NAME))
|
||
{
|
||
if (!Recv(sizeof(szClockName), &szClockName))
|
||
return false;
|
||
|
||
szClockName[16]='\0';
|
||
}
|
||
if (0 != (c_rFlag & QUEST_SEND_CLOCK_VALUE))
|
||
{
|
||
if (!Recv(sizeof(iClockValue), &iClockValue))
|
||
return false;
|
||
}
|
||
if (0 != (c_rFlag & QUEST_SEND_COUNTER_NAME))
|
||
{
|
||
if (!Recv(sizeof(szCounterName), &szCounterName))
|
||
return false;
|
||
|
||
szCounterName[16]='\0';
|
||
}
|
||
if (0 != (c_rFlag & QUEST_SEND_COUNTER_VALUE))
|
||
{
|
||
if (!Recv(sizeof(iCounterValue), &iCounterValue))
|
||
return false;
|
||
}
|
||
if (0 != (c_rFlag & QUEST_SEND_ICON_FILE))
|
||
{
|
||
if (!Recv(sizeof(szIconFileName), &szIconFileName))
|
||
return false;
|
||
|
||
szIconFileName[24]='\0';
|
||
}
|
||
// Recv Data End
|
||
|
||
CPythonQuest& rkQuest=CPythonQuest::Instance();
|
||
|
||
// Process Start
|
||
if (QUEST_PACKET_TYPE_END == byQuestPacketType)
|
||
{
|
||
rkQuest.DeleteQuestInstance(QuestInfo.index);
|
||
}
|
||
else if (QUEST_PACKET_TYPE_UPDATE == byQuestPacketType)
|
||
{
|
||
if (!rkQuest.IsQuest(QuestInfo.index))
|
||
{
|
||
rkQuest.MakeQuest(QuestInfo.index);
|
||
}
|
||
|
||
if (strlen(szTitle) > 0)
|
||
rkQuest.SetQuestTitle(QuestInfo.index, szTitle);
|
||
if (strlen(szClockName) > 0)
|
||
rkQuest.SetQuestClockName(QuestInfo.index, szClockName);
|
||
if (strlen(szCounterName) > 0)
|
||
rkQuest.SetQuestCounterName(QuestInfo.index, szCounterName);
|
||
if (strlen(szIconFileName) > 0)
|
||
rkQuest.SetQuestIconFileName(QuestInfo.index, szIconFileName);
|
||
|
||
if (c_rFlag & QUEST_SEND_CLOCK_VALUE)
|
||
rkQuest.SetQuestClockValue(QuestInfo.index, iClockValue);
|
||
if (c_rFlag & QUEST_SEND_COUNTER_VALUE)
|
||
rkQuest.SetQuestCounterValue(QuestInfo.index, iCounterValue);
|
||
}
|
||
else if (QUEST_PACKET_TYPE_BEGIN == byQuestPacketType)
|
||
{
|
||
CPythonQuest::SQuestInstance QuestInstance;
|
||
QuestInstance.dwIndex = QuestInfo.index;
|
||
QuestInstance.strTitle = szTitle;
|
||
QuestInstance.strClockName = szClockName;
|
||
QuestInstance.iClockValue = iClockValue;
|
||
QuestInstance.strCounterName = szCounterName;
|
||
QuestInstance.iCounterValue = iCounterValue;
|
||
QuestInstance.strIconFileName = szIconFileName;
|
||
CPythonQuest::Instance().RegisterQuestInstance(QuestInstance);
|
||
}
|
||
// Process Start End
|
||
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshQuest", Py_BuildValue("()"));
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvQuestConfirmPacket()
|
||
{
|
||
TPacketGCQuestConfirm kQuestConfirmPacket;
|
||
if (!Recv(sizeof(kQuestConfirmPacket), &kQuestConfirmPacket))
|
||
{
|
||
Tracen("RecvQuestConfirmPacket Error");
|
||
return false;
|
||
}
|
||
|
||
PyObject * poArg = Py_BuildValue("(sii)", kQuestConfirmPacket.msg, kQuestConfirmPacket.timeout, kQuestConfirmPacket.requestPID);
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OnQuestConfirm", poArg);
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvRequestMakeGuild()
|
||
{
|
||
TPacketGCBlank blank;
|
||
if (!Recv(sizeof(blank), &blank))
|
||
{
|
||
Tracen("RecvRequestMakeGuild Packet Error");
|
||
return false;
|
||
}
|
||
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "AskGuildName", Py_BuildValue("()"));
|
||
|
||
return true;
|
||
}
|
||
|
||
void CPythonNetworkStream::ToggleGameDebugInfo()
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ToggleDebugInfo", Py_BuildValue("()"));
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendExchangeStartPacket(DWORD vid)
|
||
{
|
||
if (!__CanActMainInstance())
|
||
return true;
|
||
|
||
TPacketCGExchange packet;
|
||
|
||
packet.header = HEADER_CG_EXCHANGE;
|
||
packet.subheader = EXCHANGE_SUBHEADER_CG_START;
|
||
packet.arg1 = vid;
|
||
|
||
if (!Send(sizeof(packet), &packet))
|
||
{
|
||
Tracef("send_trade_start_packet Error\n");
|
||
return false;
|
||
}
|
||
|
||
Tracef("send_trade_start_packet vid %d \n", vid);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendExchangeElkAddPacket(DWORD elk)
|
||
{
|
||
if (!__CanActMainInstance())
|
||
return true;
|
||
|
||
TPacketCGExchange packet;
|
||
|
||
packet.header = HEADER_CG_EXCHANGE;
|
||
packet.subheader = EXCHANGE_SUBHEADER_CG_ELK_ADD;
|
||
packet.arg1 = elk;
|
||
|
||
if (!Send(sizeof(packet), &packet))
|
||
{
|
||
Tracef("send_trade_elk_add_packet Error\n");
|
||
return false;
|
||
}
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendExchangeItemAddPacket(TItemPos ItemPos, BYTE byDisplayPos)
|
||
{
|
||
if (!__CanActMainInstance())
|
||
return true;
|
||
|
||
TPacketCGExchange packet;
|
||
|
||
packet.header = HEADER_CG_EXCHANGE;
|
||
packet.subheader = EXCHANGE_SUBHEADER_CG_ITEM_ADD;
|
||
packet.Pos = ItemPos;
|
||
packet.arg2 = byDisplayPos;
|
||
|
||
if (!Send(sizeof(packet), &packet))
|
||
{
|
||
Tracef("send_trade_item_add_packet Error\n");
|
||
return false;
|
||
}
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendExchangeItemDelPacket(BYTE pos)
|
||
{
|
||
assert(!"Can't be called function - CPythonNetworkStream::SendExchangeItemDelPacket");
|
||
return true;
|
||
|
||
if (!__CanActMainInstance())
|
||
return true;
|
||
|
||
TPacketCGExchange packet;
|
||
|
||
packet.header = HEADER_CG_EXCHANGE;
|
||
packet.subheader = EXCHANGE_SUBHEADER_CG_ITEM_DEL;
|
||
packet.arg1 = pos;
|
||
|
||
if (!Send(sizeof(packet), &packet))
|
||
{
|
||
Tracef("send_trade_item_del_packet Error\n");
|
||
return false;
|
||
}
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendExchangeAcceptPacket()
|
||
{
|
||
if (!__CanActMainInstance())
|
||
return true;
|
||
|
||
TPacketCGExchange packet;
|
||
|
||
packet.header = HEADER_CG_EXCHANGE;
|
||
packet.subheader = EXCHANGE_SUBHEADER_CG_ACCEPT;
|
||
|
||
if (!Send(sizeof(packet), &packet))
|
||
{
|
||
Tracef("send_trade_accept_packet Error\n");
|
||
return false;
|
||
}
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendExchangeExitPacket()
|
||
{
|
||
if (!__CanActMainInstance())
|
||
return true;
|
||
|
||
TPacketCGExchange packet;
|
||
|
||
packet.header = HEADER_CG_EXCHANGE;
|
||
packet.subheader = EXCHANGE_SUBHEADER_CG_CANCEL;
|
||
|
||
if (!Send(sizeof(packet), &packet))
|
||
{
|
||
Tracef("send_trade_exit_packet Error\n");
|
||
return false;
|
||
}
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
// PointReset <20><><EFBFBD>ӽ<EFBFBD>
|
||
bool CPythonNetworkStream::SendPointResetPacket()
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartPointReset", Py_BuildValue("()"));
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::__IsPlayerAttacking()
|
||
{
|
||
CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
|
||
CInstanceBase* pkInstMain=rkChrMgr.GetMainInstancePtr();
|
||
if (!pkInstMain)
|
||
return false;
|
||
|
||
if (!pkInstMain->IsAttacking())
|
||
return false;
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvScriptPacket()
|
||
{
|
||
TPacketGCScript ScriptPacket;
|
||
|
||
if (!Recv(sizeof(TPacketGCScript), &ScriptPacket))
|
||
{
|
||
TraceError("RecvScriptPacket_RecvError");
|
||
return false;
|
||
}
|
||
|
||
if (ScriptPacket.size < sizeof(TPacketGCScript))
|
||
{
|
||
TraceError("RecvScriptPacket_SizeError");
|
||
return false;
|
||
}
|
||
|
||
ScriptPacket.size -= sizeof(TPacketGCScript);
|
||
|
||
static std::string str;
|
||
str = "";
|
||
str.resize(ScriptPacket.size+1);
|
||
|
||
if (!Recv(ScriptPacket.size, &str[0]))
|
||
return false;
|
||
|
||
str[str.size()-1] = '\0';
|
||
|
||
int iIndex = CPythonEventManager::Instance().RegisterEventSetFromString(str);
|
||
|
||
if (-1 != iIndex)
|
||
{
|
||
CPythonEventManager::Instance().SetVisibleLineCount(iIndex, 30);
|
||
CPythonNetworkStream::Instance().OnScriptEventStart(ScriptPacket.skin,iIndex);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendScriptAnswerPacket(int iAnswer)
|
||
{
|
||
TPacketCGScriptAnswer ScriptAnswer;
|
||
|
||
ScriptAnswer.header = HEADER_CG_SCRIPT_ANSWER;
|
||
ScriptAnswer.answer = (BYTE) iAnswer;
|
||
if (!Send(sizeof(TPacketCGScriptAnswer), &ScriptAnswer))
|
||
{
|
||
Tracen("Send Script Answer Packet Error");
|
||
return false;
|
||
}
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendScriptButtonPacket(unsigned int iIndex)
|
||
{
|
||
TPacketCGScriptButton ScriptButton;
|
||
|
||
ScriptButton.header = HEADER_CG_SCRIPT_BUTTON;
|
||
ScriptButton.idx = iIndex;
|
||
if (!Send(sizeof(TPacketCGScriptButton), &ScriptButton))
|
||
{
|
||
Tracen("Send Script Button Packet Error");
|
||
return false;
|
||
}
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendAnswerMakeGuildPacket(const char * c_szName)
|
||
{
|
||
TPacketCGAnswerMakeGuild Packet;
|
||
|
||
Packet.header = HEADER_CG_ANSWER_MAKE_GUILD;
|
||
strncpy(Packet.guild_name, c_szName, GUILD_NAME_MAX_LEN);
|
||
Packet.guild_name[GUILD_NAME_MAX_LEN] = '\0';
|
||
|
||
if (!Send(sizeof(Packet), &Packet))
|
||
{
|
||
Tracen("SendAnswerMakeGuild Packet Error");
|
||
return false;
|
||
}
|
||
|
||
// Tracef(" SendAnswerMakeGuildPacket : %s", c_szName);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendQuestInputStringPacket(const char * c_szString)
|
||
{
|
||
TPacketCGQuestInputString Packet;
|
||
Packet.bHeader = HEADER_CG_QUEST_INPUT_STRING;
|
||
strncpy(Packet.szString, c_szString, QUEST_INPUT_STRING_MAX_NUM);
|
||
|
||
if (!Send(sizeof(Packet), &Packet))
|
||
{
|
||
Tracen("SendQuestInputStringPacket Error");
|
||
return false;
|
||
}
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendQuestConfirmPacket(BYTE byAnswer, DWORD dwPID)
|
||
{
|
||
TPacketCGQuestConfirm kPacket;
|
||
kPacket.header = HEADER_CG_QUEST_CONFIRM;
|
||
kPacket.answer = byAnswer;
|
||
kPacket.requestPID = dwPID;
|
||
|
||
if (!Send(sizeof(kPacket), &kPacket))
|
||
{
|
||
Tracen("SendQuestConfirmPacket Error");
|
||
return false;
|
||
}
|
||
|
||
Tracenf(" SendQuestConfirmPacket : %d, %d", byAnswer, dwPID);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvSkillCoolTimeEnd()
|
||
{
|
||
TPacketGCSkillCoolTimeEnd kPacketSkillCoolTimeEnd;
|
||
if (!Recv(sizeof(kPacketSkillCoolTimeEnd), &kPacketSkillCoolTimeEnd))
|
||
{
|
||
Tracen("CPythonNetworkStream::RecvSkillCoolTimeEnd - RecvError");
|
||
return false;
|
||
}
|
||
|
||
CPythonPlayer::Instance().EndSkillCoolTime(kPacketSkillCoolTimeEnd.bSkill);
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvSkillLevel()
|
||
{
|
||
assert(!"CPythonNetworkStream::RecvSkillLevel - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ʴ<EFBFBD> <20>Լ<EFBFBD>");
|
||
TPacketGCSkillLevel packet;
|
||
if (!Recv(sizeof(TPacketGCSkillLevel), &packet))
|
||
{
|
||
Tracen("CPythonNetworkStream::RecvSkillLevel - RecvError");
|
||
return false;
|
||
}
|
||
|
||
DWORD dwSlotIndex;
|
||
|
||
CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
|
||
for (int i = 0; i < SKILL_MAX_NUM; ++i)
|
||
{
|
||
if (rkPlayer.GetSkillSlotIndex(i, &dwSlotIndex))
|
||
rkPlayer.SetSkillLevel(dwSlotIndex, packet.abSkillLevels[i]);
|
||
}
|
||
|
||
__RefreshSkillWindow();
|
||
__RefreshStatus();
|
||
Tracef(" >> RecvSkillLevel\n");
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvSkillLevelNew()
|
||
{
|
||
TPacketGCSkillLevelNew packet;
|
||
|
||
if (!Recv(sizeof(TPacketGCSkillLevelNew), &packet))
|
||
{
|
||
Tracen("CPythonNetworkStream::RecvSkillLevelNew - RecvError");
|
||
return false;
|
||
}
|
||
|
||
CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
|
||
|
||
rkPlayer.SetSkill(7, 0);
|
||
rkPlayer.SetSkill(8, 0);
|
||
|
||
for (int i = 0; i < SKILL_MAX_NUM; ++i)
|
||
{
|
||
TPlayerSkill & rPlayerSkill = packet.skills[i];
|
||
|
||
if (i >= 112 && i <= 115 && rPlayerSkill.bLevel)
|
||
rkPlayer.SetSkill(7, i);
|
||
|
||
if (i >= 116 && i <= 119 && rPlayerSkill.bLevel)
|
||
rkPlayer.SetSkill(8, i);
|
||
|
||
rkPlayer.SetSkillLevel_(i, rPlayerSkill.bMasterType, rPlayerSkill.bLevel);
|
||
}
|
||
|
||
__RefreshSkillWindow();
|
||
__RefreshStatus();
|
||
//Tracef(" >> RecvSkillLevelNew\n");
|
||
return true;
|
||
}
|
||
|
||
|
||
bool CPythonNetworkStream::RecvDamageInfoPacket()
|
||
{
|
||
TPacketGCDamageInfo DamageInfoPacket;
|
||
|
||
if (!Recv(sizeof(TPacketGCDamageInfo), &DamageInfoPacket))
|
||
{
|
||
Tracen("Recv Target Packet Error");
|
||
return false;
|
||
}
|
||
|
||
CInstanceBase * pInstTarget = CPythonCharacterManager::Instance().GetInstancePtr(DamageInfoPacket.dwVID);
|
||
bool bSelf = (pInstTarget == CPythonCharacterManager::Instance().GetMainInstancePtr());
|
||
bool bTarget = (pInstTarget==m_pInstTarget);
|
||
if (pInstTarget)
|
||
{
|
||
if(DamageInfoPacket.damage >= 0)
|
||
pInstTarget->AddDamageEffect(DamageInfoPacket.damage,DamageInfoPacket.flag,bSelf,bTarget);
|
||
else
|
||
TraceError("Damage is equal or below 0.");
|
||
}
|
||
|
||
return true;
|
||
}
|
||
bool CPythonNetworkStream::RecvTargetPacket()
|
||
{
|
||
TPacketGCTarget TargetPacket;
|
||
|
||
if (!Recv(sizeof(TPacketGCTarget), &TargetPacket))
|
||
{
|
||
Tracen("Recv Target Packet Error");
|
||
return false;
|
||
}
|
||
|
||
CInstanceBase * pInstPlayer = CPythonCharacterManager::Instance().GetMainInstancePtr();
|
||
CInstanceBase * pInstTarget = CPythonCharacterManager::Instance().GetInstancePtr(TargetPacket.dwVID);
|
||
if (pInstPlayer && pInstTarget)
|
||
{
|
||
if (!pInstTarget->IsDead())
|
||
{
|
||
if (pInstTarget->IsPC() || pInstTarget->IsBuilding())
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "CloseTargetBoardIfDifferent", Py_BuildValue("(i)", TargetPacket.dwVID));
|
||
else if (pInstPlayer->CanViewTargetHP(*pInstTarget))
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetHPTargetBoard", Py_BuildValue("(ii)", TargetPacket.dwVID, TargetPacket.bHPPercent));
|
||
else
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "CloseTargetBoard", Py_BuildValue("()"));
|
||
|
||
m_pInstTarget = pInstTarget;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "CloseTargetBoard", Py_BuildValue("()"));
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvMountPacket()
|
||
{
|
||
TPacketGCMount MountPacket;
|
||
|
||
if (!Recv(sizeof(TPacketGCMount), &MountPacket))
|
||
{
|
||
Tracen("Recv Mount Packet Error");
|
||
return false;
|
||
}
|
||
|
||
CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(MountPacket.vid);
|
||
|
||
if (pInstance)
|
||
{
|
||
// Mount
|
||
if (0 != MountPacket.mount_vid)
|
||
{
|
||
// pInstance->Ride(MountPacket.pos, MountPacket.mount_vid);
|
||
}
|
||
// Unmount
|
||
else
|
||
{
|
||
// pInstance->Unride(MountPacket.pos, MountPacket.x, MountPacket.y);
|
||
}
|
||
}
|
||
|
||
if (CPythonPlayer::Instance().IsMainCharacterIndex(MountPacket.vid))
|
||
{
|
||
// CPythonPlayer::Instance().SetRidingVehicleIndex(MountPacket.mount_vid);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvChangeSpeedPacket()
|
||
{
|
||
TPacketGCChangeSpeed SpeedPacket;
|
||
|
||
if (!Recv(sizeof(TPacketGCChangeSpeed), &SpeedPacket))
|
||
{
|
||
Tracen("Recv Speed Packet Error");
|
||
return false;
|
||
}
|
||
|
||
CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(SpeedPacket.vid);
|
||
|
||
if (!pInstance)
|
||
return true;
|
||
|
||
// pInstance->SetWalkSpeed(SpeedPacket.walking_speed);
|
||
// pInstance->SetRunSpeed(SpeedPacket.running_speed);
|
||
return true;
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||
// Recv
|
||
|
||
bool CPythonNetworkStream::SendAttackPacket(UINT uMotAttack, DWORD dwVIDVictim)
|
||
{
|
||
if (!__CanActMainInstance())
|
||
return true;
|
||
|
||
#ifdef ATTACK_TIME_LOG
|
||
static DWORD prevTime = timeGetTime();
|
||
DWORD curTime = timeGetTime();
|
||
TraceError("TIME: %.4f(%.4f) ATTACK_PACKET: %d TARGET: %d", curTime/1000.0f, (curTime-prevTime)/1000.0f, uMotAttack, dwVIDVictim);
|
||
prevTime = curTime;
|
||
#endif
|
||
|
||
TPacketCGAttack kPacketAtk;
|
||
|
||
kPacketAtk.header = HEADER_CG_ATTACK;
|
||
kPacketAtk.bType = uMotAttack;
|
||
kPacketAtk.dwVictimVID = dwVIDVictim;
|
||
|
||
if (!SendSpecial(sizeof(kPacketAtk), &kPacketAtk))
|
||
{
|
||
Tracen("Send Battle Attack Packet Error");
|
||
return false;
|
||
}
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendSpecial(int nLen, void * pvBuf)
|
||
{
|
||
BYTE bHeader = *(BYTE *) pvBuf;
|
||
|
||
switch (bHeader)
|
||
{
|
||
case HEADER_CG_ATTACK:
|
||
{
|
||
TPacketCGAttack * pkPacketAtk = (TPacketCGAttack *) pvBuf;
|
||
pkPacketAtk->bCRCMagicCubeProcPiece = GetProcessCRCMagicCubePiece();
|
||
pkPacketAtk->bCRCMagicCubeFilePiece = GetProcessCRCMagicCubePiece();
|
||
return Send(nLen, pvBuf);
|
||
}
|
||
break;
|
||
}
|
||
|
||
return Send(nLen, pvBuf);
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvAddFlyTargetingPacket()
|
||
{
|
||
TPacketGCFlyTargeting kPacket;
|
||
if (!Recv(sizeof(kPacket), &kPacket))
|
||
return false;
|
||
|
||
__GlobalPositionToLocalPosition(kPacket.lX, kPacket.lY);
|
||
|
||
Tracef("VID [%d]<5D><> Ÿ<><C5B8><EFBFBD><EFBFBD> <20>߰<EFBFBD> <20><><EFBFBD><EFBFBD>\n",kPacket.dwShooterVID);
|
||
|
||
CPythonCharacterManager & rpcm = CPythonCharacterManager::Instance();
|
||
|
||
CInstanceBase * pShooter = rpcm.GetInstancePtr(kPacket.dwShooterVID);
|
||
|
||
if (!pShooter)
|
||
{
|
||
#ifndef _DEBUG
|
||
TraceError("CPythonNetworkStream::RecvFlyTargetingPacket() - dwShooterVID[%d] NOT EXIST", kPacket.dwShooterVID);
|
||
#endif
|
||
return true;
|
||
}
|
||
|
||
CInstanceBase * pTarget = rpcm.GetInstancePtr(kPacket.dwTargetVID);
|
||
|
||
if (kPacket.dwTargetVID && pTarget)
|
||
{
|
||
pShooter->GetGraphicThingInstancePtr()->AddFlyTarget(pTarget->GetGraphicThingInstancePtr());
|
||
}
|
||
else
|
||
{
|
||
float h = CPythonBackground::Instance().GetHeight(kPacket.lX,kPacket.lY) + 60.0f; // TEMPORARY HEIGHT
|
||
pShooter->GetGraphicThingInstancePtr()->AddFlyTarget(D3DXVECTOR3(kPacket.lX,kPacket.lY,h));
|
||
//pShooter->GetGraphicThingInstancePtr()->SetFlyTarget(kPacket.kPPosTarget.x,kPacket.kPPosTarget.y,);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvFlyTargetingPacket()
|
||
{
|
||
TPacketGCFlyTargeting kPacket;
|
||
if (!Recv(sizeof(kPacket), &kPacket))
|
||
return false;
|
||
|
||
__GlobalPositionToLocalPosition(kPacket.lX, kPacket.lY);
|
||
|
||
//Tracef("CPythonNetworkStream::RecvFlyTargetingPacket - VID [%d]\n",kPacket.dwShooterVID);
|
||
|
||
CPythonCharacterManager & rpcm = CPythonCharacterManager::Instance();
|
||
|
||
CInstanceBase * pShooter = rpcm.GetInstancePtr(kPacket.dwShooterVID);
|
||
|
||
if (!pShooter)
|
||
{
|
||
#ifdef _DEBUG
|
||
TraceError("CPythonNetworkStream::RecvFlyTargetingPacket() - dwShooterVID[%d] NOT EXIST", kPacket.dwShooterVID);
|
||
#endif
|
||
return true;
|
||
}
|
||
|
||
CInstanceBase * pTarget = rpcm.GetInstancePtr(kPacket.dwTargetVID);
|
||
|
||
if (kPacket.dwTargetVID && pTarget)
|
||
{
|
||
pShooter->GetGraphicThingInstancePtr()->SetFlyTarget(pTarget->GetGraphicThingInstancePtr());
|
||
}
|
||
else
|
||
{
|
||
float h = CPythonBackground::Instance().GetHeight(kPacket.lX, kPacket.lY) + 60.0f; // TEMPORARY HEIGHT
|
||
pShooter->GetGraphicThingInstancePtr()->SetFlyTarget(D3DXVECTOR3(kPacket.lX,kPacket.lY,h));
|
||
//pShooter->GetGraphicThingInstancePtr()->SetFlyTarget(kPacket.kPPosTarget.x,kPacket.kPPosTarget.y,);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendShootPacket(UINT uSkill)
|
||
{
|
||
TPacketCGShoot kPacketShoot;
|
||
kPacketShoot.bHeader=HEADER_CG_SHOOT;
|
||
kPacketShoot.bType=uSkill;
|
||
|
||
if (!Send(sizeof(kPacketShoot), &kPacketShoot))
|
||
{
|
||
Tracen("SendShootPacket Error");
|
||
return false;
|
||
}
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendAddFlyTargetingPacket(DWORD dwTargetVID, const TPixelPosition & kPPosTarget)
|
||
{
|
||
TPacketCGFlyTargeting packet;
|
||
|
||
//CPythonCharacterManager & rpcm = CPythonCharacterManager::Instance();
|
||
|
||
packet.bHeader = HEADER_CG_ADD_FLY_TARGETING;
|
||
packet.dwTargetVID = dwTargetVID;
|
||
packet.lX = kPPosTarget.x;
|
||
packet.lY = kPPosTarget.y;
|
||
|
||
__LocalPositionToGlobalPosition(packet.lX, packet.lY);
|
||
|
||
if (!Send(sizeof(packet), &packet))
|
||
{
|
||
Tracen("Send FlyTargeting Packet Error");
|
||
return false;
|
||
}
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
|
||
bool CPythonNetworkStream::SendFlyTargetingPacket(DWORD dwTargetVID, const TPixelPosition & kPPosTarget)
|
||
{
|
||
TPacketCGFlyTargeting packet;
|
||
|
||
//CPythonCharacterManager & rpcm = CPythonCharacterManager::Instance();
|
||
|
||
packet.bHeader = HEADER_CG_FLY_TARGETING;
|
||
packet.dwTargetVID = dwTargetVID;
|
||
packet.lX = kPPosTarget.x;
|
||
packet.lY = kPPosTarget.y;
|
||
|
||
__LocalPositionToGlobalPosition(packet.lX, packet.lY);
|
||
|
||
if (!Send(sizeof(packet), &packet))
|
||
{
|
||
Tracen("Send FlyTargeting Packet Error");
|
||
return false;
|
||
}
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvCreateFlyPacket()
|
||
{
|
||
TPacketGCCreateFly kPacket;
|
||
if (!Recv(sizeof(TPacketGCCreateFly), &kPacket))
|
||
return false;
|
||
|
||
CFlyingManager& rkFlyMgr = CFlyingManager::Instance();
|
||
CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
|
||
|
||
CInstanceBase * pkStartInst = rkChrMgr.GetInstancePtr(kPacket.dwStartVID);
|
||
CInstanceBase * pkEndInst = rkChrMgr.GetInstancePtr(kPacket.dwEndVID);
|
||
if (!pkStartInst || !pkEndInst)
|
||
return true;
|
||
|
||
rkFlyMgr.CreateIndexedFly(kPacket.bType, pkStartInst->GetGraphicThingInstancePtr(), pkEndInst->GetGraphicThingInstancePtr());
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendTargetPacket(DWORD dwVID)
|
||
{
|
||
TPacketCGTarget packet;
|
||
packet.header = HEADER_CG_TARGET;
|
||
packet.dwVID = dwVID;
|
||
|
||
if (!Send(sizeof(packet), &packet))
|
||
{
|
||
Tracen("Send Target Packet Error");
|
||
return false;
|
||
}
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendSyncPositionElementPacket(DWORD dwVictimVID, DWORD dwVictimX, DWORD dwVictimY)
|
||
{
|
||
TPacketCGSyncPositionElement kSyncPos;
|
||
kSyncPos.dwVID=dwVictimVID;
|
||
kSyncPos.lX=dwVictimX;
|
||
kSyncPos.lY=dwVictimY;
|
||
|
||
__LocalPositionToGlobalPosition(kSyncPos.lX, kSyncPos.lY);
|
||
|
||
if (!Send(sizeof(kSyncPos), &kSyncPos))
|
||
{
|
||
Tracen("CPythonNetworkStream::SendSyncPositionElementPacket - ERROR");
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvMessenger()
|
||
{
|
||
TPacketGCMessenger p;
|
||
if (!Recv(sizeof(p), &p))
|
||
return false;
|
||
|
||
int iSize = p.size - sizeof(p);
|
||
char char_name[24+1];
|
||
|
||
switch (p.subheader)
|
||
{
|
||
case MESSENGER_SUBHEADER_GC_LIST:
|
||
{
|
||
TPacketGCMessengerListOnline on;
|
||
while(iSize)
|
||
{
|
||
if (!Recv(sizeof(TPacketGCMessengerListOffline),&on))
|
||
return false;
|
||
|
||
if (!Recv(on.length, char_name))
|
||
return false;
|
||
|
||
char_name[on.length] = 0;
|
||
|
||
if (on.connected & MESSENGER_CONNECTED_STATE_ONLINE)
|
||
CPythonMessenger::Instance().OnFriendLogin(char_name);
|
||
else
|
||
CPythonMessenger::Instance().OnFriendLogout(char_name);
|
||
|
||
if (on.connected & MESSENGER_CONNECTED_STATE_MOBILE)
|
||
CPythonMessenger::Instance().SetMobile(char_name, TRUE);
|
||
|
||
iSize -= sizeof(TPacketGCMessengerListOffline);
|
||
iSize -= on.length;
|
||
}
|
||
break;
|
||
}
|
||
|
||
case MESSENGER_SUBHEADER_GC_LOGIN:
|
||
{
|
||
TPacketGCMessengerLogin p;
|
||
if (!Recv(sizeof(p),&p))
|
||
return false;
|
||
if (!Recv(p.length, char_name))
|
||
return false;
|
||
char_name[p.length] = 0;
|
||
CPythonMessenger::Instance().OnFriendLogin(char_name);
|
||
__RefreshTargetBoardByName(char_name);
|
||
break;
|
||
}
|
||
|
||
case MESSENGER_SUBHEADER_GC_LOGOUT:
|
||
{
|
||
TPacketGCMessengerLogout logout;
|
||
if (!Recv(sizeof(logout),&logout))
|
||
return false;
|
||
if (!Recv(logout.length, char_name))
|
||
return false;
|
||
char_name[logout.length] = 0;
|
||
CPythonMessenger::Instance().OnFriendLogout(char_name);
|
||
break;
|
||
}
|
||
|
||
case MESSENGER_SUBHEADER_GC_MOBILE:
|
||
{
|
||
BYTE byState; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ȣ<EFBFBD><C8A3> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>÷<EFBFBD><C3B7><EFBFBD>
|
||
BYTE byLength;
|
||
if (!Recv(sizeof(byState), &byState))
|
||
return false;
|
||
if (!Recv(sizeof(byLength), &byLength))
|
||
return false;
|
||
if (!Recv(byLength, char_name))
|
||
return false;
|
||
char_name[byLength] = 0;
|
||
CPythonMessenger::Instance().SetMobile(char_name, byState);
|
||
break;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////////////////////
|
||
// Party
|
||
|
||
bool CPythonNetworkStream::SendPartyInvitePacket(DWORD dwVID)
|
||
{
|
||
TPacketCGPartyInvite kPartyInvitePacket;
|
||
kPartyInvitePacket.header = HEADER_CG_PARTY_INVITE;
|
||
kPartyInvitePacket.vid = dwVID;
|
||
|
||
if (!Send(sizeof(kPartyInvitePacket), &kPartyInvitePacket))
|
||
{
|
||
Tracenf("CPythonNetworkStream::SendPartyInvitePacket [%ud] - PACKET SEND ERROR", dwVID);
|
||
return false;
|
||
}
|
||
|
||
Tracef(" << SendPartyInvitePacket : %d\n", dwVID);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendPartyInviteAnswerPacket(DWORD dwLeaderVID, BYTE byAnswer)
|
||
{
|
||
TPacketCGPartyInviteAnswer kPartyInviteAnswerPacket;
|
||
kPartyInviteAnswerPacket.header = HEADER_CG_PARTY_INVITE_ANSWER;
|
||
kPartyInviteAnswerPacket.leader_pid = dwLeaderVID;
|
||
kPartyInviteAnswerPacket.accept = byAnswer;
|
||
|
||
if (!Send(sizeof(kPartyInviteAnswerPacket), &kPartyInviteAnswerPacket))
|
||
{
|
||
Tracenf("CPythonNetworkStream::SendPartyInviteAnswerPacket [%ud %ud] - PACKET SEND ERROR", dwLeaderVID, byAnswer);
|
||
return false;
|
||
}
|
||
|
||
Tracef(" << SendPartyInviteAnswerPacket : %d, %d\n", dwLeaderVID, byAnswer);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendPartyRemovePacket(DWORD dwPID)
|
||
{
|
||
TPacketCGPartyRemove kPartyInviteRemove;
|
||
kPartyInviteRemove.header = HEADER_CG_PARTY_REMOVE;
|
||
kPartyInviteRemove.pid = dwPID;
|
||
|
||
if (!Send(sizeof(kPartyInviteRemove), &kPartyInviteRemove))
|
||
{
|
||
Tracenf("CPythonNetworkStream::SendPartyRemovePacket [%ud] - PACKET SEND ERROR", dwPID);
|
||
return false;
|
||
}
|
||
|
||
Tracef(" << SendPartyRemovePacket : %d\n", dwPID);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendPartySetStatePacket(DWORD dwVID, BYTE byState, BYTE byFlag)
|
||
{
|
||
TPacketCGPartySetState kPartySetState;
|
||
kPartySetState.byHeader = HEADER_CG_PARTY_SET_STATE;
|
||
kPartySetState.dwVID = dwVID;
|
||
kPartySetState.byState = byState;
|
||
kPartySetState.byFlag = byFlag;
|
||
|
||
if (!Send(sizeof(kPartySetState), &kPartySetState))
|
||
{
|
||
Tracenf("CPythonNetworkStream::SendPartySetStatePacket(%ud, %ud) - PACKET SEND ERROR", dwVID, byState);
|
||
return false;
|
||
}
|
||
|
||
Tracef(" << SendPartySetStatePacket : %d, %d, %d\n", dwVID, byState, byFlag);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendPartyUseSkillPacket(BYTE bySkillIndex, DWORD dwVID)
|
||
{
|
||
TPacketCGPartyUseSkill kPartyUseSkill;
|
||
kPartyUseSkill.byHeader = HEADER_CG_PARTY_USE_SKILL;
|
||
kPartyUseSkill.bySkillIndex = bySkillIndex;
|
||
kPartyUseSkill.dwTargetVID = dwVID;
|
||
|
||
if (!Send(sizeof(kPartyUseSkill), &kPartyUseSkill))
|
||
{
|
||
Tracenf("CPythonNetworkStream::SendPartyUseSkillPacket(%ud, %ud) - PACKET SEND ERROR", bySkillIndex, dwVID);
|
||
return false;
|
||
}
|
||
|
||
Tracef(" << SendPartyUseSkillPacket : %d, %d\n", bySkillIndex, dwVID);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendPartyParameterPacket(BYTE byDistributeMode)
|
||
{
|
||
TPacketCGPartyParameter kPartyParameter;
|
||
kPartyParameter.bHeader = HEADER_CG_PARTY_PARAMETER;
|
||
kPartyParameter.bDistributeMode = byDistributeMode;
|
||
|
||
if (!Send(sizeof(kPartyParameter), &kPartyParameter))
|
||
{
|
||
Tracenf("CPythonNetworkStream::SendPartyParameterPacket(%d) - PACKET SEND ERROR", byDistributeMode);
|
||
return false;
|
||
}
|
||
|
||
Tracef(" << SendPartyParameterPacket : %d\n", byDistributeMode);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvPartyInvite()
|
||
{
|
||
TPacketGCPartyInvite kPartyInvitePacket;
|
||
if (!Recv(sizeof(kPartyInvitePacket), &kPartyInvitePacket))
|
||
return false;
|
||
|
||
CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(kPartyInvitePacket.leader_pid);
|
||
if (!pInstance)
|
||
{
|
||
TraceError(" CPythonNetworkStream::RecvPartyInvite - Failed to find leader instance [%d]\n", kPartyInvitePacket.leader_pid);
|
||
return true;
|
||
}
|
||
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RecvPartyInviteQuestion", Py_BuildValue("(is)", kPartyInvitePacket.leader_pid, pInstance->GetNameString()));
|
||
Tracef(" >> RecvPartyInvite : %d, %s\n", kPartyInvitePacket.leader_pid, pInstance->GetNameString());
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvPartyAdd()
|
||
{
|
||
TPacketGCPartyAdd kPartyAddPacket;
|
||
if (!Recv(sizeof(kPartyAddPacket), &kPartyAddPacket))
|
||
return false;
|
||
|
||
CPythonPlayer::Instance().AppendPartyMember(kPartyAddPacket.pid, kPartyAddPacket.name);
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "AddPartyMember", Py_BuildValue("(is)", kPartyAddPacket.pid, kPartyAddPacket.name));
|
||
Tracef(" >> RecvPartyAdd : %d, %s\n", kPartyAddPacket.pid, kPartyAddPacket.name);
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvPartyUpdate()
|
||
{
|
||
TPacketGCPartyUpdate kPartyUpdatePacket;
|
||
if (!Recv(sizeof(kPartyUpdatePacket), &kPartyUpdatePacket))
|
||
return false;
|
||
|
||
CPythonPlayer::TPartyMemberInfo * pPartyMemberInfo;
|
||
if (!CPythonPlayer::Instance().GetPartyMemberPtr(kPartyUpdatePacket.pid, &pPartyMemberInfo))
|
||
return true;
|
||
|
||
BYTE byOldState = pPartyMemberInfo->byState;
|
||
|
||
CPythonPlayer::Instance().UpdatePartyMemberInfo(kPartyUpdatePacket.pid, kPartyUpdatePacket.state, kPartyUpdatePacket.percent_hp);
|
||
for (int i = 0; i < PARTY_AFFECT_SLOT_MAX_NUM; ++i)
|
||
{
|
||
CPythonPlayer::Instance().UpdatePartyMemberAffect(kPartyUpdatePacket.pid, i, kPartyUpdatePacket.affects[i]);
|
||
}
|
||
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "UpdatePartyMemberInfo", Py_BuildValue("(i)", kPartyUpdatePacket.pid));
|
||
|
||
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ٲ<EFBFBD><D9B2><EFBFBD><EFBFBD>ٸ<EFBFBD>, TargetBoard <20><> <20><>ư<EFBFBD><C6B0> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20>Ѵ<EFBFBD>.
|
||
DWORD dwVID;
|
||
if (CPythonPlayer::Instance().PartyMemberPIDToVID(kPartyUpdatePacket.pid, &dwVID))
|
||
if (byOldState != kPartyUpdatePacket.state)
|
||
{
|
||
__RefreshTargetBoardByVID(dwVID);
|
||
}
|
||
|
||
// Tracef(" >> RecvPartyUpdate : %d, %d, %d\n", kPartyUpdatePacket.pid, kPartyUpdatePacket.state, kPartyUpdatePacket.percent_hp);
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvPartyRemove()
|
||
{
|
||
TPacketGCPartyRemove kPartyRemovePacket;
|
||
if (!Recv(sizeof(kPartyRemovePacket), &kPartyRemovePacket))
|
||
return false;
|
||
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RemovePartyMember", Py_BuildValue("(i)", kPartyRemovePacket.pid));
|
||
Tracef(" >> RecvPartyRemove : %d\n", kPartyRemovePacket.pid);
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvPartyLink()
|
||
{
|
||
TPacketGCPartyLink kPartyLinkPacket;
|
||
if (!Recv(sizeof(kPartyLinkPacket), &kPartyLinkPacket))
|
||
return false;
|
||
|
||
CPythonPlayer::Instance().LinkPartyMember(kPartyLinkPacket.pid, kPartyLinkPacket.vid);
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "LinkPartyMember", Py_BuildValue("(ii)", kPartyLinkPacket.pid, kPartyLinkPacket.vid));
|
||
Tracef(" >> RecvPartyLink : %d, %d\n", kPartyLinkPacket.pid, kPartyLinkPacket.vid);
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvPartyUnlink()
|
||
{
|
||
TPacketGCPartyUnlink kPartyUnlinkPacket;
|
||
if (!Recv(sizeof(kPartyUnlinkPacket), &kPartyUnlinkPacket))
|
||
return false;
|
||
|
||
CPythonPlayer::Instance().UnlinkPartyMember(kPartyUnlinkPacket.pid);
|
||
|
||
if (CPythonPlayer::Instance().IsMainCharacterIndex(kPartyUnlinkPacket.vid))
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "UnlinkAllPartyMember", Py_BuildValue("()"));
|
||
}
|
||
else
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "UnlinkPartyMember", Py_BuildValue("(i)", kPartyUnlinkPacket.pid));
|
||
}
|
||
|
||
Tracef(" >> RecvPartyUnlink : %d, %d\n", kPartyUnlinkPacket.pid, kPartyUnlinkPacket.vid);
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvPartyParameter()
|
||
{
|
||
TPacketGCPartyParameter kPartyParameterPacket;
|
||
if (!Recv(sizeof(kPartyParameterPacket), &kPartyParameterPacket))
|
||
return false;
|
||
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "ChangePartyParameter", Py_BuildValue("(i)", kPartyParameterPacket.bDistributeMode));
|
||
Tracef(" >> RecvPartyParameter : %d\n", kPartyParameterPacket.bDistributeMode);
|
||
|
||
return true;
|
||
}
|
||
|
||
// Party
|
||
//////////////////////////////////////////////////////////////////////////
|
||
|
||
|
||
//////////////////////////////////////////////////////////////////////////
|
||
// Guild
|
||
|
||
bool CPythonNetworkStream::SendGuildAddMemberPacket(DWORD dwVID)
|
||
{
|
||
TPacketCGGuild GuildPacket;
|
||
GuildPacket.byHeader = HEADER_CG_GUILD;
|
||
GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_ADD_MEMBER;
|
||
if (!Send(sizeof(GuildPacket), &GuildPacket))
|
||
return false;
|
||
if (!Send(sizeof(dwVID), &dwVID))
|
||
return false;
|
||
|
||
Tracef(" SendGuildAddMemberPacket\n", dwVID);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendGuildRemoveMemberPacket(DWORD dwPID)
|
||
{
|
||
TPacketCGGuild GuildPacket;
|
||
GuildPacket.byHeader = HEADER_CG_GUILD;
|
||
GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_REMOVE_MEMBER;
|
||
if (!Send(sizeof(GuildPacket), &GuildPacket))
|
||
return false;
|
||
if (!Send(sizeof(dwPID), &dwPID))
|
||
return false;
|
||
|
||
Tracef(" SendGuildRemoveMemberPacket %d\n", dwPID);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendGuildChangeGradeNamePacket(BYTE byGradeNumber, const char * c_szName)
|
||
{
|
||
TPacketCGGuild GuildPacket;
|
||
GuildPacket.byHeader = HEADER_CG_GUILD;
|
||
GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_CHANGE_GRADE_NAME;
|
||
if (!Send(sizeof(GuildPacket), &GuildPacket))
|
||
return false;
|
||
if (!Send(sizeof(byGradeNumber), &byGradeNumber))
|
||
return false;
|
||
|
||
char szName[GUILD_GRADE_NAME_MAX_LEN+1];
|
||
strncpy(szName, c_szName, GUILD_GRADE_NAME_MAX_LEN);
|
||
szName[GUILD_GRADE_NAME_MAX_LEN] = '\0';
|
||
|
||
if (!Send(sizeof(szName), &szName))
|
||
return false;
|
||
|
||
Tracef(" SendGuildChangeGradeNamePacket %d, %s\n", byGradeNumber, c_szName);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendGuildChangeGradeAuthorityPacket(BYTE byGradeNumber, BYTE byAuthority)
|
||
{
|
||
TPacketCGGuild GuildPacket;
|
||
GuildPacket.byHeader = HEADER_CG_GUILD;
|
||
GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_CHANGE_GRADE_AUTHORITY;
|
||
if (!Send(sizeof(GuildPacket), &GuildPacket))
|
||
return false;
|
||
if (!Send(sizeof(byGradeNumber), &byGradeNumber))
|
||
return false;
|
||
if (!Send(sizeof(byAuthority), &byAuthority))
|
||
return false;
|
||
|
||
Tracef(" SendGuildChangeGradeAuthorityPacket %d, %d\n", byGradeNumber, byAuthority);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendGuildOfferPacket(DWORD dwExperience)
|
||
{
|
||
TPacketCGGuild GuildPacket;
|
||
GuildPacket.byHeader = HEADER_CG_GUILD;
|
||
GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_OFFER;
|
||
if (!Send(sizeof(GuildPacket), &GuildPacket))
|
||
return false;
|
||
if (!Send(sizeof(dwExperience), &dwExperience))
|
||
return false;
|
||
|
||
Tracef(" SendGuildOfferPacket %d\n", dwExperience);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendGuildPostCommentPacket(const char * c_szMessage)
|
||
{
|
||
TPacketCGGuild GuildPacket;
|
||
GuildPacket.byHeader = HEADER_CG_GUILD;
|
||
GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_POST_COMMENT;
|
||
if (!Send(sizeof(GuildPacket), &GuildPacket))
|
||
return false;
|
||
|
||
BYTE bySize = BYTE(strlen(c_szMessage)) + 1;
|
||
if (!Send(sizeof(bySize), &bySize))
|
||
return false;
|
||
if (!Send(bySize, c_szMessage))
|
||
return false;
|
||
|
||
Tracef(" SendGuildPostCommentPacket %d, %s\n", bySize, c_szMessage);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendGuildDeleteCommentPacket(DWORD dwIndex)
|
||
{
|
||
TPacketCGGuild GuildPacket;
|
||
GuildPacket.byHeader = HEADER_CG_GUILD;
|
||
GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_DELETE_COMMENT;
|
||
if (!Send(sizeof(GuildPacket), &GuildPacket))
|
||
return false;
|
||
|
||
if (!Send(sizeof(dwIndex), &dwIndex))
|
||
return false;
|
||
|
||
Tracef(" SendGuildDeleteCommentPacket %d\n", dwIndex);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendGuildRefreshCommentsPacket(DWORD dwHighestIndex)
|
||
{
|
||
static DWORD s_LastTime = timeGetTime() - 1001;
|
||
|
||
if (timeGetTime() - s_LastTime < 1000)
|
||
return true;
|
||
s_LastTime = timeGetTime();
|
||
|
||
TPacketCGGuild GuildPacket;
|
||
GuildPacket.byHeader = HEADER_CG_GUILD;
|
||
GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_REFRESH_COMMENT;
|
||
if (!Send(sizeof(GuildPacket), &GuildPacket))
|
||
return false;
|
||
|
||
Tracef(" SendGuildRefreshCommentPacket %d\n", dwHighestIndex);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendGuildChangeMemberGradePacket(DWORD dwPID, BYTE byGrade)
|
||
{
|
||
TPacketCGGuild GuildPacket;
|
||
GuildPacket.byHeader = HEADER_CG_GUILD;
|
||
GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_CHANGE_MEMBER_GRADE;
|
||
if (!Send(sizeof(GuildPacket), &GuildPacket))
|
||
return false;
|
||
|
||
if (!Send(sizeof(dwPID), &dwPID))
|
||
return false;
|
||
if (!Send(sizeof(byGrade), &byGrade))
|
||
return false;
|
||
|
||
Tracef(" SendGuildChangeMemberGradePacket %d, %d\n", dwPID, byGrade);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendGuildUseSkillPacket(DWORD dwSkillID, DWORD dwTargetVID)
|
||
{
|
||
TPacketCGGuild GuildPacket;
|
||
GuildPacket.byHeader = HEADER_CG_GUILD;
|
||
GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_USE_SKILL;
|
||
if (!Send(sizeof(GuildPacket), &GuildPacket))
|
||
return false;
|
||
|
||
if (!Send(sizeof(dwSkillID), &dwSkillID))
|
||
return false;
|
||
if (!Send(sizeof(dwTargetVID), &dwTargetVID))
|
||
return false;
|
||
|
||
Tracef(" SendGuildUseSkillPacket %d, %d\n", dwSkillID, dwTargetVID);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendGuildChangeMemberGeneralPacket(DWORD dwPID, BYTE byFlag)
|
||
{
|
||
TPacketCGGuild GuildPacket;
|
||
GuildPacket.byHeader = HEADER_CG_GUILD;
|
||
GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_CHANGE_MEMBER_GENERAL;
|
||
if (!Send(sizeof(GuildPacket), &GuildPacket))
|
||
return false;
|
||
|
||
if (!Send(sizeof(dwPID), &dwPID))
|
||
return false;
|
||
if (!Send(sizeof(byFlag), &byFlag))
|
||
return false;
|
||
|
||
Tracef(" SendGuildChangeMemberGeneralFlagPacket %d, %d\n", dwPID, byFlag);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendGuildInviteAnswerPacket(DWORD dwGuildID, BYTE byAnswer)
|
||
{
|
||
TPacketCGGuild GuildPacket;
|
||
GuildPacket.byHeader = HEADER_CG_GUILD;
|
||
GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_GUILD_INVITE_ANSWER;
|
||
if (!Send(sizeof(GuildPacket), &GuildPacket))
|
||
return false;
|
||
|
||
if (!Send(sizeof(dwGuildID), &dwGuildID))
|
||
return false;
|
||
if (!Send(sizeof(byAnswer), &byAnswer))
|
||
return false;
|
||
|
||
Tracef(" SendGuildInviteAnswerPacket %d, %d\n", dwGuildID, byAnswer);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendGuildChargeGSPPacket(DWORD dwMoney)
|
||
{
|
||
TPacketCGGuild GuildPacket;
|
||
GuildPacket.byHeader = HEADER_CG_GUILD;
|
||
GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_CHARGE_GSP;
|
||
if (!Send(sizeof(GuildPacket), &GuildPacket))
|
||
return false;
|
||
|
||
if (!Send(sizeof(dwMoney), &dwMoney))
|
||
return false;
|
||
|
||
Tracef(" SendGuildChargeGSPPacket %d\n", dwMoney);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendGuildDepositMoneyPacket(DWORD dwMoney)
|
||
{
|
||
TPacketCGGuild GuildPacket;
|
||
GuildPacket.byHeader = HEADER_CG_GUILD;
|
||
GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_DEPOSIT_MONEY;
|
||
if (!Send(sizeof(GuildPacket), &GuildPacket))
|
||
return false;
|
||
if (!Send(sizeof(dwMoney), &dwMoney))
|
||
return false;
|
||
|
||
Tracef(" SendGuildDepositMoneyPacket %d\n", dwMoney);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendGuildWithdrawMoneyPacket(DWORD dwMoney)
|
||
{
|
||
TPacketCGGuild GuildPacket;
|
||
GuildPacket.byHeader = HEADER_CG_GUILD;
|
||
GuildPacket.bySubHeader = GUILD_SUBHEADER_CG_WITHDRAW_MONEY;
|
||
if (!Send(sizeof(GuildPacket), &GuildPacket))
|
||
return false;
|
||
if (!Send(sizeof(dwMoney), &dwMoney))
|
||
return false;
|
||
|
||
Tracef(" SendGuildWithdrawMoneyPacket %d\n", dwMoney);
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvGuild()
|
||
{
|
||
TPacketGCGuild GuildPacket;
|
||
if (!Recv(sizeof(GuildPacket), &GuildPacket))
|
||
return false;
|
||
|
||
switch(GuildPacket.subheader)
|
||
{
|
||
case GUILD_SUBHEADER_GC_LOGIN:
|
||
{
|
||
DWORD dwPID;
|
||
if (!Recv(sizeof(DWORD), &dwPID))
|
||
return false;
|
||
|
||
// Messenger
|
||
CPythonGuild::TGuildMemberData * pGuildMemberData;
|
||
if (CPythonGuild::Instance().GetMemberDataPtrByPID(dwPID, &pGuildMemberData))
|
||
if (0 != pGuildMemberData->strName.compare(CPythonPlayer::Instance().GetName()))
|
||
CPythonMessenger::Instance().LoginGuildMember(pGuildMemberData->strName.c_str());
|
||
|
||
//Tracef(" <Login> %d\n", dwPID);
|
||
break;
|
||
}
|
||
case GUILD_SUBHEADER_GC_LOGOUT:
|
||
{
|
||
DWORD dwPID;
|
||
if (!Recv(sizeof(DWORD), &dwPID))
|
||
return false;
|
||
|
||
// Messenger
|
||
CPythonGuild::TGuildMemberData * pGuildMemberData;
|
||
if (CPythonGuild::Instance().GetMemberDataPtrByPID(dwPID, &pGuildMemberData))
|
||
if (0 != pGuildMemberData->strName.compare(CPythonPlayer::Instance().GetName()))
|
||
CPythonMessenger::Instance().LogoutGuildMember(pGuildMemberData->strName.c_str());
|
||
|
||
//Tracef(" <Logout> %d\n", dwPID);
|
||
break;
|
||
}
|
||
case GUILD_SUBHEADER_GC_REMOVE:
|
||
{
|
||
DWORD dwPID;
|
||
if (!Recv(sizeof(dwPID), &dwPID))
|
||
return false;
|
||
|
||
// Main Player <20><> <20><><EFBFBD><EFBFBD> DeleteGuild
|
||
if (CPythonGuild::Instance().IsMainPlayer(dwPID))
|
||
{
|
||
CPythonGuild::Instance().Destroy();
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "DeleteGuild", Py_BuildValue("()"));
|
||
CPythonMessenger::Instance().RemoveAllGuildMember();
|
||
__SetGuildID(0);
|
||
__RefreshMessengerWindow();
|
||
__RefreshTargetBoard();
|
||
__RefreshCharacterWindow();
|
||
}
|
||
else
|
||
{
|
||
// Get Member Name
|
||
std::string strMemberName = "";
|
||
CPythonGuild::TGuildMemberData * pData;
|
||
if (CPythonGuild::Instance().GetMemberDataPtrByPID(dwPID, &pData))
|
||
{
|
||
strMemberName = pData->strName;
|
||
CPythonMessenger::Instance().RemoveGuildMember(pData->strName.c_str());
|
||
}
|
||
|
||
CPythonGuild::Instance().RemoveMember(dwPID);
|
||
|
||
// Refresh
|
||
__RefreshTargetBoardByName(strMemberName.c_str());
|
||
__RefreshGuildWindowMemberPage();
|
||
}
|
||
|
||
Tracef(" <Remove> %d\n", dwPID);
|
||
break;
|
||
}
|
||
case GUILD_SUBHEADER_GC_LIST:
|
||
{
|
||
int iPacketSize = int(GuildPacket.size) - sizeof(GuildPacket);
|
||
|
||
for (; iPacketSize > 0;)
|
||
{
|
||
TPacketGCGuildSubMember memberPacket;
|
||
if (!Recv(sizeof(memberPacket), &memberPacket))
|
||
return false;
|
||
|
||
char szName[CHARACTER_NAME_MAX_LEN+1] = "";
|
||
if (memberPacket.byNameFlag)
|
||
{
|
||
if (!Recv(sizeof(szName), &szName))
|
||
return false;
|
||
|
||
iPacketSize -= CHARACTER_NAME_MAX_LEN+1;
|
||
}
|
||
else
|
||
{
|
||
CPythonGuild::TGuildMemberData * pMemberData;
|
||
if (CPythonGuild::Instance().GetMemberDataPtrByPID(memberPacket.pid, &pMemberData))
|
||
{
|
||
strncpy(szName, pMemberData->strName.c_str(), CHARACTER_NAME_MAX_LEN);
|
||
}
|
||
}
|
||
|
||
//Tracef(" <List> %d : %s, %d (%d, %d, %d)\n", memberPacket.pid, szName, memberPacket.byGrade, memberPacket.byJob, memberPacket.byLevel, memberPacket.dwOffer);
|
||
|
||
CPythonGuild::SGuildMemberData GuildMemberData;
|
||
GuildMemberData.dwPID = memberPacket.pid;
|
||
GuildMemberData.byGrade = memberPacket.byGrade;
|
||
GuildMemberData.strName = szName;
|
||
GuildMemberData.byJob = memberPacket.byJob;
|
||
GuildMemberData.byLevel = memberPacket.byLevel;
|
||
GuildMemberData.dwOffer = memberPacket.dwOffer;
|
||
GuildMemberData.byGeneralFlag = memberPacket.byIsGeneral;
|
||
CPythonGuild::Instance().RegisterMember(GuildMemberData);
|
||
|
||
// Messenger
|
||
if (strcmp(szName, CPythonPlayer::Instance().GetName()))
|
||
CPythonMessenger::Instance().AppendGuildMember(szName);
|
||
|
||
__RefreshTargetBoardByName(szName);
|
||
|
||
iPacketSize -= sizeof(memberPacket);
|
||
}
|
||
|
||
__RefreshGuildWindowInfoPage();
|
||
__RefreshGuildWindowMemberPage();
|
||
__RefreshMessengerWindow();
|
||
__RefreshCharacterWindow();
|
||
break;
|
||
}
|
||
case GUILD_SUBHEADER_GC_GRADE:
|
||
{
|
||
BYTE byCount;
|
||
if (!Recv(sizeof(byCount), &byCount))
|
||
return false;
|
||
|
||
for (BYTE i = 0; i < byCount; ++ i)
|
||
{
|
||
BYTE byIndex;
|
||
if (!Recv(sizeof(byCount), &byIndex))
|
||
return false;
|
||
TPacketGCGuildSubGrade GradePacket;
|
||
if (!Recv(sizeof(GradePacket), &GradePacket))
|
||
return false;
|
||
|
||
CPythonGuild::Instance().SetGradeData(byIndex, CPythonGuild::SGuildGradeData(GradePacket.auth_flag, GradePacket.grade_name));
|
||
//Tracef(" <Grade> [%d/%d] : %s, %d\n", byIndex, byCount, GradePacket.grade_name, GradePacket.auth_flag);
|
||
}
|
||
__RefreshGuildWindowGradePage();
|
||
__RefreshGuildWindowMemberPageGradeComboBox();
|
||
break;
|
||
}
|
||
case GUILD_SUBHEADER_GC_GRADE_NAME:
|
||
{
|
||
BYTE byGradeNumber;
|
||
if (!Recv(sizeof(byGradeNumber), &byGradeNumber))
|
||
return false;
|
||
|
||
char szGradeName[GUILD_GRADE_NAME_MAX_LEN+1] = "";
|
||
if (!Recv(sizeof(szGradeName), &szGradeName))
|
||
return false;
|
||
|
||
CPythonGuild::Instance().SetGradeName(byGradeNumber, szGradeName);
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildGrade", Py_BuildValue("()"));
|
||
|
||
Tracef(" <Change Grade Name> %d, %s\n", byGradeNumber, szGradeName);
|
||
__RefreshGuildWindowGradePage();
|
||
__RefreshGuildWindowMemberPageGradeComboBox();
|
||
break;
|
||
}
|
||
case GUILD_SUBHEADER_GC_GRADE_AUTH:
|
||
{
|
||
BYTE byGradeNumber;
|
||
if (!Recv(sizeof(byGradeNumber), &byGradeNumber))
|
||
return false;
|
||
BYTE byAuthorityFlag;
|
||
if (!Recv(sizeof(byAuthorityFlag), &byAuthorityFlag))
|
||
return false;
|
||
|
||
CPythonGuild::Instance().SetGradeAuthority(byGradeNumber, byAuthorityFlag);
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshGuildGrade", Py_BuildValue("()"));
|
||
|
||
Tracef(" <Change Grade Authority> %d, %d\n", byGradeNumber, byAuthorityFlag);
|
||
__RefreshGuildWindowGradePage();
|
||
break;
|
||
}
|
||
case GUILD_SUBHEADER_GC_INFO:
|
||
{
|
||
TPacketGCGuildInfo GuildInfo;
|
||
if (!Recv(sizeof(GuildInfo), &GuildInfo))
|
||
return false;
|
||
|
||
CPythonGuild::Instance().EnableGuild();
|
||
CPythonGuild::TGuildInfo & rGuildInfo = CPythonGuild::Instance().GetGuildInfoRef();
|
||
strncpy(rGuildInfo.szGuildName, GuildInfo.name, GUILD_NAME_MAX_LEN);
|
||
rGuildInfo.szGuildName[GUILD_NAME_MAX_LEN] = '\0';
|
||
|
||
rGuildInfo.dwGuildID = GuildInfo.guild_id;
|
||
rGuildInfo.dwMasterPID = GuildInfo.master_pid;
|
||
rGuildInfo.dwGuildLevel = GuildInfo.level;
|
||
rGuildInfo.dwCurrentExperience = GuildInfo.exp;
|
||
rGuildInfo.dwCurrentMemberCount = GuildInfo.member_count;
|
||
rGuildInfo.dwMaxMemberCount = GuildInfo.max_member_count;
|
||
rGuildInfo.dwGuildMoney = GuildInfo.gold;
|
||
rGuildInfo.bHasLand = GuildInfo.hasLand;
|
||
|
||
//Tracef(" <Info> %s, %d, %d : %d\n", GuildInfo.name, GuildInfo.master_pid, GuildInfo.level, rGuildInfo.bHasLand);
|
||
__RefreshGuildWindowInfoPage();
|
||
break;
|
||
}
|
||
case GUILD_SUBHEADER_GC_COMMENTS:
|
||
{
|
||
BYTE byCount;
|
||
if (!Recv(sizeof(byCount), &byCount))
|
||
return false;
|
||
|
||
CPythonGuild::Instance().ClearComment();
|
||
//Tracef(" >>> Comments Count : %d\n", byCount);
|
||
|
||
for (BYTE i = 0; i < byCount; ++i)
|
||
{
|
||
DWORD dwCommentID;
|
||
if (!Recv(sizeof(dwCommentID), &dwCommentID))
|
||
return false;
|
||
|
||
char szName[CHARACTER_NAME_MAX_LEN+1] = "";
|
||
if (!Recv(sizeof(szName), &szName))
|
||
return false;
|
||
|
||
char szComment[GULID_COMMENT_MAX_LEN+1] = "";
|
||
if (!Recv(sizeof(szComment), &szComment))
|
||
return false;
|
||
|
||
//Tracef(" [Comment-%d] : %s, %s\n", dwCommentID, szName, szComment);
|
||
CPythonGuild::Instance().RegisterComment(dwCommentID, szName, szComment);
|
||
}
|
||
|
||
__RefreshGuildWindowBoardPage();
|
||
break;
|
||
}
|
||
case GUILD_SUBHEADER_GC_CHANGE_EXP:
|
||
{
|
||
BYTE byLevel;
|
||
if (!Recv(sizeof(byLevel), &byLevel))
|
||
return false;
|
||
DWORD dwEXP;
|
||
if (!Recv(sizeof(dwEXP), &dwEXP))
|
||
return false;
|
||
CPythonGuild::Instance().SetGuildEXP(byLevel, dwEXP);
|
||
Tracef(" <ChangeEXP> %d, %d\n", byLevel, dwEXP);
|
||
__RefreshGuildWindowInfoPage();
|
||
break;
|
||
}
|
||
case GUILD_SUBHEADER_GC_CHANGE_MEMBER_GRADE:
|
||
{
|
||
DWORD dwPID;
|
||
if (!Recv(sizeof(dwPID), &dwPID))
|
||
return false;
|
||
BYTE byGrade;
|
||
if (!Recv(sizeof(byGrade), &byGrade))
|
||
return false;
|
||
CPythonGuild::Instance().ChangeGuildMemberGrade(dwPID, byGrade);
|
||
Tracef(" <ChangeMemberGrade> %d, %d\n", dwPID, byGrade);
|
||
__RefreshGuildWindowMemberPage();
|
||
break;
|
||
}
|
||
case GUILD_SUBHEADER_GC_SKILL_INFO:
|
||
{
|
||
CPythonGuild::TGuildSkillData & rSkillData = CPythonGuild::Instance().GetGuildSkillDataRef();
|
||
if (!Recv(sizeof(rSkillData.bySkillPoint), &rSkillData.bySkillPoint))
|
||
return false;
|
||
if (!Recv(sizeof(rSkillData.bySkillLevel), rSkillData.bySkillLevel))
|
||
return false;
|
||
if (!Recv(sizeof(rSkillData.wGuildPoint), &rSkillData.wGuildPoint))
|
||
return false;
|
||
if (!Recv(sizeof(rSkillData.wMaxGuildPoint), &rSkillData.wMaxGuildPoint))
|
||
return false;
|
||
|
||
Tracef(" <SkillInfo> %d / %d, %d\n", rSkillData.bySkillPoint, rSkillData.wGuildPoint, rSkillData.wMaxGuildPoint);
|
||
__RefreshGuildWindowSkillPage();
|
||
break;
|
||
}
|
||
case GUILD_SUBHEADER_GC_CHANGE_MEMBER_GENERAL:
|
||
{
|
||
DWORD dwPID;
|
||
if (!Recv(sizeof(dwPID), &dwPID))
|
||
return false;
|
||
BYTE byFlag;
|
||
if (!Recv(sizeof(byFlag), &byFlag))
|
||
return false;
|
||
|
||
CPythonGuild::Instance().ChangeGuildMemberGeneralFlag(dwPID, byFlag);
|
||
Tracef(" <ChangeMemberGeneralFlag> %d, %d\n", dwPID, byFlag);
|
||
__RefreshGuildWindowMemberPage();
|
||
break;
|
||
}
|
||
case GUILD_SUBHEADER_GC_GUILD_INVITE:
|
||
{
|
||
DWORD dwGuildID;
|
||
if (!Recv(sizeof(dwGuildID), &dwGuildID))
|
||
return false;
|
||
char szGuildName[GUILD_NAME_MAX_LEN+1];
|
||
if (!Recv(GUILD_NAME_MAX_LEN, &szGuildName))
|
||
return false;
|
||
|
||
szGuildName[GUILD_NAME_MAX_LEN] = 0;
|
||
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RecvGuildInviteQuestion", Py_BuildValue("(is)", dwGuildID, szGuildName));
|
||
Tracef(" <Guild Invite> %d, %s\n", dwGuildID, szGuildName);
|
||
break;
|
||
}
|
||
case GUILD_SUBHEADER_GC_WAR:
|
||
{
|
||
TPacketGCGuildWar kGuildWar;
|
||
if (!Recv(sizeof(kGuildWar), &kGuildWar))
|
||
return false;
|
||
|
||
switch (kGuildWar.bWarState)
|
||
{
|
||
case GUILD_WAR_SEND_DECLARE:
|
||
Tracef(" >> GUILD_SUBHEADER_GC_WAR : GUILD_WAR_SEND_DECLARE\n");
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
|
||
"BINARY_GuildWar_OnSendDeclare",
|
||
Py_BuildValue("(i)", kGuildWar.dwGuildOpp)
|
||
);
|
||
break;
|
||
case GUILD_WAR_RECV_DECLARE:
|
||
Tracef(" >> GUILD_SUBHEADER_GC_WAR : GUILD_WAR_RECV_DECLARE\n");
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
|
||
"BINARY_GuildWar_OnRecvDeclare",
|
||
Py_BuildValue("(ii)", kGuildWar.dwGuildOpp, kGuildWar.bType)
|
||
);
|
||
break;
|
||
case GUILD_WAR_ON_WAR:
|
||
Tracef(" >> GUILD_SUBHEADER_GC_WAR : GUILD_WAR_ON_WAR : %d, %d\n", kGuildWar.dwGuildSelf, kGuildWar.dwGuildOpp);
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
|
||
"BINARY_GuildWar_OnStart",
|
||
Py_BuildValue("(ii)", kGuildWar.dwGuildSelf, kGuildWar.dwGuildOpp)
|
||
);
|
||
CPythonGuild::Instance().StartGuildWar(kGuildWar.dwGuildOpp);
|
||
break;
|
||
case GUILD_WAR_END:
|
||
Tracef(" >> GUILD_SUBHEADER_GC_WAR : GUILD_WAR_END\n");
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
|
||
"BINARY_GuildWar_OnEnd",
|
||
Py_BuildValue("(ii)", kGuildWar.dwGuildSelf, kGuildWar.dwGuildOpp)
|
||
);
|
||
CPythonGuild::Instance().EndGuildWar(kGuildWar.dwGuildOpp);
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
case GUILD_SUBHEADER_GC_GUILD_NAME:
|
||
{
|
||
DWORD dwID;
|
||
char szGuildName[GUILD_NAME_MAX_LEN+1];
|
||
|
||
int iPacketSize = int(GuildPacket.size) - sizeof(GuildPacket);
|
||
|
||
int nItemSize = sizeof(dwID) + GUILD_NAME_MAX_LEN;
|
||
|
||
assert(iPacketSize%nItemSize==0 && "GUILD_SUBHEADER_GC_GUILD_NAME");
|
||
|
||
for (; iPacketSize > 0;)
|
||
{
|
||
if (!Recv(sizeof(dwID), &dwID))
|
||
return false;
|
||
|
||
if (!Recv(GUILD_NAME_MAX_LEN, &szGuildName))
|
||
return false;
|
||
|
||
szGuildName[GUILD_NAME_MAX_LEN] = 0;
|
||
|
||
//Tracef(" >> GulidName [%d : %s]\n", dwID, szGuildName);
|
||
CPythonGuild::Instance().RegisterGuildName(dwID, szGuildName);
|
||
iPacketSize -= nItemSize;
|
||
}
|
||
break;
|
||
}
|
||
case GUILD_SUBHEADER_GC_GUILD_WAR_LIST:
|
||
{
|
||
DWORD dwSrcGuildID;
|
||
DWORD dwDstGuildID;
|
||
|
||
int iPacketSize = int(GuildPacket.size) - sizeof(GuildPacket);
|
||
int nItemSize = sizeof(dwSrcGuildID) + sizeof(dwDstGuildID);
|
||
|
||
assert(iPacketSize%nItemSize==0 && "GUILD_SUBHEADER_GC_GUILD_WAR_LIST");
|
||
|
||
for (; iPacketSize > 0;)
|
||
{
|
||
if (!Recv(sizeof(dwSrcGuildID), &dwSrcGuildID))
|
||
return false;
|
||
|
||
if (!Recv(sizeof(dwDstGuildID), &dwDstGuildID))
|
||
return false;
|
||
|
||
Tracef(" >> GulidWarList [%d vs %d]\n", dwSrcGuildID, dwDstGuildID);
|
||
CInstanceBase::InsertGVGKey(dwSrcGuildID, dwDstGuildID);
|
||
CPythonCharacterManager::Instance().ChangeGVG(dwSrcGuildID, dwDstGuildID);
|
||
iPacketSize -= nItemSize;
|
||
}
|
||
break;
|
||
}
|
||
case GUILD_SUBHEADER_GC_GUILD_WAR_END_LIST:
|
||
{
|
||
DWORD dwSrcGuildID;
|
||
DWORD dwDstGuildID;
|
||
|
||
int iPacketSize = int(GuildPacket.size) - sizeof(GuildPacket);
|
||
int nItemSize = sizeof(dwSrcGuildID) + sizeof(dwDstGuildID);
|
||
|
||
assert(iPacketSize%nItemSize==0 && "GUILD_SUBHEADER_GC_GUILD_WAR_END_LIST");
|
||
|
||
for (; iPacketSize > 0;)
|
||
{
|
||
|
||
if (!Recv(sizeof(dwSrcGuildID), &dwSrcGuildID))
|
||
return false;
|
||
|
||
if (!Recv(sizeof(dwDstGuildID), &dwDstGuildID))
|
||
return false;
|
||
|
||
Tracef(" >> GulidWarEndList [%d vs %d]\n", dwSrcGuildID, dwDstGuildID);
|
||
CInstanceBase::RemoveGVGKey(dwSrcGuildID, dwDstGuildID);
|
||
CPythonCharacterManager::Instance().ChangeGVG(dwSrcGuildID, dwDstGuildID);
|
||
iPacketSize -= nItemSize;
|
||
}
|
||
break;
|
||
}
|
||
case GUILD_SUBHEADER_GC_WAR_POINT:
|
||
{
|
||
TPacketGuildWarPoint GuildWarPoint;
|
||
if (!Recv(sizeof(GuildWarPoint), &GuildWarPoint))
|
||
return false;
|
||
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
|
||
"BINARY_GuildWar_OnRecvPoint",
|
||
Py_BuildValue("(iii)", GuildWarPoint.dwGainGuildID, GuildWarPoint.dwOpponentGuildID, GuildWarPoint.lPoint)
|
||
);
|
||
break;
|
||
}
|
||
case GUILD_SUBHEADER_GC_MONEY_CHANGE:
|
||
{
|
||
DWORD dwMoney;
|
||
if (!Recv(sizeof(dwMoney), &dwMoney))
|
||
return false;
|
||
|
||
CPythonGuild::Instance().SetGuildMoney(dwMoney);
|
||
|
||
__RefreshGuildWindowInfoPage();
|
||
Tracef(" >> Guild Money Change : %d\n", dwMoney);
|
||
break;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
// Guild
|
||
//////////////////////////////////////////////////////////////////////////
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////////////
|
||
// Fishing
|
||
|
||
bool CPythonNetworkStream::SendFishingPacket(int iRotation)
|
||
{
|
||
BYTE byHeader = HEADER_CG_FISHING;
|
||
if (!Send(sizeof(byHeader), &byHeader))
|
||
return false;
|
||
BYTE byPacketRotation = iRotation / 5;
|
||
if (!Send(sizeof(BYTE), &byPacketRotation))
|
||
return false;
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendGiveItemPacket(DWORD dwTargetVID, TItemPos ItemPos, int iItemCount)
|
||
{
|
||
TPacketCGGiveItem GiveItemPacket;
|
||
GiveItemPacket.byHeader = HEADER_CG_GIVE_ITEM;
|
||
GiveItemPacket.dwTargetVID = dwTargetVID;
|
||
GiveItemPacket.ItemPos = ItemPos;
|
||
GiveItemPacket.byItemCount = iItemCount;
|
||
|
||
if (!Send(sizeof(GiveItemPacket), &GiveItemPacket))
|
||
return false;
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvFishing()
|
||
{
|
||
TPacketGCFishing FishingPacket;
|
||
if (!Recv(sizeof(FishingPacket), &FishingPacket))
|
||
return false;
|
||
|
||
CInstanceBase * pFishingInstance = NULL;
|
||
if (FISHING_SUBHEADER_GC_FISH != FishingPacket.subheader)
|
||
{
|
||
pFishingInstance = CPythonCharacterManager::Instance().GetInstancePtr(FishingPacket.info);
|
||
if (!pFishingInstance)
|
||
return true;
|
||
}
|
||
|
||
switch (FishingPacket.subheader)
|
||
{
|
||
case FISHING_SUBHEADER_GC_START:
|
||
pFishingInstance->StartFishing(float(FishingPacket.dir) * 5.0f);
|
||
break;
|
||
case FISHING_SUBHEADER_GC_STOP:
|
||
if (pFishingInstance->IsFishing())
|
||
pFishingInstance->StopFishing();
|
||
break;
|
||
case FISHING_SUBHEADER_GC_REACT:
|
||
if (pFishingInstance->IsFishing())
|
||
{
|
||
pFishingInstance->SetFishEmoticon(); // Fish Emoticon
|
||
pFishingInstance->ReactFishing();
|
||
}
|
||
break;
|
||
case FISHING_SUBHEADER_GC_SUCCESS:
|
||
pFishingInstance->CatchSuccess();
|
||
break;
|
||
case FISHING_SUBHEADER_GC_FAIL:
|
||
pFishingInstance->CatchFail();
|
||
if (pFishingInstance == CPythonCharacterManager::Instance().GetMainInstancePtr())
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnFishingFailure", Py_BuildValue("()"));
|
||
}
|
||
break;
|
||
case FISHING_SUBHEADER_GC_FISH:
|
||
{
|
||
DWORD dwFishID = FishingPacket.info;
|
||
|
||
if (0 == FishingPacket.info)
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnFishingNotifyUnknown", Py_BuildValue("()"));
|
||
return true;
|
||
}
|
||
|
||
CItemData * pItemData;
|
||
if (!CItemManager::Instance().GetItemDataPointer(dwFishID, &pItemData))
|
||
return true;
|
||
|
||
CInstanceBase * pMainInstance = CPythonCharacterManager::Instance().GetMainInstancePtr();
|
||
if (!pMainInstance)
|
||
return true;
|
||
|
||
if (pMainInstance->IsFishing())
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnFishingNotify", Py_BuildValue("(is)", CItemData::ITEM_TYPE_FISH == pItemData->GetType(), pItemData->GetName()));
|
||
}
|
||
else
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnFishingSuccess", Py_BuildValue("(is)", CItemData::ITEM_TYPE_FISH == pItemData->GetType(), pItemData->GetName()));
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
// Fishing
|
||
/////////////////////////////////////////////////////////////////////////
|
||
|
||
/////////////////////////////////////////////////////////////////////////
|
||
// Dungeon
|
||
bool CPythonNetworkStream::RecvDungeon()
|
||
{
|
||
TPacketGCDungeon DungeonPacket;
|
||
if (!Recv(sizeof(DungeonPacket), &DungeonPacket))
|
||
return false;
|
||
|
||
switch (DungeonPacket.subheader)
|
||
{
|
||
case DUNGEON_SUBHEADER_GC_TIME_ATTACK_START:
|
||
{
|
||
break;
|
||
}
|
||
case DUNGEON_SUBHEADER_GC_DESTINATION_POSITION:
|
||
{
|
||
unsigned long ulx, uly;
|
||
if (!Recv(sizeof(ulx), &ulx))
|
||
return false;
|
||
if (!Recv(sizeof(uly), &uly))
|
||
return false;
|
||
|
||
CPythonPlayer::Instance().SetDungeonDestinationPosition(ulx, uly);
|
||
break;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
// Dungeon
|
||
/////////////////////////////////////////////////////////////////////////
|
||
|
||
/////////////////////////////////////////////////////////////////////////
|
||
// MyShop
|
||
bool CPythonNetworkStream::SendBuildPrivateShopPacket(const char * c_szName, const std::vector<TShopItemTable> & c_rSellingItemStock)
|
||
{
|
||
TPacketCGMyShop packet;
|
||
packet.bHeader = HEADER_CG_MYSHOP;
|
||
strncpy(packet.szSign, c_szName, SHOP_SIGN_MAX_LEN);
|
||
packet.bCount = c_rSellingItemStock.size();
|
||
if (!Send(sizeof(packet), &packet))
|
||
return false;
|
||
|
||
for (std::vector<TShopItemTable>::const_iterator itor = c_rSellingItemStock.begin(); itor < c_rSellingItemStock.end(); ++itor)
|
||
{
|
||
const TShopItemTable & c_rItem = *itor;
|
||
if (!Send(sizeof(c_rItem), &c_rItem))
|
||
return false;
|
||
}
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvShopSignPacket()
|
||
{
|
||
TPacketGCShopSign p;
|
||
if (!Recv(sizeof(TPacketGCShopSign), &p))
|
||
return false;
|
||
|
||
CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
|
||
|
||
if (0 == strlen(p.szSign))
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
|
||
"BINARY_PrivateShop_Disappear",
|
||
Py_BuildValue("(i)", p.dwVID)
|
||
);
|
||
|
||
if (rkPlayer.IsMainCharacterIndex(p.dwVID))
|
||
rkPlayer.ClosePrivateShop();
|
||
}
|
||
else
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
|
||
"BINARY_PrivateShop_Appear",
|
||
Py_BuildValue("(is)", p.dwVID, p.szSign)
|
||
);
|
||
|
||
if (rkPlayer.IsMainCharacterIndex(p.dwVID))
|
||
rkPlayer.OpenPrivateShop();
|
||
}
|
||
|
||
return true;
|
||
}
|
||
/////////////////////////////////////////////////////////////////////////
|
||
|
||
bool CPythonNetworkStream::RecvTimePacket()
|
||
{
|
||
TPacketGCTime TimePacket;
|
||
if (!Recv(sizeof(TimePacket), &TimePacket))
|
||
return false;
|
||
|
||
IAbstractApplication& rkApp=IAbstractApplication::GetSingleton();
|
||
rkApp.SetServerTime(TimePacket.time);
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvWalkModePacket()
|
||
{
|
||
TPacketGCWalkMode WalkModePacket;
|
||
if (!Recv(sizeof(WalkModePacket), &WalkModePacket))
|
||
return false;
|
||
|
||
CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(WalkModePacket.vid);
|
||
if (pInstance)
|
||
{
|
||
if (WALKMODE_RUN == WalkModePacket.mode)
|
||
{
|
||
pInstance->SetRunMode();
|
||
}
|
||
else
|
||
{
|
||
pInstance->SetWalkMode();
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvChangeSkillGroupPacket()
|
||
{
|
||
TPacketGCChangeSkillGroup ChangeSkillGroup;
|
||
if (!Recv(sizeof(ChangeSkillGroup), &ChangeSkillGroup))
|
||
return false;
|
||
|
||
m_dwMainActorSkillGroup = ChangeSkillGroup.skill_group;
|
||
|
||
CPythonPlayer::Instance().NEW_ClearSkillData();
|
||
__RefreshCharacterWindow();
|
||
return true;
|
||
}
|
||
|
||
void CPythonNetworkStream::__TEST_SetSkillGroupFake(int iIndex)
|
||
{
|
||
m_dwMainActorSkillGroup = DWORD(iIndex);
|
||
|
||
CPythonPlayer::Instance().NEW_ClearSkillData();
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshCharacter", Py_BuildValue("()"));
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendRefinePacket(BYTE byPos, BYTE byType)
|
||
{
|
||
TPacketCGRefine kRefinePacket;
|
||
kRefinePacket.header = HEADER_CG_REFINE;
|
||
kRefinePacket.pos = byPos;
|
||
kRefinePacket.type = byType;
|
||
|
||
if (!Send(sizeof(kRefinePacket), &kRefinePacket))
|
||
return false;
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendSelectItemPacket(DWORD dwItemPos)
|
||
{
|
||
TPacketCGScriptSelectItem kScriptSelectItem;
|
||
kScriptSelectItem.header = HEADER_CG_SCRIPT_SELECT_ITEM;
|
||
kScriptSelectItem.selection = dwItemPos;
|
||
|
||
if (!Send(sizeof(kScriptSelectItem), &kScriptSelectItem))
|
||
return false;
|
||
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvRefineInformationPacket()
|
||
{
|
||
TPacketGCRefineInformation kRefineInfoPacket;
|
||
if (!Recv(sizeof(kRefineInfoPacket), &kRefineInfoPacket))
|
||
return false;
|
||
|
||
TRefineTable & rkRefineTable = kRefineInfoPacket.refine_table;
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
|
||
"OpenRefineDialog",
|
||
Py_BuildValue("(iiii)",
|
||
kRefineInfoPacket.pos,
|
||
kRefineInfoPacket.refine_table.result_vnum,
|
||
rkRefineTable.cost,
|
||
rkRefineTable.prob));
|
||
|
||
for (int i = 0; i < rkRefineTable.material_count; ++i)
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "AppendMaterialToRefineDialog", Py_BuildValue("(ii)", rkRefineTable.materials[i].vnum, rkRefineTable.materials[i].count));
|
||
}
|
||
|
||
#ifdef _DEBUG
|
||
Tracef(" >> RecvRefineInformationPacket(pos=%d, result_vnum=%d, cost=%d, prob=%d)\n",
|
||
kRefineInfoPacket.pos,
|
||
kRefineInfoPacket.refine_table.result_vnum,
|
||
rkRefineTable.cost,
|
||
rkRefineTable.prob);
|
||
#endif
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvRefineInformationPacketNew()
|
||
{
|
||
TPacketGCRefineInformationNew kRefineInfoPacket;
|
||
if (!Recv(sizeof(kRefineInfoPacket), &kRefineInfoPacket))
|
||
return false;
|
||
|
||
TRefineTable & rkRefineTable = kRefineInfoPacket.refine_table;
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME],
|
||
"OpenRefineDialog",
|
||
Py_BuildValue("(iiiii)",
|
||
kRefineInfoPacket.pos,
|
||
kRefineInfoPacket.refine_table.result_vnum,
|
||
rkRefineTable.cost,
|
||
rkRefineTable.prob,
|
||
kRefineInfoPacket.type)
|
||
);
|
||
|
||
for (int i = 0; i < rkRefineTable.material_count; ++i)
|
||
{
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "AppendMaterialToRefineDialog", Py_BuildValue("(ii)", rkRefineTable.materials[i].vnum, rkRefineTable.materials[i].count));
|
||
}
|
||
|
||
#ifdef _DEBUG
|
||
Tracef(" >> RecvRefineInformationPacketNew(pos=%d, result_vnum=%d, cost=%d, prob=%d, type=%d)\n",
|
||
kRefineInfoPacket.pos,
|
||
kRefineInfoPacket.refine_table.result_vnum,
|
||
rkRefineTable.cost,
|
||
rkRefineTable.prob,
|
||
kRefineInfoPacket.type);
|
||
#endif
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvNPCList()
|
||
{
|
||
TPacketGCNPCPosition kNPCPosition;
|
||
if (!Recv(sizeof(kNPCPosition), &kNPCPosition))
|
||
return false;
|
||
|
||
assert(int(kNPCPosition.size)-sizeof(kNPCPosition) == kNPCPosition.count*sizeof(TNPCPosition) && "HEADER_GC_NPC_POSITION");
|
||
|
||
CPythonMiniMap::Instance().ClearAtlasMarkInfo();
|
||
|
||
for (int i = 0; i < kNPCPosition.count; ++i)
|
||
{
|
||
TNPCPosition NPCPosition;
|
||
if (!Recv(sizeof(TNPCPosition), &NPCPosition))
|
||
return false;
|
||
|
||
CPythonMiniMap::Instance().RegisterAtlasMark(NPCPosition.bType, NPCPosition.name, NPCPosition.x, NPCPosition.y);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::__SendCRCReportPacket()
|
||
{
|
||
/*
|
||
DWORD dwProcessCRC = 0;
|
||
DWORD dwFileCRC = 0;
|
||
CFilename exeFileName;
|
||
//LPCVOID c_pvBaseAddress = NULL;
|
||
|
||
GetExeCRC(dwProcessCRC, dwFileCRC);
|
||
|
||
CFilename strRootPackFileName = CEterPackManager::Instance().GetRootPacketFileName();
|
||
strRootPackFileName.ChangeDosPath();
|
||
|
||
TPacketCGCRCReport kReportPacket;
|
||
|
||
kReportPacket.header = HEADER_CG_CRC_REPORT;
|
||
kReportPacket.byPackMode = CEterPackManager::Instance().GetSearchMode();
|
||
kReportPacket.dwBinaryCRC32 = dwFileCRC;
|
||
kReportPacket.dwProcessCRC32 = dwProcessCRC;
|
||
kReportPacket.dwRootPackCRC32 = GetFileCRC32(strRootPackFileName.c_str());
|
||
|
||
if (!Send(sizeof(kReportPacket), &kReportPacket))
|
||
Tracef("SendClientReportPacket Error");
|
||
|
||
return SendSequence();
|
||
*/
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::SendClientVersionPacket()
|
||
{
|
||
std::string filename;
|
||
|
||
GetExcutedFileName(filename);
|
||
|
||
filename = CFileNameHelper::NoPath(filename);
|
||
CFileNameHelper::ChangeDosPath(filename);
|
||
|
||
if (LocaleService_IsEUROPE() && false == LocaleService_IsYMIR())
|
||
{
|
||
TPacketCGClientVersion2 kVersionPacket;
|
||
kVersionPacket.header = HEADER_CG_CLIENT_VERSION2;
|
||
strncpy(kVersionPacket.filename, filename.c_str(), sizeof(kVersionPacket.filename)-1);
|
||
strncpy(kVersionPacket.timestamp, "1215955205", sizeof(kVersionPacket.timestamp)-1); // # python time.time <20><><EFBFBD>ڸ<EFBFBD>
|
||
//strncpy(kVersionPacket.timestamp, __TIMESTAMP__, sizeof(kVersionPacket.timestamp)-1); // old_string_ver
|
||
//strncpy(kVersionPacket.timestamp, "1218055205", sizeof(kVersionPacket.timestamp)-1); // new_future
|
||
//strncpy(kVersionPacket.timestamp, "1214055205", sizeof(kVersionPacket.timestamp)-1); // old_past
|
||
|
||
if (!Send(sizeof(kVersionPacket), &kVersionPacket))
|
||
Tracef("SendClientReportPacket Error");
|
||
}
|
||
else
|
||
{
|
||
TPacketCGClientVersion kVersionPacket;
|
||
kVersionPacket.header = HEADER_CG_CLIENT_VERSION;
|
||
strncpy(kVersionPacket.filename, filename.c_str(), sizeof(kVersionPacket.filename)-1);
|
||
strncpy(kVersionPacket.timestamp, __TIMESTAMP__, sizeof(kVersionPacket.timestamp)-1);
|
||
|
||
if (!Send(sizeof(kVersionPacket), &kVersionPacket))
|
||
Tracef("SendClientReportPacket Error");
|
||
}
|
||
return SendSequence();
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvAffectAddPacket()
|
||
{
|
||
TPacketGCAffectAdd kAffectAdd;
|
||
if (!Recv(sizeof(kAffectAdd), &kAffectAdd))
|
||
return false;
|
||
|
||
TPacketAffectElement & rkElement = kAffectAdd.elem;
|
||
if (rkElement.bPointIdxApplyOn == POINT_ENERGY)
|
||
{
|
||
CPythonPlayer::instance().SetStatus (POINT_ENERGY_END_TIME, CPythonApplication::Instance().GetServerTimeStamp() + rkElement.lDuration);
|
||
__RefreshStatus();
|
||
}
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_NEW_AddAffect", Py_BuildValue("(iiii)", rkElement.dwType, rkElement.bPointIdxApplyOn, rkElement.lApplyValue, rkElement.lDuration));
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvAffectRemovePacket()
|
||
{
|
||
TPacketGCAffectRemove kAffectRemove;
|
||
if (!Recv(sizeof(kAffectRemove), &kAffectRemove))
|
||
return false;
|
||
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_NEW_RemoveAffect", Py_BuildValue("(ii)", kAffectRemove.dwType, kAffectRemove.bApplyOn));
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvChannelPacket()
|
||
{
|
||
TPacketGCChannel kChannelPacket;
|
||
if (!Recv(sizeof(kChannelPacket), &kChannelPacket))
|
||
return false;
|
||
|
||
//Tracef(" >> CPythonNetworkStream::RecvChannelPacket(channel=%d)\n", kChannelPacket.channel);
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvViewEquipPacket()
|
||
{
|
||
TPacketGCViewEquip kViewEquipPacket;
|
||
if (!Recv(sizeof(kViewEquipPacket), &kViewEquipPacket))
|
||
return false;
|
||
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OpenEquipmentDialog", Py_BuildValue("(i)", kViewEquipPacket.dwVID));
|
||
|
||
for (int i = 0; i < WEAR_MAX_NUM; ++i)
|
||
{
|
||
TEquipmentItemSet & rItemSet = kViewEquipPacket.equips[i];
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetEquipmentDialogItem", Py_BuildValue("(iiii)", kViewEquipPacket.dwVID, i, rItemSet.vnum, rItemSet.count));
|
||
|
||
for (int j = 0; j < ITEM_SOCKET_SLOT_MAX_NUM; ++j)
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetEquipmentDialogSocket", Py_BuildValue("(iiii)", kViewEquipPacket.dwVID, i, j, rItemSet.alSockets[j]));
|
||
|
||
for (int k = 0; k < ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++k)
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "SetEquipmentDialogAttr", Py_BuildValue("(iiiii)", kViewEquipPacket.dwVID, i, k, rItemSet.aAttr[k].bType, rItemSet.aAttr[k].sValue));
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvLandPacket()
|
||
{
|
||
TPacketGCLandList kLandList;
|
||
if (!Recv(sizeof(kLandList), &kLandList))
|
||
return false;
|
||
|
||
std::vector<DWORD> kVec_dwGuildID;
|
||
|
||
CPythonMiniMap & rkMiniMap = CPythonMiniMap::Instance();
|
||
CPythonBackground & rkBG = CPythonBackground::Instance();
|
||
CInstanceBase * pMainInstance = CPythonPlayer::Instance().NEW_GetMainActorPtr();
|
||
|
||
rkMiniMap.ClearGuildArea();
|
||
rkBG.ClearGuildArea();
|
||
|
||
int iPacketSize = (kLandList.size - sizeof(TPacketGCLandList));
|
||
for (; iPacketSize > 0; iPacketSize-=sizeof(TLandPacketElement))
|
||
{
|
||
TLandPacketElement kElement;
|
||
if (!Recv(sizeof(TLandPacketElement), &kElement))
|
||
return false;
|
||
|
||
rkMiniMap.RegisterGuildArea(kElement.dwID,
|
||
kElement.dwGuildID,
|
||
kElement.x,
|
||
kElement.y,
|
||
kElement.width,
|
||
kElement.height);
|
||
|
||
if (pMainInstance)
|
||
if (kElement.dwGuildID == pMainInstance->GetGuildID())
|
||
{
|
||
rkBG.RegisterGuildArea(kElement.x,
|
||
kElement.y,
|
||
kElement.x+kElement.width,
|
||
kElement.y+kElement.height);
|
||
}
|
||
|
||
if (0 != kElement.dwGuildID)
|
||
kVec_dwGuildID.push_back(kElement.dwGuildID);
|
||
}
|
||
|
||
__DownloadSymbol(kVec_dwGuildID);
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvTargetCreatePacket()
|
||
{
|
||
TPacketGCTargetCreate kTargetCreate;
|
||
if (!Recv(sizeof(kTargetCreate), &kTargetCreate))
|
||
return false;
|
||
|
||
CPythonMiniMap & rkpyMiniMap = CPythonMiniMap::Instance();
|
||
rkpyMiniMap.CreateTarget(kTargetCreate.lID, kTargetCreate.szTargetName);
|
||
|
||
//#ifdef _DEBUG
|
||
// char szBuf[256+1];
|
||
// _snprintf(szBuf, sizeof(szBuf), "Ÿ<><C5B8><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>Ǿ<EFBFBD><C7BE><EFBFBD><EFBFBD>ϴ<EFBFBD> [%d:%s]", kTargetCreate.lID, kTargetCreate.szTargetName);
|
||
// CPythonChat::Instance().AppendChat(CHAT_TYPE_NOTICE, szBuf);
|
||
// Tracef(" >> RecvTargetCreatePacket %d : %s\n", kTargetCreate.lID, kTargetCreate.szTargetName);
|
||
//#endif
|
||
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OpenAtlasWindow", Py_BuildValue("()"));
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvTargetCreatePacketNew()
|
||
{
|
||
TPacketGCTargetCreateNew kTargetCreate;
|
||
if (!Recv(sizeof(kTargetCreate), &kTargetCreate))
|
||
return false;
|
||
|
||
CPythonMiniMap & rkpyMiniMap = CPythonMiniMap::Instance();
|
||
CPythonBackground & rkpyBG = CPythonBackground::Instance();
|
||
if (CREATE_TARGET_TYPE_LOCATION == kTargetCreate.byType)
|
||
{
|
||
rkpyMiniMap.CreateTarget(kTargetCreate.lID, kTargetCreate.szTargetName);
|
||
}
|
||
else
|
||
{
|
||
rkpyMiniMap.CreateTarget(kTargetCreate.lID, kTargetCreate.szTargetName, kTargetCreate.dwVID);
|
||
rkpyBG.CreateTargetEffect(kTargetCreate.lID, kTargetCreate.dwVID);
|
||
}
|
||
|
||
//#ifdef _DEBUG
|
||
// char szBuf[256+1];
|
||
// _snprintf(szBuf, sizeof(szBuf), "ij<><C4B3><EFBFBD><EFBFBD> Ÿ<><C5B8><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>Ǿ<EFBFBD><C7BE><EFBFBD><EFBFBD>ϴ<EFBFBD> [%d:%s:%d]", kTargetCreate.lID, kTargetCreate.szTargetName, kTargetCreate.dwVID);
|
||
// CPythonChat::Instance().AppendChat(CHAT_TYPE_NOTICE, szBuf);
|
||
// Tracef(" >> RecvTargetCreatePacketNew %d : %d/%d\n", kTargetCreate.lID, kTargetCreate.byType, kTargetCreate.dwVID);
|
||
//#endif
|
||
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OpenAtlasWindow", Py_BuildValue("()"));
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvTargetUpdatePacket()
|
||
{
|
||
TPacketGCTargetUpdate kTargetUpdate;
|
||
if (!Recv(sizeof(kTargetUpdate), &kTargetUpdate))
|
||
return false;
|
||
|
||
CPythonMiniMap & rkpyMiniMap = CPythonMiniMap::Instance();
|
||
rkpyMiniMap.UpdateTarget(kTargetUpdate.lID, kTargetUpdate.lX, kTargetUpdate.lY);
|
||
|
||
CPythonBackground & rkpyBG = CPythonBackground::Instance();
|
||
rkpyBG.CreateTargetEffect(kTargetUpdate.lID, kTargetUpdate.lX, kTargetUpdate.lY);
|
||
|
||
//#ifdef _DEBUG
|
||
// char szBuf[256+1];
|
||
// _snprintf(szBuf, sizeof(szBuf), "Ÿ<><C5B8><EFBFBD><EFBFBD> <20><>ġ<EFBFBD><C4A1> <20><><EFBFBD><EFBFBD> <20>Ǿ<EFBFBD><C7BE><EFBFBD><EFBFBD>ϴ<EFBFBD> [%d:%d/%d]", kTargetUpdate.lID, kTargetUpdate.lX, kTargetUpdate.lY);
|
||
// CPythonChat::Instance().AppendChat(CHAT_TYPE_NOTICE, szBuf);
|
||
// Tracef(" >> RecvTargetUpdatePacket %d : %d, %d\n", kTargetUpdate.lID, kTargetUpdate.lX, kTargetUpdate.lY);
|
||
//#endif
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvTargetDeletePacket()
|
||
{
|
||
TPacketGCTargetDelete kTargetDelete;
|
||
if (!Recv(sizeof(kTargetDelete), &kTargetDelete))
|
||
return false;
|
||
|
||
CPythonMiniMap & rkpyMiniMap = CPythonMiniMap::Instance();
|
||
rkpyMiniMap.DeleteTarget(kTargetDelete.lID);
|
||
|
||
CPythonBackground & rkpyBG = CPythonBackground::Instance();
|
||
rkpyBG.DeleteTargetEffect(kTargetDelete.lID);
|
||
|
||
//#ifdef _DEBUG
|
||
// Tracef(" >> RecvTargetDeletePacket %d\n", kTargetDelete.lID);
|
||
//#endif
|
||
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvLoverInfoPacket()
|
||
{
|
||
TPacketGCLoverInfo kLoverInfo;
|
||
if (!Recv(sizeof(kLoverInfo), &kLoverInfo))
|
||
return false;
|
||
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_LoverInfo", Py_BuildValue("(si)", kLoverInfo.szName, kLoverInfo.byLovePoint));
|
||
#ifdef _DEBUG
|
||
Tracef("RECV LOVER INFO : %s, %d\n", kLoverInfo.szName, kLoverInfo.byLovePoint);
|
||
#endif
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvLovePointUpdatePacket()
|
||
{
|
||
TPacketGCLovePointUpdate kLovePointUpdate;
|
||
if (!Recv(sizeof(kLovePointUpdate), &kLovePointUpdate))
|
||
return false;
|
||
|
||
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_UpdateLovePoint", Py_BuildValue("(i)", kLovePointUpdate.byLovePoint));
|
||
#ifdef _DEBUG
|
||
Tracef("RECV LOVE POINT UPDATE : %d\n", kLovePointUpdate.byLovePoint);
|
||
#endif
|
||
return true;
|
||
}
|
||
|
||
bool CPythonNetworkStream::RecvDigMotionPacket()
|
||
{
|
||
TPacketGCDigMotion kDigMotion;
|
||
if (!Recv(sizeof(kDigMotion), &kDigMotion))
|
||
return false;
|
||
|
||
#ifdef _DEBUG
|
||
Tracef(" Dig Motion [%d/%d]\n", kDigMotion.vid, kDigMotion.count);
|
||
#endif
|
||
|
||
IAbstractCharacterManager& rkChrMgr=IAbstractCharacterManager::GetSingleton();
|
||
CInstanceBase * pkInstMain = rkChrMgr.GetInstancePtr(kDigMotion.vid);
|
||
CInstanceBase * pkInstTarget = rkChrMgr.GetInstancePtr(kDigMotion.target_vid);
|
||
if (NULL == pkInstMain)
|
||
return true;
|
||
|
||
if (pkInstTarget)
|
||
pkInstMain->NEW_LookAtDestInstance(*pkInstTarget);
|
||
|
||
for (int i = 0; i < kDigMotion.count; ++i)
|
||
pkInstMain->PushOnceMotion(CRaceMotionData::NAME_DIG);
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
// <20><>ȥ<EFBFBD><C8A5> <20><>ȭ
|
||
bool CPythonNetworkStream::SendDragonSoulRefinePacket(BYTE bRefineType, TItemPos* pos)
|
||
{
|
||
TPacketCGDragonSoulRefine pk;
|
||
pk.header = HEADER_CG_DRAGON_SOUL_REFINE;
|
||
pk.bSubType = bRefineType;
|
||
memcpy (pk.ItemGrid, pos, sizeof (TItemPos) * DS_REFINE_WINDOW_MAX_NUM);
|
||
if (!Send(sizeof (pk), &pk))
|
||
{
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|