qafEnvironment.h

/* 
** Qaf Framework 1.2
** June 2006
** 
** Pedro Luchini de Moraes, Public Domain - Free Lunch Code
*/

#ifndef QAF_ENVIRONMENT_H
#define QAF_ENVIRONMENT_H

#include "qafDef.h"
#include "qafGameObjFactory.h"
#include "qafJoystickSystem.h"
#include "qafRoom.h"
#include "qafutil/qafBigTexture.h"
#include "qafutil/qafVector2D.h"
#include "qafutil/qafVector3D.h"



namespace qaf {
    
    template <typename T>
    class ObjIterator {
        public:
            bool hasNext () {
                return (currObjInx >= 0);
            };
            
            T * next () {
                if ( currObjInx < 0 )
                    return NULL;
                else {
                    currObjInx--;
                    return objects->elem( currObjInx + 1 );
                }
            }
            
            int getCount () {
                return objects->getCount();
            }
            
        private:
            friend class Environment;
            
            int currObjInx;
            const Container<T *> * objects;
            
            inline ObjIterator ( const Container<T *> * _objects ) : objects(_objects) {
                currObjInx = _objects->getCount() - 1;
            }
    };
    
    
    
    
    class DebugVector {
    public:
        DebugVector () {}
        
        DebugVector ( Vector2D & _p1, Vector2D & _p2, DWORD _color );
        
        void render ();
        
    private:
        Vector2D p1, p2;
        DWORD color;
    };
    
    
    
    
    class Environment {
    public:

        static float time;
        
        static int frames;
        

        static bool initialize ( bool useBackBuffer, bool useDebug );
        
        static void update ( float dt );
        
        static void enableObjUpdate ( bool flag );
        
        static bool isObjUpdateEnabled ();
        
        static void enableRender ( bool flag );
        
        static bool isRenderEnabled ();
        
        
        static void shutdown ();
        
        static void enableBackBuffer ( bool flag );
        
        static bool isBackBufferEnabled ();
        
        static unsigned long getBackBuffer ();
        
        
        static void setGameObjFactory ( GameObjFactory * _gameObjFactory );
        
        static GameObjFactory * getGameObjFactory ();
        
        static void setPrologueCallback ( void (*cb) () );
        
        static void setEpilogueCallback ( void (*cb) () );
        
        
        static bool loadRoom ( std::string filename );
        
        static Room * getLoadedRoom ();

        static void unloadRoom ();
        
        
        static void setScrollingPoint ( int x, int y );
        
        static void moveScrollingPoint ( int dx, int dy );
        
        static void centerScrollingPoint ( int x, int y );
        
        static int getScrollingX ();
        
        static int getScrollingY ();
        
        
        static int getScreenWidth ();
        
        static int getScreenHeight ();
        
        
        static void addGameObj ( GameObj * obj, int layer = -1, bool onTop = true );
        
        static int findGameObj ( GameObj * obj, int * index = NULL );
        
        static void removeGameObj ( GameObj * obj, bool deleteIt, int srcLayer = -1 );
        
        static void moveGameObj ( GameObj * obj, int destLayer, int srcLayer = -1 );
        
        static void bringGameObjToFront ( GameObj * obj, int srcLayer = -1 );
        
        static void sendGameObjToBack ( GameObj * obj, int srcLayer = -1 );
        
        
        
        static int getNumberOfJoysticks ();
        
        static Joystick * getJoystick ( int i );
        
        
        static const BigTexture * loadBigTexture ( const char * filename );
        
        static void freeBigTexture ( const BigTexture * tex );
        
        static void setBigTextureCacheSize ( int size );
        
        
    private:
        
        // A Container of pointers to Containers of pointers to GameObjs.
        // This stores all currently active GameObjs.
        static Container<Container<GameObj *> *> gameObjLayers;
        
        // A generic object discriminator:
        class AbstractObjDiscriminator {
            public:
                virtual void addGameObj ( GameObj * obj ) = 0;
                virtual void removeGameObj ( GameObj * obj ) = 0;
                virtual void removeAll () = 0;
                virtual ~AbstractObjDiscriminator () {}
        };
        
        // A type-specific object discriminator:
        template <typename T>
        class ObjDiscriminator : public AbstractObjDiscriminator {
            public:
                // The constructor looks through the current object list for
                // objects that match its target class:
                ObjDiscriminator () {
                    for ( int layerInx = 0; layerInx < gameObjLayers.getCount(); layerInx++ ) {
                        for ( int objInx = 0; objInx < gameObjLayers[layerInx]->getCount(); objInx++ ) {
                            // Try to cast this pointer to the correct type:
                            T * t_obj = dynamic_cast<T *> ( gameObjLayers[layerInx]->elem( objInx ) );
                            if ( t_obj ) {
                                // Add it:
                                objects.add( t_obj );
                            }
                        }
                    }
                }
                
                // Adds the object to the object list if it's of the correct
                // type.
                void addGameObj ( GameObj * obj ) {
                    // Try to cast this pointer to the correct type:
                    T * t_obj = dynamic_cast<T *> ( obj );
                    if ( t_obj ) {
                        // Add it:
                        objects.add( t_obj );
                    }
                }
                
                // Removes the object if it was added to a list:
                void removeGameObj ( GameObj * obj ) {
                    // Try to cast this pointer to the correct type:
                    T * t_obj = dynamic_cast<T *> ( obj );
                    if ( t_obj ) {
                        // Remove it:
                        objects.removeFirst( t_obj );
                    }
                }
                
                // Removes all objects:
                void removeAll () {
                    objects.removeAll();
                }
                
                // This is public so the ObjIterator class can see the objects
                // contained in the discriminator.
                Container<T *> objects;
        };
        
        // A Container of object discriminators:
        static Container<AbstractObjDiscriminator *> objDiscriminators;
        
    public:
        
        template <typename T>
        static ObjIterator<T> makeObjIterator () {
            // Keep a reference to the discriminator for this class.
            static ObjDiscriminator<T> myDiscriminator;
            
            // This will only be run once:
            static bool once = true;
            if ( once ) {
                // Add the discriminator to the Environment's discriminator
                // list:
                Environment::objDiscriminators.add( &myDiscriminator );
                
                once = false;
            }
            
            // Create and return an object iterator:
            return ObjIterator<T>( &(myDiscriminator.objects) );
        }
        
        
    private:
        // A generic collision handler:
        class AbstractCollisionHandler {
            public:
                virtual void checkCollisions () = 0;
                virtual ~AbstractCollisionHandler () {}
        };
        
        // A type-specific collision handler:
        template <typename T1, typename T2>
        class CollisionHandler : public AbstractCollisionHandler {
            public:
                // The constructor receives a pointer to the handler function:
                CollisionHandler ( void (*_pfHandler) (T1 *, T2 *) ) {
                    pfHandler = _pfHandler;
                }
                
                // Checks collisions between the objects:
                // From back to front, so objects that were added later are
                // checked first...
                void checkCollisions () {
                    ObjIterator<T1> objects1 = makeObjIterator<T1>();
                    while ( objects1.hasNext() ) {
                        // Get first object:
                        T1 * obj1 = objects1.next();
                        
                        ObjIterator<T2> objects2 = makeObjIterator<T2>();
                        while ( objects2.hasNext() ) {
                            // Get second object:
                            T2 * obj2 = objects2.next();
                            
                            // Both objects have collision structures?
                            CollisionStruct * cs1 = obj1->getCollisionStruct();
                            CollisionStruct * cs2 = obj2->getCollisionStruct();
                            
                            if ( cs1 && cs2 ) {
                                // The structures collide?
                                if ( cs1->collidesWith( cs2 ) ) {
                                    // Invoke the handler:
                                    pfHandler( obj1, obj2 );
                                }
                            }
                        }
                    }
                }
                
            private:
                void (*pfHandler) (T1 *, T2 *);
        };
        
        // A Container of collision handlers:
        static Container<AbstractCollisionHandler *> collisionHandlers;
        
    public:
        
        template <typename T1, typename T2>
        static void registerCollisionHandler ( void (*pfHandler) (T1 *, T2 *) ) {
            // Create the collision handler:
            AbstractCollisionHandler * newHandler = new CollisionHandler<T1, T2>( pfHandler );
            
            // Add the handler:
            collisionHandlers.add( newHandler );
        }
        
        
        class DebugConsole {
        public:
            inline DebugConsole & operator << ( char c ) {
                data += c;
                
                return *this;
            }
            
            inline DebugConsole & operator << ( const char * str ) {
                data += str;
                
                return *this;
            }
            
            inline DebugConsole & operator << ( const std::string & str ) {
                data += str;
                
                return *this;
            }
            
            inline DebugConsole & operator << ( int val ) {
                sprintf( temp, "%d", val );
                data += temp;
                
                return *this;
            }
            
            inline DebugConsole & operator << ( float val ) {
                sprintf( temp, "%f", val );
                data += temp;
                
                return *this;
            }
            
            inline DebugConsole & operator << ( bool b ) {
                data += ( b ? "true" : "false" );
                
                return *this;
            }
            
            inline DebugConsole & operator << ( const Vector2D & v2D ) {
                sprintf( temp, "(%f, %f)", v2D.x, v2D.y );
                data += temp;
                
                return *this;
            }
            
            inline DebugConsole & operator << ( const Vector3D & v3D ) {
                sprintf( temp, "(%f, %f, %f)", v3D.x, v3D.y, v3D.z );
                data += temp;
                
                return *this;
            }
            
            inline DebugConsole & operator << ( const void * ptr ) {
                sprintf( temp, "%p", ptr );
                data += temp;
                
                return *this;
            }
            
            inline const char * getData () {
                return data.c_str();
            }
            
            inline void clear () {
                data = "";
            }
            
        private:
            char temp[500];
            std::string data;
        };
        
        static DebugConsole cout;
        
        
        static Container<DebugVector> debugVectors;
        
        
    private:
        
        // Draws the entire environment -- room, game objs, water, etc.
        static void render ();
        
        // Performs pending operations in operation buffer.
        static void doOpBuffer ();
        
        // Performs the actual room loading/unloading:
        static void doLoadRoom ( Room * newRoom, void * objInfo );
        static void doUnloadRoom ();
        
        // Frees "dead" textures from the BigTexture cache.
        static void enforceBigTexCacheSize ();
        
        
    };
    
}

#endif

---