#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 - »ç¿ëÇÏÁö ¾Ê´Â ÇÔ¼ö"); 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, BYTE 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; TItemData kItemData; kItemData.vnum = kItemSet.vnum; kItemData.count = kItemSet.count; kItemData.flags = kItemSet.flags; kItemData.anti_flags = kItemSet.anti_flags; 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]; CPythonSafeBox::Instance().SetItemData(kItemSet.Cell.cell, kItemData); __RefreshSafeboxWindow(); 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; 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]; 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; 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]; IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton(); rkPlayer.SetItemData(packet_item_set.Cell, kItemData); __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; 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]; IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton(); rkPlayer.SetItemData(packet_item_set.Cell, kItemData); 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); 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); __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); 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); 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(); } bool CPythonNetworkStream::SendShopSellPacketNew(BYTE bySlot, BYTE byCount) { 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), &bySlot)) { Tracef("SendShopAddSellPacket Error\n"); return false; } if (!Send(sizeof(BYTE), &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, BYTE 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(); } 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; default: TraceError("%d ´Â ¾ø´Â ½ºÆä¼È ÀÌÆåÆ® ¹øÈ£ÀÔ´Ï´Ù.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; }