CUObstacleSelector.h

//
//  CUObstacleSelector.h
//  Cornell University Game Library (CUGL)
//
//  This class implements a selection tool for dragging physics objects with a
//  mouse. It is essentially an instance of b2MouseJoint, but with an API that
//  makes it a lot easier to use. As with all instances of b2MouseJoint, there
//  will be some lag in the drag (though this is true on touch devices in general).
//  You can adjust the degree of this lag by adjusting the force.  However,
//  larger forces can cause artifacts when dragging an obstacle through other
//  obstacles.
//
//  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 zlib 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_SELECTOR_H__
#define __CU_OBSTACLE_SELECTOR_H__

#include <Box2D/Dynamics/Joints/b2MouseJoint.h>
#include <Box2D/Dynamics/b2Fixture.h>
//#include "CUObstacleWorld.h"

#define DEFAULT_MSIZE       0.2f

#define DEFAULT_FREQUENCY  10.0f

#define DEFAULT_DAMPING     0.7f

#define DEFAULT_FORCE    1000.0f

namespace cugl {

// Forward reference to the ObstacleWorld
class ObstacleWorld;
    
#pragma mark -
#pragma mark Obstacle Selector

class ObstacleSelector {
protected:
    std::shared_ptr<ObstacleWorld> _controller;
    
    Vec2 _position;
    Size _size;
    float _force;
    
    b2Fixture*  _selection;
    b2Body*     _ground;
    
    b2MouseJointDef   _jointDef;
    b2MouseJoint*   _mouseJoint;
    
    std::shared_ptr<Node> _scene;
    std::shared_ptr<WireNode> _hatch;
    std::shared_ptr<WireNode> _connect;
    //Vec2 _drawScale;
    bool _dvisible;
    Color4 _dcolor;
    
#pragma mark -
#pragma mark Scene Graph Internals

    void resetDebug();
    
    void updateDebug();
    
    void updateTarget(Obstacle* obstacle);

    Poly2 hatchPoly() const;
    
public:
#pragma mark Constructors

    ObstacleSelector() :
        _controller(nullptr), _selection(nullptr), _ground(nullptr),
        _mouseJoint(nullptr), _scene(nullptr), _hatch(nullptr),
        _connect(nullptr) {}
    
    ~ObstacleSelector() { dispose(); }
    
    void dispose();
    
    bool init(const std::shared_ptr<ObstacleWorld>& world) {
        return init(world, Size(DEFAULT_MSIZE, DEFAULT_MSIZE));
    }
    
    bool init(const std::shared_ptr<ObstacleWorld>& world, const Size& mouseSize);
    

#pragma mark Static Constructors

    static std::shared_ptr<ObstacleSelector> alloc(const std::shared_ptr<ObstacleWorld>& world) {
        std::shared_ptr<ObstacleSelector> result = std::make_shared<ObstacleSelector>();
        return (result->init(world) ? result : nullptr);
    }
    
    static std::shared_ptr<ObstacleSelector> alloc(const std::shared_ptr<ObstacleWorld>& world,
                                                   const Size& mouseSize) {
        std::shared_ptr<ObstacleSelector> result = std::make_shared<ObstacleSelector>();
        return (result->init(world,mouseSize) ? result : nullptr);
    }

#pragma mark Positional Methods

    const Vec2& getPosition() { return _position; }

    void setPosition(float x, float y);

    void setPosition(const Vec2& pos) { setPosition(pos.x,pos.y); }


    
#pragma mark Selection Methods

    bool isSelected() const { return _selection != nullptr; }
    
    bool select();
    
    void deselect();
    
    Obstacle* getObstacle();
    
    bool onQuery(b2Fixture* fixture);
    
    
#pragma mark Attribute Properties

    float getFrequency() const { return _jointDef.frequencyHz; }
    
    void setFrequency(float speed) { _jointDef.frequencyHz = speed; }
    
    float getDamping() const { return _jointDef.dampingRatio; }
    
    void setDamping(float ratio) { _jointDef.dampingRatio = ratio; }
    
    float getForce() const { return _force; }
    
    void setForce(float force) { _force = force; }
    
    const Size& getMouseSize() const { return _size; }
    
    void setMouseSize(const Size& size) { _size = size; resetDebug(); }
    
    
#pragma mark -
#pragma mark Scene Graph Methods

    Color4 getDebugColor() const { return _dcolor; }
    
    void setDebugColor(Color4 color) {
        _dcolor = color;
        if (_hatch)   { _hatch->setColor(color);   }
        if (_connect) { _connect->setColor(color); }
    }
    
    Node* getDebugScene() const { return _scene.get(); }
    
    void setDebugScene(const std::shared_ptr<Node>& node);
    
    void setVisible(bool flag) {
        _dvisible = flag;
        if (_hatch)   { _hatch->setVisible(flag);   }
        if (_connect) { _connect->setVisible(flag); }
    }
    
    bool isVisible() { return _dvisible; }
    
    bool hasDebug() { return _hatch != nullptr; }
};

}
#endif /* __CU_OBSTACLE_SELECTOR_H__ */