Set dp branch as trunk

Driver.h

@@ -0,0 +1,320 @@
+//---------------------------------------------------------------------------
+
+#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