ShootingSimulation.h

Go to the documentation of this file.

#pragma once

#include <vrecko/Ability.h>
#include <vrecko/EnvironmentObject.h>
#include <vrecko/EventDispatcher.h>
#include <vrecko/Logger.h>
#include <vrecko/Message.h>
#include <vrecko/Scene.h>
#include <vrecko/World.h>

#include <osgText/Font>

using namespace vrecko;

namespace APShootingSimulation
{

enum GameStates {
    PREPARE_NEW_GAME,     // before starting a new game => after initializing of the app or after the last level
    PREPARE_NEXT_LEVEL,    // prepare state for next level
    WAITING_FOR_START,   // waiting for pressing 'start' button
    COUNTDOWN,            // after pressing 'start' button
    RUNNING_LEVEL         // during playing levels
};

enum MoveDirections {
    NO_MOVE,
    MOVE_UP,
    MOVE_DOWN,
    MOVE_LEFT,
    MOVE_RIGHT
};

class ShootingSimulation: public vrecko::Ability
{
public:

    ShootingSimulation();
    virtual ~ShootingSimulation() {};

    virtual bool initialize(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *parameters = NULL);

    virtual void update(void);

    osg::ref_ptr<vrecko::EnvironmentObject> resolveIntersections(osg::Vec3 &vector,
                                                                 osg::Vec3 &position, 
                                                                 std::vector<osg::Node*> **nodePath = NULL);

protected:

    bool addObject(osg::ref_ptr<vrecko::EnvironmentObject> &obj, const std::string& geoPath);
    
    void setCrosshairPos();
    
    void moveTarget(osg::Vec3 currentTargetPos);

    void testAndHandleHit();

    DECLARE_INPUT(Start, MessageBool);
    DECLARE_INPUT(Mouse, MessageVec2);
    DECLARE_INPUT(Trigger, MessageBool);
    DECLARE_INPUT(Sensor_Transformation, MessageSensorTransformation);

private:
    // string of start buttons for 'startText'
    static const std::string START_BUTTONS;

    // paths to models
    static const std::string PATH_WALL;
    static const std::string PATH_CROSSHAIR;
    static const std::string PATH_TARGET;

    #define      NUM_TARGETS    3
    static const std::string PATH_TARGET_DAMAGED[];

    // Environment objects
    osg::ref_ptr<vrecko::EnvironmentObject> wall;
    osg::ref_ptr<vrecko::EnvironmentObject> target;
    osg::ref_ptr<vrecko::EnvironmentObject> crosshair;
    osg::ref_ptr<vrecko::EnvironmentObject> damagedTargets[NUM_TARGETS];

    // index of damagedTarget currently in use
    unsigned int dmgTargetIndex;
    // current start position of the target
    unsigned int targetPosIndex;

    // osg vectors for aiming
    osg::Vec2    _mouse2DVector;
    osg::Vec3    _aimVector;
    osg::Vec3    _standingPosition;
    osg::Vec3    _opti3DVector0;
    osg::Vec3    _opti3DVector1;

    static const float CROSSHAIR_DIFF;
    static const float DEFAULT_Z_GRID;
    float              screenZGrid;

    // target appearance setup
    static const int   NUM_TARGETS_POS;
    static const float X_TARGETS[];
    static const float Y_TARGETS[];

    static const float MIN_X;
    static const float MAX_X;
    static const float MIN_Y;
    static const float MAX_Y;

    static const float TARGET_INITIAL_SPEED;
    static const float TARGET_SPEED_INCREASE_VALUE;
    float _targetSpeed;

    // state of game
    GameStates       gameState;
    // current target move direction
    MoveDirections   moveDirection;
    unsigned int     level;
    static const int MAX_LEVEL;
    
    // score variables
    std::string scoreString;
    int         score;

    // text variables
    osg::ref_ptr<osgText::Text> startText;
    osg::ref_ptr<osg::Geode>    startTextGeode;
    osg::ref_ptr<osgText::Text> scoreText;
    osg::ref_ptr<osg::Geode>    scoreTextGeode;
    osg::ref_ptr<osgText::Font> textFont;
    
    // timing
    std::string      timeString;
    int              timeToEnd;
    static const int STARTING_TIME;

    osg::Timer_t beginningTime;
    osg::Timer_t currentTime;
    osg::Timer_t startOfMove;
    osg::Timer_t previousTick;

    double movingTime;
    static const double MOVE_UP_SPEED;
    static const double MOVE_DOWN_SPEED;
};

}