Generator.cpp

gehe zur Dokumentation dieser Datei

#include "Generator.h"


Generator::Generator(){
        clear();
        spur_ = 0;
}


Generator::Generator( Spur* spur, long int id ){
        clear();
        spur_ = spur;
        idBenutzer_ = id;
}

void Generator::clear(){
        letzteErstellungszeit_ = 0;
        aktuelleAnzahlFahrzeuge_ = 0;
        anzahlFahrzeuge_ = 0;
        loescheMich_ = 0;
        zufallsFlag_ = 1;
        idBenutzer_ = 0;
        
        fahrzeugTyp_ = 2;
        fahrzeugBeschleunigungPositiv_ = 3;
        fahrzeugBeschleunigungNegativ_ = 7.5;
        fahrzeugLebensdauer_ = -1;
        fahrzeugLaenge_ = 3.5;
        fahrzeugHoechstgeschwindigkeit_ = 200;
        fahrzeugFahrtenbuch_ = 0;
        fahrzeugAnzahlWegpunkte_ = 0;
}

void Generator::takt(double zeitintervall){
        letzteErstellungszeit_ = letzteErstellungszeit_ + zeitintervall;
        if( letzteErstellungszeit_ < taktZeit_ ){
                // tue nichts .. nur die Zeit zaehlen
        }
        else{
                if( aktuelleAnzahlFahrzeuge_ >= anzahlFahrzeuge_ ){
                        loescheMich_ = 1;
                        return;
                }
                // erstelle ein Fahrzeug und setze díe Zeit auf 0
                if( zufallsFlag_ == 1 ){
                        zufall();
                }
                try{
                        erstelleFahrzeug();
                }
                catch( Fehler *fehler ){
                        throw( fehler );
                }
                letzteErstellungszeit_ = 0;
                aktuelleAnzahlFahrzeuge_ ++;
        }
}

void Generator::aufraeumen(){
}


int Generator::zufallszahl( int minimum, int maximum ){
        srand((unsigned)time(NULL));
        int zahl(0);

        if( minimum >= maximum ){
                Fehler *fehler = new Fehler("Parameter ausserhalb zulaessiger Grenzen.\nDer Zufallsgenerator kann nur mit einem Minimum kleiner als dem Maximum einen sinnvolen Wert ermitteln.");
                throw(fehler);
        }

        do{
                zahl = rand()%(maximum+1-minimum);
                zahl += minimum;
        }while( zahl < minimum || zahl > maximum );

        return zahl;
}

void Generator::wegpunktHinzufuegen( int richtung ){
        int *tmp(0);
        int i(0);
        // wenn es der erste Punkt ist
        if( fahrzeugFahrtenbuch_ == 0 ){
                fahrzeugFahrtenbuch_ = new int[1];
                fahrzeugFahrtenbuch_[0] = richtung;
                fahrzeugAnzahlWegpunkte_ = 1;
        }
        // sonst muessen die Wegpunkte neu sortiert werden
        else{
                tmp = fahrzeugFahrtenbuch_;
                fahrzeugFahrtenbuch_ = 0;
                // neues Array anlegen, welches um eine Einheit groesser ist
                fahrzeugFahrtenbuch_ = new int[(fahrzeugAnzahlWegpunkte_+1)];
                // die vorhandenen Eintraege hinueberkopieren
                for( i = 0; i < fahrzeugAnzahlWegpunkte_; i++ ){
                        fahrzeugFahrtenbuch_[i] = tmp[i];
                }
                // den neuen Eintrag hunzufuegen
                fahrzeugAnzahlWegpunkte_++;
                fahrzeugFahrtenbuch_[fahrzeugAnzahlWegpunkte_-1] = richtung;
                // das alte Fahrtenbuch loeschen
                delete tmp;
        }
}

void Generator::setzeAnzahlFahrzeuge(int anzahl){
        anzahlFahrzeuge_ = anzahl;
        aktuelleAnzahlFahrzeuge_ = 0;
}

void Generator::setzeFahrzeugeigenschaften(int typ, double beschleunigungPositiv, double beschleunigungNegativ, int lebensdauer, double laenge, Koordinaten farbe, double hoechstgeschwindigkeit ){
        if( typ < 1 || typ > 4 ){
                Fehler *fehler = new Fehler("Parameter ausserhalb zulaessiger Grenzen.\nDer Typ fuer Fahrzeuge in einem Generator entspricht nicht den geforderten Parametern.");
                throw(fehler);
        }
        fahrzeugTyp_ = typ;
        fahrzeugBeschleunigungPositiv_ = beschleunigungPositiv;
        fahrzeugBeschleunigungNegativ_ = beschleunigungNegativ;
        fahrzeugLebensdauer_ = lebensdauer;
        fahrzeugFarbe_ = farbe;
        fahrzeugLaenge_ = laenge;
        fahrzeugHoechstgeschwindigkeit_ = hoechstgeschwindigkeit;
        // Nun nicht mehr zufaellig waehlen, sondern die Voreinstellungen nutzen
        zufallsFlag_ = 0;
}

void Generator::setzeTaktZeit( double zeitintervall ){
        taktZeit_ = zeitintervall;
}

long int Generator::gibId(){
        return id_;
}


int Generator::gibAnzahlFahrzeuge(){
        return anzahlFahrzeuge_;
}

int Generator::gibAktuelleAnzahlFahrzeuge(){
        return aktuelleAnzahlFahrzeuge_;
}

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

void Generator::zufall(){
        int rgb(0), farbe(0);
        
        // Zu erst den Fahrzeugtyp ermitteln
        fahrzeugTyp_ = zufallszahl( 1, 4 );
        // Auf Basis des Types Vmax, a_pos, a_neg, laenge bestimmen
        switch( fahrzeugTyp_ ){
                case BIKE:{
                        fahrzeugHoechstgeschwindigkeit_ = zufallszahl( 200, 360 );
                        fahrzeugBeschleunigungPositiv_ = (double) zufallszahl( 70, 93 ) / 10;
                        fahrzeugBeschleunigungNegativ_ = (double) zufallszahl( 70, 100 ) / -10;
                        fahrzeugLaenge_ = (double) zufallszahl( 13, 25 ) / 10;
                        break;
                           }
                case PKW:{
                        fahrzeugHoechstgeschwindigkeit_ = zufallszahl( 170, 250 );
                        fahrzeugBeschleunigungPositiv_ = (double) zufallszahl( 19, 35 ) / 10;
                        fahrzeugBeschleunigungNegativ_ = (double) zufallszahl( 60, 75 ) / -10;
                        fahrzeugLaenge_ = (double) zufallszahl( 25, 50 ) / 10;
                        break;
                           }
                case LKW:{
                        fahrzeugHoechstgeschwindigkeit_ = zufallszahl( 70, 90 );
                        fahrzeugBeschleunigungPositiv_ = (double) zufallszahl( 13, 14 ) / 10;
                        fahrzeugBeschleunigungNegativ_ = (double) zufallszahl( 45, 55 ) / -10;
                        fahrzeugLaenge_ = (double) zufallszahl( 6, 12 );
                        break;
                           }
                case BUS:{
                        fahrzeugHoechstgeschwindigkeit_ = zufallszahl( 80, 130 );
                        fahrzeugBeschleunigungPositiv_ = (double) zufallszahl( 15, 16 ) / 10;
                        fahrzeugBeschleunigungNegativ_ = (double) zufallszahl( 45, 55 ) / -10;
                        fahrzeugLaenge_ = (double) zufallszahl( 6, 10 );
                        break;
                           }
        }
        // Die Farbe bestimmen
        rgb = zufallszahl( 0, 2 );
        if( rgb == 0 ){
                fahrzeugFarbe_.x = zufallszahl( 150, 255 );
                fahrzeugFarbe_.y = 0;
                fahrzeugFarbe_.z = 0;
        }
        else if( rgb == 1 ){
                fahrzeugFarbe_.x = 0;
                fahrzeugFarbe_.y = zufallszahl( 150, 255 );
                fahrzeugFarbe_.z = 0;
        }
        else{
                fahrzeugFarbe_.x = 0;
                fahrzeugFarbe_.y = 0;
                fahrzeugFarbe_.z = zufallszahl( 150, 255 );
        }

        fahrzeugLebensdauer_ = zufallszahl( -1, 1000 );
}

void Generator::erstelleFahrzeug(){
        Fahrzeug *fahrzeug;
        try{
                fahrzeug = new Fahrzeug( fahrzeugTyp_, fahrzeugLaenge_, fahrzeugFarbe_, 
                                                                        fahrzeugBeschleunigungPositiv_, fahrzeugBeschleunigungNegativ_, 
                                                                        fahrzeugHoechstgeschwindigkeit_, spur_, fahrzeugLebensdauer_ );
                if( fahrzeugFahrtenbuch_ != 0 ){
                        fahrzeug->setzeFahrtenbuch( fahrzeugFahrtenbuch_, fahrzeugAnzahlWegpunkte_ );
                }
                fahrzeugliste_->datenHinzufuegen( fahrzeug );
        }
        catch( Fehler *fehler ){
                throw( fehler );
        }
}

void Generator::setzeFahrzeugliste( Liste *fahrzeugliste ){
        fahrzeugliste_ = fahrzeugliste;
}


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

ostream &operator<< ( ostream &os, Generator *generator ){
        os << "----------Generator----------" << endl;
        os << "ID:                   " << generator->id_ << endl;
        os << "Erstellzeit:          " << generator->taktZeit_ << endl;
        os << "noch erstllende Fzg:  " << generator->anzahlFahrzeuge_ - generator->aktuelleAnzahlFahrzeuge_ << endl;
        
        return os;
}

void Generator::exportieren( string cvsDateiname ){
        // Datei oeffnen
        // Daten ausstreamen
        // Datei schliessen
}

---