CUObstacle.h

//
//  CUObstacle.h
//  Cornell University Game Library (CUGL)
//
//  Box2D is an excellent physics engine in how it decouples collision and
//  geometry from rigid body dynamics.  However, there are some times in which
//  coupling is okay for convenience reasons (particularly when we have the
//  option to uncouple).  This module is such an example; it couples the
//  bodies and fixtures from Box2d into a single class, making the physics
//  easier to use (in most cases).
//
//  This class uses our standard shared-pointer architecture.
//
//  1. The constructor does not perform any initialization; it just sets all
//     attributes to their defaults.
//
//  2. All initialization takes place via init methods, which can fail if an
//     object is initialized more than once.
//
//  3. All allocation takes place via static constructors which return a shared
//     pointer.
//
//  CUGL MIT License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  This file is based on the CS 3152 PhysicsDemo Lab by Don Holden, 2007
//
//  Author: Walker White
//  Version: 11/6/16
//
#ifndef __CU_OBSTACLE_H__
#define __CU_OBSTACLE_H__
 
#include <Box2D/Dynamics/b2Body.h>
#include <Box2D/Dynamics/b2Fixture.h>
#include <iostream>
#include <cugl/2d/CUWireNode.h>
 
namespace cugl {
    
#pragma mark -
#pragma mark Obstacle
 
class Obstacle {
protected:
    b2BodyDef _bodyinfo;
    b2FixtureDef _fixture;
    b2MassData _massdata;
    bool _masseffect;
    
    std::shared_ptr<Node> _scene;
    std::shared_ptr<WireNode> _debug;
    Color4 _dcolor;
    std::string _tag;
    
    std::function<void(Obstacle* obstacle)> _listener;
    
#pragma mark -
#pragma mark Scene Graph Internals
 
    virtual void resetDebug() { }
    
     virtual void updateDebug();
 
    
private:
 
    bool _remove;
    bool _dirty;
    
 
#pragma mark -
#pragma mark Constructors
public:
    Obstacle(void);
    
    virtual ~Obstacle();
    
    virtual bool init() { return init(Vec2::ZERO); }
    
    virtual bool init(const Vec2& vec);
 
    
#pragma mark -
#pragma mark BodyDef Methods
 
    virtual b2BodyType getBodyType() const { return _bodyinfo.type; }
    
    virtual void setBodyType(b2BodyType value) { _bodyinfo.type = value; }
    
    virtual Vec2 getPosition() const { return Vec2(_bodyinfo.position.x,_bodyinfo.position.y); }
    
    virtual void setPosition(const Vec2& value) { setPosition(value.x,value.y); }
    
    virtual void setPosition(float x, float y) { _bodyinfo.position.Set(x,y); }
    
    virtual float getX() const { return _bodyinfo.position.x; }
    
    virtual void setX(float value) { _bodyinfo.position.x = value; }
    
    virtual float getY() const { return _bodyinfo.position.y; }
    
    virtual void setY(float value) { _bodyinfo.position.y = value; }
    
    virtual float getAngle() const { return _bodyinfo.angle; }
    
    virtual void setAngle(float value) { _bodyinfo.angle = value; }
    
    virtual Vec2 getLinearVelocity() const {
        return Vec2(_bodyinfo.linearVelocity.x,_bodyinfo.linearVelocity.y);
    }
    
    virtual void setLinearVelocity(const Vec2& value) { setLinearVelocity(value.x,value.y); }
    
    virtual void setLinearVelocity(float x, float y) { _bodyinfo.linearVelocity.Set(x,y); }
    
    virtual float getVX() const { return _bodyinfo.linearVelocity.x; }
    
    virtual void setVX(float value) { _bodyinfo.linearVelocity.x = value; }
    
    virtual float getVY() const { return _bodyinfo.linearVelocity.y; }
    
    virtual void setVY(float value) { _bodyinfo.linearVelocity.y = value; }
    
    virtual float getAngularVelocity() const { return _bodyinfo.angularVelocity; }
    
    virtual void setAngularVelocity(float value) { _bodyinfo.angularVelocity = value; }
    
    virtual bool isActive() const { return _bodyinfo.active; }
    
    virtual void setActive(bool value) { _bodyinfo.active = value; }
    
    virtual bool isAwake() const { return _bodyinfo.awake; }
    
    virtual void setAwake(bool value) { _bodyinfo.awake = value; }
    
    virtual bool isSleepingAllowed() const { return _bodyinfo.allowSleep; }
    
    virtual void setSleepingAllowed(bool value) { _bodyinfo.allowSleep = value; }
    
    virtual bool isBullet() const { return _bodyinfo.bullet; }
    
    virtual void setBullet(bool value) { _bodyinfo.bullet = value; }
    
    virtual bool isFixedRotation() const { return _bodyinfo.fixedRotation; }
    
    virtual void setFixedRotation(bool value) { _bodyinfo.fixedRotation = value; }
    
    virtual float getGravityScale() const { return _bodyinfo.gravityScale; }
    
    virtual void setGravityScale(float value) { _bodyinfo.gravityScale = value; }
    
    virtual float getLinearDamping() const { return _bodyinfo.linearDamping; }
    
    virtual void setLinearDamping(float value) { _bodyinfo.linearDamping = value; }
    
    virtual float getAngularDamping() const { return _bodyinfo.angularDamping; }
    
    virtual void setAngularDamping(float value) { _bodyinfo.angularDamping = value; }
    
    void setBodyState(const b2Body& body);
 
    
#pragma mark -
#pragma mark FixtureDef Methods
 
    float getDensity() const { return _fixture.density; }
    
    virtual void setDensity(float value) { _fixture.density = value; }
    
    float getFriction() const { return _fixture.friction; }
    
    virtual void setFriction(float value) { _fixture.friction = value; }
    
    float getRestitution() const { return _fixture.restitution; }
    
    virtual void setRestitution(float value) { _fixture.restitution = value; }
    
    bool isSensor() const { return _fixture.isSensor; }
    
    virtual void setSensor(bool value) { _fixture.isSensor = value; }
    
    b2Filter getFilterData() const { return _fixture.filter; }
    
    virtual void setFilterData(b2Filter value) { _fixture.filter = value; }
    
    
#pragma mark -
#pragma mark MassData Methods
 
    virtual Vec2 getCentroid() const { return Vec2(_massdata.center.x,_massdata.center.y); }
    
    virtual void setCentroid(const Vec2& value) { setCentroid(value.x,value.y); }
    
    virtual void setCentroid(float x, float y);
    
    virtual float getInertia() const { return _massdata.I; }
    
    virtual void setInertia(float value);
    
    virtual float getMass() const { return _massdata.mass; }
    
    virtual void setMass(float value);
    
    virtual void resetMass() { _masseffect = false; }
    
    
#pragma mark -
#pragma mark Garbage Collection
 
    bool isRemoved() const { return _remove; }
    
    void markRemoved(bool value) { _remove = value; }
    
    bool isDirty() const { return _dirty; }
    
    void markDirty(bool value) { _dirty = value; }
    
#pragma mark -
#pragma mark Physics Methods
 
    virtual b2Body* getBody() { return nullptr; }
    
    virtual bool activatePhysics(b2World& world) { return false; }
    
    virtual void deactivatePhysics(b2World& world) {}
 
    
#pragma mark -
#pragma mark Update Methods
 
    virtual void update(float delta) {
        if (_scene) { updateDebug(); }
        if (_listener) { _listener(this); }
    }
    
    const std::function<void(Obstacle* obstacle)>& getListener() const {
        return _listener;
    }
 
    void setListener(const std::function<void(Obstacle* obstacle)>& listener) {
        _listener = listener;
    }
 
#pragma mark -
#pragma mark Debugging Methods
 
    std::string getName() const { return _tag; }
    
    void setName(std::string value) { _tag = value; }
 
    std::string toString() const;
    
    friend std::ostream&   operator<<(std::ostream& os, const Obstacle& obj);
 
    
#pragma mark -
#pragma mark Scene Graph Methods
 
    Color4 getDebugColor() const { return _dcolor; }
    
    virtual void setDebugColor(Color4 color);
    
    Node* getDebugScene() const { return _scene.get(); }
    
    WireNode* getDebugNode() const { return _debug.get(); }
    
    virtual void setDebugScene(const std::shared_ptr<Node>& node);
    
    bool hasDebug() { return _scene != nullptr; }
};
 
}
 
#endif /* __CU_OBSTACLE_H__ */