Araçlar FoxFS Pack Kilitleme ve Kaynak Dosyaları (Visual Studio 2022)

Durum
İçerik kilitlendiği için mesaj gönderimine kapatıldı.

hasanmacit

Yasaklanmış Üye
Cezalı
Geliştirici
Yardımsever Üye
Editör
Mesaj
4.951
Çözümler
210
Beğeni
5.262
Puan
2.850
Ticaret Puanı
7
FoxFS kaynak kodları için Karbust'a sevgiler ve şükranlar.

Selamlar. Böyle bir paylaşım görmedim. Diğer forumlarda da bizim forumlarda da. Genelde 2013 kullanıyor tüm filesler. 2022 visual studioda kullanılabilecektir artık.
Ben hem debug hem de release build alıp client build alarak test ettim. Arşivlemesi ve libler sembol hatası vermeden çalışıyor. İçindeki boost ve cryptopp sürümünü client srcnizde kullanmanızı öneririm. Aksi halde hatalar alabilirsiniz. Hata almanız durumunda kendi dosyalarımı da koydum. Çözümü için bakabilirsiniz.

İndirme Linki

Türkçe Anlatım (@bckntr 'ye teşekkürler)

Linkleri görebilmek için giriş yap veya kayıt ol.
C++:
Genişlet Daralt Kopyala
//////////////////////////////////////////////////////////////////////////
Gamelib/Property.h
//////////////////////////////////////////////////////////////////////////

Ara:
        DWORD            GetCRC();

Altına Ekle:
        bool            ReadFromXML(const char* c_pszCRC);
//////////////////////////////////////////////////////////////////////////       
Gamelib/Property.cpp
//////////////////////////////////////////////////////////////////////////

//Ara:

bool CProperty::Save(const char * c_pszFileName)
{
//Altına Ekle:
    return false;

//şöyle görünmeli:

bool CProperty::Save(const char * c_pszFileName)
{
    return false;
    CTempFile file;
    ...
    ...
}

//////////////////////////////////////////////////////////////////////////

//Ara:
void CProperty::Clear()

// Üstüne Ekle
bool CProperty::ReadFromXML(const char* c_pszCRC)
{
    m_dwCRC = atoi(c_pszCRC);

    return true;
}
//////////////////////////////////////////////////////////////////////////
Gamelib/PropertyManager.cpp
//////////////////////////////////////////////////////////////////////////

//Ara :
#include "Property.h"

// Altına Ekle:
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <boost/foreach.hpp>

//////////////////////////////////////////////////////////////////////////

//Ara:
bool CPropertyManager::Initialize(const char * c_pszPackFileName)
{
    if (c_pszPackFileName)
    {
        if (!m_pack.Create(m_fileDict, c_pszPackFileName, "", true))
        {
            LogBoxf("Cannot open property pack file (filename %s)", c_pszPackFileName);
            return false;
        }

        m_isFileMode = false;

        TDataPositionMap & indexMap = m_pack.GetIndexMap();

        TDataPositionMap::iterator itor = indexMap.begin();

        typedef std::map<DWORD, TEterPackIndex *> TDataPositionMap;

        int i = 0;

        while (indexMap.end() != itor)
        {
            TEterPackIndex * pIndex = itor->second;
            ++itor;

            if (!stricmp("property/reserve", pIndex->filename))
            {
                LoadReservedCRC(pIndex->filename);
                continue;
            }

            if (!Register(pIndex->filename))
                continue;

            ++i;
        }
    }
    else
    {
        m_isFileMode = true;
        // NOTE : 여기서 Property를 등록시키면 WorldEditor에서 이상이 생김 ;
        //        또한, Property Tree List에도 등록을 시켜야 되기 때문에 바깥쪽에서.. - [levites]
    }

    return true;
}

bool CPropertyManager::BuildPack()
{
    if (!m_pack.Create(m_fileDict, "property", ""))
        return false;

    WIN32_FIND_DATA fdata;
    HANDLE hFind = FindFirstFile("property\\*", &fdata);

    if (hFind == INVALID_HANDLE_VALUE)
        return false;

    do
    {
        if (fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
            continue;

        char szSourceFileName[256 + 1];
        _snprintf(szSourceFileName, sizeof(szSourceFileName), "property\\%s", fdata.cFileName);

        m_pack.Put(fdata.cFileName, szSourceFileName,COMPRESSED_TYPE_NONE,"");
    }
    while (FindNextFile(hFind, &fdata));

    FindClose(hFind);
    return true;
}

// Değiştir:
bool CPropertyManager::Initialize(const char * c_pszPackFileName)
{
    if (c_pszPackFileName)
    {
        if (CEterPackManager::Instance().isExist("property/reserve"))
        {
            LoadReservedCRC("property/reserve");
        }

        CMappedFile kListFile;
        PBYTE pbListData;
        if (CEterPackManager::Instance().Get(kListFile, "property/list", (LPCVOID*)&pbListData))
        {
            std::stringstream kSS;
            kSS << (char*)pbListData;

            std::string strLine;
            while (std::getline(kSS, strLine))
            {
                std::size_t posRight = strLine.find_last_not_of(" \t\r\n");
                strLine = (posRight == std::string::npos ? "" : strLine.substr(0, posRight + 1));
                std::size_t posLeft = strLine.find_first_not_of(" \t\r\n");
                strLine = (posLeft == std::string::npos ? "" : strLine.substr(posLeft, std::string::npos));

                if (!Register(strLine.c_str(), NULL))
                {
                    TraceError("CPropertyManager::Initialize: Cannot register property '%s'!", strLine.c_str());
                }
            }
        }

        CMappedFile kPropertyXML;
        PBYTE pbPropertyXML;
        if (CEterPackManager::Instance().Get(kPropertyXML, "property.xml", (LPCVOID*)&pbPropertyXML))
        {
            char* pszXML = new char[kPropertyXML.Size() + 1];
            memcpy(pszXML, pbPropertyXML, kPropertyXML.Size());
            pszXML[kPropertyXML.Size()] = 0;
            std::stringstream kXML;
            kXML << pszXML;
            delete[] pszXML;

            try
            {
                boost::property_tree::ptree kPT;
                read_xml(kXML, kPT);

                BOOST_FOREACH(boost::property_tree::ptree::value_type& v, kPT.get_child("PropertyList"))
                {
                    if (v.first == "Property")
                    {
                        CProperty* pProperty = new CProperty(v.second.get<std::string>("<xmlattr>.filename").c_str());
                        if (!pProperty->ReadFromXML(v.second.get<std::string>("<xmlattr>.crc").c_str()))
                        {
                            TraceError("CPropertyManager::Initialize: Cannot register '%s'!", v.second.get<std::string>("<xmlattr>.filename").c_str());
                            delete pProperty;
                            continue;
                        }

                        DWORD dwCRC = pProperty->GetCRC();

                        TPropertyCRCMap::iterator itor = m_PropertyByCRCMap.find(dwCRC);

                        if (m_PropertyByCRCMap.end() != itor)
                        {
                            Tracef("Property already registered, replace %s to %s\n",
                                itor->second->GetFileName(), v.second.get<std::string>("<xmlattr>.filename").c_str());

                            delete itor->second;
                            itor->second = pProperty;
                        }
                        else
                            m_PropertyByCRCMap.insert(TPropertyCRCMap::value_type(dwCRC, pProperty));

                        BOOST_FOREACH(boost::property_tree::ptree::value_type& s, v.second)
                        {
                            if (s.first == "<xmlattr>")
                            {
                                BOOST_FOREACH(boost::property_tree::ptree::value_type& d, s.second)
                                {
                                    CTokenVector kVec;
                                    kVec.push_back(d.second.data());
                                    pProperty->PutVector(d.first.c_str(), kVec);
                                }
                            }
                        }
                    }
                }
            }
            catch (std::exception& e)
            {
                TraceError("CPropertyManager::Initialize: %s", e.what());
                return false;
            }
        }
    }
    else
    {
        m_isFileMode = true;
    }

    return true;
}

bool CPropertyManager::BuildPack()
{
    return false;
}

//////////////////////////////////////////////////////////////////////////

//Ara:
bool CPropertyManager::Get(DWORD dwCRC, CProperty ** ppProperty)
{
    TPropertyCRCMap::iterator itor = m_PropertyByCRCMap.find(dwCRC);

    if (m_PropertyByCRCMap.end() == itor)
        return false;

    *ppProperty = itor->second;
    return true;
}

//Altına Ekle:
bool CPropertyManager::Put(const char * c_pszFileName, const char * c_pszSourceFileName)
{
    if (!CopyFile(c_pszSourceFileName, c_pszFileName, FALSE))
        return false;

    if (!m_isFileMode)    // 팩 파일에도 넣음
    {
        if (!m_pack.Put(c_pszFileName, NULL, COMPRESSED_TYPE_NONE,""))
        {
            assert(!"CPropertyManager::Put cannot write to pack file");
            return false;
        }
    }

    Register(c_pszFileName);
    return true;
}

bool CPropertyManager::Erase(DWORD dwCRC)
{
    TPropertyCRCMap::iterator itor = m_PropertyByCRCMap.find(dwCRC);

    if (m_PropertyByCRCMap.end() == itor)
        return false;

    CProperty * pProperty = itor->second;
    m_PropertyByCRCMap.erase(itor);

    DeleteFile(pProperty->GetFileName());
    ReserveCRC(pProperty->GetCRC());

    if (!m_isFileMode)    // 파일 모드가 아니면 팩에서도 지움
        m_pack.Delete(pProperty->GetFileName());

    FILE * fp = fopen("property/reserve", "a+");

    if (!fp)
        LogBox("예약 CRC 파일을 열 수 없습니다.");
    else
    {
        char szCRC[64 + 1];
        _snprintf(szCRC, sizeof(szCRC), "%u\r\n", pProperty->GetCRC());

        fputs(szCRC, fp);
        fclose(fp);
    }

    delete pProperty;
    return true;
}

bool CPropertyManager::Erase(const char * c_pszFileName)
{
    CProperty * pProperty = NULL;

    if (Get(c_pszFileName, &pProperty))
        return Erase(pProperty->GetCRC());
    
    return false;
    
//////////////////////////////////////////////////////////////////////////
EterPack/EterPackManager.h
//////////////////////////////////////////////////////////////////////////

//Ara:
#include "EterPack.h"
//Altına Ekle:
#include "FoxFS.h"

//////////////////////////////////////////////////////////////////////////

//Ara:
        enum ESearchModes
        {
            SEARCH_FILE_FIRST,
            SEARCH_PACK_FIRST
        };
//Değiştir:
        enum ESearchModes
        {
            SEARCH_FILE,
            SEARCH_PACK
        };

        enum ESearchModes2
        {
            SEARCH_FILE_FIRST,
            SEARCH_PACK_FIRST
        };

//////////////////////////////////////////////////////////////////////////

//Ara:
CRITICAL_SECTION        m_csFinder;
//Altına Ekle:
PFoxFS                    m_pFoxFS;

//////////////////////////////////////////////////////////////////////////
EterPack/EterPackManager.cpp
//////////////////////////////////////////////////////////////////////////

//Ara:
#ifdef __THEMIDA__
#include <ThemidaSDK.h>
#endif
//Altına Ekle:
namespace FoxFS
{
    enum
    {
        ERROR_OK = 0,
        ERROR_BASE_CODE = 0,
        ERROR_FILE_WAS_NOT_FOUND = ERROR_BASE_CODE + 1,
        ERROR_CORRUPTED_FILE = ERROR_BASE_CODE + 2,
        ERROR_MISSING_KEY = ERROR_BASE_CODE + 3,
        ERROR_MISSING_IV = ERROR_BASE_CODE + 4,
        ERROR_DECRYPTION_HAS_FAILED = ERROR_BASE_CODE + 5,
        ERROR_DECOMPRESSION_FAILED = ERROR_BASE_CODE + 6,
        ERROR_ARCHIVE_NOT_FOUND = ERROR_BASE_CODE + 7,
        ERROR_ARCHIVE_NOT_READABLE = ERROR_BASE_CODE + 8,
        ERROR_ARCHIVE_INVALID = ERROR_BASE_CODE + 9,
        ERROR_ARCHIVE_ACCESS_DENIED = ERROR_BASE_CODE + 10,
        ERROR_KEYSERVER_SOCKET = ERROR_BASE_CODE + 11,
        ERROR_KEYSERVER_CONNECTION = ERROR_BASE_CODE + 12,
        ERROR_KEYSERVER_RESPONSE = ERROR_BASE_CODE + 13,
        ERROR_KEYSERVER_TIMEOUT = ERROR_BASE_CODE + 14,
        ERROR_UNKNOWN = ERROR_BASE_CODE + 15
    };
}

const char* white_file_list[] = { "mark\10_0.tga" "mark\250_0.tga" };

bool isWhiteFile(const char* c_szFileName)
{
    for (int i = 0; i < ARRAYSIZE(white_file_list); i++)
    {
        if (stricmp(c_szFileName, white_file_list[i]) == 0)
        {
            return true;
        }
    }
    return false;
}

const char* white_file_list_ext[] = { "xml", "tga", "png", "bmp", "mp3", "jpg" };

bool isWhiteFileExt(const char* c_szFileName)
{
    for (int i = 0; i < ARRAYSIZE(white_file_list_ext); i++)
    {
        std::string ext = CFileNameHelper::GetExtension(std::string(c_szFileName));
        std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
        std::string whiteExt = std::string(white_file_list_ext[i]);

        if (ext == whiteExt)
            return true;
    }
    return false;
}

//////////////////////////////////////////////////////////////////////////

//Ara
bool CEterPackManager::Get(CMappedFile & rMappedFile, const char * c_szFileName, LPCVOID * pData)
    if (m_iSearchMode == SEARCH_FILE_FIRST)
    {
        if (GetFromFile(rMappedFile, c_szFileName, pData))
        {
            return true;
        }

        return GetFromPack(rMappedFile, c_szFileName, pData);
    }

    if (GetFromPack(rMappedFile, c_szFileName, pData))
    {
        return true;
    }

    return GetFromFile(rMappedFile, c_szFileName, pData);
//Değiştir:
    if (m_iSearchMode == SEARCH_FILE)
    {
        if (GetFromFile(rMappedFile, c_szFileName, pData))
        {
            return true;
        }

        return GetFromPack(rMappedFile, c_szFileName, pData);
    }
    else
    {
        if (isExistInPack(c_szFileName))
        {
            return GetFromPack(rMappedFile, c_szFileName, pData);
        }
        else if (isExist(c_szFileName))
        {
            return GetFromFile(rMappedFile, c_szFileName, pData);
        }
    }
    return false;

//////////////////////////////////////////////////////////////////////////

//Ara
bool CEterPackManager::GetFromPack(CMappedFile & rMappedFile, const char * c_szFileName, LPCVOID * pData)
{
...
...
}
// Değiştir
bool CEterPackManager::GetFromPack(CMappedFile & rMappedFile, const char * c_szFileName, LPCVOID * pData)
{
    assert(c_szFileName);

    FinderLock lock(m_csFinder);

    if (m_pFoxFS)
    {
        int errorCodeSize = 0;
        if ((errorCodeSize = FoxFS_ExistsA(m_pFoxFS, c_szFileName)) == FoxFS::ERROR_OK)
        {
            unsigned int dwSize = FoxFS_SizeA(m_pFoxFS, c_szFileName), dwReadSize = 0;
            BYTE* pbData = new BYTE[dwSize + 1];
            int errorCode = 0;
            if ((errorCode = FoxFS_GetA(m_pFoxFS, c_szFileName, pbData, dwSize, &dwReadSize)) == FoxFS::ERROR_OK)
            {
                pbData[dwReadSize] = 0;
                *pData = pbData;
                rMappedFile.Link(dwReadSize, pbData);
                return true;
            }
            else {
                TraceError("FoxFS - Could not get file %s Error Code %d", c_szFileName, errorCode);
            }
            delete[] pbData;
        }
        else {
            TraceError("FoxFS: File not existing %s Error Code %d", c_szFileName, errorCodeSize);

        }
    }
    else
    {
        TraceError("FoxFS: Not initialized!");
    }

    return false;
}

//////////////////////////////////////////////////////////////////////////

//Ara
bool CEterPackManager::isExistInPack(const char * c_szFileName)
{
...
...
}
// Değiştir
bool CEterPackManager::isExistInPack(const char * c_szFileName)
{
    assert(c_szFileName);

    if (m_pFoxFS)
    {
        int errorCodeSize = 0;
        if ((errorCodeSize = FoxFS_ExistsA(m_pFoxFS, c_szFileName)) == FoxFS::ERROR_OK)
        {
            return true;
        }
        else
        {
            Tracenf("FoxFS :  File not exists %s with error code %d", c_szFileName, errorCodeSize);
        }
    }
    else
    {
        TraceError("FoxFS: Not initialized!");
    }

    return false;
}

//////////////////////////////////////////////////////////////////////////

// Ara
bool CEterPackManager::isExist(const char * c_szFileName)
{
...
...   
}
// Değiştir
bool CEterPackManager::isExist(const char * c_szFileName)
{
    if (m_iSearchMode == SEARCH_PACK)
    {
        if (isWhiteFile(c_szFileName) || isWhiteFileExt(c_szFileName))
        {
            return isExistInPack(c_szFileName) || (_access(c_szFileName, 0) == 0);
        }
        return isExistInPack(c_szFileName);
    }

    if (_access(c_szFileName, 0) == 0)
        return true;

    return isExistInPack(c_szFileName);
}

//////////////////////////////////////////////////////////////////////////

//ARA
void CEterPackManager::RegisterRootPack(const char * c_szName)
{
...
...
}
// Değiştir
void CEterPackManager::RegisterRootPack(const char * c_szName)
{
    assert(c_szName);
    if (m_pFoxFS)
    {
        int errorCode = 0;
        if ((errorCode = FoxFS_LoadA(m_pFoxFS, c_szName)) != FoxFS::ERROR_OK)
        {
            TraceError("%s: Error Code %d", c_szName, errorCode);
        }
    }
    else
    {
        TraceError("FoxFS: Not initialized!");
    }
}

//////////////////////////////////////////////////////////////////////////

// Ara
bool CEterPackManager::RegisterPack(const char * c_szName, const char * c_szDirectory, const BYTE* c_pbIV)
{
...
...
}
// Değiştir
bool CEterPackManager::RegisterPack(const char * c_szName, const char * c_szDirectory, const BYTE* c_pbIV)
{
    assert(c_szName);
    if (m_pFoxFS)
    {
        int errorCode = 0;
        if ((errorCode = FoxFS_LoadA(m_pFoxFS, c_szName)) != FoxFS::ERROR_OK)
        {
            TraceError("%s: Error Code %d", c_szName, errorCode);
        }
    }
    else
#ifdef _DEBUG
                Tracef("The eterpack doesn't exist [%s]\n", c_szName);
#endif
    {
        TraceError("FoxFS: Not initialized!");
    }

    return false;
}

//////////////////////////////////////////////////////////////////////////

// Ara
CEterPackManager::CEterPackManager() : m_bTryRelativePath(false), m_iSearchMode(SEARCH_FILE_FIRST), m_isCacheMode(false)
{
    InitializeCriticalSection(&m_csFinder);
}
// Değiştir
CEterPackManager::CEterPackManager() : m_bTryRelativePath(false), m_iSearchMode(SEARCH_FILE_FIRST), m_isCacheMode(false)
{
    InitializeCriticalSection(&m_csFinder);
    m_pFoxFS = FoxFS_Create();
}

//////////////////////////////////////////////////////////////////////////

// Ara
DeleteCriticalSection(&m_csFinder);
// Altına Ekle
    if (m_pFoxFS)
    {
        FoxFS_Destroy(m_pFoxFS);
    }
    
//////////////////////////////////////////////////////////////////////////
UserInterface/UserInterface.cpp
//////////////////////////////////////////////////////////////////////////

// Ara
#pragma comment( lib, "dmoguids.lib" )
// Altına Ekle
#pragma comment( lib, "lz4.lib" )
#pragma comment( lib, "xxhash.lib" )
#pragma comment( lib, "FoxFS.lib" )

// Ara
bool PackInitialize(const char * c_pszFolder)
{
...
...
}
// DEĞİŞTİR
bool PackInitialize(const char * c_pszFolder)
{
    NANOBEGIN
        if (_access(c_pszFolder, 0) != 0)
            return true;

    std::string stFolder(c_pszFolder);
    stFolder += "/";

    CTextFileLoader::SetCacheMode();
    CEterPackManager::Instance().SetCacheMode();
    CEterPackManager::Instance().SetSearchMode(CEterPackManager::SEARCH_PACK);

    CSoundData::SetPackMode();

    CEterPackManager::Instance().RegisterPack("pack/bgm", "bgm/");
    CEterPackManager::Instance().RegisterPack("pack/effect", "d:/ymir work/effect/");
    CEterPackManager::Instance().RegisterPack("pack/etc", "*");
    CEterPackManager::Instance().RegisterPack("pack/guild", "d:/ymir work/guild/");
    CEterPackManager::Instance().RegisterPack("pack/icon", "icon/");
    CEterPackManager::Instance().RegisterPack("pack/item", "d:/ymir work/item/");
    CEterPackManager::Instance().RegisterPack("pack/locale", "locale/");
    CEterPackManager::Instance().RegisterPack("pack/monster", "d:/ymir work/monster/");
    CEterPackManager::Instance().RegisterPack("pack/monster2", "d:/ymir work/monster2/");
    CEterPackManager::Instance().RegisterPack("pack/season1", "season1/");
    CEterPackManager::Instance().RegisterPack("pack/season2", "season2/");
    CEterPackManager::Instance().RegisterPack("pack/npc", "d:/ymir work/npc/");
    CEterPackManager::Instance().RegisterPack("pack/npc2", "d:/ymir work/npc2/");
    CEterPackManager::Instance().RegisterPack("pack/pc", "d:/ymir work/pc/");
    CEterPackManager::Instance().RegisterPack("pack/pc2", "d:/ymir work/pc2/");
    CEterPackManager::Instance().RegisterPack("pack/property", "property");
    CEterPackManager::Instance().RegisterPack("pack/sound", "sound/");
    CEterPackManager::Instance().RegisterPack("pack/terrain", "d:/ymir work/terrainmaps/");
    CEterPackManager::Instance().RegisterPack("pack/textureset", "textureset/");
    CEterPackManager::Instance().RegisterPack("pack/tree", "d:/ymir work/tree/");
    CEterPackManager::Instance().RegisterPack("pack/zone", "d:/ymir work/zone/");
    CEterPackManager::Instance().RegisterPack("pack/map", "map/");

    CEterPackManager::Instance().RegisterRootPack((stFolder + std::string("root")).c_str());
    NANOEND
        return true;
}

///////////////////    BİTTTTTTTTTTTTTTTİİİİİİİİİİİİİİ    ///

///    MMO TUTKUNLARI !

Burayı görüntülemek için üye girişi yapmalı veya kayıt olmalısınız.


Önemli:

FoxFS build alacağınız zaman:

Adsız.png


1 numaradaki yerden FoxFS ve FoxFSArchiver kısmından özellikleri seçip 2 ve 3 numaralı kısımdaki yerleri kendi klasörlerinize göre ekleyin. Ya da benim klasör dizinimi oluşturup orada build alın. Karbust böyle yapmıştı bende ekleme yaptım. Tekrar uğraşmadım.

Herkese iyi kullanımlar iyi forumlar.

Meraklısı için Virüs Total

1713990185722.png
 
En son bir moderatör tarafından düzenlenmiş:
Güzle paylasim icin teşekkürler
 
Fox sağlamlığı nedir hasan bey genelde unpack ediliyor da önercegin yol yorga varmı acep
 
Fox sağlamlığı nedir hasan bey genelde unpack ediliyor da önercegin yol yorga varmı acep
valla içinde key felan varsa değiştirilebilir. o kadar incelemedim hiç. burada paylaşacağım kadar kullandım desem yeridir.
 
konu linki güncellendi. google drive kendi kafasına göre ihlal atmış anlamadım. orayı düzeltene kadar başka bir yere upload ettim. zaten kendi bilgisayarımda yüklü olduğu için ölürse güncellerim. iyi kullanımlar tekrardan.
 
konu linki güncellendi. google drive kendi kafasına göre ihlal atmış anlamadım. orayı düzeltene kadar başka bir yere upload ettim. zaten kendi bilgisayarımda yüklü olduğu için ölürse güncellerim. iyi kullanımlar tekrardan.
Bence rar formatında yüklediğin için içerik analizi yapabiliyor olabilirler. 7z ile arşivlersen sorun olmaz diye tahmin ediyorum.
 
arkadaşlar çalıştıramayan bazı kişiler olduğu için buraya zorunlu bir açıklama yapıyorum. ben foxfs hiç kullanmadım ama çalıştırabildim. make_xml kısmını kendinize göre düzenleyin. userinterfacedeki dosya konumlarına iyice bakın. ben bir kaç xml düzenleyip girdim ama belkide düzenlememek gerekiyordu dediğim gibi bilmiyorum. ama ben bu cahillikle çalıştırabildiysem siz hayli haylisini yaparsınız.
 
arkadaşlar çalıştıramayan bazı kişiler olduğu için buraya zorunlu bir açıklama yapıyorum. ben foxfs hiç kullanmadım ama çalıştırabildim. make_xml kısmını kendinize göre düzenleyin. userinterfacedeki dosya konumlarına iyice bakın. ben bir kaç xml düzenleyip girdim ama belkide düzenlememek gerekiyordu dediğim gibi bilmiyorum. ama ben bu cahillikle çalıştırabildiysem siz hayli haylisini yaparsınız.
Anlatım karışıktı onu herkesin anlayabileceği kıvama getirdim. Zamanında FoxFS kullandım +235 ile WS LİK sunucumda problem yaşamadım sistemi müsait zamanda kullanıp sorun vs görürsem sağlıklı hale derleyip paylaşacağım.
 
Fox fs iyi hoş ta biraz kasıntılı ilk açılışta bekletiyor biraz yani en azından bende öyleydi bir süre kullandım onu haricinde bir sıkıntı görmedim ama sonra geri eski sisteme döndüm.
 
Fox fs iyi hoş ta biraz kasıntılı ilk açılışta bekletiyor biraz yani en azından bende öyleydi bir süre kullandım onu haricinde bir sıkıntı görmedim ama sonra geri eski sisteme döndüm.
birde bunu dene 2022 model sıfır sıkıntı. yavaşlık olursa para iadesi garantili
 
Durum
İçerik kilitlendiği için mesaj gönderimine kapatıldı.
Geri
Üst