Fethi Polat 1
Fethi Polat
TuZaKK 1
TuZaKK
xranzei 1
xranzei
Agresifizm 1
Agresifizm
Bvural41 1
Bvural41
noisiv 1
noisiv
Manwe Work 1
Manwe Work
Hikaye Ekle

Cevaplanmadı in game wiki pazar sorunu

  • Konuyu başlatan Konuyu başlatan R&K
  • Başlangıç tarihi Başlangıç tarihi
  • Cevaplar Cevaplar 4
  • Görüntüleme Görüntüleme 1K

Ayyıldız2 | 2008 TR Yapısı • 1-99 Orta Emek Destan • Oto Avsız • 10 Temmuz 21:00 HEMEN TIKLA!

Volvox337' Alıntı:
Hey. I cant use shops anymore since i build Wiki
20d63028ab7f6549374136e672055d06.png

After i click NPC, everything does not work anymore.
If i disable the System, everything is fine.


Kod: 
        if (!Recv(iSize, &vecBuffer[0])) {
            return false;
        }

This causes the error. Sizes are the same with and without system
Genişletmek için tıkla

ÜSTTEKİ HATAYI ALIYORUM ÜSTEKİ KODU DEVRE DIŞI BIRAKINCA PAZAR RANDUMANLI ÇALIŞIYOR WİKİ SİSTEMİNİ KALDIRINCA PAZAR SORUNSUZ ÇALIŞIYOR
YARDICI OLABİLCEK VARMI
OFFLİNESHOP OVERFAL




[CODE title="OFLİNESHOP PYTHONNETWORKSTREAMGAME.CPP"]#ifdef ENABLE_OFFLINE_SHOP_SYSTEM
/////////////////////////////////////////////////////////////////////////
// MyOfflineShop
bool CPythonNetworkStream::SendBuildOfflineShopPacket(const char* c_szName, const std::vector<TOfflineShopItemTable>& c_rSellingItemStock, BYTE bNpcType, BYTE bBoardStyle)
{
TPacketCGMyOfflineShop packet;
packet.bHeader = HEADER_CG_MY_OFFLINE_SHOP;
strncpy(packet.szSign, c_szName, SHOP_SIGN_MAX_LEN);
packet.bCount = (short)c_rSellingItemStock.size();
packet.bNpcType = bNpcType;
packet.bBoardStyle = bBoardStyle;
if (!Send(sizeof(packet), &packet))
return false;

for (std::vector<TOfflineShopItemTable>::const_iterator itor = c_rSellingItemStock.begin(); itor < c_rSellingItemStock.end(); ++itor)
{
const TOfflineShopItemTable& c_rItem = *itor;
if (!Send(sizeof(c_rItem), &c_rItem))
return false;
}

return SendSequence();
}

bool CPythonNetworkStream::RecvOfflineShopSignPacket()
{
TPacketGCShopSign p;
if (!Recv(sizeof(TPacketGCShopSign), &p))
return false;

CInstanceBase* pInstance = CPythonCharacterManager::instance().GetInstancePtr(p.dwVID);
if (pInstance)
{
if (pInstance->IsShop())
{
if (0 == strlen(p.szSign))
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OfflineShop_Disappear", Py_BuildValue("(i)", p.dwVID));
else
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OfflineShop_Appear", Py_BuildValue("(isi)", p.dwVID, p.szSign, p.bBorderStyle));
}
else
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OfflineShop_Disappear", Py_BuildValue("(i)", p.dwVID));
}
return true;
}

bool CPythonNetworkStream::RecvOfflineShopOpenPanelPacket()
{
TPacketGCOpenOffShopPanel p;
if (!Recv(sizeof(TPacketGCOpenOffShopPanel), &p))
return false;

BYTE hasOfflineShop = p.hasOfflineShop;
UINT lMapIndex = (UINT)p.lMapIndex;
BYTE shopChannel = p.shopChannel;
int iTime = p.iTime;
BYTE isPremium = p.isPremium;
DWORD displayedCount = p.displayedCount;
const char * shopName = p.shopName;

PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OfflineShop_Open", Py_BuildValue("(iiiiiis)", hasOfflineShop, lMapIndex, shopChannel, iTime, isPremium, displayedCount, shopName));
return true;
}

bool CPythonNetworkStream::RecvOfflineShopStartP2PPacket()
{
TPacketGCOfflineShopStartP2P pShopStartPacket;
if (!Recv(sizeof(TPacketGCOfflineShopStartP2P), &pShopStartPacket))
return false;

CPythonShop::Instance().Clear();
for (BYTE iItemIndex = 0; iItemIndex < OFFLINE_SHOP_HOST_ITEM_MAX_NUM; ++iItemIndex)
{
CPythonShop::Instance().SetOfflineShopItemData(iItemIndex, pShopStartPacket.items[iItemIndex]);
}
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshOfflineShopManager", Py_BuildValue("()"));
return true;
}

bool CPythonNetworkStream::RecvOfflineShopChangeSignPacket()
{
TPacketGCShopSign p;
if (!Recv(sizeof(TPacketGCShopSign), &p))
return false;

CInstanceBase* pInstance = CPythonCharacterManager::instance().GetInstancePtr(p.dwVID);
if (pInstance)
{
if (pInstance->IsShop())
{
if (0 == strlen(p.szSign))
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OfflineShop_Disappear", Py_BuildValue("(i)", p.dwVID));
else
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OfflineShop_ChangeSign", Py_BuildValue("(is)", p.dwVID, p.szSign));
}
else
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OfflineShop_Disappear", Py_BuildValue("(i)", p.dwVID));
}

return true;
}

bool CPythonNetworkStream::RecvOfflineShopChangeSignPacketP2P()
{
TPacketGCShopSign p;
if (!Recv(sizeof(TPacketGCShopSign), &p))
return false;

PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_ChangeOfflineShopName", Py_BuildValue("(s)", p.szSign));

return true;
}

bool CPythonNetworkStream::RecvOfflineShopPlayerBuyItem()
{
TPacketGCOfflineShopAdviseOwnerSell p;
if (!Recv(sizeof(TPacketGCOfflineShopAdviseOwnerSell), &p))
return false;

PyObject *args = PyTuple_New(3);
PyTuple_SetItem(args, 0, Py_BuildValue("i", p.itemSelled));
PyTuple_SetItem(args, 1, Py_BuildValue("s", p.buyerName));
PyTuple_SetItem(args, 2, PyLong_FromLongLong(p.itemPrice));

PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "BINARY_OfflineShopAdviseBuyItem", args);

return true;
}

bool CPythonNetworkStream::RecvOfflineShopPacket()
{
std::vector<int> 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];

TPacketGCOfflineShopStart* pShopStartPacket = (TPacketGCOfflineShopStart*)&vecBuffer[1];
for (BYTE iItemIndex = 0; iItemIndex < OFFLINE_SHOP_HOST_ITEM_MAX_NUM; ++iItemIndex)
{
CPythonShop::Instance().SetOfflineShopItemData(iItemIndex, pShopStartPacket->items[iItemIndex]);
}

CPythonShop::Instance().SetShopDisplayedCount(pShopStartPacket->m_dwDisplayedCount);

PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartOfflineShop", Py_BuildValue("(i)", dwVID));
}
break;

case SHOP_SUBHEADER_GC_UPDATE_ITEM2:
{
CPythonShop::Instance().Clear();
TPacketGCOfflineShopStart* pShopStartPacket = (TPacketGCOfflineShopStart*)&vecBuffer[1];
for (BYTE iItemIndex = 0; iItemIndex < OFFLINE_SHOP_HOST_ITEM_MAX_NUM; ++iItemIndex)
{
CPythonShop::Instance().SetOfflineShopItemData(iItemIndex, pShopStartPacket->items[iItemIndex]);
}
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshOfflineShopManager", Py_BuildValue("()"));
}
break;

case SHOP_SUBHEADER_GC_END:
CPythonShop::instance().Clear();
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "EndOfflineShop", Py_BuildValue("()"));
break;

case SHOP_SUBHEADER_GC_UPDATE_PRICE:
{
TPacketGCShopUpdatePrice* pShopUpdateItemPricePacket = (TPacketGCShopUpdatePrice*)&vecBuffer[0];
PyObject *args = PyTuple_New(3);
PyTuple_SetItem(args, 0, Py_BuildValue("i", pShopUpdateItemPricePacket->dwShopVid));
PyTuple_SetItem(args, 1, Py_BuildValue("i", pShopUpdateItemPricePacket->bPos));
PyTuple_SetItem(args, 2, PyLong_FromLongLong(pShopUpdateItemPricePacket->iPrice));
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshShopSellingPrice", args);
}
break;

case SHOP_SUBHEADER_GC_UPDATE_ITEM:
{
TPacketGCOfflineShopUpdateItem* pShopUpdateItemPacket = (TPacketGCOfflineShopUpdateItem*)&vecBuffer[0];
CPythonShop::Instance().SetOfflineShopItemData(pShopUpdateItemPacket->pos, pShopUpdateItemPacket->item);
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshOfflineShop", Py_BuildValue("()"));
}
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;

case SHOP_SUBHEADER_GC_YOU_DONT_HAVE_DS:
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "YOU_DONT_HAVE_DS"));
break;

case SHOP_SUBHEADER_GC_REFRESH_MONEY:
{
TPacketGCOfflineShopMoney* pOfflineShopMoney = (TPacketGCOfflineShopMoney*)&vecBuffer[0];
CPythonPlayer::Instance().SetCurrentOfflineShopMoney(pOfflineShopMoney->llMoney);
#ifdef ENABLE_CHEQUE_SYSTEM
CPythonPlayer::Instance().SetCurrentOfflineShopCheque(pOfflineShopMoney->dwCheque);
#endif
break;
}

case SHOP_SUBHEADER_GC_CHECK_RESULT:
{
BYTE bHasOfflineShop;
if (!Recv(sizeof(BYTE), &bHasOfflineShop))
return false;

CPythonPlayer::instance().SetHasOfflineShop(bHasOfflineShop == 1 ? true : false);
if (bHasOfflineShop != 0)
{
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshOfflineShopManager", Py_BuildValue("()"));
}
else
{
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "CloseOfflineShopManager", Py_BuildValue("()"));
}

break;
}

#ifdef ENABLE_CHEQUE_SYSTEM
case SHOP_SUBHEADER_GC_NOT_ENOUGH_CHEQUE:
PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OnShopError", Py_BuildValue("(s)", "NOT_ENOUGH_MONEY"));
break;
#endif

default:
TraceError("CPythonNetworkStream::RecvOfflineShopPacket: Unknown subheader %d\n", packet_shop.subheader);
break;
}

return true;
}
#endif[/CODE]

[CODE title="WİKİ PYTHONNETWORKSTREAMGAME.CPP"]#ifdef INGAME_WIKI
extern PyObject* wikiModule;

bool CPythonNetworkStream::SendWikiRequestInfo(unsigned long long retID, DWORD vnum, bool isMob)
{
InGameWiki::TCGWikiPacket pack;
pack.vnum = vnum;
pack.is_mob = isMob;
pack.ret_id = retID;

if (!Send(sizeof(InGameWiki::TCGWikiPacket), &pack))
return false;

return true;
}

bool CPythonNetworkStream::RecvWikiPacket()
{
InGameWiki::TGCWikiPacket pack;
if (!Recv(sizeof(InGameWiki::TGCWikiPacket), &pack))
return false;

WORD iPacketSize = pack.size - sizeof(InGameWiki::TGCWikiPacket);
if (iPacketSize <= 0)
return false;

unsigned long long ret_id = 0;
DWORD data_vnum = 0;

if (pack.is_data_type(InGameWiki::LOAD_WIKI_ITEM))
{
const size_t recv_size = sizeof(InGameWiki::TGCItemWikiPacket);
iPacketSize -= WORD(recv_size);

InGameWiki::TGCItemWikiPacket item_data;
if (!Recv(recv_size, &item_data))
return false;

ret_id = item_data.ret_id;
data_vnum = item_data.vnum;

CItemData* pData = nullptr;
if (!CItemManager::instance().GetItemDataPointer(item_data.vnum, &pData)) {
TraceError("Cant get pointer from item -> %d", item_data.vnum);
return false;
}

auto& recv_wiki = item_data.wiki_info;
auto wikiInfo = pData->GetWikiTable();

const int origin_size = item_data.origin_infos_count;
const int chest_info_count = recv_wiki.chest_info_count;
const int refine_infos_count = recv_wiki.refine_infos_count;

wikiInfo->isSet = true;
wikiInfo->hasData = true;
wikiInfo->bIsCommon = recv_wiki.is_common;
wikiInfo->dwOrigin = recv_wiki.origin_vnum;
wikiInfo->maxRefineLevel = refine_infos_count;

{
wikiInfo->pOriginInfo.clear();
const size_t origin_info_recv_base_size = sizeof(CommonWikiData::TWikiItemOriginInfo);

for (int idx = 0; idx < origin_size; ++idx) {
CommonWikiData::TWikiItemOriginInfo origin_data;
if (!Recv(origin_info_recv_base_size, &origin_data))
return false;

wikiInfo->pOriginInfo.emplace_back(origin_data);
iPacketSize -= WORD(origin_info_recv_base_size);
}


wikiInfo->pChestInfo.clear();
const size_t chest_info_recv_base_size = sizeof(CommonWikiData::TWikiChestInfo);

for (int idx = 0; idx < chest_info_count; ++idx) {
CommonWikiData::TWikiChestInfo chest_data;
if (!Recv(chest_info_recv_base_size, &chest_data))
return false;

wikiInfo->pChestInfo.emplace_back(chest_data);
iPacketSize -= WORD(chest_info_recv_base_size);
}

wikiInfo->pRefineData.clear();
const size_t refine_info_recv_base_size = sizeof(CommonWikiData::TWikiRefineInfo);

for (int idx = 0; idx < refine_infos_count; ++idx) {
CommonWikiData::TWikiRefineInfo refine_info_data;
if (!Recv(refine_info_recv_base_size, &refine_info_data))
return false;

wikiInfo->pRefineData.emplace_back(refine_info_data);
iPacketSize -= WORD(refine_info_recv_base_size);
}
}

if (iPacketSize != 0)
return false;
}
else
{
const size_t recv_size = sizeof(InGameWiki::TGCMobWikiPacket);
iPacketSize -= WORD(recv_size);

InGameWiki::TGCMobWikiPacket mob_data;
if (!Recv(recv_size, &mob_data))
return false;

ret_id = mob_data.ret_id;
data_vnum = mob_data.vnum;
const int drop_info_count = mob_data.drop_info_count;

CPythonNonPlayer::TWikiInfoTable* mobData = nullptr;
if (!(mobData = CPythonNonPlayer::instance().GetWikiTable(mob_data.vnum))) {
TraceError("Cant get mob data from monster -> %d", mob_data.vnum);
return false;
}

mobData->isSet = (drop_info_count > 0);

{
mobData->dropList.clear();
const size_t mob_drop_info_recv_base_size = sizeof(CommonWikiData::TWikiMobDropInfo);

for (int idx = 0; idx < drop_info_count; ++idx) {
CommonWikiData::TWikiMobDropInfo drop_data;
if (!Recv(mob_drop_info_recv_base_size, &drop_data))
return false;

mobData->dropList.push_back(drop_data);
iPacketSize -= WORD(mob_drop_info_recv_base_size);
}
}

if (iPacketSize != 0)
return false;
}

if (wikiModule)
PyCallClassMemberFunc(wikiModule, "BINARY_LoadInfo", Py_BuildValue("(Li)", (long long)ret_id, data_vnum));

return true;
}
#endif[/CODE]

Ekli dosyayı görüntüle 76404
 
Tarihe Göre Sırala Reaksiyona göre sırala Oylara göre sırala
Bu hata Shop ex Sistemlerinden kaynaklanıyor Temiz Yaptığım alt yapıda Bu Hatayı almıyordum fakat aynı alt yapının Shop Ex Vs olan Halinde bu hata mevcuttu shopu açtığın an tüm packet.h packetleri hata olarak gösterip syser yazıyor packetleri tıkandiriyor
 
Upvote 0 Downvote
Cevap yazmak için giriş yap yada kayıt ol.

Şu an konuyu görüntüleyenler (Toplam : 0, Üye: 0, Misafir: 0)

Benzer konular

Black Jack36
  • Soru Soru
Cevaplanmadı language system
Cevaplar
4
Görüntüleme
104
Black Jack36
Aliyldrim
Ninja Kombo Seviyesine Bağlı Çoklu Hedefe Saldırı Sistemi
2
Cevaplar
9
Görüntüleme
487
brsturk
Aliyldrim
Metin2 - Şaman Karakteri Uzak Mesafe Düz Vuruş - Ateş Büyücüsü Yılmaz Sistemi
2 3 4
Cevaplar
15
Görüntüleme
765
Aliyldrim
N
  • Çözüldü
Cevaplandı Source Build sorunu 2
2
Cevaplar
8
Görüntüleme
226
Nida2
devemoji
  • Soru Soru
Cevaplanmadı item yansıtma 7. efsun sorunu
Cevaplar
3
Görüntüleme
165
Karadayı ✓
Geri
Üst