include/World2D.h

#ifndef _WORLD2D_
#define _WORLD2D_

#include <Vector2D.h>
#include <Body2D.h>
#include <disableWarnings.h>

namespace sonus
{
        template <class T>
        class World2D
        {
                public:

                        World2D();

                        World2D( int length );

                        ~World2D();

                        bool setBorder( Body2D<T>* b );

                        Body2D<T>* getBorder();

                        int     pushObstacle( Body2D<T>* b );

                        Body2D<T>*      popObstacle();

                        Body2D<T>* getObstacleAt( int index );

                        void clear();

                        int     getIndexOf( Body2D<T>* b );

                        int     getLength();

                        int     getSize();
                        
                private:

                        int                     count;
                        int                     length;
                        Body2D<T>**     obstacles;
                        Body2D<T>*      border;

        };

        template<class T>
        World2D<T>::World2D()
        {
                this->count = 0;
                this->length = 10;
                this->obstacles = new Body2D<T>*[ length ];
        }

        template<class T>
        World2D<T>::World2D( int length )
        {
                this->count = 0;
                this->length = length;
                this->obstacles = new Body2D<T>*[ length ];
        }

        template<class T>
        World2D<T>::~World2D()
        {
                delete this->obstacles;
        }

        template<class T>
        bool World2D<T>::setBorder( Body2D<T>* b )
        {
                border = b;
                return true;
        }

        template<class T>
        Body2D<T>* World2D<T>::getBorder()
        {
                return border;
        }

        template<class T>
        int World2D<T>::pushObstacle( Body2D<T>* b )
        {
                if ( count < length )
                {
                        obstacles[ count++ ] = b;
                        return count;
                }
                else
                {
                        return -1;
                }
        }

        template<class T>
        Body2D<T>* World2D<T>::popObstacle()
        {
                Body2D<T>* b = obstacles[ --count ];
                obstacles[ count ] = ( Body2D<T>* )0;
                return b;
        }

        template<class T>
        Body2D<T>* World2D<T>::getObstacleAt( int index )
        {
                if ( index <= count )
                {
                        return obstacles[ index ];
                }
                else
                {
                        return ( Body2D<T>* )0;
                }
        }

        template<class T>
        void World2D<T>::clear()
        {
                for ( int i = 0; i < count; i++ )
                {
                        obstacles[ i ] = ( Body2D<T>* )0;
                }
                count = 0;
        }

        template<class T>
        int World2D<T>::getIndexOf( Body2D<T>* b )
        {
                for ( int i = 0; i < count; i++ )
                {
                        if ( obstacles[ i ] == b )
                        {
                                return i;
                        }
                }
                return -1;
        }

        template<class T>
        int World2D<T>::getLength()
        {
                return length;
        }

        template<class T>
        int World2D<T>::getSize()
        {
                return count;
        }

}

#endif

---