CUCapsuleObstacle.h

//
//  CUCapsuleObstacle.h
//  Cornell Extensions to Cocos2D
//
//  This class implements a capsule physics object. A capsule is a box with
//  semicircular ends along the major axis.  They are a popular physics objects,
//  particularly for character avatars.  The rounded ends means they are less
//  likely to snag, and they naturally fall off platforms when they go too far.
//
//  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_CAPSULE_OBSTACLE_H__
#define __CU_CAPSULE_OBSTACLE_H__
 
#include <Box2D/Collision/Shapes/b2PolygonShape.h>
#include <Box2D/Collision/Shapes/b2CircleShape.h>
#include <Box2D/Collision/b2Collision.h>
#include "CUSimpleObstacle.h"
 
namespace cugl {
 
#pragma mark -
#pragma mark Capsule Obstacle
 
class CapsuleObstacle : public SimpleObstacle {
public:
    enum class Orientation {
        TOP,
        VERTICAL,
        BOTTOM,
        LEFT,
        HORIZONTAL,
        RIGHT
    };
    
protected:
    b2PolygonShape _shape;
    b2CircleShape  _ends;
    b2AABB _center;
    
    b2Fixture* _core;
    b2Fixture* _cap1;
    b2Fixture* _cap2;
    Size _dimension;
    Orientation _orient;
    
    float _seamEpsilon;
    
    
#pragma mark -
#pragma mark Scene Graph Methods
 
    void resize(const Size& size);
    
    virtual void resetDebug() override;
    
    
#pragma mark -
#pragma mark Constructors
public:
    CapsuleObstacle(void) : SimpleObstacle(),
    _core(nullptr), _cap1(nullptr), _cap2(nullptr), _seamEpsilon(0.0f) { }
    
    virtual ~CapsuleObstacle() {
        CUAssertLog(_core == nullptr, "You must deactive physics before deleting an object");
    }
    
    virtual bool init() override { return init(Vec2::ZERO,Size::ZERO); }
    
    virtual bool init(const Vec2& pos) override { return init(pos,Size::ZERO); }
    
    virtual bool init(const Vec2& pos, const Size& size);
    
    virtual bool init(const Vec2& pos, const Size& size, Orientation orient);
    
#pragma mark -
#pragma mark Static Constructors
 
    static std::shared_ptr<CapsuleObstacle> alloc() {
        std::shared_ptr<CapsuleObstacle> result = std::make_shared<CapsuleObstacle>();
        return (result->init() ? result : nullptr);
    }
    
    static std::shared_ptr<CapsuleObstacle> alloc(const Vec2& pos) {
        std::shared_ptr<CapsuleObstacle> result = std::make_shared<CapsuleObstacle>();
        return (result->init(pos) ? result : nullptr);
    }
    
    static std::shared_ptr<CapsuleObstacle> alloc(const Vec2& pos, const Size& size) {
        std::shared_ptr<CapsuleObstacle> result = std::make_shared<CapsuleObstacle>();
        return (result->init(pos,size) ? result : nullptr);
    }
    
    static std::shared_ptr<CapsuleObstacle> alloc(const Vec2& pos, const Size& size, Orientation orient) {
        std::shared_ptr<CapsuleObstacle> result = std::make_shared<CapsuleObstacle>();
        return (result->init(pos,size,orient) ? result : nullptr);
    }
    
    
#pragma mark -
#pragma mark Dimensions
 
    const Size& getDimension() const { return _dimension; }
    
    void setDimension(const Size& value) { resize(value); markDirty(true); }
    
    void setDimension(float width, float height) { setDimension(Size(width,height)); }
    
    float getWidth() const { return _dimension.width; }
    
    void setWidth(float value) { setDimension(value,_dimension.height); }
    
    float getHeight() const { return _dimension.height; }
    
    void setHeight(float value) { setDimension(_dimension.width,value); }
    
    const Orientation& getOrientation() const { return _orient; }
    
    bool setOrientation(Orientation value);
    
    static bool isHorizontal(Orientation value) {
        return (value == Orientation::LEFT || value == Orientation::RIGHT || value == Orientation::HORIZONTAL);
    }
    
#pragma mark -
#pragma mark Physics Methods
 
    void setSeamOffset(float value);
    
    float getSeamOffset() const { return _seamEpsilon; }
    
    virtual void setDensity(float value) override;
    
    virtual void createFixtures() override;
    
    virtual void releaseFixtures() override;
    
};
 
}
#endif /* __CU_CAPSULE_OBSTACLE_H__ */