[C++] Unnecessary/Incorrect `foreach_break` and `foreach_return`

[Lavesiime]

In the C API, foreach loops are handled through macros, where the foreach_break and foreach_return macros serve a purpose as they need to call RSDK.BreakForeachLoop() before exiting the loop. In the C++ API, however, foreach loops are handled by first constructing an std::list of all entities in GameObject::GetEntities, and then the loop code is ran after the entire entity list has been formed. Despite this, however, the C++ GameAPI bindings still include the foreach_break and foreach_return macros, despite simply break and return being all that's needed. Beyond being unnecessary, these macros incorrectly include calls to RSDK::RSDKTable->BreakForeachLoop(), which decrement the foreach stack pointer despite the GetActive/AllEntities loop already being completed.

[Jds2ce]

Seems like an issue with GetEntities rather than a foreach_break/foreach_return issue - I believe that this could be fixed using a custom iterator if i'm not mistaken:

// GameObject::EntityIterator
template <typename T> struct EntityIterator {
    T *entity;
    uint16 group;
    ForeachTypes type;

    inline T *operator*() { return entity; }
    inline bool operator!=(const EntityIterator &)
    {
        if (type == FOR_ALL_ENTITIES)
            return RSDKTable->GetAllEntities(group, (void **)&entity);

        if (type == FOR_ACTIVE_ENTITIES)
            return RSDKTable->GetActiveEntities(group, (void **)&entity);

#if RETRO_USE_MOD_LOADER && RETRO_MOD_LOADER_VER >= 2
        if (type == FOR_GROUP_ENTITIES)
            return modTable->GetGroupEntities(group, (void **)&entity);
#endif

        return false;
    }
    inline void operator++() const {}
};

// GameObject::EntityList
template <typename T> struct EntityList {
    uint16 group;
    ForeachTypes type;

    inline EntityIterator<T> begin() { return { nullptr, group, type }; }
    inline EntityIterator<T> end() { return { nullptr, group, type }; }
};

template <typename T> static inline EntityList<T> GetEntities(ForeachTypes type)
{
    return { T::sVars ? T::sVars->classID : (uint16)GROUP_ALL, type };
}

template <typename T> static inline EntityList<T> GetEntities(ForeachTypes type, uint16 group) 
{ 
    return { group, type }; 
}

static inline EntityList<GameObject::Entity> GetEntities(ForeachTypes type) 
{ 
    return { (uint16)GROUP_ALL, type }; 
}

static inline EntityList<GameObject::Entity> GetEntities(ForeachTypes type, uint16 group) 
{ 
    return { group, type }; 
}

Two other things to note, this would break code that uses std::list's functions like .empty - so that'd have to be reimplemented

if (GameObject::GetEntities<TestObject>(FOR_ALL_ENTITIES).empty())
    return;
    
GameObject::Get<TestObject>(0)->position.x += 0x10000;

This also hasn't been tested extensively, someone might know how to write this better than I do