CUObstacle.h

//
//  CUObstacle.cpp
//  Cornell Extensions to Cocos2D
//
//  Cocos2d fits well with Box2d physics.  However, it tightly couples the physics
//  into the scene graph, which is the cardinal sin. With that said, 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 file is based on the CS 3152 PhysicsDemo Lab by Don Holden, 2007
//
//  Author: Walker White
//  Version: 11/24/15
//
#ifndef __CU_OBSTACLE_H__
#define __CU_OBSTACLE_H__

#include <Box2D/Dynamics/b2Body.h>
#include <Box2D/Dynamics/b2Fixture.h>
#include <iostream>
#include <cocos2d.h>
#include "CUWireNode.h"


NS_CC_BEGIN

#pragma mark -
#pragma mark Obstacle

class CC_DLL Obstacle : public Ref {
private:
    CC_DISALLOW_COPY_AND_ASSIGN(Obstacle);

protected:
    b2BodyDef _bodyinfo;
    b2FixtureDef _fixture;
    b2MassData _massdata;
    Vec2 _drawScale;
    bool _masseffect;
    
    Node* _node;
    WireNode* _debug;
    string _tag;
    
    
#pragma mark -
#pragma mark Scene Graph Internals

    virtual void resetSceneNode() { }
    
     virtual void positionSceneNode();

    virtual void resetDebugNode() { }
    
    virtual void positionDebugNode();
    
private:

    bool _remove;
    bool _dirty;
    
    
public:
#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 Scene Graph Methods

    const Vec2& getDrawScale() const { return _drawScale; }
    
    virtual void setDrawScale(const Vec2& value) { setDrawScale(value.x,value.y); }
    
    virtual void setDrawScale(float x, float y);
    
    Node* getSceneNode() const { return _node; }
    
    void setSceneNode(Node* node);
    
    WireNode* getDebugNode() const { return _debug; }
    
    void setDebugNode(WireNode* node);

    
#pragma mark -
#pragma mark Physics Methods

    virtual b2Body* getBody() const { return nullptr; }
    
    virtual bool activatePhysics(b2World& world) { return false; }
    
    virtual void deactivatePhysics(b2World& world) {}
    
    virtual void update(float delta) {}
    
    
#pragma mark -
#pragma mark Debugging Methods

    string getName() const { return _tag; }
    
    void setName(string value) { _tag = value; }

    string toString() const;
    
    friend ostream&   operator<<(ostream& os, const Obstacle& obj);
    
    
#pragma mark -
#pragma mark Initializers
CC_CONSTRUCTOR_ACCESS:
    /*
     * Creates a new physics object at the origin.
     */
    Obstacle(void);
    
    virtual ~Obstacle();

    virtual bool init() { return init(Vec2::ZERO); }

    virtual bool init(const Vec2& vec);

};

NS_CC_END

#endif /* defined(__CU_OBSTACLE_H__) */