include/TraplasObject.h

Go to the documentation of this file.

#define STATECONTROL_H

#ifndef _STDLIB_H
#include <stdlib.h>
#endif

#ifndef _STDIO_H
#include <stdio.h>
#endif

#ifndef _GLIBCXX_VECTOR
#include <vector>
#endif

#ifndef _GLIBCXX_MAP
#include <map>
#endif

#ifndef _GLIBCXX_STRING
#include <string>
#endif

#ifndef _PTHREAD_H
#include <pthread.h>
#endif

#ifndef OSG_REFERENCED
#include <osg/Referenced>
#endif

#ifndef OSG_GROUP
#include <osg/Group>
#endif

#ifndef OSG_NODE
#include <osg/Node>
#endif

#ifndef OSG_ANIMATIONPATH
#include <osg/AnimationPath>
#endif

#ifndef BOOST_SHARED_PTR_HPP_INCLUDED
#include <boost/shared_ptr.hpp>
#endif

//forward declaration.
class Dispatcher;

using namespace boost;
using namespace std; 

#define CARGO 0
#define TRANSPORT 1
#define LOCATION 2


class TraplasObject:public osg::Referenced{
        public:
        TraplasObject();
        inline virtual int getId(){return id;}
        inline virtual int getType(){return type;}
        virtual void setDescription(string descript);
        virtual bool select();
        inline virtual bool isSelected(){return selected;}
        inline virtual osg::Node* getModel(){return model;}
        virtual osg::Vec3d getPosition();
  virtual string toString();
        bool setLabel(shared_ptr<string> desc);
        void initLabel();
        protected:
  /* The destructor is protected because this class inherets from osg::Referenced. This enables a kind of shared pointers functionality so we won't have to worry much about memory management. */
        virtual ~TraplasObject();
        int id;                                                         //the ID of the object in Traplas. used by statecontrol to manage objects.
        int type;                                               //the type of object. Can be TRANSPORT, CARGO or LOCATION.
        bool selected;                          //whether or not this object is currently selected.
        string description;     //The description of the object as given by Traplas.
        osg::Node* model;               //reference to the model that represents this object in the visualisation.
        osg::Geode* label;              //The text label that is visible over all objects.
};

class Cargo:public TraplasObject{
        public:
        Cargo(int carg_id, int type_carg, osg::Node* carg_model);
        string toString();
};

class Transport:public TraplasObject{
        public:
        Transport(int transport_id, int type_transport, double spd, osg::Node* trans_model);
        inline double getSpeed(){return speed;}
        bool setSpeed(double s_spd);
        inline string getDestination(){return destination;}
        bool setDestination(string s_dest);
        inline int getCargo(){return carg;}
        bool setCargo(int s_carg, string desc);
        int clearCargo();
  string toString();
        protected:
        double speed;                   //the speed at which this transport is driving.
        string c_desc;          //The description of the cargo that is currently loaded.
        int carg;                                       //The traplas id of the cargo currently loaded.
        string destination;     //The final destination of this transport.
};

class Infrastructure:public TraplasObject{
        public:
        Infrastructure(int infrastructure_id, int type_infrastructure, double spd, int tile_type, unsigned int cap, double dist, osg::Node* infra_model);
        bool addCarg(int a_carg);
        int removeCarg(int r_carg);
        inline int getTileType(){return tileType;}
        inline double getSpeed(){return speed;}
        bool setSpeed(double s_spd);
        inline unsigned int getCapacity(){return capacity;}
        inline double getDistance(){return distance;}
        bool addArc(int to);
        bool isArc(int end);
  virtual string toString();
        protected:
        int tileType;                                           //What tile is used to represent this infrastructure resource. See the dbus interface specification, appendix B.
        unsigned int capacity;  //The maximum amount of transports that can drive through this location at one time.
        double distance;                                //distance.
        double speed;                                           //The maximum speed at this location.
        int width;                                                      //The width of this tile. Used for scaling.
        int height;                                                     //""  height "" "" "".
        set<int> cargoSet;              //The cargo that is at this location.
        map<int, int*> arcs;            //one-directional arcs to the locations that are adjacent to and reachable from this one.
};

---