1508 lines
41 KiB
C++
1508 lines
41 KiB
C++
#include "StdAfx.h"
|
|
#include "PythonNetworkStream.h"
|
|
#include "PythonItem.h"
|
|
#include "PythonShop.h"
|
|
#include "PythonExchange.h"
|
|
#include "PythonSafeBox.h"
|
|
#include "PythonCharacterManager.h"
|
|
|
|
#include "AbstractPlayer.h"
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// SafeBox
|
|
|
|
bool CPythonNetworkStream::SendSafeBoxMoneyPacket(BYTE byState, DWORD dwMoney)
|
|
{
|
|
assert(!"CPythonNetworkStream::SendSafeBoxMoneyPacket - Don't use this function");
|
|
return false;
|
|
|
|
// TPacketCGSafeboxMoney kSafeboxMoney;
|
|
// kSafeboxMoney.bHeader = HEADER_CG_SAFEBOX_MONEY;
|
|
// kSafeboxMoney.bState = byState;
|
|
// kSafeboxMoney.dwMoney = dwMoney;
|
|
// if (!Send(sizeof(kSafeboxMoney), &kSafeboxMoney))
|
|
// return false;
|
|
//
|
|
// return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendSafeBoxCheckinPacket(TItemPos InventoryPos, BYTE bySafeBoxPos)
|
|
{
|
|
__PlayInventoryItemDropSound(InventoryPos);
|
|
|
|
TPacketCGSafeboxCheckin kSafeboxCheckin;
|
|
kSafeboxCheckin.bHeader = HEADER_CG_SAFEBOX_CHECKIN;
|
|
kSafeboxCheckin.ItemPos = InventoryPos;
|
|
kSafeboxCheckin.bSafePos = bySafeBoxPos;
|
|
if (!Send(sizeof(kSafeboxCheckin), &kSafeboxCheckin))
|
|
return false;
|
|
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendSafeBoxCheckoutPacket(BYTE bySafeBoxPos, TItemPos InventoryPos)
|
|
{
|
|
__PlaySafeBoxItemDropSound(bySafeBoxPos);
|
|
|
|
TPacketCGSafeboxCheckout kSafeboxCheckout;
|
|
kSafeboxCheckout.bHeader = HEADER_CG_SAFEBOX_CHECKOUT;
|
|
kSafeboxCheckout.bSafePos = bySafeBoxPos;
|
|
kSafeboxCheckout.ItemPos = InventoryPos;
|
|
if (!Send(sizeof(kSafeboxCheckout), &kSafeboxCheckout))
|
|
return false;
|
|
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendSafeBoxItemMovePacket(BYTE bySourcePos, BYTE byTargetPos, DWORD byCount)
|
|
{
|
|
__PlaySafeBoxItemDropSound(bySourcePos);
|
|
|
|
TPacketCGItemMove kItemMove;
|
|
kItemMove.header = HEADER_CG_SAFEBOX_ITEM_MOVE;
|
|
kItemMove.pos = TItemPos(INVENTORY, bySourcePos);
|
|
kItemMove.num = byCount;
|
|
kItemMove.change_pos = TItemPos(INVENTORY, byTargetPos);
|
|
if (!Send(sizeof(kItemMove), &kItemMove))
|
|
return false;
|
|
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::RecvSafeBoxSetPacket()
|
|
{
|
|
TPacketGCItemSet2 kItemSet;
|
|
if (!Recv(sizeof(kItemSet), &kItemSet))
|
|
return false;
|
|
TraceError("CheckNetworkProblem: Step 0 Size: %d", sizeof(kItemSet));
|
|
|
|
TItemData kItemData;
|
|
kItemData.vnum = kItemSet.vnum;
|
|
kItemData.count = kItemSet.count;
|
|
kItemData.flags = kItemSet.flags;
|
|
kItemData.anti_flags = kItemSet.anti_flags;
|
|
#ifdef ELEMENT_SPELL_WORLDARD
|
|
kItemData.grade_element = kItemSet.grade_element;
|
|
for (int i=0; i<MAX_ELEMENTS_SPELL; ++i){
|
|
kItemData.attack_element[i] = kItemSet.attack_element[i];
|
|
kItemData.elements_value_bonus[i] = kItemSet.elements_value_bonus[i];
|
|
}
|
|
kItemData.element_type_bonus = kItemSet.element_type_bonus;
|
|
#endif
|
|
for (int isocket=0; isocket<ITEM_SOCKET_SLOT_MAX_NUM; ++isocket)
|
|
kItemData.alSockets[isocket] = kItemSet.alSockets[isocket];
|
|
for (int iattr=0; iattr<ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++iattr)
|
|
kItemData.aAttr[iattr] = kItemSet.aAttr[iattr];
|
|
#ifdef ENABLE_GLOVE_SYSTEM
|
|
for (int iattr=0; iattr<GLOVE_ATTR_MAX_NUM; ++iattr)
|
|
kItemData.randomAttr[iattr] = kItemSet.randomAttr[iattr];
|
|
#endif
|
|
#ifdef ENABLE_NEW_NAME_ITEM
|
|
//sprintf(kItemData.name, "%s", kItemSet.name);
|
|
strcpy(kItemData.name, kItemSet.name);
|
|
#endif
|
|
#ifdef ENABLE_SOULBIND_SYSTEM
|
|
kItemData.bind = kItemSet.bind;
|
|
#endif
|
|
TraceError("CheckNetworkProblem: Step 1 Size: %d", sizeof(kItemSet));
|
|
CPythonSafeBox::Instance().SetItemData(kItemSet.Cell.cell, kItemData);
|
|
TraceError("CheckNetworkProblem: Step 2 Size: %d", sizeof(kItemSet));
|
|
__RefreshSafeboxWindow();
|
|
TraceError("CheckNetworkProblem: Step 3 Size: %d", sizeof(kItemSet));
|
|
return true;
|
|
}
|
|
|
|
bool CPythonNetworkStream::RecvSafeBoxDelPacket()
|
|
{
|
|
TPacketGCItemDel kItemDel;
|
|
if (!Recv(sizeof(kItemDel), &kItemDel))
|
|
return false;
|
|
|
|
CPythonSafeBox::Instance().DelItemData(kItemDel.pos);
|
|
|
|
__RefreshSafeboxWindow();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CPythonNetworkStream::RecvSafeBoxWrongPasswordPacket()
|
|
{
|
|
TPacketGCSafeboxWrongPassword kSafeboxWrongPassword;
|
|
|
|
if (!Recv(sizeof(kSafeboxWrongPassword), &kSafeboxWrongPassword))
|
|
return false;
|
|
|
|
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnSafeBoxError", Py_BuildValue("()"));
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CPythonNetworkStream::RecvSafeBoxSizePacket()
|
|
{
|
|
TPacketGCSafeboxSize kSafeBoxSize;
|
|
if (!Recv(sizeof(kSafeBoxSize), &kSafeBoxSize))
|
|
return false;
|
|
|
|
CPythonSafeBox::Instance().OpenSafeBox(kSafeBoxSize.bSize);
|
|
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OpenSafeboxWindow", Py_BuildValue("(i)", kSafeBoxSize.bSize));
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CPythonNetworkStream::RecvSafeBoxMoneyChangePacket()
|
|
{
|
|
TPacketGCSafeboxMoneyChange kMoneyChange;
|
|
if (!Recv(sizeof(kMoneyChange), &kMoneyChange))
|
|
return false;
|
|
|
|
CPythonSafeBox::Instance().SetMoney(kMoneyChange.dwMoney);
|
|
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshSafeboxMoney", Py_BuildValue("()"));
|
|
|
|
return true;
|
|
}
|
|
|
|
// SafeBox
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Mall
|
|
bool CPythonNetworkStream::SendMallCheckoutPacket(BYTE byMallPos, TItemPos InventoryPos)
|
|
{
|
|
__PlayMallItemDropSound(byMallPos);
|
|
|
|
TPacketCGMallCheckout kMallCheckoutPacket;
|
|
kMallCheckoutPacket.bHeader = HEADER_CG_MALL_CHECKOUT;
|
|
kMallCheckoutPacket.bMallPos = byMallPos;
|
|
kMallCheckoutPacket.ItemPos = InventoryPos;
|
|
if (!Send(sizeof(kMallCheckoutPacket), &kMallCheckoutPacket))
|
|
return false;
|
|
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::RecvMallOpenPacket()
|
|
{
|
|
TPacketGCMallOpen kMallOpen;
|
|
if (!Recv(sizeof(kMallOpen), &kMallOpen))
|
|
return false;
|
|
|
|
CPythonSafeBox::Instance().OpenMall(kMallOpen.bSize);
|
|
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OpenMallWindow", Py_BuildValue("(i)", kMallOpen.bSize));
|
|
|
|
return true;
|
|
}
|
|
bool CPythonNetworkStream::RecvMallItemSetPacket()
|
|
{
|
|
TPacketGCItemSet2 kItemSet;
|
|
if (!Recv(sizeof(kItemSet), &kItemSet))
|
|
return false;
|
|
|
|
TItemData kItemData;
|
|
kItemData.vnum = kItemSet.vnum;
|
|
kItemData.count = kItemSet.count;
|
|
kItemData.flags = kItemSet.flags;
|
|
kItemData.anti_flags = kItemSet.anti_flags;
|
|
#ifdef ELEMENT_SPELL_WORLDARD
|
|
kItemData.grade_element = kItemSet.grade_element;
|
|
for (int i=0; i<MAX_ELEMENTS_SPELL; ++i){
|
|
kItemData.attack_element[i] = kItemSet.attack_element[i];
|
|
kItemData.elements_value_bonus[i] = kItemSet.elements_value_bonus[i];
|
|
}
|
|
kItemData.element_type_bonus = kItemSet.element_type_bonus;
|
|
#endif
|
|
for (int isocket=0; isocket<ITEM_SOCKET_SLOT_MAX_NUM; ++isocket)
|
|
kItemData.alSockets[isocket] = kItemSet.alSockets[isocket];
|
|
for (int iattr=0; iattr<ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++iattr)
|
|
kItemData.aAttr[iattr] = kItemSet.aAttr[iattr];
|
|
#ifdef ENABLE_GLOVE_SYSTEM
|
|
for (int iattr=0; iattr<GLOVE_ATTR_MAX_NUM; ++iattr)
|
|
kItemData.randomAttr[iattr] = kItemSet.randomAttr[iattr];
|
|
#endif
|
|
#ifdef ENABLE_NEW_NAME_ITEM
|
|
sprintf(kItemData.name, "%s", kItemSet.name);
|
|
#endif
|
|
#ifdef ENABLE_SOULBIND_SYSTEM
|
|
kItemData.bind = kItemSet.bind;
|
|
#endif
|
|
CPythonSafeBox::Instance().SetMallItemData(kItemSet.Cell.cell, kItemData);
|
|
|
|
__RefreshMallWindow();
|
|
|
|
return true;
|
|
}
|
|
bool CPythonNetworkStream::RecvMallItemDelPacket()
|
|
{
|
|
TPacketGCItemDel kItemDel;
|
|
if (!Recv(sizeof(kItemDel), &kItemDel))
|
|
return false;
|
|
|
|
CPythonSafeBox::Instance().DelMallItemData(kItemDel.pos);
|
|
|
|
__RefreshMallWindow();
|
|
Tracef(" >> CPythonNetworkStream::RecvMallItemDelPacket\n");
|
|
|
|
return true;
|
|
}
|
|
// Mall
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
// Item
|
|
// Recieve
|
|
bool CPythonNetworkStream::RecvItemSetPacket()
|
|
{
|
|
TPacketGCItemSet packet_item_set;
|
|
|
|
if (!Recv(sizeof(TPacketGCItemSet), &packet_item_set))
|
|
return false;
|
|
|
|
TItemData kItemData;
|
|
kItemData.vnum = packet_item_set.vnum;
|
|
kItemData.count = packet_item_set.count;
|
|
kItemData.flags = 0;
|
|
#ifdef ELEMENT_SPELL_WORLDARD
|
|
kItemData.grade_element = packet_item_set.grade_element;
|
|
for (int i=0; i<MAX_ELEMENTS_SPELL; ++i){
|
|
kItemData.attack_element[i] = packet_item_set.attack_element[i];
|
|
kItemData.elements_value_bonus[i] = packet_item_set.elements_value_bonus[i];
|
|
}
|
|
kItemData.element_type_bonus = packet_item_set.element_type_bonus;
|
|
#endif
|
|
for (int i=0; i<ITEM_SOCKET_SLOT_MAX_NUM; ++i)
|
|
kItemData.alSockets[i]=packet_item_set.alSockets[i];
|
|
for (int j=0; j<ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++j)
|
|
kItemData.aAttr[j]=packet_item_set.aAttr[j];
|
|
#ifdef ENABLE_GLOVE_SYSTEM
|
|
for (int j=0; j<GLOVE_ATTR_MAX_NUM; ++j)
|
|
kItemData.randomAttr[j]=packet_item_set.randomAttr[j];
|
|
#endif
|
|
/*
|
|
#ifdef ENABLE_NEW_NAME_ITEM
|
|
sprintf(kItemData.name, "%s", packet_item_set.name);
|
|
#endif
|
|
*/
|
|
#ifdef ENABLE_SOULBIND_SYSTEM
|
|
kItemData.bind = packet_item_set.bind;
|
|
#endif
|
|
IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
|
|
|
|
rkPlayer.SetItemData(packet_item_set.Cell, kItemData);
|
|
|
|
#ifdef ENABLE_SWITCHBOT
|
|
if (packet_item_set.Cell.window_type == SWITCHBOT)
|
|
{
|
|
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshSwitchbotWindow", Py_BuildValue("()"));
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
__RefreshInventoryWindow();
|
|
return true;
|
|
}
|
|
|
|
bool CPythonNetworkStream::RecvItemSetPacket2()
|
|
{
|
|
TPacketGCItemSet2 packet_item_set;
|
|
|
|
if (!Recv(sizeof(TPacketGCItemSet2), &packet_item_set))
|
|
return false;
|
|
|
|
TItemData kItemData;
|
|
kItemData.vnum = packet_item_set.vnum;
|
|
kItemData.count = packet_item_set.count;
|
|
kItemData.flags = packet_item_set.flags;
|
|
kItemData.anti_flags = packet_item_set.anti_flags;
|
|
#ifdef ELEMENT_SPELL_WORLDARD
|
|
kItemData.grade_element = packet_item_set.grade_element;
|
|
for (int i=0; i<MAX_ELEMENTS_SPELL; ++i){
|
|
kItemData.attack_element[i] = packet_item_set.attack_element[i];
|
|
kItemData.elements_value_bonus[i] = packet_item_set.elements_value_bonus[i];
|
|
}
|
|
kItemData.element_type_bonus = packet_item_set.element_type_bonus;
|
|
#endif
|
|
for (int i=0; i<ITEM_SOCKET_SLOT_MAX_NUM; ++i)
|
|
kItemData.alSockets[i]=packet_item_set.alSockets[i];
|
|
for (int j=0; j<ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++j)
|
|
kItemData.aAttr[j]=packet_item_set.aAttr[j];
|
|
#ifdef ENABLE_GLOVE_SYSTEM
|
|
for (int j=0; j<GLOVE_ATTR_MAX_NUM; ++j)
|
|
kItemData.randomAttr[j]=packet_item_set.randomAttr[j];
|
|
#endif
|
|
#ifdef ENABLE_NEW_NAME_ITEM
|
|
sprintf(kItemData.name, "%s", packet_item_set.name);
|
|
#endif
|
|
#ifdef ENABLE_SOULBIND_SYSTEM
|
|
kItemData.bind = packet_item_set.bind;
|
|
#endif
|
|
IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
|
|
rkPlayer.SetItemData(packet_item_set.Cell, kItemData);
|
|
|
|
#ifdef ENABLE_SWITCHBOT
|
|
if (packet_item_set.Cell.window_type == SWITCHBOT)
|
|
{
|
|
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshSwitchbotWindow", Py_BuildValue("()"));
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
if (packet_item_set.highlight)
|
|
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_Highlight_Item", Py_BuildValue("(ii)", packet_item_set.Cell.window_type, packet_item_set.Cell.cell));
|
|
|
|
__RefreshInventoryWindow();
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CPythonNetworkStream::RecvItemUsePacket()
|
|
{
|
|
TPacketGCItemUse packet_item_use;
|
|
|
|
if (!Recv(sizeof(TPacketGCItemUse), &packet_item_use))
|
|
return false;
|
|
|
|
__RefreshInventoryWindow();
|
|
return true;
|
|
}
|
|
|
|
bool CPythonNetworkStream::RecvItemUpdatePacket()
|
|
{
|
|
TPacketGCItemUpdate packet_item_update;
|
|
|
|
if (!Recv(sizeof(TPacketGCItemUpdate), &packet_item_update))
|
|
return false;
|
|
|
|
IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
|
|
rkPlayer.SetItemCount(packet_item_update.Cell, packet_item_update.count);
|
|
#ifdef ENABLE_NEW_NAME_ITEM
|
|
rkPlayer.SetItemNewName(packet_item_update.Cell, packet_item_update.name);
|
|
#endif
|
|
|
|
#ifdef ELEMENT_SPELL_WORLDARD
|
|
rkPlayer.SetElement(packet_item_update.Cell, packet_item_update.grade_element, packet_item_update.element_type_bonus);
|
|
for (int i = 0; i < MAX_ELEMENTS_SPELL; ++i){
|
|
rkPlayer.SetElementAttack(packet_item_update.Cell, i, packet_item_update.attack_element[i]);
|
|
rkPlayer.SetElementValue(packet_item_update.Cell, i, packet_item_update.elements_value_bonus[i]);
|
|
}
|
|
#endif
|
|
for (int i = 0; i < ITEM_SOCKET_SLOT_MAX_NUM; ++i)
|
|
rkPlayer.SetItemMetinSocket(packet_item_update.Cell, i, packet_item_update.alSockets[i]);
|
|
for (int j = 0; j < ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++j)
|
|
rkPlayer.SetItemAttribute(packet_item_update.Cell, j, packet_item_update.aAttr[j].bType, packet_item_update.aAttr[j].sValue);
|
|
#ifdef ENABLE_GLOVE_SYSTEM
|
|
for (int j = 0; j < GLOVE_ATTR_MAX_NUM; ++j)
|
|
rkPlayer.SetItemRandomAttribute(packet_item_update.Cell, j, packet_item_update.randomAttr[j].bType, packet_item_update.randomAttr[j].sValue);
|
|
#endif
|
|
#ifdef ENABLE_SOULBIND_SYSTEM
|
|
rkPlayer.SetItemBind(packet_item_update.Cell, packet_item_update.bind);
|
|
#endif
|
|
__RefreshInventoryWindow();
|
|
return true;
|
|
}
|
|
|
|
bool CPythonNetworkStream::RecvItemGroundAddPacket()
|
|
{
|
|
TPacketGCItemGroundAdd packet_item_ground_add;
|
|
|
|
if (!Recv(sizeof(TPacketGCItemGroundAdd), &packet_item_ground_add))
|
|
return false;
|
|
|
|
__GlobalPositionToLocalPosition(packet_item_ground_add.lX, packet_item_ground_add.lY);
|
|
|
|
#ifdef ENABLE_EXTENDED_ITEMNAME_ON_GROUND
|
|
CPythonItem::Instance().CreateItem(packet_item_ground_add.dwVID,
|
|
packet_item_ground_add.dwVnum,
|
|
packet_item_ground_add.lX,
|
|
packet_item_ground_add.lY,
|
|
packet_item_ground_add.lZ,
|
|
true,
|
|
packet_item_ground_add.alSockets,
|
|
packet_item_ground_add.aAttrs
|
|
,packet_item_ground_add.itemCount
|
|
,packet_item_ground_add.ownerTime+time(0));
|
|
#else
|
|
CPythonItem::Instance().CreateItem(packet_item_ground_add.dwVID,
|
|
packet_item_ground_add.dwVnum,
|
|
packet_item_ground_add.lX,
|
|
packet_item_ground_add.lY,
|
|
packet_item_ground_add.lZ);
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CPythonNetworkStream::RecvItemOwnership()
|
|
{
|
|
TPacketGCItemOwnership p;
|
|
|
|
if (!Recv(sizeof(TPacketGCItemOwnership), &p))
|
|
return false;
|
|
|
|
CPythonItem::Instance().SetOwnership(p.dwVID, p.szName);
|
|
return true;
|
|
}
|
|
|
|
bool CPythonNetworkStream::RecvItemGroundDelPacket()
|
|
{
|
|
TPacketGCItemGroundDel packet_item_ground_del;
|
|
|
|
if (!Recv(sizeof(TPacketGCItemGroundDel), &packet_item_ground_del))
|
|
return false;
|
|
|
|
CPythonItem::Instance().DeleteItem(packet_item_ground_del.vid);
|
|
return true;
|
|
}
|
|
|
|
bool CPythonNetworkStream::RecvQuickSlotAddPacket()
|
|
{
|
|
TPacketGCQuickSlotAdd packet_quick_slot_add;
|
|
|
|
if (!Recv(sizeof(TPacketGCQuickSlotAdd), &packet_quick_slot_add))
|
|
return false;
|
|
|
|
IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
|
|
rkPlayer.AddQuickSlot(packet_quick_slot_add.pos, packet_quick_slot_add.slot.Type, packet_quick_slot_add.slot.Position);
|
|
|
|
__RefreshInventoryWindow();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CPythonNetworkStream::RecvQuickSlotDelPacket()
|
|
{
|
|
TPacketGCQuickSlotDel packet_quick_slot_del;
|
|
|
|
if (!Recv(sizeof(TPacketGCQuickSlotDel), &packet_quick_slot_del))
|
|
return false;
|
|
|
|
IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
|
|
rkPlayer.DeleteQuickSlot(packet_quick_slot_del.pos);
|
|
|
|
__RefreshInventoryWindow();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CPythonNetworkStream::RecvQuickSlotMovePacket()
|
|
{
|
|
TPacketGCQuickSlotSwap packet_quick_slot_swap;
|
|
|
|
if (!Recv(sizeof(TPacketGCQuickSlotSwap), &packet_quick_slot_swap))
|
|
return false;
|
|
|
|
IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
|
|
rkPlayer.MoveQuickSlot(packet_quick_slot_swap.pos, packet_quick_slot_swap.change_pos);
|
|
|
|
__RefreshInventoryWindow();
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
bool CPythonNetworkStream::SendShopEndPacket()
|
|
{
|
|
if (!__CanActMainInstance())
|
|
return true;
|
|
|
|
TPacketCGShop packet_shop;
|
|
packet_shop.header = HEADER_CG_SHOP;
|
|
packet_shop.subheader = SHOP_SUBHEADER_CG_END;
|
|
|
|
if (!Send(sizeof(packet_shop), &packet_shop))
|
|
{
|
|
Tracef("SendShopEndPacket Error\n");
|
|
return false;
|
|
}
|
|
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendShopBuyPacket(BYTE bPos)
|
|
{
|
|
if (!__CanActMainInstance())
|
|
return true;
|
|
|
|
TPacketCGShop PacketShop;
|
|
PacketShop.header = HEADER_CG_SHOP;
|
|
PacketShop.subheader = SHOP_SUBHEADER_CG_BUY;
|
|
|
|
if (!Send(sizeof(TPacketCGShop), &PacketShop))
|
|
{
|
|
Tracef("SendShopBuyPacket Error\n");
|
|
return false;
|
|
}
|
|
|
|
BYTE bCount=1;
|
|
if (!Send(sizeof(BYTE), &bCount))
|
|
{
|
|
Tracef("SendShopBuyPacket Error\n");
|
|
return false;
|
|
}
|
|
|
|
if (!Send(sizeof(BYTE), &bPos))
|
|
{
|
|
Tracef("SendShopBuyPacket Error\n");
|
|
return false;
|
|
}
|
|
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendShopSellPacket(BYTE bySlot)
|
|
{
|
|
if (!__CanActMainInstance())
|
|
return true;
|
|
|
|
TPacketCGShop PacketShop;
|
|
PacketShop.header = HEADER_CG_SHOP;
|
|
PacketShop.subheader = SHOP_SUBHEADER_CG_SELL;
|
|
|
|
if (!Send(sizeof(TPacketCGShop), &PacketShop))
|
|
{
|
|
Tracef("SendShopSellPacket Error\n");
|
|
return false;
|
|
}
|
|
if (!Send(sizeof(BYTE), &bySlot))
|
|
{
|
|
Tracef("SendShopAddSellPacket Error\n");
|
|
return false;
|
|
}
|
|
|
|
return SendSequence();
|
|
}
|
|
|
|
|
|
#ifdef ENABLE_SPECIAL_STORAGE
|
|
bool CPythonNetworkStream::SendShopSellPacketNew(BYTE byInv, BYTE bySlot, DWORD byCount)
|
|
#else
|
|
bool CPythonNetworkStream::SendShopSellPacketNew(BYTE bySlot, DWORD byCount)
|
|
#endif
|
|
|
|
{
|
|
if (!__CanActMainInstance())
|
|
return true;
|
|
|
|
TPacketCGShop PacketShop;
|
|
PacketShop.header = HEADER_CG_SHOP;
|
|
PacketShop.subheader = SHOP_SUBHEADER_CG_SELL2;
|
|
|
|
if (!Send(sizeof(TPacketCGShop), &PacketShop))
|
|
{
|
|
Tracef("SendShopSellPacket Error\n");
|
|
return false;
|
|
}
|
|
if (!Send(sizeof(BYTE), &byInv))
|
|
{
|
|
Tracef("SendShopAddSellPacket Error\n");
|
|
return false;
|
|
}
|
|
if (!Send(sizeof(BYTE), &bySlot))
|
|
{
|
|
Tracef("SendShopAddSellPacket Error\n");
|
|
return false;
|
|
}
|
|
if (!Send(sizeof(DWORD), &byCount))
|
|
{
|
|
Tracef("SendShopAddSellPacket Error\n");
|
|
return false;
|
|
}
|
|
Tracef(" SendShopSellPacketNew(bySlot=%d, byCount=%d)\n", bySlot, byCount);
|
|
|
|
return SendSequence();
|
|
}
|
|
|
|
// Send
|
|
bool CPythonNetworkStream::SendItemUsePacket(TItemPos pos)
|
|
{
|
|
if (!__CanActMainInstance())
|
|
return true;
|
|
|
|
if (__IsEquipItemInSlot(pos))
|
|
{
|
|
if (CPythonExchange::Instance().isTrading())
|
|
{
|
|
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_AppendNotifyMessage", Py_BuildValue("(s)", "CANNOT_EQUIP_EXCHANGE"));
|
|
return true;
|
|
}
|
|
|
|
if (CPythonShop::Instance().IsOpen())
|
|
{
|
|
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_AppendNotifyMessage", Py_BuildValue("(s)", "CANNOT_EQUIP_SHOP"));
|
|
return true;
|
|
}
|
|
|
|
if (__IsPlayerAttacking())
|
|
return true;
|
|
}
|
|
|
|
__PlayInventoryItemUseSound(pos);
|
|
|
|
TPacketCGItemUse itemUsePacket;
|
|
itemUsePacket.header = HEADER_CG_ITEM_USE;
|
|
itemUsePacket.pos = pos;
|
|
|
|
if (!Send(sizeof(TPacketCGItemUse), &itemUsePacket))
|
|
{
|
|
Tracen("SendItemUsePacket Error");
|
|
return false;
|
|
}
|
|
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendItemUseToItemPacket(TItemPos source_pos, TItemPos target_pos)
|
|
{
|
|
if (!__CanActMainInstance())
|
|
return true;
|
|
|
|
TPacketCGItemUseToItem itemUseToItemPacket;
|
|
itemUseToItemPacket.header = HEADER_CG_ITEM_USE_TO_ITEM;
|
|
itemUseToItemPacket.source_pos = source_pos;
|
|
itemUseToItemPacket.target_pos = target_pos;
|
|
|
|
if (!Send(sizeof(TPacketCGItemUseToItem), &itemUseToItemPacket))
|
|
{
|
|
Tracen("SendItemUseToItemPacket Error");
|
|
return false;
|
|
}
|
|
|
|
#ifdef _DEBUG
|
|
Tracef(" << SendItemUseToItemPacket(src=%d, dst=%d)\n", source_pos, target_pos);
|
|
#endif
|
|
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendItemDropPacket(TItemPos pos, DWORD elk)
|
|
{
|
|
if (!__CanActMainInstance())
|
|
return true;
|
|
|
|
TPacketCGItemDrop itemDropPacket;
|
|
itemDropPacket.header = HEADER_CG_ITEM_DROP;
|
|
itemDropPacket.pos = pos;
|
|
itemDropPacket.elk = elk;
|
|
|
|
if (!Send(sizeof(TPacketCGItemDrop), &itemDropPacket))
|
|
{
|
|
Tracen("SendItemDropPacket Error");
|
|
return false;
|
|
}
|
|
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendItemDropPacketNew(TItemPos pos, DWORD elk, DWORD count)
|
|
{
|
|
if (!__CanActMainInstance())
|
|
return true;
|
|
|
|
TPacketCGItemDrop2 itemDropPacket;
|
|
itemDropPacket.header = HEADER_CG_ITEM_DROP2;
|
|
itemDropPacket.pos = pos;
|
|
itemDropPacket.gold = elk;
|
|
itemDropPacket.count = count;
|
|
|
|
if (!Send(sizeof(itemDropPacket), &itemDropPacket))
|
|
{
|
|
Tracen("SendItemDropPacket Error");
|
|
return false;
|
|
}
|
|
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::__IsEquipItemInSlot(TItemPos uSlotPos)
|
|
{
|
|
IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
|
|
return rkPlayer.IsEquipItemInSlot(uSlotPos);
|
|
}
|
|
|
|
void CPythonNetworkStream::__PlayInventoryItemUseSound(TItemPos uSlotPos)
|
|
{
|
|
IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
|
|
DWORD dwItemID=rkPlayer.GetItemIndex(uSlotPos);
|
|
|
|
CPythonItem& rkItem=CPythonItem::Instance();
|
|
rkItem.PlayUseSound(dwItemID);
|
|
}
|
|
|
|
void CPythonNetworkStream::__PlayInventoryItemDropSound(TItemPos uSlotPos)
|
|
{
|
|
IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
|
|
DWORD dwItemID=rkPlayer.GetItemIndex(uSlotPos);
|
|
|
|
CPythonItem& rkItem=CPythonItem::Instance();
|
|
rkItem.PlayDropSound(dwItemID);
|
|
}
|
|
|
|
//void CPythonNetworkStream::__PlayShopItemDropSound(UINT uSlotPos)
|
|
//{
|
|
// DWORD dwItemID;
|
|
// CPythonShop& rkShop=CPythonShop::Instance();
|
|
// if (!rkShop.GetSlotItemID(uSlotPos, &dwItemID))
|
|
// return;
|
|
//
|
|
// CPythonItem& rkItem=CPythonItem::Instance();
|
|
// rkItem.PlayDropSound(dwItemID);
|
|
//}
|
|
|
|
void CPythonNetworkStream::__PlaySafeBoxItemDropSound(UINT uSlotPos)
|
|
{
|
|
DWORD dwItemID;
|
|
CPythonSafeBox& rkSafeBox=CPythonSafeBox::Instance();
|
|
if (!rkSafeBox.GetSlotItemID(uSlotPos, &dwItemID))
|
|
return;
|
|
|
|
CPythonItem& rkItem=CPythonItem::Instance();
|
|
rkItem.PlayDropSound(dwItemID);
|
|
}
|
|
|
|
void CPythonNetworkStream::__PlayMallItemDropSound(UINT uSlotPos)
|
|
{
|
|
DWORD dwItemID;
|
|
CPythonSafeBox& rkSafeBox=CPythonSafeBox::Instance();
|
|
if (!rkSafeBox.GetSlotMallItemID(uSlotPos, &dwItemID))
|
|
return;
|
|
|
|
CPythonItem& rkItem=CPythonItem::Instance();
|
|
rkItem.PlayDropSound(dwItemID);
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendItemMovePacket(TItemPos pos, TItemPos change_pos, DWORD num)
|
|
{
|
|
if (!__CanActMainInstance())
|
|
return true;
|
|
|
|
if (__IsEquipItemInSlot(pos))
|
|
{
|
|
if (CPythonExchange::Instance().isTrading())
|
|
{
|
|
if (pos.IsEquipCell() || change_pos.IsEquipCell())
|
|
{
|
|
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_AppendNotifyMessage", Py_BuildValue("(s)", "CANNOT_EQUIP_EXCHANGE"));
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (CPythonShop::Instance().IsOpen())
|
|
{
|
|
if (pos.IsEquipCell() || change_pos.IsEquipCell())
|
|
{
|
|
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_AppendNotifyMessage", Py_BuildValue("(s)", "CANNOT_EQUIP_SHOP"));
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (__IsPlayerAttacking())
|
|
return true;
|
|
}
|
|
|
|
__PlayInventoryItemDropSound(pos);
|
|
|
|
TPacketCGItemMove itemMovePacket;
|
|
itemMovePacket.header = HEADER_CG_ITEM_MOVE;
|
|
itemMovePacket.pos = pos;
|
|
itemMovePacket.change_pos = change_pos;
|
|
itemMovePacket.num = num;
|
|
|
|
if (!Send(sizeof(TPacketCGItemMove), &itemMovePacket))
|
|
{
|
|
Tracen("SendItemMovePacket Error");
|
|
return false;
|
|
}
|
|
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendItemPickUpPacket(DWORD vid)
|
|
{
|
|
if (!__CanActMainInstance())
|
|
return true;
|
|
|
|
TPacketCGItemPickUp itemPickUpPacket;
|
|
itemPickUpPacket.header = HEADER_CG_ITEM_PICKUP;
|
|
itemPickUpPacket.vid = vid;
|
|
|
|
if (!Send(sizeof(TPacketCGItemPickUp), &itemPickUpPacket))
|
|
{
|
|
Tracen("SendItemPickUpPacket Error");
|
|
return false;
|
|
}
|
|
|
|
return SendSequence();
|
|
}
|
|
|
|
|
|
#ifdef ENABLE_AUTOMATIC_PICK_UP_SYSTEM
|
|
bool CPythonNetworkStream::SendItemsPickUpPacket(std::vector<DWORD> itemVector)
|
|
{
|
|
if (!__CanActMainInstance())
|
|
return true;
|
|
|
|
TPacketCGItemsPickUp itemsPickUpPacket;
|
|
itemsPickUpPacket.header = HEADER_CG_ITEMS_PICKUP;
|
|
itemsPickUpPacket.count = itemVector.size();
|
|
if (!Send(sizeof(itemsPickUpPacket), &itemsPickUpPacket))
|
|
return false;
|
|
|
|
for (size_t i = 0; i < itemVector.size(); i++){
|
|
DWORD vid = itemVector[i];
|
|
if (!Send(sizeof(vid), &vid))
|
|
return false;
|
|
}
|
|
|
|
return SendSequence();
|
|
}
|
|
#endif
|
|
|
|
|
|
bool CPythonNetworkStream::SendQuickSlotAddPacket(BYTE wpos, BYTE type, BYTE pos)
|
|
{
|
|
if (!__CanActMainInstance())
|
|
return true;
|
|
|
|
TPacketCGQuickSlotAdd quickSlotAddPacket;
|
|
|
|
quickSlotAddPacket.header = HEADER_CG_QUICKSLOT_ADD;
|
|
quickSlotAddPacket.pos = wpos;
|
|
quickSlotAddPacket.slot.Type = type;
|
|
quickSlotAddPacket.slot.Position = pos;
|
|
|
|
if (!Send(sizeof(TPacketCGQuickSlotAdd), &quickSlotAddPacket))
|
|
{
|
|
Tracen("SendQuickSlotAddPacket Error");
|
|
return false;
|
|
}
|
|
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendQuickSlotDelPacket(BYTE pos)
|
|
{
|
|
if (!__CanActMainInstance())
|
|
return true;
|
|
|
|
TPacketCGQuickSlotDel quickSlotDelPacket;
|
|
|
|
quickSlotDelPacket.header = HEADER_CG_QUICKSLOT_DEL;
|
|
quickSlotDelPacket.pos = pos;
|
|
|
|
if (!Send(sizeof(TPacketCGQuickSlotDel), &quickSlotDelPacket))
|
|
{
|
|
Tracen("SendQuickSlotDelPacket Error");
|
|
return false;
|
|
}
|
|
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendQuickSlotMovePacket(BYTE pos, BYTE change_pos)
|
|
{
|
|
if (!__CanActMainInstance())
|
|
return true;
|
|
|
|
TPacketCGQuickSlotSwap quickSlotSwapPacket;
|
|
|
|
quickSlotSwapPacket.header = HEADER_CG_QUICKSLOT_SWAP;
|
|
quickSlotSwapPacket.pos = pos;
|
|
quickSlotSwapPacket.change_pos = change_pos;
|
|
|
|
if (!Send(sizeof(TPacketCGQuickSlotSwap), &quickSlotSwapPacket))
|
|
{
|
|
Tracen("SendQuickSlotSwapPacket Error");
|
|
return false;
|
|
}
|
|
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::RecvSpecialEffect()
|
|
{
|
|
TPacketGCSpecialEffect kSpecialEffect;
|
|
if (!Recv(sizeof(kSpecialEffect), &kSpecialEffect))
|
|
return false;
|
|
|
|
DWORD effect = -1;
|
|
bool bPlayPotionSound = false; //������ ���� ������ ���� �����带 ��������.!!
|
|
bool bAttachEffect = true; //ij���Ϳ� �ٴ� ����ġ ����Ʈ�� �Ϲ� ����Ʈ ����.!!
|
|
switch (kSpecialEffect.type)
|
|
{
|
|
case SE_HPUP_RED:
|
|
effect = CInstanceBase::EFFECT_HPUP_RED;
|
|
bPlayPotionSound = true;
|
|
break;
|
|
case SE_SPUP_BLUE:
|
|
effect = CInstanceBase::EFFECT_SPUP_BLUE;
|
|
bPlayPotionSound = true;
|
|
break;
|
|
case SE_SPEEDUP_GREEN:
|
|
effect = CInstanceBase::EFFECT_SPEEDUP_GREEN;
|
|
bPlayPotionSound = true;
|
|
break;
|
|
case SE_DXUP_PURPLE:
|
|
effect = CInstanceBase::EFFECT_DXUP_PURPLE;
|
|
bPlayPotionSound = true;
|
|
break;
|
|
case SE_CRITICAL:
|
|
effect = CInstanceBase::EFFECT_CRITICAL;
|
|
break;
|
|
case SE_PENETRATE:
|
|
effect = CInstanceBase::EFFECT_PENETRATE;
|
|
break;
|
|
case SE_BLOCK:
|
|
effect = CInstanceBase::EFFECT_BLOCK;
|
|
break;
|
|
case SE_DODGE:
|
|
effect = CInstanceBase::EFFECT_DODGE;
|
|
break;
|
|
case SE_CHINA_FIREWORK:
|
|
effect = CInstanceBase::EFFECT_FIRECRACKER;
|
|
bAttachEffect = false;
|
|
break;
|
|
case SE_SPIN_TOP:
|
|
effect = CInstanceBase::EFFECT_SPIN_TOP;
|
|
bAttachEffect = false;
|
|
break;
|
|
case SE_SUCCESS :
|
|
effect = CInstanceBase::EFFECT_SUCCESS ;
|
|
bAttachEffect = false ;
|
|
break ;
|
|
case SE_FAIL :
|
|
effect = CInstanceBase::EFFECT_FAIL ;
|
|
break ;
|
|
case SE_FR_SUCCESS:
|
|
effect = CInstanceBase::EFFECT_FR_SUCCESS;
|
|
bAttachEffect = false ;
|
|
break;
|
|
case SE_LEVELUP_ON_14_FOR_GERMANY: //������ 14�϶� ( �������� )
|
|
effect = CInstanceBase::EFFECT_LEVELUP_ON_14_FOR_GERMANY;
|
|
bAttachEffect = false ;
|
|
break;
|
|
case SE_LEVELUP_UNDER_15_FOR_GERMANY: //������ 15�϶� ( �������� )
|
|
effect = CInstanceBase::EFFECT_LEVELUP_UNDER_15_FOR_GERMANY;
|
|
bAttachEffect = false ;
|
|
break;
|
|
case SE_PERCENT_DAMAGE1:
|
|
effect = CInstanceBase::EFFECT_PERCENT_DAMAGE1;
|
|
break;
|
|
case SE_PERCENT_DAMAGE2:
|
|
effect = CInstanceBase::EFFECT_PERCENT_DAMAGE2;
|
|
break;
|
|
case SE_PERCENT_DAMAGE3:
|
|
effect = CInstanceBase::EFFECT_PERCENT_DAMAGE3;
|
|
break;
|
|
case SE_AUTO_HPUP:
|
|
effect = CInstanceBase::EFFECT_AUTO_HPUP;
|
|
break;
|
|
case SE_AUTO_SPUP:
|
|
effect = CInstanceBase::EFFECT_AUTO_SPUP;
|
|
break;
|
|
case SE_EQUIP_RAMADAN_RING:
|
|
effect = CInstanceBase::EFFECT_RAMADAN_RING_EQUIP;
|
|
break;
|
|
case SE_EQUIP_HALLOWEEN_CANDY:
|
|
effect = CInstanceBase::EFFECT_HALLOWEEN_CANDY_EQUIP;
|
|
break;
|
|
case SE_EQUIP_HAPPINESS_RING:
|
|
effect = CInstanceBase::EFFECT_HAPPINESS_RING_EQUIP;
|
|
break;
|
|
case SE_EQUIP_LOVE_PENDANT:
|
|
effect = CInstanceBase::EFFECT_LOVE_PENDANT_EQUIP;
|
|
break;
|
|
#ifdef ENABLE_SASH_SYSTEM
|
|
case SE_EFFECT_SASH_SUCCEDED:
|
|
effect = CInstanceBase::EFFECT_SASH_SUCCEDED;
|
|
break;
|
|
case SE_EFFECT_SASH_EQUIP:
|
|
effect = CInstanceBase::EFFECT_SASH_EQUIP;
|
|
break;
|
|
#endif
|
|
#if defined(WJ_COMBAT_ZONE)
|
|
case SE_COMBAT_ZONE_POTION:
|
|
effect = CInstanceBase::EFFECT_COMBAT_ZONE_POTION;
|
|
break;
|
|
#endif
|
|
#ifdef VERSION_162_ENABLED
|
|
case SE_EFFECT_HEALER:
|
|
effect = CInstanceBase::EFFECT_HEALER;
|
|
break;
|
|
#endif
|
|
#ifdef ENABLE_ZODIAC_MISSION
|
|
case EFFECT_SKILL_DAMAGE_ZONE:
|
|
effect = CInstanceBase::EFFECT_SKILL_DAMAGE_ZONE;
|
|
break;
|
|
|
|
case EFFECT_SKILL_DAMAGE_ZONE_BUYUK:
|
|
effect = CInstanceBase::EFFECT_SKILL_DAMAGE_ZONE_BUYUK;
|
|
break;
|
|
|
|
case EFFECT_SKILL_DAMAGE_ZONE_ORTA:
|
|
effect = CInstanceBase::EFFECT_SKILL_DAMAGE_ZONE_ORTA;
|
|
break;
|
|
|
|
case EFFECT_SKILL_DAMAGE_ZONE_KUCUK:
|
|
effect = CInstanceBase::EFFECT_SKILL_DAMAGE_ZONE_KUCUK;
|
|
break;
|
|
|
|
case EFFECT_SKILL_SAFE_ZONE:
|
|
effect = CInstanceBase::EFFECT_SKILL_SAFE_ZONE;
|
|
break;
|
|
|
|
case EFFECT_SKILL_SAFE_ZONE_BUYUK:
|
|
effect = CInstanceBase::EFFECT_SKILL_SAFE_ZONE_BUYUK;
|
|
break;
|
|
|
|
case EFFECT_SKILL_SAFE_ZONE_ORTA:
|
|
effect = CInstanceBase::EFFECT_SKILL_SAFE_ZONE_ORTA;
|
|
break;
|
|
|
|
case EFFECT_SKILL_SAFE_ZONE_KUCUK:
|
|
effect = CInstanceBase::EFFECT_SKILL_SAFE_ZONE_KUCUK;
|
|
break;
|
|
|
|
case EFFECT_METEOR:
|
|
effect = CInstanceBase::EFFECT_METEOR;
|
|
break;
|
|
|
|
case EFFECT_BEAD_RAIN:
|
|
effect = CInstanceBase::EFFECT_BEAD_RAIN;
|
|
break;
|
|
|
|
case EFFECT_FALL_ROCK:
|
|
effect = CInstanceBase::EFFECT_FALL_ROCK;
|
|
break;
|
|
|
|
case EFFECT_ARROW_RAIN:
|
|
effect = CInstanceBase::EFFECT_ARROW_RAIN;
|
|
break;
|
|
|
|
case EFFECT_HORSE_DROP:
|
|
effect = CInstanceBase::EFFECT_HORSE_DROP;
|
|
break;
|
|
|
|
case EFFECT_EGG_DROP:
|
|
effect = CInstanceBase::EFFECT_EGG_DROP;
|
|
break;
|
|
|
|
case EFFECT_DEAPO_BOOM:
|
|
effect = CInstanceBase::EFFECT_DEAPO_BOOM;
|
|
break;
|
|
#endif
|
|
default:
|
|
TraceError("%d is not a special effect number. TPacketGCSpecialEffect",kSpecialEffect.type);
|
|
break;
|
|
}
|
|
|
|
if (bPlayPotionSound)
|
|
{
|
|
IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
|
|
if(rkPlayer.IsMainCharacterIndex(kSpecialEffect.vid))
|
|
{
|
|
CPythonItem& rkItem=CPythonItem::Instance();
|
|
rkItem.PlayUsePotionSound();
|
|
}
|
|
}
|
|
|
|
if (-1 != effect)
|
|
{
|
|
CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(kSpecialEffect.vid);
|
|
if (pInstance)
|
|
{
|
|
if(bAttachEffect)
|
|
pInstance->AttachSpecialEffect(effect);
|
|
else
|
|
pInstance->CreateSpecialEffect(effect);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CPythonNetworkStream::RecvSpecificEffect()
|
|
{
|
|
TPacketGCSpecificEffect kSpecificEffect;
|
|
if (!Recv(sizeof(kSpecificEffect), &kSpecificEffect))
|
|
return false;
|
|
|
|
CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(kSpecificEffect.vid);
|
|
//EFFECT_TEMP
|
|
if (pInstance)
|
|
{
|
|
CInstanceBase::RegisterEffect(CInstanceBase::EFFECT_TEMP, "", kSpecificEffect.effect_file, false);
|
|
pInstance->AttachSpecialEffect(CInstanceBase::EFFECT_TEMP);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CPythonNetworkStream::RecvDragonSoulRefine()
|
|
{
|
|
TPacketGCDragonSoulRefine kDragonSoul;
|
|
|
|
if (!Recv(sizeof(kDragonSoul), &kDragonSoul))
|
|
return false;
|
|
|
|
|
|
switch (kDragonSoul.bSubType)
|
|
{
|
|
case DS_SUB_HEADER_OPEN:
|
|
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_DragonSoulRefineWindow_Open", Py_BuildValue("()"));
|
|
break;
|
|
case DS_SUB_HEADER_REFINE_FAIL:
|
|
case DS_SUB_HEADER_REFINE_FAIL_MAX_REFINE:
|
|
case DS_SUB_HEADER_REFINE_FAIL_INVALID_MATERIAL:
|
|
case DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MONEY:
|
|
case DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MATERIAL:
|
|
case DS_SUB_HEADER_REFINE_FAIL_TOO_MUCH_MATERIAL:
|
|
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_DragonSoulRefineWindow_RefineFail", Py_BuildValue("(iii)",
|
|
kDragonSoul.bSubType, kDragonSoul.Pos.window_type, kDragonSoul.Pos.cell));
|
|
break;
|
|
case DS_SUB_HEADER_REFINE_SUCCEED:
|
|
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_DragonSoulRefineWindow_RefineSucceed",
|
|
Py_BuildValue("(ii)", kDragonSoul.Pos.window_type, kDragonSoul.Pos.cell));
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
#ifdef ENABLE_CALENDAR_SYSTEM
|
|
|
|
bool CPythonNetworkStream::RecvCalendarSystem()
|
|
{
|
|
TPacketGCCalendarReceive KCalendar;
|
|
|
|
if (!Recv(sizeof(KCalendar), &KCalendar))
|
|
return false;
|
|
|
|
switch (KCalendar.bSubType)
|
|
{
|
|
case CALENDAR_RECEIVE_OPEN:
|
|
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_CALENDAR_OPEN", Py_BuildValue("(i)", KCalendar.dwCurrentTimeStamp));
|
|
break;
|
|
|
|
case CALENDAR_RECEIVE_LOAD_EVENTS:
|
|
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_CALENDAR_LOAD_EVENTS", Py_BuildValue("(issssi)", KCalendar.bDay, KCalendar.szName, KCalendar.szImage, KCalendar.szStartAt, KCalendar.szEndAt, KCalendar.dwDuration));
|
|
//PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_CALENDAR_LOAD_EVENTS", Py_BuildValue("(isssssss)", KCalendar.day,KCalendar.event,KCalendar.event_descript,KCalendar.banner,KCalendar.hora_inicio,KCalendar.hora_final,KCalendar.hora_inicio_2,KCalendar.hora_final_2));
|
|
break;
|
|
|
|
case CALENDAR_RECEIVE_CLEAR_EVENTS:
|
|
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_CALENDAR_CLEAR_EVENTS", Py_BuildValue("()"));
|
|
break;
|
|
|
|
case CALENDAR_RECEIVE_LOADING_EVENTS:
|
|
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_CALENDAR_LOADING_EVENTS", Py_BuildValue("()"));
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CPythonNetworkStream::RecvCalendarSystemADM()
|
|
{
|
|
TPacketGCCalendarReceiveADM KCalendar;
|
|
|
|
if (!Recv(sizeof(KCalendar), &KCalendar))
|
|
return false;
|
|
|
|
switch (KCalendar.bSubType)
|
|
{
|
|
case CALENDAR_RECEIVE_OPEN_ADM:
|
|
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_CALENDAR_OPEN_ADM", Py_BuildValue("()"));
|
|
break;
|
|
|
|
case CALENDAR_RECEIVE_LOAD_EVENTS_ADM:
|
|
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_CALENDAR_LOAD_EVENTS_ADM", Py_BuildValue("(iss)", KCalendar.index_event,KCalendar.event,KCalendar.event_descript));
|
|
break;
|
|
|
|
case CALENDAR_RECEIVE_CLEAR_EVENTS_ADM:
|
|
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_CALENDAR_CLEAR_EVENTS_ADM", Py_BuildValue("()"));
|
|
break;
|
|
|
|
case CALENDAR_RECEIVE_LOADING_EVENTS_ADM:
|
|
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_CALENDAR_LOADING_EVENTS_ADM", Py_BuildValue("()"));
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
#ifdef ENABLE_OFFLINESHOP_SYSTEM
|
|
bool CPythonNetworkStream::SendOfflineShopEndPacket()
|
|
{
|
|
if (!__CanActMainInstance())
|
|
return true;
|
|
|
|
TPacketCGShop packet_shop;
|
|
packet_shop.header = HEADER_CG_OFFLINE_SHOP;
|
|
packet_shop.subheader = SHOP_SUBHEADER_CG_END;
|
|
|
|
if (!Send(sizeof(packet_shop), &packet_shop))
|
|
{
|
|
Tracef("SendOfflineShopEndPacket Error\n");
|
|
return false;
|
|
}
|
|
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendOfflineShopBuyPacket(DWORD vid, BYTE bPos)
|
|
{
|
|
if (!__CanActMainInstance())
|
|
return true;
|
|
|
|
TPacketCGShop PacketShop;
|
|
PacketShop.header = HEADER_CG_OFFLINE_SHOP;
|
|
PacketShop.subheader = SHOP_SUBHEADER_CG_BUY;
|
|
PacketShop.vid = vid;
|
|
PacketShop.pos = bPos;
|
|
if (!Send(sizeof(TPacketCGShop), &PacketShop))
|
|
{
|
|
Tracef("SendOfflineShopBuyPacket Error\n");
|
|
return false;
|
|
}
|
|
//TraceError("SendOfflineShopBuyPacket vid=%d sub=%d",vid,bPos);
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendAddOfflineShopItem(TItemPos bDisplayPos, BYTE bPos, long long lPrice)
|
|
{
|
|
TPacketCGShop PacketShop;
|
|
PacketShop.header = HEADER_CG_OFFLINE_SHOP;
|
|
PacketShop.subheader = SHOP_SUBHEADER_CG_ADD_ITEM;
|
|
|
|
if (!Send(sizeof(TPacketCGShop), &PacketShop))
|
|
{
|
|
Tracef("SendAddOfflineShopItem Error\n");
|
|
return false;
|
|
}
|
|
|
|
TOfflineShopAddItem pTable;
|
|
|
|
pTable.bDisplayPos = bDisplayPos;
|
|
pTable.bPos = bPos;
|
|
pTable.lPrice = lPrice;
|
|
if (!Send(sizeof(TOfflineShopAddItem), &pTable))
|
|
{
|
|
Tracef("SendAddOfflineShopItem Error\n");
|
|
return false;
|
|
}
|
|
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendRemoveOfflineShopItem(BYTE bPos)
|
|
{
|
|
TPacketCGShop PacketShop;
|
|
PacketShop.header = HEADER_CG_OFFLINE_SHOP;
|
|
PacketShop.subheader = SHOP_SUBHEADER_CG_REMOVE_ITEM;
|
|
|
|
if (!Send(sizeof(TPacketCGShop), &PacketShop))
|
|
{
|
|
Tracef("SendRemoveOfflineShopItem Error\n");
|
|
return false;
|
|
}
|
|
|
|
if (!Send(sizeof(BYTE), &bPos))
|
|
{
|
|
Tracef("SendRemoveOfflineShopItem Packet Error\n");
|
|
return false;
|
|
}
|
|
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendOpenShopSlot(BYTE bPos)
|
|
{
|
|
TPacketCGShop PacketShop;
|
|
PacketShop.header = HEADER_CG_OFFLINE_SHOP;
|
|
PacketShop.subheader = SHOP_SUBHEADER_CG_OPEN_SLOT;
|
|
|
|
if (!Send(sizeof(TPacketCGShop), &PacketShop))
|
|
{
|
|
Tracef("SendOpenShopSlot Error\n");
|
|
return false;
|
|
}
|
|
|
|
if (!Send(sizeof(BYTE), &bPos))
|
|
{
|
|
Tracef("SendOpenShopSlot Packet Error\n");
|
|
return false;
|
|
}
|
|
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendGetBackItems()
|
|
{
|
|
TPacketCGShop PacketShop;
|
|
PacketShop.header = HEADER_CG_OFFLINE_SHOP;
|
|
PacketShop.subheader = SHOP_SUBHEADER_CG_GET_ITEM;
|
|
if (!Send(sizeof(TPacketCGShop), &PacketShop))
|
|
{
|
|
Tracef("SendOpenShopSlot Error\n");
|
|
return false;
|
|
}
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendAddTime()
|
|
{
|
|
TPacketCGShop PacketShop;
|
|
PacketShop.header = HEADER_CG_OFFLINE_SHOP;
|
|
PacketShop.subheader = SHOP_SUBHEADER_CG_ADD_TIME;
|
|
if (!Send(sizeof(TPacketCGShop), &PacketShop))
|
|
{
|
|
Tracef("SendOpenShopSlot Error\n");
|
|
return false;
|
|
}
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendDestroyOfflineShop()
|
|
{
|
|
TPacketCGShop PacketShop;
|
|
PacketShop.header = HEADER_CG_OFFLINE_SHOP;
|
|
PacketShop.subheader = SHOP_SUBHEADER_CG_DESTROY_OFFLINE_SHOP;
|
|
if (!Send(sizeof(TPacketCGShop), &PacketShop))
|
|
{
|
|
Tracef("SendDestroyOfflineShop Packet Error\n");
|
|
return false;
|
|
}
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendTakeOfflineMoney()
|
|
{
|
|
static DWORD s_LastTime = timeGetTime() - 5001;
|
|
if (timeGetTime() - s_LastTime < 5000)
|
|
return true;
|
|
s_LastTime = timeGetTime();
|
|
TPacketCGShop PacketShop;
|
|
PacketShop.header = HEADER_CG_OFFLINE_SHOP;
|
|
PacketShop.subheader = SHOP_SUBHEADER_CG_TAKE_MONEY;
|
|
if (!Send(sizeof(TPacketCGShop), &PacketShop))
|
|
{
|
|
Tracef("SendRefreshOfflineShopMoney Packet Error\n");
|
|
return false;
|
|
}
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendOfflineShopChangeTitle(const char* title)
|
|
{
|
|
TPacketCGShop PacketShop;
|
|
PacketShop.header = HEADER_CG_OFFLINE_SHOP;
|
|
PacketShop.subheader = SHOP_SUBHEADER_CG_CHANGE_TITLE;
|
|
strcpy(PacketShop.title, title);
|
|
if (!Send(sizeof(TPacketCGShop), &PacketShop))
|
|
{
|
|
Tracef("SendOfflineShopChangeTitle Packet Error\n");
|
|
return false;
|
|
}
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendOfflineShopCheck()
|
|
{
|
|
//static DWORD s_LastTime = timeGetTime() - 5001;
|
|
//if (timeGetTime() - s_LastTime < 5000)
|
|
// return true;
|
|
//s_LastTime = timeGetTime();
|
|
TPacketCGShop PacketShop;
|
|
PacketShop.header = HEADER_CG_OFFLINE_SHOP;
|
|
PacketShop.subheader = SHOP_SUBHEADER_CG_CHECK;
|
|
if (!Send(sizeof(TPacketCGShop), &PacketShop))
|
|
{
|
|
Tracef("SendOfflineShopCheck Packet error\n");
|
|
return false;
|
|
}
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendOfflineShopButton()
|
|
{
|
|
//static DWORD s_LastTime = timeGetTime() - 5001;
|
|
//if (timeGetTime() - s_LastTime < 5000)
|
|
// return true;
|
|
//s_LastTime = timeGetTime();
|
|
TPacketCGShop PacketShop;
|
|
PacketShop.header = HEADER_CG_OFFLINE_SHOP;
|
|
PacketShop.subheader = SHOP_SUBHEADER_CG_BUTTON;
|
|
if (!Send(sizeof(TPacketCGShop), &PacketShop))
|
|
{
|
|
Tracef("SendOfflineShopCheck Packet error\n");
|
|
return false;
|
|
}
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendOfflineShopRemoveLogs()
|
|
{
|
|
//static DWORD s_LastTime = timeGetTime() - 5001;
|
|
//if (timeGetTime() - s_LastTime < 5000)
|
|
// return true;
|
|
//s_LastTime = timeGetTime();
|
|
TPacketCGShop PacketShop;
|
|
PacketShop.header = HEADER_CG_OFFLINE_SHOP;
|
|
PacketShop.subheader = SHOP_SUBHEADER_CG_LOG_REMOVE;
|
|
if (!Send(sizeof(TPacketCGShop), &PacketShop))
|
|
{
|
|
Tracef("SendOfflineShopCheck Packet error\n");
|
|
return false;
|
|
}
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendOfflineOpenWithVID(DWORD vid)
|
|
{
|
|
//static DWORD s_LastTime = timeGetTime() - 5001;
|
|
//if (timeGetTime() - s_LastTime < 5000)
|
|
// return true;
|
|
//s_LastTime = timeGetTime();
|
|
TPacketCGShop PacketShop;
|
|
PacketShop.header = HEADER_CG_OFFLINE_SHOP;
|
|
PacketShop.subheader = SHOP_SUBHEADER_CG_OPEN_WITH_VID;
|
|
if (!Send(sizeof(TPacketCGShop), &PacketShop))
|
|
{
|
|
Tracef("SendOfflineOpenWithVID Packet error\n");
|
|
return false;
|
|
}
|
|
if (!Send(sizeof(DWORD), &vid))
|
|
{
|
|
Tracef("SendOfflineOpenWithVID Packet Error\n");
|
|
return false;
|
|
}
|
|
return SendSequence();
|
|
}
|
|
|
|
bool CPythonNetworkStream::SendOfflineShopChangeDecoration(const char* sign, DWORD vnum, DWORD type)
|
|
{
|
|
//static DWORD s_LastTime = timeGetTime() - 5001;
|
|
//if (timeGetTime() - s_LastTime < 5000)
|
|
// return true;
|
|
//s_LastTime = timeGetTime();
|
|
TPacketCGShop PacketShop;
|
|
PacketShop.header = HEADER_CG_OFFLINE_SHOP;
|
|
PacketShop.subheader = SHOP_SUBHEADER_CG_CHANGE_DECORATION;
|
|
if (!Send(sizeof(TPacketCGShop), &PacketShop))
|
|
{
|
|
Tracef("SendOfflineShopChangeDecoration Packet error\n");
|
|
return false;
|
|
}
|
|
|
|
TShopDecoration p;
|
|
snprintf(p.sign, sizeof(p.sign), sign);
|
|
p.vnum = vnum;
|
|
p.type = type;
|
|
if (!Send(sizeof(TShopDecoration), &p))
|
|
{
|
|
Tracef("SendOfflineShopChangeDecoration Packet Error\n");
|
|
return false;
|
|
}
|
|
|
|
return SendSequence();
|
|
}
|
|
#endif
|