spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#endif  /* CRTDLL */
        else    //  __active_heap == __SYSTEM_HEAP

#endif  /* _WIN64 */
        {
            retval = HeapFree(_crtheap, 0, pBlock);    //<=== AN DIESER STELLE!

            if (retval == 0)
            {
                errno = _get_errno_from_oserr(GetLastError());
            }
        }
}

#else  /* WINHEAP */

C-/C++-Quelltext

//Alle Einheiten löschen

    CGame* pGame = CMain::Instance().GetCurrentGameState<CGame>();
    for(UINT y = 0; y < pGame->m_iGridHeight; ++y)
    {
        for(UINT x = 0; x < pGame->m_iGridWidth; ++x)
        {
            for(ogUtilsIterator<CDivision*> i = m_pppDivisions[y][x].Begin(); i.NotEndOfList(); ++i)
            {
                //Einheit dieses Sektors löschen

                og2DVector vPos = og2DVector(static_cast<float>(x), static_cast<float>(y));
                ogEMS::Instance().SendOneMessage(this, OTCEM_DIVISIONDESTROYED, &i, &vPos);
            }
        }
        OG_SAFE_DELETE_ARRAY(m_pppDivisions[y]);
    }
    OG_SAFE_DELETE_ARRAY(m_pppDivisions);

    //Alle Buildings löschen

    for(ogUtilsIterator<CBuilding*> iterator = m_pBuildings.Begin(); iterator.NotEndOfList(); ++iterator)
    {
        ogEMS::Instance().SendOneMessage(this, OTCEM_BUILDINGDESTROYED, &iterator);
    }

C-/C++-Quelltext

bool BuildingDestroyed(ogUtilsIterator<CBuilding*>* iterator)
    {
        //Aus EntityManager löschen

        ogEMS::Instance().DeleteObject(**iterator);

        //Instanz selbst löschen

        OG_SAFE_DELETE(iterator->m_pCurrent->Data);

        //Aus GebäudeListe entfernen

        m_pBuildings.Remove(iterator);
        return true;
    }

    bool DivisionDestroyed(ogUtilsIterator<CDivision*>* it, const UINT x, const UINT y)
    {
        //Aus EntityManager löschen

        ogEMS::Instance().DeleteObject(**it);

        //Instanz selbst löschen

        OG_SAFE_DELETE(it->m_pCurrent->Data);
        
        //Aus der "richtigen" Liste löschen

        m_pppDivisions[y][x].Remove(it);
        return true;
    }

C-/C++-Quelltext

bool Remove(ogUtilsIterator<T>* it)
    {
        ogUtilsListEntry<T>* pTemp = m_pFirst;
        ogUtilsListEntry<T>* pLast = NULL;
        for(UINT i = 0; i < m_iSize; ++i)
        {
            if(it->m_pCurrent == pTemp)
            {
                if(pLast) pLast->pNext = pTemp->pNext;
                else m_pFirst = pTemp->pNext;
                if(pTemp == m_pLast) m_pLast = pLast;

                it->m_pNextOne = pTemp->pNext;
                it->m_pCurrent = NULL;

                //Delete it!

                OG_SAFE_DELETE(pTemp);
                --m_iSize;
                return true;
            }
            pLast = pTemp;
            pTemp = pTemp->pNext;
        }
        return false;
    }

C-/C++-Quelltext

template <typename T> class ogUtilsIterator;

template <typename T> struct ogUtilsListEntry
{
    ogUtilsListEntry<T>*        pNext;
    T                           Data;
};

template <typename T>
class ogUtilsList
{   
private:
    ogUtilsListEntry<T>*        m_pFirst;
    ogUtilsListEntry<T>*        m_pLast;
    UINT                        m_iSize;

public:
    ogUtilsList() : m_iSize(0), m_pFirst(NULL), m_pLast(NULL)       {}
    ~ogUtilsList()                                                  {Clear();}

    ogUtilsListEntry<T>*        Begin()             {return m_pFirst;}
    ogUtilsListEntry<T>*        End()               {return m_pLast;}
    UINT                        GetSize()           {return m_iSize;}
    //-------------------------------------------------------------------------//


    bool Insert(T& Data)
    {
        if(m_iSize <= 0) m_pFirst = m_pLast = new ogUtilsListEntry<T>;
        else
        {
            m_pLast->pNext  = new ogUtilsListEntry<T>;
            m_pLast         = m_pLast->pNext;
        }
        m_pLast->pNext = NULL;
        m_pLast->Data  = Data;
        ++m_iSize;
        return true;
    }

    bool Remove(T& Data)
    {
        ogUtilsListEntry<T>* pTemp = m_pFirst;
        ogUtilsListEntry<T>* pLast = NULL;
        for(UINT i = 0; i < m_iSize; ++i)
        {
            if(::memcmp(&(pTemp->Data), &Data, sizeof(T)) == 0)
            {
                if(pLast) pLast->pNext = pTemp->pNext;
                else m_pFirst = pTemp->pNext;
                if(pTemp == m_pLast) m_pLast = pLast;

                //Delete it!

                OG_SAFE_DELETE(pTemp);
                --m_iSize;
                return true;
            }
            pLast = pTemp;
            pTemp = pTemp->pNext;
        }
        return false;
    }
    bool Remove(ogUtilsIterator<T>* it)
    {
        ogUtilsListEntry<T>* pTemp = m_pFirst;
        ogUtilsListEntry<T>* pLast = NULL;
        for(UINT i = 0; i < m_iSize; ++i)
        {
            if(it->m_pCurrent == pTemp)
            {
                if(pLast) pLast->pNext = pTemp->pNext;
                else m_pFirst = pTemp->pNext;
                if(pTemp == m_pLast) m_pLast = pLast;

                it->m_pNextOne = pTemp->pNext;
                it->m_pCurrent = NULL;

                //Delete it!

                OG_SAFE_DELETE(pTemp);
                --m_iSize;
                return true;
            }
            pLast = pTemp;
            pTemp = pTemp->pNext;
        }
        return false;
    }

    bool Clear()
    {
        for(UINT i = 0; i < m_iSize; ++i)
        {
            ogUtilsListEntry<T>* pTemp = m_pFirst;
            m_pFirst = m_pFirst->pNext;
            OG_SAFE_DELETE(pTemp);
        }
        m_iSize     = 0;
        m_pFirst    = NULL;
        m_pLast     = NULL;
        return true;
    }
};

template <typename T>
class ogUtilsIterator
{
public:
    ogUtilsListEntry<T>*        m_pCurrent;
    //Wird verwendet, um während eines Schleifendurchgangs auch etwas aus der Liste löschen zu können

    //Hier wird dann gespeichert, auf welchen Eintrag der Iterator beim nächsten ++ springen soll

    ogUtilsListEntry<T>*        m_pNextOne;

    ogUtilsIterator() : m_pCurrent(NULL)                                    {}
    ogUtilsIterator(ogUtilsListEntry<T>* pStart) : m_pCurrent(pStart)       {}
    ~ogUtilsIterator()                                                      {}

    bool                    EndOfList()                 {return m_pCurrent == NULL;}
    bool                    NotEndOfList()              {return m_pCurrent != NULL;}
    void                    SetData(T NewData)          {if(m_pCurrent) m_pCurrent->Data = NewData;}

    //Operatoren

    ogUtilsIterator<T>& operator ++ ()                              
        {if(m_pCurrent) m_pCurrent = m_pCurrent->pNext; else {m_pCurrent = m_pNextOne; m_pNextOne = NULL;} return *this;}
    ogUtilsIterator<T>& operator ++ (int)                           
        {ogUtilsIterator<T> OldIt = *this; if(m_pCurrent) m_pCurrent = m_pCurrent->pNext; else {m_pCurrent = m_pNextOne; m_pNextOne = NULL;} return OldIt;}

    ogUtilsIterator<T>& operator () (ogUtilsListEntry<T>* pStart)   {m_pCurrent = pStart; return *this;}
    ogUtilsIterator<T>& operator = (ogUtilsListEntry<T>* pStart)    {m_pCurrent = pStart; return *this;}

    bool operator == (const ogUtilsListEntry<T>* pEntry) {return m_pCurrent == pEntry;}
    bool operator != (const ogUtilsListEntry<T>* pEntry) {return m_pCurrent != pEntry;}

    T* operator -> () {return &(m_pCurrent->Data);}
    T operator * () {return m_pCurrent->Data;}
};