ikarus v2 ultimate

// kendi bloğunu buna göre düzenle

enum EItemMisc
{
    ITEM_NAME_MAX_LEN            = 24,
    ITEM_VALUES_MAX_NUM            = 6,
    ITEM_SMALL_DESCR_MAX_LEN    = 256,
    ITEM_LIMIT_MAX_NUM            = 2,
    ITEM_APPLY_MAX_NUM            = 3,
    ITEM_SOCKET_MAX_NUM            = 3,
    ITEM_MAX_COUNT                = 200,

    ITEM_ATTRIBUTE_NORM_NUM        = 5,
    ITEM_ATTRIBUTE_RARE_NUM        = 2,

    ITEM_ATTRIBUTE_NORM_START    = 0,
    ITEM_ATTRIBUTE_NORM_END        = ITEM_ATTRIBUTE_NORM_START + ITEM_ATTRIBUTE_NORM_NUM,

    ITEM_ATTRIBUTE_RARE_START    = ITEM_ATTRIBUTE_NORM_END,
    ITEM_ATTRIBUTE_RARE_END        = ITEM_ATTRIBUTE_RARE_START + ITEM_ATTRIBUTE_RARE_NUM,

    ITEM_ATTRIBUTE_MAX_NUM        = ITEM_ATTRIBUTE_RARE_END, // 7


    ITEM_ATTRIBUTE_MAX_LEVEL    = 5,
    ITEM_AWARD_WHY_MAX_LEN        = 50,

    REFINE_MATERIAL_MAX_NUM        = 5,

    ITEM_ELK_VNUM                = 50026,
};

//kontrol edersiniz eksikse eklersiniz

inline std::string FormatNumberWithDots(long long number) {
    std::string result;
    bool isNegative = false;

    // Handle the case for negative numbers
    if (number < 0) {
        isNegative = true;
        number = -number; // Make it positive for processing
    }

    // Convert the number to a string
    std::string numStr = std::to_string(number);

    // Insert dots from the right every three digits
    int count = 0;
    for (int i = numStr.size() - 1; i >= 0; --i) {
        result.push_back(numStr[i]);
        if (++count == 3 && i > 0) {
            result.push_back('.');
            count = 0;
        }
    }

    // Reverse the result string to get the correct order
    std::reverse(result.begin(), result.end());

    // Add the negative sign if necessary
    if (isNegative) {
        result.insert(result.begin(), '-');
    }

    return result;
}

arat
/*    void        EncodeBYTE(BYTE b);
    void        EncodeWORD(WORD w);
    void        EncodeDWORD(DWORD dw);
    void        Encode(const void* data, DWORD size);
    int        Send();
 
*///altına ekle
    template<typename T, std::enable_if_t<utils::IsRawV<T>>* = nullptr>
    void Encode(const T& c_pvData) {
        Encode(&c_pvData, sizeof(T));
    }
    template<typename C, std::enable_if_t<utils::IsContiguousV<C>>* = nullptr>
    void Encode(const C& v) {
        Encode(v.data(), v.size() * sizeof(typename C::value_type));
    }

#ifndef __INC_METIN_II_GAME_BUFFER_MANAGER_H__
#define __INC_METIN_II_GAME_BUFFER_MANAGER_H__
#include "../../common/stl.h"

class TEMP_BUFFER
{
    public:
        TEMP_BUFFER(int Size = 8192, bool ForceDelete = false );
        ~TEMP_BUFFER();

        const void *     read_peek();

        template<typename T, std::enable_if_t<utils::IsRawV<T>>* = nullptr>
        void write(const T& c_pvData) {
            write(&c_pvData, sizeof(T));
        }
        template<typename C, std::enable_if_t<utils::IsContiguousV<C>>* = nullptr>
        void write(const C& v) {
            write(v.data(), v.size() * sizeof(typename C::value_type));
        }

        void        write(const void * data, int size);
        int        size();
        void    reset();

        LPBUFFER    getptr() { return buf; }

    protected:
        LPBUFFER    buf;
        bool        forceDelete;
};

#endif
// vaffanculo a chi t'e morto martysama

//ekle

#undef max
#undef min

// arat

        void            BufferedPacket (const void* c_pvData, int iSize);
        void            Packet (const void* c_pvData, int iSize);
        void            LargePacket (const void* c_pvData, int iSize);

//üstüne ekle

        template<typename T, std::enable_if_t<utils::IsRawV<T>>* = nullptr>
        void BufferedPacket(const T& c_pvData) {
            BufferedPacket(&c_pvData, sizeof(T));
        }
        template<typename C, std::enable_if_t<utils::IsContiguousV<C>>* = nullptr>
        void BufferedPacket(const C& v) {
            BufferedPacket(v.data(), v.size() * sizeof(typename C::value_type));
        }

        template<typename T, std::enable_if_t<utils::IsRawV<T>>* = nullptr>
        void Packet(const T& c_pvData) {
            Packet(&c_pvData, sizeof(T));
        }
        template<typename C, std::enable_if_t<utils::IsContiguousV<C>>* = nullptr>
        void Packet(const C& v) {
            Packet(v.data(), v.size() * sizeof(typename C::value_type));
        }

        template<typename T, std::enable_if_t<utils::IsRawV<T>>* = nullptr>
        void LargePacket(const T& c_pvData) {
            LargePacket(&c_pvData, sizeof(T));
        }
        template<typename C, std::enable_if_t<utils::IsContiguousV<C>>* = nullptr>
        void LargePacket(const C& v) {
            LargePacket(v.data(), v.size() * sizeof(typename C::value_type));
        }

        template<typename T, std::enable_if_t<utils::IsRawV<T>>* = nullptr>
        void RawPacket(const T& c_pvData) {
            RawPacket(&c_pvData, sizeof(T));
        }
        template<typename C, std::enable_if_t<utils::IsContiguousV<C>>* = nullptr>
        void RawPacket(const C& v) {
            RawPacket(v.data(), v.size() * sizeof(typename C::value_type));
        }