Fahrzeug.cpp

gehe zur Dokumentation dieser Datei

#include <iostream>
#include <fstream>
#include <time.h> 
#include <stdlib.h>
using namespace std;

#include "Fahrzeug.h"
#include "Fehler.h"
#include "Konstanten.h"

Fahrzeug::Fahrzeug( ){
        clear();
}

Fahrzeug::Fahrzeug(     int typ, 
                                        double laenge, 
                                        Koordinaten farbe, 
                                        double beschleunigungPositiv, 
                                        double beschleunigungNegativ, 
                                        double hoechstgeschwindigkeit, 
                                        Spur *spur,
                                        double lebensdauer,
                                        long int id){
        clear();
        id_ = id;
        typ_ = typ;
        laenge_ = laenge;
        farbe_ = farbe;
        beschleunigungPositiv_ = beschleunigungPositiv;
        beschleunigungNegativ_ = beschleunigungNegativ;
        hoechstgeschwindigkeit_ = hoechstgeschwindigkeit;

        // Falls es eine Lebensdauer > 0 geben soll, muss 1 dazu addiert werden ... denn das 1.Aufsetzen auf die Spur zaehlt als Lebensdauer
        if( lebensdauer == -1 )
                lebensdauer_ = lebensdauer;
        else
                lebensdauer_ = lebensdauer + 1;

        try{
                wechselSpur( spur );
        }
        catch( Fehler *fehler ){
                throw(fehler);
        }
}


void Fahrzeug::aufraeumen(){
        try{
                if( aktuelleSpur_ != 0 ){
                        aktuelleSpur_->abmelden( this );
                        aktuelleSpur_ = 0;
                }
        }
        catch( Fehler *fehler ){
                throw( fehler );
        }
}

void Fahrzeug::takt( double zeitintervall ){
        try{
                fahren( zeitintervall );
        }
        catch( Fehler *fehler ){
                throw( fehler );
        }
}


void Fahrzeug::fahren( double zeitintervall ){
    double abstandVorgaenger(0), bremsweg(0), abstandEndeSpur(0), abstandHindernis(0);
        double temp(0), bremsIntensivitaet(0);
        int ueberAmpel(0);

        if( aktuelleSpur_ == 0 ){
                Fehler *fehler = new Fehler( "Ein Fahrzeug befindet sich nicht mehr auf einer Spur.");
                throw(fehler);
                return;
        }
        
        // errechne das neue Alter eines Fahrzeuges
        alter_ = alter_ + zeitintervall;

        // Zunaechst benoetigen wir den Bremsweg, den das Fahrzeug bei der aktuellen Geschwindigkeit braucht
        bremsweg = gibBremsweg();
        // Als erstes darauf pruefen, wie weit der Vorgaenger weg ist
        abstandVorgaenger = gibAbstandZumVordermann();
        // Wie lang ist noch die Spur
        abstandEndeSpur = gibAbstandZurKreuzung();

        // Dies kann passieren, wenn eine XML-Datei eingelesen wird und an einer Stelle mehrere Fahrzeuge erstellt werden
        // Ist der Abstand kleiner als -1, dann fahren die Fahrzeuge in falscher Reihenfolge
        // Durch eine Vollbremsung wird die Reihenfolge wieder hergestellt
        if( abstandVorgaenger < -1 ){
                beschleunigeNegativ(zeitintervall, 1);
                return;
        }

        // Wenn zischen dem Ende der Spur und dem Fahrzeug noch ein Vorgaenger fahert, dann ist dieser das Hinderniss.
        if( abstandEndeSpur > abstandVorgaenger && abstandVorgaenger != -1 ){
                abstandHindernis = abstandVorgaenger;
        }               // sonst
        else{   // ist das Ende der Spur das Hindernis falls die Ampel Rot ist
                if( aktuelleSpur_->istRot() && bremsweg <= abstandEndeSpur ){
                        abstandHindernis = abstandEndeSpur;
                }       // ist der Vorgaenger das Hindernis, wenn die Ampel Gruen ist oder eine Sackgasse ist
                else if( aktuelleSpur_->istGruen() || aktuelleSpur_->istSackgasse() ){
                        abstandHindernis = abstandVorgaenger;
                        ueberAmpel = 1;
                }       // ist der Vorgaenger das Hindernis, wenn die Ampel Gelb ist und der Bremsweg nicht reicht zum Anhalten
                else if( (aktuelleSpur_->istGelb() || aktuelleSpur_->istRot()) && bremsweg > abstandEndeSpur ){
                        abstandHindernis = abstandVorgaenger;
                        ueberAmpel = 1;
                }       // ist das End der Spur das Hindernis, wenn die Ampel Gelb ist und der Bremsweg zum Anhalten ausreicht
                else if( aktuelleSpur_->istGelb() && bremsweg <= abstandEndeSpur ){
                        abstandHindernis = abstandEndeSpur;
                }
        }

        // Bei freier Fahrt stelle den Abstand so ein, dass nie eine Bremsung eingeleitet wird
        if( abstandHindernis == -1)
                abstandHindernis = bremsweg*3 + 10;
        
        // Falls nun der Abstand zum Hinderniss kleiner ist als 0.5m (Sicherheitsabstand) + Bremsweg, leite eine Bremsung ein
        bremsIntensivitaet =  (bremsweg+0.5) / abstandHindernis;
        if( bremsIntensivitaet >= 0.5 ){
                beschleunigeNegativ(zeitintervall, bremsIntensivitaet);
        }
        else{           // Kann bei noch nicht erreichen der Hoechstgeschwindigkeit auf der Spur beschleunigt werden
                if( geschwindigkeit_ < aktuelleSpur_->gibMaximaleGeschwindigkeit() ){
                        beschleunigePositiv(zeitintervall);
                }               // Muss bei ueberschreiten der Hoechstgeschwindigkeit gebremst werden
                if( geschwindigkeit_ > aktuelleSpur_->gibMaximaleGeschwindigkeit() ){
                        beschleunigeNegativ(zeitintervall, 0.5);
                }               // Kann sich das Auto bei Erreichen der Hoechstgeschwindigkeit mit gleicher Geschwindigkeit fortbewegen
                if( geschwindigkeit_ == aktuelleSpur_->gibMaximaleGeschwindigkeit() ){
                        beschleunigeNicht(zeitintervall);
                }
        }

        if( aktuelleSpur_->istSackgasse() && gibAbstandZurKreuzung() < 1 ){
                        loescheMich_ = 1;
        }

        // Test, ob die aktuelle Spur noch aktuell ist
        if( (gibAbstandZurKreuzung() <= 0) && (ueberAmpel == 1) && ( !aktuelleSpur_->istSackgasse() ) ){
                temp = gibAbstandZurKreuzung() * -1;
                wechselSpur();
                aktuellePosition_ = temp;
        }
}


void Fahrzeug::setzeFahrtenbuch(int *fahrtenbuch, int anzahlWegpunkte){
        if( anzahlWegpunkte != 0 && fahrtenbuch == 0 ){
                Fehler *fehler = new Fehler("Parameterfehler: Es wurde einem Fahrzeug ein ungueltiges Fahrtenbuch uebergeben.");
                throw( fehler );
        }
        fahrtenbuch_ = fahrtenbuch;
        anzahlWegpunkte_ = anzahlWegpunkte;
}


double Fahrzeug::gibPosition( ){
        return aktuellePosition_;
}


Koordinaten Fahrzeug::gibFarbe( ){
        return farbe_;
}


double Fahrzeug::gibAbstandZumVordermann( ){
        double abstand(0);
        Fahrzeug* vorgaenger(0);
        vorgaenger = aktuelleSpur_->gibVorgaenger( this );
        // Wenn das aktuelle Fahrzeug das erste auf der Spur ist, dann hat es keinen Vorgaenger auf dieser Spur
        if( vorgaenger == 0 ){
                // Wenn nach der Spur eine weitere Befahren werden soll
                if( naechsteSpur_ != 0 ){
                        vorgaenger = naechsteSpur_->gibLetztes();
                        if( vorgaenger == 0 ){
                                if( naechsteSpur_->istRot() || naechsteSpur_->istGelb() ){
                                        // Falls auf der naechsten Spur Rot oder Gelb ist, muss vielleicht gebremst werden
                                        // Rechne den Rest der aktuellen Spur + die Laenge der kommenden Spur
                                        abstand = aktuelleSpur_->gibLaenge() + naechsteSpur_->gibLaenge() - this->gibPosition();
                                        // Ziehe noch die Laenge des aktuellen Fahrzeuges ab ... damit von der vorderen Stossstange gemessen wird
                                        abstand = abstand - laenge_;
                                        return abstand;
                                }
                                else
                                        return -1;
                        }
                        else{
                                // Rechne den Rest der aktuellen Spur + die bisherige Bewegung des Vorgaengers auf der naechsten Spur
                                abstand = aktuelleSpur_->gibLaenge() - this->gibPosition();
                                abstand = abstand + vorgaenger->gibPosition();
                                // Ziehe noch die Laenge des aktuellen Fahrzeuges ab ... damit von der vorderen Stossstange gemessen wird
                                abstand = abstand - laenge_;
                                return abstand;
                        }
                }
                else{
                        return -1;
                }
        }
        // Wenn auf der Spur vor dem Fahrzeug ein weiteres faehrt
        else{
                abstand = vorgaenger->gibPosition() - this->gibPosition() - laenge_;
                return abstand;
        }
        return abstand;
}


double Fahrzeug::gibAbstandZurKreuzung(){
        double abstand(0);
        abstand = aktuelleSpur_->gibLaenge() - aktuellePosition_ - laenge_;
        return abstand;
}


void Fahrzeug::beschleunigePositiv( double zeitintervall ){
        double wegstrecke(0);
        double vBegin(0);
        vBegin = geschwindigkeit_;
        geschwindigkeit_ = geschwindigkeit_ + ( beschleunigungPositiv_  * zeitintervall )  * 3.6;
                //         v =        v0        +           a             *       t 
                
        // Falls das Fahrzeug schneller als seine Hoechstgeschwindigkeit fahren soll, setze es auf die Hoechstgeschwindigkeit
        // Ausserdem kommt es dann zu einer gleichmaessigen Bewegung
        if( geschwindigkeit_ >= hoechstgeschwindigkeit_ ){
                geschwindigkeit_ = hoechstgeschwindigkeit_;
                wegstrecke = geschwindigkeit_ / 3.6   * zeitintervall;
                        //          s =        v          *      t
        }
        else{ // Eine beschleunigte Bewegung
                wegstrecke = ( beschleunigungPositiv_ / 2 )  * zeitintervall  * zeitintervall + ( vBegin / 3.6  * zeitintervall);
                //       s = (      a                 / 2 )  *              t^2  + v0  * t
        }
        aktuellePosition_ = wegstrecke + aktuellePosition_;
        // wegstrecke ist zur Zeit in m --> Umrechnung in km
        kilometerstand_ = (wegstrecke/1000) + kilometerstand_;
        bremst_ = -5;
}


void Fahrzeug::beschleunigeNicht( double zeitintervall ){
        double wegstrecke(0);
        wegstrecke = geschwindigkeit_ / 3.6  * zeitintervall;
        aktuellePosition_ = aktuellePosition_ + wegstrecke;
        kilometerstand_ = kilometerstand_ + (wegstrecke / 1000);
        bremst_ = 0;
}

void Fahrzeug::beschleunigeNegativ( double zeitintervall, double intensivitaet  ){
        if( intensivitaet < 0.5 || intensivitaet > 1 )
                return;

        double wegstrecke(0);
        double vBegin(0);
        vBegin = geschwindigkeit_;
        geschwindigkeit_ = geschwindigkeit_ + ( intensivitaet * beschleunigungNegativ_  * zeitintervall )  * 3.6;
                //         v =        v0        +           a             *       t 
                
        // Falls das Fahrzeug langsamer als 0km/h fahren soll, setze es auf 0km/h
        // Ausserdem kommt es dann zu keiner Bewegung mehr
        if( geschwindigkeit_ <= 0 ){
                geschwindigkeit_ = 0;
                wegstrecke = 0;
                        //          s =        0          *      t
        }
        else{ // Eine (negativ) beschleunigte Bewegung
                wegstrecke = ( intensivitaet * beschleunigungNegativ_ / 2 )  * zeitintervall  * zeitintervall + ( vBegin / 3.6  * zeitintervall);
                //       s = (      a                 / 2 )  *              t^2  + v0  * t
        }
        aktuellePosition_ = wegstrecke + aktuellePosition_;
        // wegstrecke ist zur Zeit in m --> Umrechnung in km
        kilometerstand_ = (wegstrecke/1000) + kilometerstand_;
        bremst_++;
}


void Fahrzeug::wechselSpur( Spur *spur ){
        srand((unsigned)time(NULL));
        int zufall(0);
        int richtung[3];
        int grenze[3][2];
        int neueSpur(-1);

        try{
                // Falls es eine aktuelle Spur gibt, melde dich ab
                if( aktuelleSpur_ != 0 ){
                        aktuelleSpur_->abmelden( this );
                        aktuelleSpur_ = 0;
                }

                // Wenn die Lebensdauer abgelaufen ist
                if( lebensdauer_ == 0 ){
                        naechsteRichtung_ = MITTE;
                        loescheMich_ = 1;
                        return;
                }
        }
        catch( Fehler *fehler ){
                throw( fehler );
        }

        // wechsel die Spur
        if( spur != 0 ){
                aktuelleSpur_ = spur;
        }
        else{
                aktuelleSpur_ = naechsteSpur_;
        }
        
        if( aktuelleSpur_ == 0 ){
                loescheMich_ = 1;
                return;
        }

        if( aktuelleSpur_->istSackgasse() ){
                naechsteSpur_ = 0;
                naechsteRichtung_ = MITTE;
                aktuelleSpur_->anmelden( this );
                lebensdauer_ = 0;
                // Den Zaehler fuer die Position auf der Spur auf 0 setzten
                aktuellePosition_ = 0;
                return;
        }

        richtung[0] = (int) (aktuelleSpur_->gibWahrscheinlichkeit(1) * 100);
        richtung[1] = (int) (aktuelleSpur_->gibWahrscheinlichkeit(2) * 100);
        richtung[2] = (int) (aktuelleSpur_->gibWahrscheinlichkeit(3) * 100);

        // schaue in das Fahrtenbuch, wenn eines da ist
        if( anzahlWegpunkte_ != 0 ){
                while( (neueSpur < 1 || neueSpur > 3) && anzahlWegpunkte_ != 0 ){
                        // wenn der letzte Wegpunkt angefahren wurde, naht das Lebensende
                        if( aktuellerWegpunkt_ > ( anzahlWegpunkte_ - 1 ) ){
                                anzahlWegpunkte_ = 0;
                                break;
                        }
                        // Wenn die naechste Richtung im Fahrtenbuch befahren werden darf.
                        // Waehle ihn aus und gehe zum naechsten
                        if( richtung[fahrtenbuch_[aktuellerWegpunkt_]] != 0 ){
                                neueSpur = fahrtenbuch_[aktuellerWegpunkt_];
                                aktuellerWegpunkt_++;
                        }
                        // sonst ignoriere ihn und gehe die Schleife nochmal durch
                        else{
                                aktuellerWegpunkt_++;
                                neueSpur = -1;
                        }
                }
        }

        // Wenn es kein Fahrtenbuch (mehr) gibt, entscheidet der Zufallsalgorithmus
        if( anzahlWegpunkte_ == 0 ){    
                while( neueSpur < 1 || neueSpur > 3 ){
                        grenze[0][0] = 0;
                        grenze[0][1] = richtung[0];
                        grenze[1][0] = richtung[0];
                        grenze[1][1] = grenze[1][0] + richtung[1];
                        grenze[2][0] = richtung[0] + richtung[1];
                        grenze[2][1] = grenze[2][0] + richtung[2];

                        zufall = rand()%100 + 1;                                        // Eine Zufallszahl erzeugen (zw 1-100)
                        
                        // Die Zufallszahl mit den Grenzen vergleichen
                        if( zufall > grenze[0][0] && zufall <= grenze[0][1] )
                                neueSpur = LINKS;
                        else if( zufall > grenze[1][0] && zufall <= grenze[1][1] )
                                neueSpur = MITTE;
                        else if( zufall > grenze[2][0] && zufall <= grenze[2][1] )
                                neueSpur = RECHTS;
                        else
                                neueSpur = -1;
                }
        }

        try{
                naechsteSpur_ = aktuelleSpur_->gibNaechsteSpur(neueSpur);
                naechsteRichtung_ = neueSpur;
        }
        catch( Fehler *fehler ){
                throw( fehler );
        }

        if( lebensdauer_ != -1 )
                lebensdauer_--;

        aktuelleSpur_->anmelden( this );
        // Den Zaehler fuer die Position auf der Spur auf 0 setzten
        aktuellePosition_ = 0;
}


double Fahrzeug::gibBremsweg( ){
        double bremsweg(0);
        bremsweg = ( (geschwindigkeit_ / 3.6)  * (geschwindigkeit_ / 3.6) ) / ( 2  * beschleunigungNegativ_ )  * -1;
        //   s   =                   v^2                   /   2  * a
        //  * -1, da beschleunigungNegativ_ als negativer Wert angegeben wird
        return bremsweg;
}


bool Fahrzeug::istBremsend(){
        if( bremst_ < 1 )
                return 0;
        else
                return 1;
}


bool Fahrzeug::sollEntferntWerden(){
        return loescheMich_;
}

double Fahrzeug::gibLaenge(){
        return laenge_;
}

Spur *Fahrzeug::gibSpur( ){
        return aktuelleSpur_;
}


int Fahrzeug::gibTyp (){
        return typ_;
}

/*
 * @fn          void Fahrzeug::inStream( )
 * @brief       Gibt das Fahrzeug auf der Konsole aus
 *
 * @author      Nico Schroeder
 */
void Fahrzeug::inString( ){
        cout << this;
}

/*
 * @fn          void Fahrzeug::gibNaechsteRichtung( )
 * @brief       Gibt die Naechste Abbiegerichtung des Fahrzeuges aus
 *
 * @author      Nico Schroeder
 *
 * @return      Die Richtung.
 */
int Fahrzeug::gibNaechsteRichtung(){
        return naechsteRichtung_;
}

ostream &operator<< ( ostream &os, Fahrzeug *fahrzeug ){
        os << "----------Fahrzeug----------" << endl;
        os << "ID:                   " << fahrzeug->id_ << endl;
        os << "Beschleunigung:       " << fahrzeug->beschleunigungPositiv_ << " m/s^2" << endl;
        os << "Bremsen:              " << fahrzeug->beschleunigungNegativ_ << " m/s^2" << endl;
        os << "max. Geschwindigkeit: " << fahrzeug->hoechstgeschwindigkeit_ << " km/h" << endl;
        os << "Typ:                  " << fahrzeug->typ_ << " ( 1 = Motorrad | 2 = Pkw | 3 = Lkw | 4 = Bus )" << endl;
        os << "Farbe:                " << fahrzeug->farbe_ << endl;
        os << "Laenge:               " << fahrzeug->laenge_ << " m" << endl;
        os << endl;
        os << "akt. Geschwindigkeit: " << fahrzeug->geschwindigkeit_ << " km/h" << endl;
        os << "Kilometerstand:       " << fahrzeug->kilometerstand_ << " km" << endl;
        os << "akt. Position:        " << fahrzeug->aktuellePosition_ << " m auf Spur ??" << endl;
        os << "akt. Bremsweg:        " << fahrzeug->gibBremsweg() << " m bis auf 0 km/h" << endl;
        if( fahrzeug->aktuelleSpur_ != 0 ){
                os << "Abstand. Vordermann:  " << fahrzeug->gibAbstandZumVordermann( ) << " m" << endl;
                os << "Abstand. Kreuzung:    " << fahrzeug->gibAbstandZurKreuzung( ) << " m" << endl;
        }
        os << "Lebensdauer:          " << fahrzeug->lebensdauer_ << endl;

        os << "aktuelle Spur:" << endl;
        if( fahrzeug->aktuelleSpur_ != 0 )
                os << fahrzeug->aktuelleSpur_ << endl;
        else
                os << "leer" << endl;
        
        os << "naechste Spur:" << endl;
        if( fahrzeug->naechsteSpur_ != 0 );
                // os << fahrzeug->naechsteSpur_ << endl;
        else
                os << "leer" << endl;
        return os;
}


void Fahrzeug::clear(){
        id_ = 0;
        typ_ = 2;
        beschleunigungPositiv_ = 2.3;
        beschleunigungNegativ_ = -11.0;
        aktuellePosition_ = 0;
        lebensdauer_ = -1;
        laenge_ = 4.5;
        farbe_ = Koordinaten(125,125,125);
        geschwindigkeit_ = 0;
        hoechstgeschwindigkeit_ = 250;
        kilometerstand_ = 0;
        aktuelleSpur_ = 0;
        naechsteSpur_ = 0;
        fahrtenbuch_ = 0;
        loescheMich_ = 0;
        bremst_ = 0;
        alter_ = 0;
        naechsteRichtung_ = 0;
        fahrtenbuch_ = 0;
        anzahlWegpunkte_ = 0;
        aktuellerWegpunkt_ = 0;
}

void Fahrzeug::exportieren( string cvsDateiname ){
        string dateiname = cvsDateiname;
        ofstream cvsDatei;
        // Datei oeffnen
        cvsDatei.open( dateiname.c_str(), ios::app );
        if( !cvsDatei ){
                Fehler *fehler = new Fehler( "Die CVS-Datei fuer Fahrzeuge konnte nicht geoeffnet werden.\n");
                fehler->ergaenzeMeldung( dateiname );
                throw(fehler);
                return;
        }

        // Daten ausstreamen
        // Fahrzeug-Id, Fahrzeug-Typ, Fahrzeug-Alter, Fahrzeug-Kilometerstand
        cvsDatei << "\"" << id_ << "\";\"" << typ_ << "\";\"" << alter_ << "\";\"" << kilometerstand_ << "\"" << endl;

        // Datei schliessen
        cvsDatei.close();
}

---