CUComplexObstacle.h

//
//  CUSimpleObstacle.h
//  Cornell Extensions to Cocos2D
//
//  This module provides a physics object that supports mutliple Bodies.
//  This is the base class for objects that are tied together with joints.
//
//  This class does not provide Shape information, and cannot be instantiated
//  directly.  There are no default complex objects.  You will need to create
//  your own subclasses to use this class.  It is very similar to Lab 4
//  from CS 3152.
//
//  This file is based on the CS 3152 PhysicsDemo Lab by Don Holden, 2007
//
//  Author: Walker White
//  Version: 11/24/15
//
#ifndef __CC_COMPLEX_OBSTACLE_H__
#define __CC_COMPLEX_OBSTACLE_H__

#include <Box2D/Dynamics/Joints/b2Joint.h>
#include "CUObstacle.h"


NS_CC_BEGIN

#pragma mark -
#pragma mark Simple Obstacle


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

protected:
    b2Body* _body;
    vector<Obstacle*> _bodies;
    vector<b2Joint*>  _joints;
    bool _tracking;
    
public:
#pragma mark -
#pragma mark BodyDef Methods

    virtual b2BodyType getBodyType() const override {
        return (_body != nullptr ? _body->GetType() : _bodyinfo.type);
    }
    
    virtual void setBodyType(b2BodyType value) override {
        if (_body != nullptr) {
            _body->SetType(value);
        } else {
            _bodyinfo.type = value;
        }
    }
    
    virtual Vec2 getPosition() const override {
        if (_body != nullptr) {
            return Vec2(_body->GetPosition().x,_body->GetPosition().y);
        } else {
            return Vec2(_bodyinfo.position.x,_bodyinfo.position.y);
        }
    }
    
    virtual void setPosition(const Vec2& value) override { setPosition(value.x,value.y); }
    
    virtual void setPosition(float x, float y) override {
        if (_body != nullptr) {
            _body->SetTransform(b2Vec2(x,y),_body->GetAngle());
        } else {
            _bodyinfo.position.Set(x,y);
        }
    }
    
    virtual float getX() const override {
        return (_body != nullptr ? _body->GetPosition().x : _bodyinfo.position.x);
    }
    
    virtual void setX(float value) override {
        if (_body != nullptr) {
            _body->SetTransform(b2Vec2(value,_body->GetPosition().y),_body->GetAngle());
        } else {
            _bodyinfo.position.x = value;
        }
    }
    
    virtual float getY() const override {
        return (_body != nullptr ? _body->GetPosition().y : _bodyinfo.position.y);
    }
    
    virtual void setY(float value) override {
        if (_body != nullptr) {
            _body->SetTransform(b2Vec2(_body->GetPosition().x,value),_body->GetAngle());
        } else {
            _bodyinfo.position.y = value;
        }
    }
    
    virtual float getAngle() const override {
        return (_body != nullptr ? _body->GetAngle() : _bodyinfo.angle);
    }
    
    virtual void setAngle(float value) override {
        if (_body != nullptr) {
            _body->SetTransform(_body->GetPosition(),value);
        } else {
            _bodyinfo.angle = value;
        }
    }
    
    virtual Vec2 getLinearVelocity() const override {
        if (_body != nullptr) {
            return Vec2(_body->GetLinearVelocity().x,_body->GetLinearVelocity().y);
        } else {
            return Vec2(_bodyinfo.linearVelocity.x,_bodyinfo.linearVelocity.y);
        }
    }
    
    virtual void setLinearVelocity(const Vec2& value) override { setLinearVelocity(value.x,value.y); }
    
    virtual void setLinearVelocity(float x, float y) override {
        if (_body != nullptr) {
            _body->SetLinearVelocity(b2Vec2(x,y));
        } else {
            _bodyinfo.linearVelocity.Set(x,y);
        }
    }
    
    virtual float getVX() const override {
        if (_body != nullptr) {
            return _body->GetLinearVelocity().x;
        } else {
            return _bodyinfo.linearVelocity.x;
        }
    }
    
    virtual void setVX(float value) override {
        if (_body != nullptr) {
            _body->SetLinearVelocity(b2Vec2(value,_body->GetLinearVelocity().y));
        } else {
            _bodyinfo.linearVelocity.x = value;
        }
    }
    
    virtual float getVY() const override {
        if (_body != nullptr) {
            return _body->GetLinearVelocity().y;
        } else {
            return _bodyinfo.linearVelocity.y;
        }
    }
    
    virtual void setVY(float value) override {
        if (_body != nullptr) {
            _body->SetLinearVelocity(b2Vec2(value,_body->GetLinearVelocity().y));
        } else {
            _bodyinfo.linearVelocity.x = value;
        }
    }
    
    virtual float getAngularVelocity() const override {
        return (_body != nullptr ? _body->GetAngularVelocity() : _bodyinfo.angularVelocity);
    }
    
    virtual void setAngularVelocity(float value) override {
        if (_body != nullptr) {
            _body->SetAngularVelocity(value);
        } else {
            _bodyinfo.angularVelocity = value;
        }
    }
    
    virtual bool isActive() const override {
        return (_body != nullptr ? _body->IsActive() : _bodyinfo.active);
    }
    
    virtual void setActive(bool value) override {
        if (_body != nullptr) {
            _body->SetActive(value);
        } else {
            _bodyinfo.active = value;
        }
    }
    
    virtual bool isAwake() const override {
        return (_body != nullptr ? _body->IsAwake() : _bodyinfo.awake);
    }
    
    virtual void setAwake(bool value) override {
        if (_body != nullptr) {
            _body->SetAwake(value);
        } else {
            _bodyinfo.awake = value;
        }
    }
    
    virtual bool isSleepingAllowed() const override {
        return (_body != nullptr ? _body->IsSleepingAllowed() : _bodyinfo.allowSleep);
    }
    
    virtual void setSleepingAllowed(bool value) override {
        if (_body != nullptr) {
            _body->SetSleepingAllowed(value);
        } else {
            _bodyinfo.allowSleep = value;
        }
    }

    
    virtual bool isBullet() const override {
        return (_body != nullptr ? _body->IsBullet() : _bodyinfo.bullet);
    }
    
    virtual void setBullet(bool value) override {
        if (_body != nullptr) {
            _body->SetBullet(value);
        } else {
            _bodyinfo.bullet = value;
        }
    }
    
    virtual bool isFixedRotation() const override {
        return (_body != nullptr ? _body->IsFixedRotation() : _bodyinfo.fixedRotation);
    }
    
    virtual void setFixedRotation(bool value) override {
        if (_body != nullptr) {
            _body->SetFixedRotation(value);
        } else {
            _bodyinfo.fixedRotation = value;
        }
    }
    
    virtual float getGravityScale() const override {
        return (_body != nullptr ? _body->GetGravityScale() : _bodyinfo.gravityScale);
    }
    
    virtual void setGravityScale(float value) override {
        if (_body != nullptr) {
            _body->SetGravityScale(value);
        } else {
            _bodyinfo.gravityScale = value;
        }
    }
    
    virtual float getLinearDamping() const override {
        return (_body != nullptr ? _body->GetLinearDamping() : _bodyinfo.linearDamping);
    }
    
    virtual void setLinearDamping(float value) override {
        if (_body != nullptr) {
            _body->SetLinearDamping(value);
        } else {
            _bodyinfo.linearDamping = value;
        }
    }
    
    virtual float getAngularDamping() const override {
        return (_body != nullptr ? _body->GetAngularDamping() : _bodyinfo.angularDamping);
    }
    
    virtual void setAngularDamping(float value) override {
        if (_body != nullptr) {
            _body->SetAngularDamping(value);
        } else {
            _bodyinfo.angularDamping = value;
        }
    }
    
    
#pragma mark -
#pragma mark FixtureDef Methods

    virtual void setDensity(float value) override;
    
    virtual void setFriction(float value) override;
    
    virtual void setRestitution(float value) override;
    
    virtual void setSensor(bool value) override;
    
    virtual void setFilterData(b2Filter value) override;
    
    
#pragma mark -
#pragma mark MassData Methods    

    virtual Vec2 getCentroid() const override {
        if (_body != nullptr) {
            return Vec2(_body->GetLocalCenter().x,_body->GetLocalCenter().y);
        } else {
            return Vec2(_massdata.center.x,_massdata.center.y);
        }
    }
    
    virtual void setCentroid(const Vec2& value) override { setCentroid(value.x,value.y); }
    
    virtual void setCentroid(float x, float y) override {
        Obstacle::setCentroid(x, y);
        if (_body != nullptr) {
            _body->SetMassData(&_massdata); // Protected accessor?
        }
    }
    
    virtual float getInertia() const override {
        return  (_body != nullptr ? _body->GetInertia() : _massdata.I);
    }
    
    virtual void setInertia(float value) override {
        Obstacle::setInertia(value);
        if (_body != nullptr) {
            _body->SetMassData(&_massdata); // Protected accessor?
        }
    }
    
    virtual float getMass() const override {
        return  (_body != nullptr ? _body->GetMass() : _massdata.mass);
    }
    
    virtual void setMass(float value) override {
        Obstacle::setMass(value);
        if (_body != nullptr) {
            _body->SetMassData(&_massdata); // Protected accessor?
        }
    }
    
    virtual void resetMass() override {
        Obstacle::resetMass();
        if (_body != nullptr) {
            _body->ResetMassData();
        }
    }
    
#pragma mark -
#pragma mark Physics Methods

    virtual b2Body* getBody() const override { return _body; }
    
    const vector<Obstacle*>& getBodies() { return _bodies; }
    
    const vector<b2Joint*>& getJoints() { return _joints; }
    
    virtual bool activatePhysics(b2World& world) override;
    
    virtual void deactivatePhysics(b2World& world) override;
    
    virtual void createFixtures() {}
    
    virtual void releaseFixtures() {}
    
    virtual bool createJoints(b2World& world) {  return false;  }
    
    virtual void update(float delta) override;

    
#pragma mark -
#pragma mark Scene Graph Methods

    virtual void setDrawScale(const Vec2& value) override { setDrawScale(value.x,value.y); }
    
    virtual void setDrawScale(float x, float y) override;
    
    bool isSceneTracking() { return _tracking; }

    void setSceneTracking(bool track) { _tracking = track; }
    
    virtual void positionSceneNode() override;
    
    virtual void positionDebugNode() override;
    
    
#pragma mark -
#pragma mark Initializers
CC_CONSTRUCTOR_ACCESS:
    ComplexObstacle() : Obstacle(), _body(nullptr), _tracking(false) { }
    
    virtual ~ComplexObstacle();
};

NS_CC_END
#endif /* defined(__CC_COMPLEX_OBSTACLE_H__) */