qafPlatformerObj.h

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

#ifndef QAF_OBJ_PLATFORMEROBJ_H
#define QAF_OBJ_PLATFORMEROBJ_H

#include "../qafCollisionStruct.h"
#include "../qafGameObj.h"
#include "../qafEnvironment.h"
#include "../qafutil/qafVector2D.h"


namespace qaf {
    
    class PlatformerObj : public GameObj {
    public:
        
        class PlatformerInput {
        public:
            bool left, right, down;
            
            bool jumpPress;
            
            bool jump;
            
            PlatformerInput ();
            virtual ~PlatformerInput() {}
        };
        
        
        
        PlatformerInput * platformerInput;
        
        
        float WIDTH;
        
        float HEIGHT;
        
        float CAMERA_DX;
        
        float CAMERA_DY;
        
        float CAMERA_STICKINESS;
        
        bool CENTER_SCROLLING_ON_SELF;
        
        float WALK_SPEED;
        
        float CLIMB_26_SLOPE_SLOWDOWN;
        
        float CLIMB_45_SLOPE_SLOWDOWN;
        
        float WALK_ACCELERATION;
        
        float WALK_DECELERATION;
        
        float JUMP_STRENGTH;
        
        float WATER_JUMP_STRENGTH;
        
        float GRAVITY;
        
        float MAX_FALL_SPEED;
        
        float SUBMERSION_HEIGHT;
        
        float BUOYANCY;
        
        float MAX_FLOAT_SPEED;
        
        float MAX_SINK_SPEED;
        
        float SWIM_SPEED;
        
        float SWIM_ACCELERATION;
        
        float SWIM_DECELERATION;
        
        bool FLOAT_ON_WATER_SURFACE;
        
        PlatformerObj ( float x, float y, PlatformerInput * platformerInput, AttributeTable & attributes = AttributeTable() );
        
        
        void initialize ();
        
        void update ( int objLayer, float dt );
        
        void render ( int objLayer, float scrollX, float scrollY );
        
        CollisionStruct * getCollisionStruct ();
        
        bool isFacingLeft;
        

        bool rightContact, leftContact, topContact, bottomContact;
        
        
        inline const Vector2D & getPos() {
            return pos;
        }
        
        inline void setPos ( float x, float y ) {
            float dx = x - pos.x;
            float dy = y - pos.y;
            
            translate( dx, dy );
        }
        
        inline void translate ( float dx, float dy ) {
            pos.x += dx;
            pos.y += dy;
            
            platformerCollisionStruct.setX(
                platformerCollisionStruct.getX() + dx );
            platformerCollisionStruct.setY(
                platformerCollisionStruct.getY() + dy );
        }
        
        inline const Vector2D & getVel() {
            return vel;
        }
        
        inline void setVel ( float x, float y ) {
            float dx = x - vel.x;
            float dy = y - vel.y;
            
            vel.x += dx;
            vel.y += dy;
        }
        
        inline bool isUnderwater () {
            return (pos.y > Environment::getLoadedRoom()->waterLevel + SUBMERSION_HEIGHT);
        }
        
        inline bool isFloatingOnWaterSurface () {
            if ( !FLOAT_ON_WATER_SURFACE )
                return false;
            else
            if ( ABS(vel.y) > QAF_EPSILON )
                return false;
            else
            if ( ABS(pos.y - (Environment::getLoadedRoom()->waterLevel + SUBMERSION_HEIGHT)) > QAF_EPSILON )
                return false;
            else
                return true;
        }
        
    private:
        float accDX, accDT;
        Vector2D pos, vel;
        Vector2D prevCamPos, nextCamPos;
        CollisionStruct::Box platformerCollisionStruct;
        
        inline float botRightX () { return pos.x + WIDTH/2; }
        inline float botRightY () { return pos.y; }
        inline float topRightX () { return pos.x + WIDTH/2; }
        inline float topRightY () { return pos.y - HEIGHT; }
        inline float topLeftX  () { return pos.x - WIDTH/2; }
        inline float topLeftY  () { return pos.y - HEIGHT; }
        inline float botLeftX  () { return pos.x - WIDTH/2; }
        inline float botLeftY  () { return pos.y; }
        
        inline bool rightCollision () {
            return Environment::getLoadedRoom()->segmentCollision(
                    topRightX(), topRightY(),
                    botRightX(), botRightY(),
                    false ); 
        }
        inline bool leftCollision () {
            return Environment::getLoadedRoom()->segmentCollision(
                    topLeftX(), topLeftY(),
                    botLeftX(), botLeftY(),
                    false );
        }
        inline bool topCollision () {
            return Environment::getLoadedRoom()->segmentCollision(
                    topLeftX(),  topLeftY(),
                    topRightX(), topRightY(),
                    false );
        }
        inline bool botCollision () {
            return Environment::getLoadedRoom()->segmentCollision(
                    botLeftX(),  botLeftY(),
                    botRightX(), botRightY(),
                    false );
        }
        
        // Encapsulate input access here. These methods return false if the
        // input object is NULL.
        inline bool inputLeft() {
            return (platformerInput != NULL && platformerInput->left);
        }
        inline bool inputRight() {
            return (platformerInput != NULL && platformerInput->right);
        }
        inline bool inputDown() {
            return (platformerInput != NULL && platformerInput->down);
        }
        inline bool inputJumpPress() {
            return (platformerInput != NULL && platformerInput->jumpPress);
        }
        inline bool inputJump() {
            return (platformerInput != NULL && platformerInput->jump);
        }
        
    };
    
}



#endif

---