CarControlUnit.h

Go to the documentation of this file.

#ifndef CAR_CONTROL_UNIT
#define CAR_CONTROL_UNIT

#include <vrecko/Ability.h>
#include <osg/Matrix>
#include "CCUStructs.h"
#include "CarState.h"
#include "CarEnvirons.h"

namespace CarSim {
    class CarControlUnit: public vrecko::Ability {
        public:
            CarControlUnit();
            // tento konstruktor bude slouzit k nastaveni generovanych aut
            CarControlUnit(const unsigned int startRoad,const unsigned int stopRoad,
                const bool startDirection,const bool stopDirection,
                const float startEdge,const float stopEdge,
                const float startOffset,const float stopOffset,
                const float recVelOnFstJunc,const unsigned int fstJuncTurn,
                Ability *const pRoadsState,Ability *const pCEU,const std::vector<unsigned int> *const pPath);
            ~CarControlUnit();

            void preInitialize(void);
            void update(void);

            bool loadXMLParameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *pParametersNode);    
        protected:
            Parameters params;
            // I. jestlize neni auto odsunuto (pozna se to z params.carNextJuncRel), bude zde
            // cas, po ktery auto stoji pred (tesne) bodem stopBeforeJunc a ceka az
            // dostane povoleni jet krizovatkou; jestlize se ten cas nepocita, bude obsahovat -1.0,
            // jinak hodnotu >=0.0;
            // II. jestlize auto bylo na hrane odsunuto a
            // a) bylo odsunuto nejdriv (1. ze vsech aut, ktere jsou nyni
            // odsunuty na hrane), bude zde cas, ktery uplynul od posledniho pokusu dostat
            // se z kraje vozovky zpatky do ni nebo od doby, kdy se auto stalo prvnim (nejdrive)
            // odsunutym autem na hrane
            // b) nebylo odsunuto nejdriv, bude obsahovat hodnotu -1.0
            // III. ve zbylych pripadech -1.0
            float timeWaiting;

            // rika, zda bylo auto nastaveno rucne (false) nebo vygenerovano (true)
            const bool gen;
            
            // jestlize je true, nastala chyba v inicializaci, takze se odregistruje
            // aktualizovani CCU
            bool errorOccuredInInit;
            // rika, zda byla provedena inicializace v metode update()
            bool initBool;

            // z XML souboru se vyextrahuje silnice (id pro Road - ulozi se
            // v promenne startRoad) pres uzel StartRoad a jeji smer (true - "forward" 
            // nebo false - "backward" - ulozi se v promenne startDirection) pres uzel startDirection,
            // ktere uruji hranu, na ktere auto zacina;
            unsigned int startRoad;
            bool startDirection;
            // obdobne je tomu s stopRoad a stopDirection, ktere urcuji,
            // na ktere hrane auto zastavuje
            unsigned int stopRoad;
            bool stopDirection;
            
            // doporucena rychlost na pristi krizovatce od RoadsState (ulozi se zde,
            // aby se v kazdem snimku nemusela pocitat znovu v RoadsState);
            // jestlize je < 0, neobsahuje aktualni data
            float recVelocityOnJunc;

            // ukazatel na abilitu RoadsState
            Ability *pRoadsState;

            // cas zjisteny v minulem snimku
            osg::Timer_t lastTick;

            /*// slouzi ke zjisteni prumerneho poctu aktualizaci jednotky
            // CCU 1. generovaneho auta za sekundu v 1. minute
            bool isFPSmeasured;
            float totalTime;
            unsigned int count;*/

            // rika, zda auto bude na pristi krizovatce zatacet doleva nebo doprava
            unsigned int nextJuncTurn;

            // metody, ktere provedou inicializaci v ramci metody update()
            // (slouzi jen pro negenerovana auta)
            void init();
            void initPositionAndDirection();
            // metoda, ktera zkontroluje vstupni XML parametry
            void checkInputXMLParameters();
            // metoda, ktera urci pres RoadsState nejkratsi cestu pro auto
            void computeShortestPath();
            // metoda, ktera vypocita optimalni rychlost prujezdu 1. kriz. v ceste
            void computeRecVelOnFstJunc();
            // metoda urci, jakym smerem (viz nextJuncTurn) se auto vyda na prvni
            // krizovatce
            void figureOutFirstJuncTurn();

            // metoda, ktera ukonci aktualizovani auta, u Removera prihlasi toto auto
            void quitAfterError();

            // vrati pocet sekund, ktere ubehly od posledniho updatu
            float getTimeFromLastUpdate();

            // metoda nastavi blinkry pres jednotku CEU podle nextJuncTurn,
            // pokud jeste nejsou ve spravnem stavu
            // (jestlize auto zataci doleva, zapne se levy blinkr, pokud jeste neni zapnuty;
            // jestlize doprava, tak pravy blinkr (pokud neni zapnuty) a jestlize auto jede rovne,
            // vypnou se blikry (pokud jeste nejsou vypnute));
            // aktualni stav blinkru urcuje druhy parametr blinkLightState;
            // jestlize je parametr isEmergency true, nenastavuji se blinkry podle
            // nextJuncTurn, ale jestli jeste vsechny neblikaji, tak zacnou;
            void setBlinkers(Ability *const pCEU,const unsigned int blinkLightState,
                const bool isEmergency);
            
    };

    // tato metoda vypocita vzdalenost, po kterou musi auto brzdit, aby
    // se jeho aktualni rychlost snizila na pozadovanou rychlost
    // (jestlize je pozadovana rychlost vetsi nez aktualni, vrati se 0.0);
    // parametry:
    // carVel - aktualni rychlost auta
    // desiredVel - pozadovana rychlost
    // carDecel - zpomaleni, kterym bude auto brzdit
    // hillAcc - prirustek zrychleni diky naklonu vozovky
    // (pred krizovatkou budou zatim vsechna auta brzdit se zpomalenim AVERAGE_CAR_DEC;
    // maximalni zpomaleni bude vyuzito v budoucnu pri krizovych situacich)
    float getBrakeDist(const float carVel,const float desiredVel,
        const float carDecel,const float hillAcc);
}

#endif