//---------------------------------------------------------------------------

#ifndef DriverH
#define DriverH

#include "Classes.h"
#include "dumb3d.h"
#include <fstream>
using namespace Math3D;

enum TOrders
{//rozkazy dla AI
 Wait_for_orders=0,       //czekanie na dostarczenie następnych rozkazów
 //operacje tymczasowe
 Prepare_engine=1,        //włączenie silnika
 Release_engine=2,        //wyłączenie silnika
 Change_direction=4,      //zmiana kierunku (bez skanowania sygnalizacji)
 Connect=8,               //podłączanie wagonów (z częściowym skanowaniem sygnalizacji)
 Disconnect=0x10,         //odłączanie wagonów (bez skanowania sygnalizacji)
 //jazda
 Shunt=0x20,              //tryb manewrowy
 Obey_train=0x40,         //tryb pociągowy
 Jump_to_first_order=0x60 //zapęlenie do pierwszej pozycji (po co?)
};

enum TMovementStatus
{//flagi bitowe ruchu (iDrivigFlags)
 moveStopCloser=1, //podjechać blisko W4 (nie podjeżdżać na początku ani po zmianie czoła)
 moveStopPoint=2, //stawać na W4 (wyłączone podczas zmiany czoła)
 moveActive=4, //pojazd jest załączony i skanuje
 movePress=8, //dociskanie przy odłączeniu (zamiast zmiennej Prepare2press)
 moveConnect=0x10, //jest blisko innego pojazdu i można próbować podłączyć
 movePrimary=0x20, //ma priorytet w składzie (master)
 moveLate=0x40, //flaga spóźnienia, włączy bardziej
 moveStopHere=0x80, //nie podjeżdżać do semafora, jeśli droga nie jest wolna
 moveStartHorn=0x100, //podawaj sygnał po podaniu wolnej drogi
 moveStartHornNow=0x200, //podaj sygnał po odhamowaniu
 moveStartHornDone=0x400, //podano sygnał po podaniu wolnej drogi
 moveOerlikons=0x800, //skład wyłącznie z zaworami? Oerlikona
 moveIncSpeed=0x1000, //załączenie jazdy (np. dla EZT)
 moveTrackEnd=0x2000, //dalsza jazda do przodu trwale ograniczona (W5, koniec toru)
 moveSwitchFound=0x4000, //na drodze skanowania do przodu jest rozjazd
 moveGuardSignal=0x8000, //sygnał od kierownika (minął czas postoju)
 moveVisibility=0x10000, //jazda na widoczność po przejechaniu S1 na SBL
 moveDoorOpened=0x20000, //drzwi zostały otwarte - doliczyć czas na zamknięcie
 movePushPull=0x40000 //zmiana czoła przez zmianę kabiny - nie odczepiać przy zmianie kierunku
};

enum TStopReason
{//powód zatrzymania, dodawany do SetVelocity 0 - w zasadzie do usunięcia
 stopNone,  //nie ma powodu - powinien jechać
 stopSleep, //nie został odpalony, to nie pojedzie
 stopSem,   //semafor zamknięty
 stopTime,  //czekanie na godzinę odjazdu
 stopEnd,   //brak dalszej części toru
 stopDir,   //trzeba stanąć, by zmienić kierunek jazdy
 stopJoin,  //stoi w celu połączenia wagonów
 stopBlock, //przeszkoda na drodze ruchu
 stopComm,  //otrzymano taką komendę (niewiadomego pochodzenia)
 stopOut,   //komenda wyjazdu poza stację (raczej nie powinna zatrzymywać!)
 stopRadio, //komunikat przekazany radiem (Radiostop)
 stopExt,   //komenda z zewnątrz
 stopError  //z powodu błędu w obliczeniu drogi hamowania
};

enum TAction
{//przechowanie aktualnego stanu AI od poprzedniego przebłysku świadomości
 actUnknown,   //stan nieznany (domyślny na początku)
 actPantUp,    //podnieś pantograf (info dla użytkownika)
 actConv,      //załącz przetwornicę (info dla użytkownika)
 actCompr,     //załącz sprężarkę (info dla użytkownika)
 actSleep,     //śpi (wygaszony)
 actDrive,     //jazda
 actGo,        //ruszanie z miejsca
 actSlow,      //przyhamowanie przed ograniczeniem
 sctStop,      //hamowanie w celu precyzyjnego zatrzymania
 actIdle,      //luzowanie składu przed odjazdem
 actRelease,   //luzowanie składu po zmniejszeniu prędkości
 actConnect,   //dojazd w celu podczepienia
 actWait,      //czekanie na przystanku
 actReady,     //zgłoszona gotowość do odjazdu od kierownika
 actEmergency, //hamowanie awaryjne
 actGoUphill,  //ruszanie pod górę
 actTest,      //hamowanie kontrolne (podczas jazdy)
 actTrial      //próba hamulca (na postoju)
};

class TSpeedPos
{//pozycja tabeli prędkości dla AI
public:
 double fDist; //aktualna odległość (ujemna gdy minięte)
 double fVelNext; //prędkość obowiązująca od tego miejsca
 //double fAcc;
 int iFlags;
 //1=istotny,2=tor,4=odwrotnie,8-zwrotnica (może się zmienić),16-stan zwrotnicy,32-minięty,64=koniec,128=łuk
 //0x100=event,0x200=manewrowa,0x400=przystanek,0x800=SBL,0x1000=wysłana komenda,0x2000=W5
 //0x10000=zatkanie 
 vector3 vPos; //współrzędne XYZ do liczenia odległości
 struct
 {
  TTrack *trTrack; //wskaźnik na tor o zmiennej prędkości (zwrotnica, obrotnica)
  TEvent *evEvent; //połączenie z eventem albo komórką pamięci
 };
 void __fastcall CommandCheck();
public:
 void __fastcall Clear();
 bool __fastcall Update(vector3 *p,vector3 *dir,double &len);
 bool __fastcall Set(TEvent *e,double d);
 void __fastcall Set(TTrack *t,double d,int f);
 AnsiString __fastcall TableText();
};

//----------------------------------------------------------------------------
static const bool Aggressive=true;
static const bool Easyman=false;
static const bool AIdriver=true;
static const bool Humandriver=false;
static const int maxorders=32; //ilość rozkazów w tabelce
static const int maxdriverfails=4; //ile błędów może zrobić AI zanim zmieni nastawienie
extern bool WriteLogFlag; //logowanie parametrów fizycznych
//----------------------------------------------------------------------------

class TController
{
private: //obsługa tabelki prędkości (musi mieć możliwość odhaczania stacji w rozkładzie)
 TSpeedPos *sSpeedTable; //najbliższe zmiany prędkości
 int iSpeedTableSize; //wielkość tabelki
 int iFirst; //aktualna pozycja w tabeli (modulo iSpeedTableSize)
 int iLast; //ostatnia wypełniona pozycja w tabeli <iFirst (modulo iSpeedTableSize)
 int iTableDirection; //kierunek zapełnienia tabelki względem pojazdu z AI
 double fLastVel; //prędkość na poprzednio sprawdzonym torze
 TTrack *tLast; //ostatni analizowany tor
 TEvent *eSignSkip; //można pominąć ten SBL po zatrzymaniu
private: //parametry aktualnego składu
 double fLength; //długość składu (do wyciągania z ograniczeń)
 double fMass; //całkowita masa do liczenia stycznej składowej grawitacji
 double fAccGravity; //przyspieszenie składowej stycznej grawitacji
public:
 TEvent *eSignNext; //sygnał zmieniający prędkość, do pokazania na [F2]
 AnsiString asNextStop; //nazwa następnego punktu zatrzymania wg rozkładu
 int iStationStart; //numer pierwszej stacji pokazywanej na podglądzie rozkładu
private: //parametry sterowania pojazdem (stan, hamowanie)
 double fShuntVelocity; //maksymalna prędkość manewrowania, zależy m.in. od składu
 int iVehicles; //ilość pojazdów w składzie
 int iEngineActive; //ABu: Czy silnik byl juz zalaczony; Ra: postęp w załączaniu
 //vector3 vMechLoc; //pozycja pojazdu do liczenia odległości od semafora (?)
 bool Psyche;
 int iDrivigFlags; //flagi bitowe ruchu
 double fDriverBraking; //po pomnożeniu przez v^2 [km/h] daje ~drogę hamowania [m]
 double fDriverDist; //dopuszczalna odległość podjechania do przeszkody
 double fVelMax; //maksymalna prędkość składu (sprawdzany każdy pojazd)
 double fBrakeDist; //przybliżona droga hamowania
 double fAccThreshold; //próg opóźnienia dla zadziałania hamulca
public:
 double fLastStopExpDist; //odległość wygasania ostateniego przystanku
 double ReactionTime; //czas reakcji Ra: czego i na co? świadomości AI
 double fBrakeTime;  //wpisana wartość jest zmniejszana do 0, gdy ujemna należy zmienić nastawę hamulca
private:
 double fReady; //poziom odhamowania wagonów
 bool Ready; //ABu: stan gotowosci do odjazdu - sprawdzenie odhamowania wagonow
 double LastUpdatedTime; //czas od ostatniego logu
 double ElapsedTime; //czas od poczatku logu
 double deltalog; //przyrost czasu
 double LastReactionTime;
 double fActionTime; //czas używany przy regulacji prędkości i zamykaniu drzwi
 TAction eAction; //aktualny stan
 bool HelpMeFlag; //wystawiane True jesli cos niedobrego sie dzieje
public:
 bool AIControllFlag; //rzeczywisty/wirtualny maszynista
 int iRouteWanted; //oczekiwany kierunek jazdy (0-stop,1-lewo,2-prawo,3-prosto) np. odpala migacz lub czeka na stan zwrotnicy
private:
 TDynamicObject *pVehicle; //pojazd w którym siedzi sterujący
 TDynamicObject *pVehicles[2]; //skrajne pojazdy w składzie (niekoniecznie bezpośrednio sterowane)
 TMoverParameters *mvControlling; //jakim pojazdem steruje (może silnikowym w EZT)
 TMoverParameters *mvOccupied; //jakim pojazdem hamuje
 Mtable::TTrainParameters *TrainParams; //rozkład jazdy zawsze jest, nawet jeśli pusty
 //int TrainNumber; //numer rozkladowy tego pociagu
 //AnsiString OrderCommand; //komenda pobierana z pojazdu
 //double OrderValue; //argument komendy
 int iRadioChannel; //numer aktualnego kanału radiowego
 TTextSound *tsGuardSignal; //komunikat od kierownika
 int iGuardRadio; //numer kanału radiowego kierownika (0, gdy nie używa radia)
public:
 double AccPreferred; //preferowane przyspieszenie (wg psychiki kierującego, zmniejszana przy wykryciu kolizji)
 double AccDesired; //przyspieszenie, jakie ma utrzymywać (<0:nie przyspieszaj,<-0.1:hamuj)
 double VelDesired; //predkość, z jaką ma jechać, wynikająca z analizy tableki; <=VelSignal
 double fAccDesiredAv; //uśrednione przyspieszenie z kolejnych przebłysków świadomości, żeby ograniczyć migotanie
private:
 double VelforDriver; //prędkość, używana przy zmianie kierunku (ograniczenie przy nieznajmości szlaku?)
 double VelSignal; //predkość zadawana przez semafor (funkcją SetVelocity())
 double VelLimit; //predkość zadawana przez event jednokierunkowego ograniczenia prędkości (PutValues albo komendą)
public:
 double VelNext; //prędkość, jaka ma być po przejechaniu długości ProximityDist
private:
 //double fProximityDist; //odleglosc podawana w SetProximityVelocity(); >0:przeliczać do punktu, <0:podana wartość
public:
 double ActualProximityDist; //odległość brana pod uwagę przy wyliczaniu prędkości i przyspieszenia
private:
 vector3 vCommandLocation; //polozenie wskaznika, sygnalizatora lub innego obiektu do ktorego odnosi sie komenda
 TOrders OrderList[maxorders]; //lista rozkazów
 int OrderPos,OrderTop; //rozkaz aktualny oraz wolne miejsce do wstawiania nowych
 std::ofstream LogFile; //zapis parametrow fizycznych
 std::ofstream AILogFile; //log AI
 bool MaxVelFlag;
 bool MinVelFlag;
 int iDirection; //kierunek jazdy względem sprzęgów pojazdu, w którym siedzi AI (1=przód,-1=tył)
 int iDirectionOrder; //żadany kierunek jazdy (służy do zmiany kierunku)
 int iVehicleCount; //ilość pojazdów do odłączenia albo zabrania ze składu (-1=wszystkie)
 int iCoupler; //maska sprzęgu, jaką należy użyć przy łączeniu (po osiągnięciu trybu Connect), 0 gdy jazda bez łączenia
 int iDriverFailCount; //licznik błędów AI
 bool Need_TryAgain; //true, jeśli druga pozycja w elektryku nie załapała
 bool Need_BrakeRelease;
public:
 double fMinProximityDist; //minimalna oległość do przeszkody, jaką należy zachować
 double fOverhead1;  //informacja o napięciu w sieci trakcyjnej (0=brak drutu, zatrzymaj!)
 double fOverhead2;  //informacja o sposobie jazdy (-1=normalnie, 0=bez prądu, >0=z opuszczonym i ograniczeniem prędkości)
 int iOverheadZero;  //suma bitowa jezdy bezprądowej, bity ustawiane przez pojazdy z podniesionymi pantografami
 int iOverheadDown;  //suma bitowa opuszczenia pantografów, bity ustawiane przez pojazdy z podniesionymi pantografami
 double fVoltage; //uśrednione napięcie sieci: przy spadku poniżej wartości minimalnej opóźnić rozruch o losowy czas
private:
 double fMaxProximityDist; //akceptowalna odległość stanięcia przed przeszkodą
 TStopReason eStopReason; //powód zatrzymania przy ustawieniu zerowej prędkości
 AnsiString VehicleName;
 double fVelPlus; //dopuszczalne przekroczenie prędkości na ograniczeniu bez hamowania
 double fVelMinus; //margines obniżenia prędkości, powodujący załączenie napędu
 double fWarningDuration; //ile czasu jeszcze trąbić
 double fStopTime; //czas postoju przed dalszą jazdą (np. na przystanku)
 double WaitingTime; //zliczany czas oczekiwania do samoistnego ruszenia
 double WaitingExpireTime; //maksymlany czas oczekiwania do samoistnego ruszenia
 //TEvent* eSignLast; //ostatnio znaleziony sygnał, o ile nie minięty
private: //---//---//---//---// koniec zmiennych, poniżej metody //---//---//---//---//
 void __fastcall SetDriverPsyche();
 bool __fastcall PrepareEngine();
 bool __fastcall ReleaseEngine();
 bool __fastcall IncBrake();
 bool __fastcall DecBrake();
 bool __fastcall IncSpeed();
 bool __fastcall DecSpeed(bool force=false);
 void __fastcall SpeedSet();
 void __fastcall Doors(bool what);
 void __fastcall RecognizeCommand(); //odczytuje komende przekazana lokomotywie
 void __fastcall Activation(); //umieszczenie obsady w odpowiednim członie
 void __fastcall ControllingSet(); //znajduje człon do sterowania
 void __fastcall AutoRewident(); //ustawia hamulce w składzie
public:
 Mtable::TTrainParameters* __fastcall Timetable() {return TrainParams;};
 void __fastcall PutCommand(AnsiString NewCommand,double NewValue1,double NewValue2,const _mover::TLocation &NewLocation,TStopReason reason=stopComm);
 bool __fastcall PutCommand(AnsiString NewCommand,double NewValue1,double NewValue2,const vector3 *NewLocation,TStopReason reason=stopComm);
 bool __fastcall UpdateSituation(double dt); //uruchamiac przynajmniej raz na sekundę
 //procedury dotyczace rozkazow dla maszynisty
 void __fastcall SetVelocity(double NewVel,double NewVelNext,TStopReason r=stopNone); //uaktualnia informacje o prędkości
 bool __fastcall SetProximityVelocity(double NewDist,double NewVelNext); //uaktualnia informacje o prędkości przy nastepnym semaforze
public:
 void __fastcall JumpToNextOrder();
 void __fastcall JumpToFirstOrder();
 void __fastcall OrderPush(TOrders NewOrder);
 void __fastcall OrderNext(TOrders NewOrder);
 TOrders __fastcall OrderCurrentGet();
 TOrders __fastcall OrderNextGet();
 bool __fastcall CheckVehicles(TOrders user=Wait_for_orders);
private:
 void __fastcall CloseLog();
 void __fastcall OrderCheck();
public:
 void __fastcall OrdersInit(double fVel);
 void __fastcall OrdersClear();
 void __fastcall OrdersDump();
 __fastcall TController
 (bool AI,
  TDynamicObject *NewControll,
  bool InitPsyche,
  bool primary=true //czy ma aktywnie prowadzić?
 );
 AnsiString __fastcall OrderCurrent();
 void __fastcall WaitingSet(double Seconds);
private:
 AnsiString __fastcall Order2Str(TOrders Order);
 void __fastcall DirectionForward(bool forward);
 int __fastcall OrderDirectionChange(int newdir,TMoverParameters *Vehicle);
 void __fastcall Lights(int head,int rear);
 double __fastcall Distance(vector3 &p1,vector3 &n,vector3 &p2);
private: //Ra: metody obsługujące skanowanie toru
 TEvent* __fastcall CheckTrackEvent(double fDirection,TTrack *Track);
 bool __fastcall TableCheckEvent(TEvent *e);
 bool __fastcall TableAddNew();
 bool __fastcall TableNotFound(TEvent *e);
 void __fastcall TableClear();
 TEvent* __fastcall TableCheckTrackEvent(double fDirection,TTrack *Track);
 void __fastcall TableTraceRoute(double fDistance,TDynamicObject *pVehicle=NULL);
 void __fastcall TableCheck(double fDistance);
 TCommandType __fastcall TableUpdate(double &fVelDes,double &fDist,double &fNext,double &fAcc);
 void __fastcall TablePurger();
private: //Ra: stare funkcje skanujące, używane do szukania sygnalizatora z tyłu
 bool __fastcall BackwardTrackBusy(TTrack *Track);
 TEvent* __fastcall CheckTrackEventBackward(double fDirection,TTrack *Track);
 TTrack* __fastcall BackwardTraceRoute(double &fDistance,double &fDirection,TTrack *Track,TEvent*&Event);
 void __fastcall SetProximityVelocity(double dist,double vel,const vector3 *pos);
 TCommandType __fastcall BackwardScan();
public:
 void __fastcall PhysicsLog();
 AnsiString __fastcall StopReasonText();
 __fastcall ~TController();
 AnsiString __fastcall NextStop();
 void __fastcall TakeControl(bool yes);
 AnsiString __fastcall Relation();
 AnsiString __fastcall TrainName();
 int __fastcall StationCount();
 int __fastcall StationIndex();
 bool __fastcall IsStop();
 bool __fastcall Primary() {return this?bool(iDrivigFlags&movePrimary):false;};
 int inline __fastcall DrivigFlags() {return iDrivigFlags;};
 void __fastcall MoveTo(TDynamicObject *to);
 void __fastcall DirectionInitial();
 AnsiString __fastcall TableText(int i);
 int __fastcall CrossRoute(TTrack *tr);
 void __fastcall RouteSwitch(int d);
 AnsiString __fastcall OwnerName();
};

#endif