Yardım Client Src'ye eklenen yeni dosyalar hakkında bilgi

Konu sahibi bu konuda soru soruyor. Sorusu ile ilgili bilgisi olanların yanıtlamasını bekliyor.
beratcanleylek

beratcanleylek

Üye
Üye
Mesaj
35
Çözümler
1
Beğeni
7
Puan
39
Ticaret Puanı
0
Herkese merhaba,

Yeni eklediğim Wiki sisteminde client src de diğer hiç bir dosyalarda sorun yaşamadım fakat userinterface'e eklediklerimde bu hatalarla karşılaştım ve genelde verdiği hatalar sistemin kendine ait olan dosyalarından.
1665148590168.png


EterPythonLib klasörüne de benzer sistemin kendine ait dosyalarından attım ama bir hata ile karşılaşmadım.
Ayrıca şunu da sormak isterim bu dosyalar için şöyle bir not bırakılmıştı;
Add this files inside UserInterface:
--> PythonWikiModule.cpp;
--> PythonWikiRenderTarget.cpp;
--> PythonWikiRenderTarget.h;

(Dont forget to add them on your project too)
Proje dosyalarına ekleyinden kastı nedir acaba bunu anlamadım bununla ilgil bir problem olabilir mi?
 
Tarihe göre sırala Oy skoruna göre sırala
--> PythonWikiModule.cpp;
--> PythonWikiRenderTarget.cpp;
--> PythonWikiRenderTarget.h;

Bu dosyaları, clienr_src/source/UserInterface içerisine kopyala. Daha sonra visual studio üzerinden UserInterface bölümüne sağ tıkla ve bu adımlardan yeni eklediğin dosyaları seç.
1665149645706.png
 
Upvote 0 Downvote
adv1453 demiş ki:
--> PythonWikiModule.cpp;
--> PythonWikiRenderTarget.cpp;
--> PythonWikiRenderTarget.h;

Bu dosyaları, clienr_src/source/UserInterface içerisine kopyala. Daha sonra visual studio üzerinden UserInterface bölümüne sağ tıkla ve bu adımlardan yeni eklediğin dosyaları seç.
10911 eklentisini görüntüle
Hepsini görmek için tıklayın...
Dr Livesey demiş ki:
Arat değiştir arat değiştir

_wuint32 = unsigned int
_wint32 = int
_wfloat = float
Hepsini görmek için tıklayın...

Dediklerinizi yaptım ve hataların %90'ı çözüldü son bunlar kaldı

1665151786591.png
 
Upvote 0 Downvote
Dr Livesey demiş ki:
.cpp ve .h dosyalarınızı konuya dahil eder misiniz yardımcı olabilmem için ;

--> PythonWikiModule.cpp;
--> PythonWikiRenderTarget.cpp;
--> PythonWikiRenderTarget.h;
Hepsini görmek için tıklayın...

Tabi paylaşıyorum

PythonWikiModule.cpp: 
#include "StdAfx.h"

#ifdef INGAME_WIKI

#include "../gamelib/ItemManager.h"
#include "../gamelib/in_game_wiki.h"
#include "../EterBase/Stl.h"

#include "PythonNetworkStream.h"
#include "PythonNonPlayer.h"
#include "PythonWikiRenderTarget.h"
#include "PythonExchange.h"
using namespace CPythonExchange::trade;

PyObject* wikiModule = NULL;

PyObject* wikiGetBaseClass(PyObject* poSelf, PyObject* poArgs)
{
    if (!wikiModule)
        return Py_BuildNone();
    
    return Py_BuildValue("O", wikiModule);
}

PyObject* wikiGetChestInfo(PyObject* poSelf, PyObject* poArgs)
{
    int itemVnum;
    if (!PyTuple_GetInteger(poArgs, 0, &itemVnum))
        return Py_BadArgument();
    
    CItemData* table;
    if (CItemManager::instance().GetItemDataPointer(itemVnum, &table) && !table->GetWikiTable()->pChestInfo.empty())
    {
        const size_t dataCount = table->GetWikiTable()->pChestInfo.size();
        PyObject* ret = PyTuple_New(dataCount);
        for (int i = 0; i < dataCount; ++i)
            PyTuple_SetItem(ret, i, Py_BuildValue("ii", table->GetWikiTable()->pChestInfo[i].vnum, table->GetWikiTable()->pChestInfo[i].count));
        return Py_BuildValue("iiO", table->GetWikiTable()->dwOrigin, table->GetWikiTable()->bIsCommon ? 1 : 0, ret);
    }
    
    return Py_BuildValue("ii", table->GetWikiTable()->dwOrigin, table->GetWikiTable()->bIsCommon ? 1 : 0);;
}

PyObject* wikiGetMobInfo(PyObject* poSelf, PyObject* poArgs)
{
    int itemVnum;
    if (!PyTuple_GetInteger(poArgs, 0, &itemVnum))
        return Py_BadArgument();
    
    const CPythonNonPlayer::TWikiInfoTable* mobData = CPythonNonPlayer::instance().GetWikiTable(itemVnum);
    if (!mobData->dropList.empty())
    {
        const size_t dataCount = mobData->dropList.size();
        PyObject* ret = PyTuple_New(dataCount);
        
        int idx = 0;
        for (const auto& [CPythonExchange::trade::item_vnum, item_count] : mobData->dropList) {
            PyTuple_SetItem(ret, idx, Py_BuildValue("ii", item_vnum, item_count));
            ++idx;
        }
        return Py_BuildValue("O", ret);
    }
    
    return Py_BuildNone();
}

PyObject* wikiLoadClassItems(PyObject* poSelf, PyObject* poArgs)
{
    _wunsignedchar classType;
    int raceFilter;
    
    if (!PyTuple_GetByte(poArgs, 0, &classType))
        return Py_BadArgument();
    
    if (!PyTuple_GetInteger(poArgs, 1, &raceFilter))
        return Py_BadArgument();
    
    return Py_BuildValue("i", CItemManager::Instance().WikiLoadClassItems(classType, raceFilter));
}

PyObject* wikiLoadClassMobs(PyObject* poSelf, PyObject* poArgs)
{
    _wunsignedchar classType;
    if (!PyTuple_GetByte(poArgs, 0, &classType))
        return Py_BadArgument();
    
    _wunsignedshort fromLvl, toLvl;
    if (!PyTuple_GetInteger(poArgs, 1, &fromLvl))
        return Py_BadArgument();
    
    if (!PyTuple_GetInteger(poArgs, 2, &toLvl))
        return Py_BadArgument();
    
    return Py_BuildValue("i", CPythonNonPlayer::instance().WikiLoadClassMobs(classType, fromLvl, toLvl));
}

PyObject* GetWikiModule()
{
    return wikiModule;
}

PyObject* wikiChangePage(PyObject* poSelf, PyObject* poArgs)
{
    _wunsignedshort from;
    _wunsignedshort to;
    int isMob = 0;
    
    if (!PyTuple_GetInteger(poArgs, 0, &from))
        return Py_BadArgument();
    
    if (!PyTuple_GetInteger(poArgs, 1, &to))
        return Py_BadArgument();
    
    if (PyTuple_Size(poArgs) > 2 && !PyTuple_GetInteger(poArgs, 2, &isMob))
        return Py_BadArgument();
    
    if (from > to)
        return Py_BuildException("to must be bigger than from");
    
    std::vector<unsigned int>* loadVec;
    
    if (!isMob)
        loadVec = CItemManager::Instance().WikiGetLastItems();
    else
        loadVec = CPythonNonPlayer::instance().WikiGetLastMobs();
    
    PyObject* tuple;
    if (loadVec->size() > 0)
    {
        if (loadVec->size() < to)
            to = (_wunsignedshort)loadVec->size();
        
        if (from > to)
            return Py_BuildException("to must be bigger than from");
        
        tuple = PyTuple_New(to - from);
        for (_wunsignedshort i = from; i < to; ++i)
            PyTuple_SetItem(tuple, i - from, Py_BuildValue("i", (*loadVec)[i]));
        
        return tuple;
    }
    
    return Py_BuildNone();
}

PyObject* wikiLoadInfo(PyObject* poSelf, PyObject* poArgs)
{
    int iretID;
    if (!PyTuple_GetInteger(poArgs, 0, &iretID))
        return Py_BadArgument();
    
    _wuint64 retID = static_cast<_wuint64>(iretID);
    
    int itemVnum;
    if (!PyTuple_GetInteger(poArgs, 1, &itemVnum))
        return Py_BadArgument();
    
    int isMob = 0;
    if (PyTuple_Size(poArgs) > 2 && !PyTuple_GetInteger(poArgs, 2, &isMob))
        return Py_BadArgument();
    
    if (!isMob)
    {
        CItemData* itemData;
        if (CItemManager::Instance().GetItemDataPointer(itemVnum, &itemData))
        {
            if (!itemData->GetWikiTable()->isSet)
                CPythonNetworkStream::instance().SendWikiRequestInfo(retID, itemVnum, false);
            else
            {
                if (wikiModule)
                    PyCallClassMemberFunc(wikiModule, "BINARY_LoadInfo", Py_BuildValue("(Ki)", retID, itemVnum));
            }
        }
    }
    else
    {
        const CPythonNonPlayer::TWikiInfoTable* mobData = CPythonNonPlayer::instance().GetWikiTable(itemVnum);
        if (mobData)
        {
            if (!mobData->isSet)
                CPythonNetworkStream::instance().SendWikiRequestInfo(retID, itemVnum, true);
            else
            {
                if (wikiModule)
                    PyCallClassMemberFunc(wikiModule, "BINARY_LoadInfo", Py_BuildValue("(Ki)", retID, itemVnum));
            }
        }
    }
    
    return Py_BuildNone();
}

PyObject* wikiGetRefineInfo(PyObject* poSelf, PyObject* poArgs)
{
    int itemVnum;
    if (!PyTuple_GetInteger(poArgs, 0, &itemVnum))
        return Py_BadArgument();
    
    CItemData* table;
    if (CItemManager::instance().GetItemDataPointer(itemVnum, &table))
    {
        const int refineMaxLevel = table->GetWikiTable()->maxRefineLevel;
        PyObject* ret = PyTuple_New(refineMaxLevel);
        
        for (int i = 0; i < refineMaxLevel; ++i)
        {
            PyObject* ret2 = PyTuple_New(CommonWikiData::REFINE_MATERIAL_MAX_NUM);
            
            for (int j = 0; j < CommonWikiData::REFINE_MATERIAL_MAX_NUM; ++j)
                PyTuple_SetItem(ret2, j, Py_BuildValue("ii", table->GetWikiTable()->pRefineData[i].materials[j].vnum, table->GetWikiTable()->pRefineData[i].materials[j].count));
            
            PyTuple_SetItem(ret, i, Py_BuildValue("iO", table->GetWikiTable()->pRefineData[i].price, ret2));
        }
        return Py_BuildValue("iO", refineMaxLevel, ret);
    }
    
    return Py_BuildNone();
}

PyObject* wikiGetOriginInfo(PyObject* poSelf, PyObject* poArgs)
{
    int itemVnum;
    if (!PyTuple_GetInteger(poArgs, 0, &itemVnum))
        return Py_BadArgument();
    
    CItemData* table;
    if (CItemManager::instance().GetItemDataPointer(itemVnum, &table) && !table->GetWikiTable()->pOriginInfo.empty())
    {
        CItemData::TWikiItemInfo* wikiTbl = table->GetWikiTable();
        PyObject* ret = PyTuple_New(wikiTbl->pOriginInfo.size());
        for (int i = 0; i < wikiTbl->pOriginInfo.size(); ++i)
            PyTuple_SetItem(ret, i, Py_BuildValue("ii", wikiTbl->pOriginInfo[i].vnum, wikiTbl->pOriginInfo[i].is_mob ? 1 : 0));

        return Py_BuildValue("O", ret);
    }
    
    return Py_BuildNone();
}

PyObject* wikiGetWikiItemStartRefineVnum(PyObject* poSelf, PyObject* poArgs)
{
    int itemVnum;
    if (!PyTuple_GetInteger(poArgs, 0, &itemVnum))
        return Py_BadArgument();
    
    return Py_BuildValue("i", CItemManager::instance().GetWikiItemStartRefineVnum(itemVnum));
}

PyObject* wikiIsSet(PyObject* poSelf, PyObject* poArgs)
{
    int itemVnum;
    if (!PyTuple_GetInteger(poArgs, 0, &itemVnum))
        return Py_BadArgument();
    
    bool isMob = false;
    if (PyTuple_Size(poArgs) > 1)
        if (!PyTuple_GetBoolean(poArgs, 1, &isMob))
            return Py_BadArgument();
    
    if (!isMob)
    {
        CItemData* table;
        if (CItemManager::instance().GetItemDataPointer(itemVnum, &table))
            return Py_BuildValue("i", table->GetWikiTable()->isSet ? 1 : 0);
    }
    else
    {
        CPythonNonPlayer::TWikiInfoTable* ptr = CPythonNonPlayer::instance().GetWikiTable(itemVnum);
        if (ptr)
            return Py_BuildValue("i", ptr->isSet ? 1 : 0);
    }
    
    return Py_BuildValue("i", 0);
}

PyObject* wikiHasData(PyObject* poSelf, PyObject* poArgs)
{
    int itemVnum;
    if (!PyTuple_GetInteger(poArgs, 0, &itemVnum))
        return Py_BadArgument();
    
    CItemData* table;
    if (CItemManager::instance().GetItemDataPointer(itemVnum, &table))
    {
        return Py_BuildValue("i", table->GetWikiTable()->hasData ? 1 : 0);
    }
    
    return Py_BuildValue("i", 0);
}

PyObject* wikiRegisterClass(PyObject* poSelf, PyObject* poArgs)
{
    PyObject* mClass;
    if (!PyTuple_GetObject(poArgs, 0, &mClass))
        return Py_BadArgument();

    wikiModule = mClass;
    return Py_BuildNone();
}

PyObject* wikiUnregisterClass(PyObject* poSelf, PyObject* poArgs)
{
    wikiModule = NULL;
    return Py_BuildNone();
}

PyObject* wikiRegisterItemBlacklist(PyObject* poSelf, PyObject* poArgs)
{
    int vnum;
    if (!PyTuple_GetInteger(poArgs, 0, &vnum))
        return Py_BadArgument();
    
    CItemManager::instance().WikiAddVnumToBlacklist(vnum);
    return Py_BuildNone();
}

PyObject* wikiRegisterMonsterBlacklist(PyObject* poSelf, PyObject* poArgs)
{
    int vnum;
    if (!PyTuple_GetInteger(poArgs, 0, &vnum))
        return Py_BadArgument();
    
    CPythonNonPlayer::instance().WikiSetBlacklisted(vnum);
    return Py_BuildNone();
}

PyObject* wikiCanIncrRefineLevel(PyObject* poSelf, PyObject* poArgs)
{
    return Py_BuildValue("i", CItemManager::instance().CanIncrSelectedItemRefineLevel());
}

PyObject* wikiRegisterModelViewWindow(PyObject* poSelf, PyObject* poArgs)
{
    int moduleID;
    if (!PyTuple_GetInteger(poArgs, 0, &moduleID))
        return Py_BadArgument();
    
    int hwnd;
    if (!PyTuple_GetInteger(poArgs, 1, &hwnd))
        return Py_BadArgument();
    
    CPythonWikiRenderTarget::instance().RegisterRenderModule(moduleID, hwnd);
    return Py_BuildNone();
}

PyObject* wikiGetFreeModelViewID(PyObject* poSelf, PyObject* poArgs)
{
    return Py_BuildValue("i", CPythonWikiRenderTarget::instance().GetFreeID());
}

PyObject* wikiManageModelViewVisibility(PyObject* poSelf, PyObject* poArgs)
{
    int moduleID;
    if (!PyTuple_GetInteger(poArgs, 0, &moduleID))
        return Py_BadArgument();
    
    bool flag = false;
    if (!PyTuple_GetBoolean(poArgs, 1, &flag))
        return Py_BadArgument();
    
    CPythonWikiRenderTarget::instance().ManageModelViewVisibility(moduleID, flag);
    return Py_BuildNone();
}

PyObject* wikiShowModelViewManager(PyObject* poSelf, PyObject* poArgs)
{
    bool flag = false;
    if (!PyTuple_GetBoolean(poArgs, 0, &flag))
        return Py_BadArgument();
    
    CPythonWikiRenderTarget::instance().ShowModelViewManager(flag);
    return Py_BuildNone();
}

PyObject* wikiSetModelViewModel(PyObject* poSelf, PyObject* poArgs)
{
    int moduleID;
    if (!PyTuple_GetInteger(poArgs, 0, &moduleID))
        return Py_BadArgument();
    
    int moduleVnum;
    if (!PyTuple_GetInteger(poArgs, 1, &moduleVnum))
        return Py_BadArgument();
    
    CPythonWikiRenderTarget::instance().SetModelViewModel(moduleID, moduleVnum);
    return Py_BuildNone();
}

PyObject* wikiSetWeaponModel(PyObject* poSelf, PyObject* poArgs)
{
    int moduleID;
    if (!PyTuple_GetInteger(poArgs, 0, &moduleID))
        return Py_BadArgument();
    
    int weaponVnum;
    if (!PyTuple_GetInteger(poArgs, 1, &weaponVnum))
        return Py_BadArgument();
    
    CPythonWikiRenderTarget::instance().SetWeaponModel(moduleID, weaponVnum);
    return Py_BuildNone();
}

PyObject* wikiSetModelForm(PyObject* poSelf, PyObject* poArgs)
{
    int moduleID;
    if (!PyTuple_GetInteger(poArgs, 0, &moduleID))
        return Py_BadArgument();
    
    int mainVnum;
    if (!PyTuple_GetInteger(poArgs, 1, &mainVnum))
        return Py_BadArgument();
    
    CPythonWikiRenderTarget::instance().SetModelForm(moduleID, mainVnum);
    return Py_BuildNone();
}

PyObject* wikiSetModelHair(PyObject* poSelf, PyObject* poArgs)
{
    int moduleID;
    if (!PyTuple_GetInteger(poArgs, 0, &moduleID))
        return Py_BadArgument();
    
    int hairVnum;
    if (!PyTuple_GetInteger(poArgs, 1, &hairVnum))
        return Py_BadArgument();
    
    CPythonWikiRenderTarget::instance().SetModelHair(moduleID, hairVnum);
    return Py_BuildNone();
}

PyObject* wikiSetModelV3Eye(PyObject* poSelf, PyObject* poArgs)
{
    int moduleID;
    if (!PyTuple_GetInteger(poArgs, 0, &moduleID))
        return Py_BadArgument();
    
    float x, y, z;
    if (!PyTuple_GetFloat(poArgs, 1, &x))
        return Py_BadArgument();

    if (!PyTuple_GetFloat(poArgs, 2, &y))
        return Py_BadArgument();

    if (!PyTuple_GetFloat(poArgs, 3, &z))
        return Py_BadArgument();
    
    CPythonWikiRenderTarget::instance().SetModelV3Eye(moduleID, x, y, z);
    return Py_BuildNone();
}

PyObject* wikiSetModelV3Target(PyObject* poSelf, PyObject* poArgs)
{
    int moduleID;
    if (!PyTuple_GetInteger(poArgs, 0, &moduleID))
        return Py_BadArgument();
    
    float x, y, z;
    if (!PyTuple_GetFloat(poArgs, 1, &x))
        return Py_BadArgument();

    if (!PyTuple_GetFloat(poArgs, 2, &y))
        return Py_BadArgument();

    if (!PyTuple_GetFloat(poArgs, 3, &z))
        return Py_BadArgument();
    
    CPythonWikiRenderTarget::instance().SetModelV3Target(moduleID, x, y, z);
    return Py_BuildNone();
}

void initWiki()
{
    static PyMethodDef s_methods[] =
    {
        { "GetBaseClass",                        wikiGetBaseClass,                    METH_VARARGS },
        { "GetChestInfo",                        wikiGetChestInfo,                    METH_VARARGS },
        { "LoadClassItems",                        wikiLoadClassItems,                    METH_VARARGS },
        { "ChangePage",                            wikiChangePage,                        METH_VARARGS },
        { "LoadInfo",                            wikiLoadInfo,                        METH_VARARGS },
        { "RegisterClass",                        wikiRegisterClass,                    METH_VARARGS },
        { "UnregisterClass",                    wikiUnregisterClass,                METH_VARARGS },
        { "HasData",                            wikiHasData,                        METH_VARARGS },
        { "IsSet",                                wikiIsSet,                            METH_VARARGS },
        { "GetRefineInfo",                        wikiGetRefineInfo,                    METH_VARARGS },
        { "GetOriginInfo",                        wikiGetOriginInfo,                    METH_VARARGS },
        { "GetWikiItemStartRefineVnum",            wikiGetWikiItemStartRefineVnum,        METH_VARARGS },
        
        { "RegisterItemBlacklist",                wikiRegisterItemBlacklist,            METH_VARARGS },
        { "RegisterMonsterBlacklist",            wikiRegisterMonsterBlacklist,        METH_VARARGS },
        
        { "LoadClassMobs",                        wikiLoadClassMobs,                    METH_VARARGS },
        { "GetMobInfo",                            wikiGetMobInfo,                        METH_VARARGS },
        
        { "CanIncrRefineLevel",                    wikiCanIncrRefineLevel,                METH_VARARGS },
        
        { "GetFreeModelViewID",                    wikiGetFreeModelViewID,                METH_VARARGS },
        { "RegisterModelViewWindow",            wikiRegisterModelViewWindow,        METH_VARARGS },
        { "ManageModelViewVisibility",            wikiManageModelViewVisibility,        METH_VARARGS },
        { "ShowModelViewManager",                wikiShowModelViewManager,            METH_VARARGS },
        
        { "SetModelViewModel",                    wikiSetModelViewModel,                METH_VARARGS },
        { "SetWeaponModel",                        wikiSetWeaponModel,                    METH_VARARGS },
        { "SetModelForm",                        wikiSetModelForm,                    METH_VARARGS },
        { "SetModelHair",                        wikiSetModelHair,                    METH_VARARGS },
        { "SetModelV3Eye",                        wikiSetModelV3Eye,                    METH_VARARGS },
        { "SetModelV3Target",                    wikiSetModelV3Target,                METH_VARARGS },
        
        { NULL,                                    NULL,                                NULL         }
    };
    
    PyObject* module = Py_InitModule("wiki", s_methods);
    
    PyModule_AddIntConstant(module, "MAX_REFINE_COUNT", CommonWikiData::MAX_REFINE_COUNT);
    PyModule_AddIntConstant(module, "REFINE_MATERIAL_MAX_NUM", CommonWikiData::REFINE_MATERIAL_MAX_NUM);
    PyModule_AddIntConstant(module, "CONTROL_ITEM_VNUM", 10); //This is static value! Please dont touch in him.
    
    PyModule_AddIntConstant(module, "WIKI_RENDER_MODULE_DELETE", CPythonWikiRenderTarget::DELETE_PARM);
    PyModule_AddIntConstant(module, "WIKI_RENDER_MODULE_START", CPythonWikiRenderTarget::START_MODULE);
}
#endif

PythonWikiRenderTarget.cpp: 
#pragma once

#include "../gamelib/in_game_wiki.h"
#include "../EterPythonLib/PythonWindow.h"
#include "../eterLib/CWikiRenderTargetManager.h"
#include "../eterLib/GrpWikiRenderTargetTexture.h"

class CPythonWikiRenderTarget : public CSingleton<CPythonWikiRenderTarget>
{
    public:
        CPythonWikiRenderTarget();
        virtual ~CPythonWikiRenderTarget();
    
    public:
        const static    int DELETE_PARM = -1;
        const static    int START_MODULE = 1;
        
        typedef std::vector<std::tuple<int, std::shared_ptr<UI::CUiWikiRenderTarget>>> TWikiRenderTargetModules;
        
        int        GetFreeID();
        void        RegisterRenderModule(int module_id, int module_wnd);
        
        void        ManageModelViewVisibility(int module_id, bool flag);
        
        void        ShowModelViewManager(bool flag) { _bCanRenderModules = flag; }
        bool        CanRenderWikiModules() const;
        
        void        SetModelViewModel(int module_id, int module_vnum);
        void        SetWeaponModel(int module_id, int weapon_vnum);
        void        SetModelForm(int module_id, int main_vnum);
        void        SetModelHair(int module_id, int hair_vnum);
        void        SetModelV3Eye(int module_id, float x, float y, float z);
        void        SetModelV3Target(int module_id, float x, float y, float z);
    
    protected:
        bool                                    _InitializeWindow(int module_id, UI::CUiWikiRenderTarget* handle_window);
        std::shared_ptr<CWikiRenderTarget>        _GetRenderTargetHandle(int module_id);
    
    private:
        TWikiRenderTargetModules                _RenderWikiModules;
        bool                                    _bCanRenderModules;
};

PythonWikiRenderTarget.h: 
#include "StdAfx.h"

#ifdef INGAME_WIKI

#include "PythonApplication.h"

CPythonWikiRenderTarget::~CPythonWikiRenderTarget() {}
CPythonWikiRenderTarget::CPythonWikiRenderTarget()
{
    _bCanRenderModules = false;
    _RenderWikiModules.clear();
}

/*----------------------------
--------PUBLIC CLASS FUNCTIONS
-----------------------------*/

int CPythonWikiRenderTarget::GetFreeID()
{
    const size_t render_wiki_size = _RenderWikiModules.size();
    int new_module = START_MODULE;
    
    if (!render_wiki_size)
        return new_module;
    
    for (const auto &[module_id, module_wnd] : _RenderWikiModules) {
        if (module_id != new_module)
            break;
        
        ++new_module;
    }
    
    return new_module;
}

void CPythonWikiRenderTarget::RegisterRenderModule(int module_id, int module_wnd)
{
    if (module_id == DELETE_PARM)
    {
        auto it = std::find_if(_RenderWikiModules.begin(), _RenderWikiModules.end(),
                [=](const std::tuple<int, std::shared_ptr<UI::CUiWikiRenderTarget>>& _s)
                {
                    return std::get<0>(_s) == module_id;
                } );
        
        if (it != _RenderWikiModules.end())
            _RenderWikiModules.erase(it);
        
        CWikiRenderTargetManager::Instance().DeleteRenderTarget(module_id);
    }
    else
    {
        if (!module_wnd)
            return;
        
        UI::CUiWikiRenderTarget* _hwn = (UI::CUiWikiRenderTarget*)module_wnd;
        _RenderWikiModules.emplace_back(std::make_tuple(module_id, _hwn));
        
        if (!_InitializeWindow(module_id, _hwn))
        {
            TraceError("RegisterRenderModule Cant Regist Module ID : %d", module_id);
            return;
        }
    }
}

void CPythonWikiRenderTarget::ManageModelViewVisibility(int module_id, bool flag)
{
    auto _Wrt = _GetRenderTargetHandle(module_id);
    if (!_Wrt)
        return;
    
    _Wrt->SetVisibility(flag);
}

bool CPythonWikiRenderTarget::CanRenderWikiModules() const
{
    bool _canRender = false;
    
    if (_bCanRenderModules)
    {
        const auto hWnd = CPythonApplication::Instance().GetWindowHandle();
        const auto isMinimized = static_cast<bool>(IsIconic(hWnd));
        _canRender = isMinimized ? false : true;
    }
    
    return _canRender;
}

void CPythonWikiRenderTarget::SetModelViewModel(int module_id, int module_vnum)
{
    auto _Wrt = _GetRenderTargetHandle(module_id);
    if (!_Wrt)
        return;
    
    _Wrt->SelectModel(module_vnum);
}

void CPythonWikiRenderTarget::SetWeaponModel(int module_id, int weapon_vnum)
{
    auto _Wrt = _GetRenderTargetHandle(module_id);
    if (!_Wrt)
        return;
    
    _Wrt->SetWeapon(weapon_vnum);
}

void CPythonWikiRenderTarget::SetModelForm(int module_id, int main_vnum)
{
    auto _Wrt = _GetRenderTargetHandle(module_id);
    if (!_Wrt)
        return;
    
    _Wrt->SetArmor(main_vnum);
}

void CPythonWikiRenderTarget::SetModelHair(int module_id, int hair_vnum)
{
    auto _Wrt = _GetRenderTargetHandle(module_id);
    if (!_Wrt)
        return;
    
    _Wrt->SetHair(hair_vnum);
}

void CPythonWikiRenderTarget::SetModelV3Eye(int module_id, float x, float y, float z)
{
    auto _Wrt = _GetRenderTargetHandle(module_id);
    if (!_Wrt)
        return;
    
    _Wrt->SetModelV3Eye(x, y, z);
}

void CPythonWikiRenderTarget::SetModelV3Target(int module_id, float x, float y, float z)
{
    auto _Wrt = _GetRenderTargetHandle(module_id);
    if (!_Wrt)
        return;
    
    _Wrt->SetModelV3Target(x, y, z);
}

/*----------------------------
------PROTECTED CLASS FUNCTIONS
-----------------------------*/

bool CPythonWikiRenderTarget::_InitializeWindow(int module_id, UI::CUiWikiRenderTarget* handle_window)
{
    if (!handle_window)
        return false;
    
    return handle_window->SetWikiRenderTargetModule(module_id);
}

std::shared_ptr<CWikiRenderTarget> CPythonWikiRenderTarget::_GetRenderTargetHandle(int module_id)
{
    auto it = std::find_if(_RenderWikiModules.begin(), _RenderWikiModules.end(),
            [=](const std::tuple<int, std::shared_ptr<UI::CUiWikiRenderTarget>>& _s)
            {
                return std::get<0>(_s) == module_id;
            } );
    
    if (it == _RenderWikiModules.end())
        return nullptr;
    
    return CWikiRenderTargetManager::Instance().GetRenderTarget(module_id);
}
#endif
 
Upvote 0 Downvote
Hatanın sebebi EterLib/GrpTextInstance.h dosyasında eksik olması. Ek olarak client c++17 değilse bu hataların hepsini çözsen bile bunun yüzünden derleyemezsin. C++17 yükseltmen gerekecek.
 
Upvote 0 Downvote
Kaiser demiş ki:
Hatanın sebebi EterLib/GrpTextInstance.h dosyasında eksik olması. Ek olarak client c++17 değilse bu hataların hepsini çözsen bile bunun yüzünden derleyemezsin. C++17 yükseltmen gerekecek.
Hepsini görmek için tıklayın...
EterLib/GrpTextInstance.h dosyasında ekli hocam onu bende kontrol etmiştim ama göründüğü gibi hatalar işte. c++17 hatasının kastı client versiyonu ise 2019
 
Upvote 0 Downvote
GrpTextInstance.h ve .cpp dosyasında ifdef olmadan eklemeyi dene. Ayrıca clientin 2019 olmasıyla c++17 farklı şeylerdir.
 
Upvote 0 Downvote

Benzer konular

A
Yardım Otomatik Sohbet Banı Tüm Haritayı Banlıyor
Yanıt
4
Gösterim
5
asilords
A
TheAdmin33
Yardım Tek Affect ile birden fazla özellik verme
Yanıt
3
Gösterim
70
TheAdmin33
TheAdmin33
CalvinGiorgio
Yardım Quest ile resim çağırmak
Yanıt
4
Gösterim
110
CalvinGiorgio
CalvinGiorgio
CalvinGiorgio
Yardım Pet sistemi hk.
Yanıt
1
Gösterim
75
delioyuncu16
D
A
Yardım Toplu Pm Sistemi Build Hata
Yanıt
2
Gösterim
96
MT2Dev
MT2Dev
Geri
Üst