WorldObject.h

Go to the documentation of this file.

#ifndef __WORLDOBJECT_H__
#define __WORLDOBJECT_H__
#include "fns.h"
#include "CollisionObject.h"

// predeclared for build
class CollisionObject;

class WorldObject
{
public:
        WorldObject(std::string name, Point2D pos = Point2D(), int z = 0);

        enum WorldObjectType {
                SPRITE,
                BACKGROUND,
                MENU,
                TEXT,
                PARTICLESYSTEM
        };

        virtual void draw() = 0;

        virtual void drawCollisions();

        void drawCollisions(vector<CollisionObject*>& vec, const Point2D& pos);

        virtual void update();

        virtual void runBehavior();

        void setPosition(double x, double y) {mPos.x = x; mPos.y = y;}

        void setPosition(Point2D pos) { mPos = pos; }

        void setBasePosition(double x, double y) {Point2D bPos = getBasePos(); mPos.x = x - bPos.x; mPos.y = y - bPos.y;}

        void setBasePosition(Point2D pos) {Point2D bPos = getBasePos(); mPos.x = pos.x - bPos.x; mPos.y = pos.y - bPos.y;}

        void setCenterPosition(double x, double y) {Point2D cPos = getCenterPos(); mPos.x = x - cPos.x; mPos.y = y - cPos.y;}

        void setCenterPosition(Point2D pos) {Point2D cPos = getCenterPos(); mPos.x = pos.x - cPos.x; mPos.y = pos.y - cPos.y;}
        
        void move(double dx=0.0, double dy=0.0){mPos.x+=dx; mPos.y+=dy;}

        virtual void move(Point2D direction) { mPos += direction; }

        virtual void moveTowards(Point2D direction);

        Point2D getPosition() { return mPos; }

        void setTransparency(float f) { mTransparency = f>1?1:f<0?0:f;}

        float getTransparency() {return mTransparency;}

        void setAngle(float a) { mAngle = a; while(a>360)a-=360;}

        float getAngle() {return mAngle;}

        void setVelocity(Point2D vel) { 
                mVelocity = vel;
                if(mMaxVelocity < vel){
                        setMaxVelocity(vel);
                }
        }

        void setVelocity(double xVel, double yVel) { 
                mVelocity.x = xVel;
                mVelocity.y = yVel;
                if(mMaxVelocity < mVelocity){
                        setMaxVelocity(mVelocity);
                }
        }

        Point2D getVelocity() {return mVelocity;}

        void setMaxVelocity(Point2D vel) { mMaxVelocity = vel; }

        void setMaxVelocity(double vel, Point2D dir) { 
                mMaxVelocity = dir.unitVec();
                mMaxVelocity *= vel;
        }

        void setMaxSpeed(double vel) { 
                if(abs(mMaxVelocity.lengthSquared())  < numeric_limits<double>::epsilon()){//if the velocity is 0
                        mMaxSpeed = vel;
                }
                else{
                        setMaxVelocity(vel, mVelocity);
                }
        }

        Point2D getMaxVelocity() {return mMaxVelocity;}

        double getMaxSpeed();

        double getMaxSpeedSquared();

        void setAcceleration(Point2D accel) { mAcceleration = accel; }

        Point2D getAcceleration() {return mAcceleration;}

        void setZOrder(int i) { ZOrder=i; }
        int     getZOrder() { return ZOrder; }

        std::string getName() { return mName; }

        bool operator<(WorldObject &rhs) { return ZOrder == rhs.getZOrder() ?  getBasePos().y < rhs.getBasePos().y : ZOrder < rhs.getZOrder(); }
        
        virtual Point2D getBasePos() = 0;

        virtual Point2D getCenterPos() = 0;

        virtual WorldObjectType getType() = 0;

protected:
        std::string mName;
        Point2D mPos;
        Point2D mVelocity;
        Point2D mMaxVelocity;
        double mMaxSpeed;
        Point2D mAcceleration;
        bool mVisible;
        float mTransparency;
        float mAngle;
        float mScale;
        int ZOrder;
        long mLastUpdate;
        long mLastDraw;
        bool mUnused;
        Behavior mBehavior;
};
#endif