CUComplexObstacle.h

//
//  CUComplexObstacle.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 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 __CC_COMPLEX_OBSTACLE_H__
#define __CC_COMPLEX_OBSTACLE_H__
 
#include <Box2D/Dynamics/Joints/b2Joint.h>
#include "CUObstacle.h"
 
 
namespace cugl {
 
#pragma mark -
#pragma mark Complex Obstacle
 
 
class ComplexObstacle : public Obstacle {
protected:
    b2Body* _body;
    std::vector<std::shared_ptr<Obstacle>> _bodies;
    std::vector<b2Joint*>  _joints;
    
#pragma mark -
#pragma mark Scene Graph Internals
 
    virtual void resetDebug() override;
    
    virtual void updateDebug() override;
 
#pragma mark -
#pragma mark Constructors
public:
    ComplexObstacle() : Obstacle(), _body(nullptr) { }
    
    virtual ~ComplexObstacle();
 
    
#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() override { return _body; }
    
    const std::vector<std::shared_ptr<Obstacle>>& getBodies() { return _bodies; }
    
    const std::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 setDebugColor(Color4 color) override;
    
    void setDebugColor(Color4 color, bool cascade);
    
    virtual void setDebugScene(const std::shared_ptr<Node>& node) override;
    
};
 
}
#endif /* __CU_COMPLEX_OBSTACLE_H__ */