oto av modüller ve bazı şeyler [c++]

#ifdef ENABLE_AUTOMATIC_HUNTING
    if (IsAutoHuntEnabled())
    {
        static DWORD lastAutoHuntTime = 0;
        DWORD currentTime = CTimer::Instance().GetCurrentMillisecond();

        // Attack speed multiplier, where 1.0 = normal speed, 2.0 = twice as fast, etc.
        float attackSpeedMultiplier = 3.0f; // Adjust this value to control attack speed
        DWORD attackInterval = static_cast<DWORD>(1000 / attackSpeedMultiplier);  // Dynamic interval based on multiplier

        if (currentTime - lastAutoHuntTime >= attackInterval)
        {
            // Call SetAutoHuntMode to trigger the attack action
            SetAutoHuntMode(m_attackMode, true, m_isAutoPick, m_attackRange, m_characterOriginX, m_characterOriginY);
            lastAutoHuntTime = currentTime;
        }
    }
#endif

instancebase.cpp


#ifdef ENABLE_AUTOMATIC_HUNTING
int CInstanceBase::GetAffectFlags(int affIdx)
{
    if (m_kAffectFlagContainer.IsSet(affIdx))
        return true;
    return false;
}
#endif

instancebase.h

#ifdef ENABLE_AUTOMATIC_HUNTING
        int        GetAffectFlags(int affIdx);
#endif

locale.inc.h

define ENABLE_AUTOMATIC_HUNTING

pythoncharactermodule.cpp

#ifdef ENABLE_AUTOMATIC_HUNTING
PyObject* chrIsAffect(PyObject* poSelf, PyObject* poArgs)
{
    UINT uAffect;
    if (!PyTuple_GetUnsignedInteger(poArgs, 0, &uAffect))
        return Py_BuildException();

    CInstanceBase* pInstance = CPythonCharacterManager::Instance().GetMainInstancePtr();
    if (!pInstance)
        return Py_BuildValue("i", 0);

    return Py_BuildValue("i", pInstance->IsAffect(uAffect));
}

PyObject* chrIsFishing(PyObject* poSelf, PyObject* poArgs)
{
    CInstanceBase* pInstance = CPythonCharacterManager::Instance().GetMainInstancePtr();
    if (!pInstance)
        return Py_BuildValue("i", 0);

    return Py_BuildValue("i", pInstance->IsFishing());
}

PyObject* chrIsDead(PyObject* poSelf, PyObject* poArgs)
{
    int iVirtualID;
    if (!PyTuple_GetInteger(poArgs, 0, &iVirtualID))
        return Py_BuildException();

    CInstanceBase* pInstance = CPythonCharacterManager::Instance().GetInstancePtr(iVirtualID);
    if (!pInstance)
        return Py_BuildValue("i", 0);

    return Py_BuildValue("i", pInstance->IsDead());
}

PyObject* chrGetWeaponType(PyObject* poSelf, PyObject* poArgs)
{
    CInstanceBase* pInstance = CPythonCharacterManager::Instance().GetMainInstancePtr();
    if (!pInstance)
        return Py_BuildNone();

    return Py_BuildValue("i", pInstance->GetWeaponType());
}
#endif

        #ifdef ENABLE_AUTOMATIC_HUNTING
        { "IsAffect",                    chrIsAffect,                        METH_VARARGS },
        { "IsFishing",                    chrIsFishing,                        METH_VARARGS },
        { "IsDead",                        chrIsDead,                            METH_VARARGS },
        { "GetWeaponType",                chrGetWeaponType,                    METH_VARARGS },
        #endif

pythonitem.cpp

#ifdef ENABLE_AUTOMATIC_HUNTING
bool CPythonItem::IsItemNameExist(const std::string& itemName) const
{
    const auto& itemMap = CItemManager::Instance().GetItemMap();

    for (const auto& entry : itemMap) {
        const CItemData* pItemData = entry.second;
        if (pItemData && pItemData->GetName()) {
            std::string itemFullName(pItemData->GetName());
            if (itemFullName.find(itemName) != std::string::npos) {
                return true;
            }
        }
    }
    return false;
}
#endif

pythonitem.h

#ifdef ENABLE_AUTOMATIC_HUNTING
        bool    IsItemNameExist(const std::string& itemName) const;
#endif

pythonitemmodule.cpp

#ifdef ENABLE_AUTOMATIC_HUNTING
PyObject* itemIsItemNameExist(PyObject* poSelf, PyObject* poArgs)
{
    const char* itemName = NULL;

    if (!PyArg_ParseTuple(poArgs, "s", &itemName))
        return Py_BuildException("Invalid argument: expected a string.");

    // Convert C-string to std::string
    std::string itemNameStr(itemName);

    bool found = CPythonItem::Instance().IsItemNameExist(itemNameStr);

    return Py_BuildValue("i", found ? 1 : 0);
}
#endif

        #ifdef ENABLE_AUTOMATIC_HUNTING
        { "IsItemNameExist",                itemIsItemNameExist,                    METH_VARARGS },
#endif

pythonnetworkstreammodule.cpp

#ifdef ENABLE_AUTOMATIC_HUNTING
        { "SaveInfo",                            netSaveInfo,                            METH_VARARGS },
        { "ClearInfo",                            netClearInfo,                            METH_VARARGS },
#endif

pythonplayer.cpp

#ifdef ENABLE_AUTOMATIC_HUNTING
DWORD CPythonPlayer::SkillIndexToAffectIndex(DWORD dwSkillIndex)
{
    // Iterate through the map to find the skill index.
    for (const auto& pair : m_kMap_dwAffectIndexToSkillIndex)
    {
        if (pair.second == dwSkillIndex)  // Check if the skill index matches.
        {
            return pair.first;  // Return the corresponding affect index.
        }
    }

    return DWORD(-1);  // Return an invalid affect index if not found.
}
#endif


#ifdef ENABLE_AUTOMATIC_HUNTING
    /*if (IsAutoHuntEnabled())
    {
        static DWORD lastAutoHuntTime = 0;
        DWORD currentTime = CTimer::Instance().GetCurrentMillisecond();

        if (CTimer::Instance().GetCurrentMillisecond() - lastAutoHuntTime >= 1000) { // 1 second interval
            SetAutoHuntMode(m_attackMode, true, m_attackRange, m_characterOriginX, m_characterOriginY);
            lastAutoHuntTime = currentTime;
        }
    }*/

    if (IsAutoHuntEnabled())
    {
        static DWORD lastAutoHuntTime = 0;
        DWORD currentTime = CTimer::Instance().GetCurrentMillisecond();

        // Attack speed multiplier, where 1.0 = normal speed, 2.0 = twice as fast, etc.
        float attackSpeedMultiplier = 6.0f; // Adjust this value to control attack speed
        DWORD attackInterval = static_cast<DWORD>(1000 / attackSpeedMultiplier);  // Dynamic interval based on multiplier

        if (currentTime - lastAutoHuntTime >= attackInterval) {
            // Call SetAutoHuntMode to trigger the attack action
            SetAutoHuntMode(m_attackMode, true, m_attackRange, m_characterOriginX, m_characterOriginY, m_isAutoPick);
            lastAutoHuntTime = currentTime; // Update the last attack time
        }
    }

#endif

pythonplayer.h

        SetAttackKeyState

#ifdef ENABLE_AUTOMATIC_HUNTING
        void    SetAutoHuntMode(BYTE type, bool state, bool autopickup, int range = 2630, int origin_x = 0, int origin_y = 0);
        static  std::vector<DWORD> GetNearbyPCs(int nDistance);
        bool    IsAutoHuntEnabled();
        bool    IsAutoPickEnabled();
#endif

AffectIndexToSkillIndex
#ifdef ENABLE_AUTOMATIC_HUNTING
        DWORD    SkillIndexToAffectIndex(DWORD dwSkillIndex);
#endif

pythonsystem.cpp

#ifdef ENABLE_AUTOMATIC_HUNTING
void CPythonSystem::SetPickupFilterName(const std::string& itemName)
{
    itemNameFilter[itemName] = true;
}

void CPythonSystem::ClearPickupFilter()
{
    itemNameFilter.clear();
}
bool CPythonSystem::CheckPickupFilterName(const CItemData* pItem) const
{
    std::string itemName = pItem->GetName();

    // Iterate through the itemNameFilter map to check for substring matches
    for (const auto& filterEntry : itemNameFilter) {
        const std::string& filterName = filterEntry.first;

        // Check if filterName is a substring of itemName
        if (itemName.find(filterName) != std::string::npos) {
            return filterEntry.second;
        }
    }
    return false;
}
bool CPythonSystem::CanPickItem(DWORD dwIID)
{
    CItemData* pItemData;
    if (!CItemManager::Instance().GetItemDataPointer(CPythonItem::Instance().GetVirtualNumberOfGroundItem(dwIID), &pItemData))
    {
        Tracenf("CPickUpFilter::CanPickItem(dwIID=%d) : Non-exist item.", dwIID);
        return true;
    }

    if (!CPythonSystem::Instance().CheckPickupFilterName(pItemData))
        return false;
/*     TraceError("can pick lol"); */
    return true;
}
#endif

pythonsystem.h

#ifdef ENABLE_AUTOMATIC_HUNTING
        bool                            CanPickItem(DWORD dwIID);
        void                            SetPickupFilterName(const std::string& itemName);
        void                            ClearPickupFilter();
        bool                            CheckPickupFilterName(const CItemData* pItem) const;

        std::map<std::string, bool> itemNameFilter;
#endif

pythonsystemmodule.cpp

#ifdef ENABLE_AUTOMATIC_HUNTING
PyObject* systemSetPickUpFilterName(PyObject* poSelf, PyObject* poArgs)
{
    PyObject* pyItemNames;
    if (!PyArg_ParseTuple(poArgs, "O!", &PyList_Type, &pyItemNames)) {
        return Py_BuildException();
    }

    if (PyList_Size(pyItemNames) == 0) {
        CPythonSystem::Instance().ClearPickupFilter();
        return Py_BuildNone();
    }

    CPythonSystem::Instance().ClearPickupFilter();

    for (Py_ssize_t i = 0; i < PyList_Size(pyItemNames); i++) {
        const char* itemName = PyString_AsString(PyList_GetItem(pyItemNames, i));
        if (itemName == nullptr || itemName[0] == '\0') {
            continue;
        }

        CPythonSystem::Instance().SetPickupFilterName(itemName);
    }

    return Py_BuildNone();
}
#endif

        #ifdef ENABLE_AUTOMATIC_HUNTING
        { "SetPickUpFilterName",        systemSetPickUpFilterName,        METH_VARARGS },
#endif

#ifdef ENABLE_AUTOMATIC_HUNTING
PyObject* netSaveInfo(PyObject* poSelf, PyObject* poArgs)
{
    CInstanceBase* pInstance = CPythonCharacterManager::Instance().GetMainInstancePtr();
    if (!pInstance)
        return Py_BuildException("Main instance not found.");

    pInstance->SaveInfo();
    return Py_BuildNone();
}

PyObject* netClearInfo(PyObject* poSelf, PyObject* poArgs)
{
    CInstanceBase* pInstance = CPythonCharacterManager::Instance().GetMainInstancePtr();
    if (!pInstance)
        return Py_BuildException("Main instance not found.");

    pInstance->ClearInfo();
    return Py_BuildNone();
}
#endif

instancebase.cpp

#ifdef ENABLE_AUTOMATIC_HUNTING

// Otomatik avlanma sırasında bilgileri saklamak için kullanılacak alanlar
static BYTE    s_savedAttackMode = 0;
static bool    s_savedAutoPickup = false;
static int    s_savedRange = 0;
static int    s_savedOriginX = 0;
static int    s_savedOriginY = 0;

void CInstanceBase::SaveInfo()
{
    s_savedAttackMode = m_attackMode;
    s_savedAutoPickup = m_isAutoPick;
    s_savedRange = m_attackRange;
    s_savedOriginX = m_characterOriginX;
    s_savedOriginY = m_characterOriginY;
}

void CInstanceBase::ClearInfo()
{
    s_savedAttackMode = 0;
    s_savedAutoPickup = false;
    s_savedRange = 0;
    s_savedOriginX = 0;
    s_savedOriginY = 0;
}

#endif