unit mover; {fizyka ruchu dla symulatora lokomotywy} (* (C) McZapkie v.2002.11b Co brakuje: 3. Nie przetestowany hamulec elektrodynamiczny w roznych konfiguracjach 6. brak pantografow itp 7. brak efektu grzania oporow rozruchowych, silnika, osi 9. ulepszyc sprzeg sztywny oraz automatyczny 10. klopoty z EN57 ... n. Inne lokomotywy oprocz elektrowozu pradu stalego *) (* Zrobione: 1. model szeregowego silnika elektrycznego sterowanego reostatem 2. fizyka ruchu - sily oporu, nachylenia, przyspieszenia styczne i normalne, przyczepnosc/poslizg przy hamowaniu i rozruchu 3. docisk klockow hamulcowych -hamulec reczny oraz pomocniczy hamulec pneumatyczny 4. ubytki cisnienia wskutek hamowania, kompresor - ladowanie zbiornika 5. niektore uszkodzenia i awarie - logika rozmyta a) silnik elektryczny - za duzy prad, napiecie, obroty b) sprzegi - zerwanie gdy zbyt duze sily 6. flagi niektorych dzwiekow 7. hamulec zasadniczy - elektropneumatyczny (impulsowanie), pneumatyczny - zmiany cisnienia zwiekszenie nacisku przy duzych predkosciach w hamulcach Oerlikona 8. sprzegi - sila, tlumiennosc 9. lok. el. - wylacznik glowny, odlacznik uszkodzonych silnikow 10. parametry trakcji 11. opoznienia w zalaczaniu stycznikow 12. trakcja wielokrotna 13. informacja na temat zrodla mocy dla silnikow trakcyjnych, ogrzewania, oswietlenia 14. dumb - uproszczony model lokomotywy (tylko dla AI) 15. ladunki - ilosc, typ, szybkosc na- i rozladunku, funkcje przetestowac! 16. ulepszony model fizyczny silnika elektrycznego (hamowanie silnikiem, ujemne napiecia) 17. poprawione hamulce - parametry cylindrow itp 18. ulepszone hamulce - napelnianie uderzeniowe, stopnie hamowania 19. poprawione hamulce - wyszczegolnenie cisnienia dla stopni hamowania 20. poprawione hamulce elektropneumatyczne 21. poprawione hamowanie przeciwposlizgowe i odluzniacz 22. dodany model mechanicznego napedu recznego (drezyna) 23. poprawiona szybkosc hamowania pomocniczego i przeciwposlizgowego, odlaczanie silnikow, odlaczanie bocznikow 24. wprowadzone systemy zabezpieczenia: SHP, Czuwak, sygnalizacja kabinowa (nie dzialaja w DebugMode). 25. poprawiona predkosc propagacji fali cisnienia (normalizacja przez kwadrat dlugosci) 26. uwzgledniona masa ladunku, przesuniecie w/m toru ruchu ... *) interface uses mctools; CONST Go=True; Hold=False; {dla CheckLocomotiveParameters} ResArraySize=64; {dla silnikow elektrycznych} MotorParametersArraySize=8; maxcc=4; {max. ilosc odbierakow pradu} LocalBrakePosNo=10; {ilosc nastaw hamulca recznego lub pomocniczego} MainBrakeMaxPos=10; {max. ilosc nastaw hamulca zasadniczego} {uszkodzenia toru} dtrack_railwear=2; dtrack_freerail=4; dtrack_thinrail=8; dtrack_railbend=16; dtrack_plants=32; dtrack_nomove=64; dtrack_norail=128; {uszkodzenia taboru} dtrain_thinwheel=1; {dla lokomotyw} dtrain_loadshift=1; {dla wagonow} dtrain_wheelwear=2; dtrain_bearing=4; dtrain_coupling=8; dtrain_ventilator=16; {dla lokomotywy el.} dtrain_loaddamage=16; {dla wagonow} dtrain_engine=32; {dla lokomotyw} dtrain_loaddestroyed=32;{dla wagonow} dtrain_axle=64; dtrain_out=128; {wykolejenie} {wagi prawdopodobienstwa dla funkcji FuzzyLogic} p_elengproblem = 0.01; p_elengdamage = 0.1; p_coupldmg = 1.0; p_derail=0.001; {typ sprzegu} ctrain_virtual=0; ctrain_coupler=1; {sprzeg fizyczny} ctrain_pneumatic=2; {przewody hamulcowe} ctrain_controll=4; {przewody sterujace} ctrain_power=8; {przewody zasilajace} ctrain_passenger=16; {mostek przejsciowy} {typ hamulca elektrodynamicznego} dbrake_none=0; dbrake_passive=1; dbrake_switch=2; dbrake_reversal=4; dbrake_automatic=8; {status hamulca} b_off=0; b_on=1; b_dmg=2; b_release=4; b_antislip=8; {status czuwaka/SHP} s_waiting=1; s_aware=2; s_active=4; s_alarm=8; s_ebrake=16; {dzwieki} sound_none=0; sound_loud=1; sound_couplerstretch=2; sound_bufferclamp=4; sound_bufferbump=8; sound_relay=16; TYPE PMoverParameters=^TMoverParameters; {ogolne} TLocation = record X,Y,Z: real; {lokacja} end; TRotation = record Rx,Ry,Rz: real; {rotacja} end; TDimension= record W,L,H: real; {wymiary} end; TCommand = record Command: string; {komenda} Value1,Value2: real; {argumenty komendy} Location: TLocation; end; {tory} TTrackShape= record {ksztalt odcinka - promien, dlugosc, nachylenie, przechylka} R, Len, dHtrack, dHrail: real; end; TTrackParam= record {parametry odcinka - szerokosc, tarcie statyczne, kategoria, obciazalnosc w t/os, uszkodzenia} Width, friction: real; CategoryFlag, QualityFlag, DamageFlag: byte; Velmax:real; {dla uzytku maszynisty w ai_driver} end; TTractionParam= record TractionVoltage: real; {napiecie} TractionFreq: real; {czestotliwosc} HoverTrack: real; {wysokosc przewodu nad glowka szyny} dW: real; {przesuniecie przewodu w/m osi toru} end; {powyzsze parametry zwiazane sa z torem po ktorym aktualnie pojazd jedzie} {sprzegi} TCouplerType=(NoCoupler,Articulated,Bare,Chain,Screw,Automatic); TCoupling = record {parametry} SpringKB,SpringKC,beta:real; {stala sprezystosci zderzaka/sprzegu, %tlumiennosci } DmaxB,FmaxB,DmaxC,FmaxC: real; {tolerancja scisku/rozciagania, sila rozerwania} CouplerType: TCouplerType; {typ sprzegu} {zmienne} CouplingFlag : byte; {0 - wirtualnie, 1 - sprzegi, 2 - pneumatycznie, 4 - sterowanie, 8 - kabel mocy} Connected: PMoverParameters; {co jest podlaczone} CForce: real; {sila z jaka dzialal} Dist: real; {strzalka ugiecia} CheckCollision: boolean; {czy sprawdzac sile czy pedy} end; TCouplers= array[0..1] of TCoupling; {typy hamulcow zespolonych} TBrakeSystem = (Individual, Pneumatic, ElectroPneumatic); {podtypy hamulcow zespolonych} TBrakeSubsystem = (Standard, WeLu, Knorr, Oerlikon); {typy hamulcow indywidualnych} TLocalBrake = (NoBrake, ManualBrake, PneumaticBrake, HydraulicBrake); TBrakeDelayTable= array[1..4] of real; {dla osob/towar: opoznienie hamowania/odhamowania} TBrakePressure= record PipePressureVal: real; BrakePressureVal: real; FlowSpeedVal: real; BrakeType: TBrakeSystem; end; TBrakePressureTable= array[-1..MainBrakeMaxPos] of TBrakePressure; {typy napedow} TEngineTypes = (None, Dumb, WheelsDriven, ElectricSeriesMotor, DieselEngine, SteamEngine); {postac dostarczanej energii} TPowerType = (NoPower, BioPower, MechPower, ElectricPower, SteamPower); {rodzaj paliwa} TFuelType = (Undefined, Coal, Oil); {rodzaj rusztu} TGrateType = record FuelType: TFuelType; GrateSurface: real; FuelTransportSpeed: real; IgnitionTemperature: real; MaxTemperature: real; end; {rodzaj kotla} TBoilerType = record BoilerVolume: real; BoilerHeatSurface: real; SuperHeaterSurface: real; MaxWaterVolume,MinWaterVolume: real; MaxPressure: real; end; {rodzaj odbieraka pradu} TCurrentCollector = record MinH,MaxH: real; CSW: real; {szerokosc slizgacza} end; {typy zrodel mocy} TPowerSource = (NotDefined, InternalSource, Transducer, Generator, Accumulator, CurrentCollector, PowerCable, Heater); {parametry zrodel mocy} TPowerParameters = record MaxVoltage: real; MaxCurrent: real; IntR: real; case SourceType: TPowerSource of NotDefined,InternalSource : (PowerType: TPowerType); Transducer : (InputVoltage: real); Generator : (GeneratorEngine: TEngineTypes); Accumulator: (MaxCapacity: real; RechargeSource:TPowerSource); CurrentCollector: (CollectorsNo: byte; CollectorParameters: TCurrentCollector); PowerCable : (PowerTrans:TPowerType; SteamPressure: real); Heater : (Grate: TGrateType; Boiler: TBoilerType); end; {dla lokomotyw elektrycznych:} TScheme= record Relay: byte; {numer pozycji rozruchu samoczynnego} R: real; {opornik rozruchowy} Bn,Mn:byte; {ilosc galezi i silnikow w galezi} AutoSwitch: boolean; {czy dana pozycja nastawniana jest recznie czy autom.} end; TSchemeTable = array[0..ResArraySize] of TScheme; {tablica rezystorow rozr.} TMotorParameters = record mfi,mIsat:real; { aproksymacja M(I) silnika} fi,Isat: real; { aproksymacja E(n)=fi*n} AutoSwitch: boolean; end; TSecuritySystem= record SystemType: byte; {0: brak, 1: czuwak aktywny, 2: SHP/sygnalizacja kabinowa} AwareDelay,SoundSignalDelay,EmergencyBrakeDelay:real; Status: byte; {0: wylaczony, 1: wlaczony, 2: czuwak, 4: shp, 8: alarm, 16: hamowanie awaryjne} SystemTimer, SystemSoundTimer, SystemBrakeTimer: real; VelocityAllowed, NextVelocityAllowed: integer; {predkosc pokazywana przez sygnalizacje kabinowa} end; {----------------------------------------------} {glowny obiekt} TMoverParameters = class(TObject) filename:string; {---opis lokomotywy, wagonu itp} {--opis serii--} CategoryFlag: byte; {1 - pociag, 2 - samochod, 4 - statek, 8 - samolot} {--sekcja stalych typowych parametrow} TypeName: string; {nazwa serii/typu} EngineType: TEngineTypes; {typ napedu} EnginePowerSource: TPowerParameters; {zrodlo mocy dla silnikow} SystemPowerSource: TPowerParameters; {zrodlo mocy dla systemow sterowania/przetwornic/sprezarek} HeatingPowerSource: TPowerParameters; {zrodlo mocy dla ogrzewania} AlterHeatPowerSource: TPowerParameters; {alternatywne zrodlo mocy dla ogrzewania} LightPowerSource: TPowerParameters; {zrodlo mocy dla oswietlenia} AlterLightPowerSource: TPowerParameters;{alternatywne mocy dla oswietlenia} Vmax,Mass,Power: real; {max. predkosc kontrukcyjna, masa wlasna, moc} HeatingPower, LightPower: real; {moc pobierana na ogrzewanie/oswietlenie} Dim: TDimension; {wymiary} Cx: real; {wsp. op. aerodyn.} WheelDiameter : real; {srednica kol napednych} TrackW: real; {nominalna szerokosc toru [m]} AxleInertialMoment: real; {moment bezwladnosci zestawu kolowego} AxleArangement : string; {uklad osi np. Bo'Bo' albo 1'C} NPoweredAxles : byte; {ilosc osi napednych liczona z powyzszego} NAxles : byte; {ilosc wszystkich osi j.w.} BearingType: byte; {lozyska: 0 - slizgowe, 1 - toczne} ADist, BDist: real; {odlegosc osi oraz czopow skretu} {hamulce:} NBpA : byte; {ilosc el. ciernych na os: 0 1 2 lub 4} SandCapacity: integer; {zasobnik piasku [kg]} BrakeSystem: TBrakeSystem;{rodzaj hamulca zespolonego} BrakeSubsystem: TBrakeSubsystem; LocalBrake: TLocalBrake; {rodzaj hamulca indywidualnego} BrakePressureTable: TBrakePressureTable; {wyszczegolnienie cisnien w rurze} ASBType: byte; {0: brak hamulca przeciwposlizgowego, 1: reczny, 2: automat} MaxBrakeForce: real; {maksymalna sila nacisku hamulca} MaxBrakePress,P2FTrans: real; {max. cisnienie w cyl. ham., stala proporcjonalnosci p-K} HighPipePress,LowPipePress,DeltaPipePress: real; {max. i min. robocze cisnienie w przewodzie glownym oraz roznica miedzy nimi} BrakeVolume, VeselVolume: real; {pojemnosc powietrza w ukladzie hamulcowym, w ukladzie glownej sprezarki [m^3] } BrakeCylNo: integer; {ilosc cylindrow ham.} BrakeCylRadius, BrakeCylDist, BrakeCylMult: real; {promien cylindra, skok cylindra, przekladnia hamulcowa} MinCompressor,MaxCompressor,CompressorSpeed:real; {cisnienie wlaczania, zalaczania sprezarki, wydajnosc sprezarki} BrakeDelay: TBrakeDelayTable; {opoznienie hamowania/odhamowania t/o} BrakeCtrlPosNo:byte; {ilosc pozycji hamulca} {nastawniki:} MainCtrlPosNo: byte; {ilosc pozycji nastawnika} ScndCtrlPosNo: byte; SecuritySystem:TSecuritySystem; {-sekcja parametrow dla lokomotywy elektrycznej} RList: TSchemeTable; {lista rezystorow rozruchowych i polaczen silnikow} RlistSize: integer; MotorParam: array[0..MotorParametersArraySize] of TMotorParameters; {rozne parametry silnika przy bocznikowaniach} Transmision : record {liczba zebow przekladni} NToothM, NToothW : byte; Ratio: real; {NToothW/NToothM} end; NominalVoltage: real; {nominalne napiecie silnika} WindingRes : real; CircuitRes : real; {rezystancje silnika i obwodu} IminLo,IminHi: integer; {prady przelacznika automatycznego rozruchu, uzywane tez przez ai_driver} ImaxLo,ImaxHi: integer; {maksymalny prad niskiego i wysokiego rozruchu} nmax: real; {maksymalna dop. ilosc obrotow /s} InitialCtrlDelay, {ile sek. opoznienia po wl. silnika} CtrlDelay: real; { -//- -//- miedzy kolejnymi poz.} AutoRelayType: byte; {0 -brak, 1 - jest, 2 - opcja} CoupledCtrl: boolean; {czy mainctrl i scndctrl sa sprzezone} DynamicBrakeType: byte; {0 - brak, 1 - przelaczany, 2 - rewersyjny, 3 - automatyczny} RVentType: byte; {0 - brak, 1 - jest, 2 - automatycznie wlaczany} RVentnmax: real; {maks. obroty wentylatorow oporow rozruchowych} RVentCutOff: real; {rezystancja wylaczania wentylatorow dla RVentType=2} {- dla uproszczonego modelu silnika (dumb) oraz dla drezyny} Ftmax:real; {-dla wagonow} MaxLoad: longint; {masa w T lub ilosc w sztukach - ladownosc} LoadAccepted, LoadQuantity: string; {co moze byc zaladowane, jednostki miary} OverLoadFactor: real; {ile razy moze byc przekroczona ladownosc} LoadSpeed,UnLoadSpeed: real;{szybkosc na- i rozladunku jednostki/s} {--sekcja zmiennych} {--opis konkretnego egzemplarza taboru} Loc: TLocation; Rot: TRotation; Name: string; {nazwa wlasna} Couplers: TCouplers; {urzadzenia zderzno-sprzegowe, polaczenia miedzy wagonami} EventFlag: boolean; {!o True jesli cos nietypowego sie wydarzy} SoundFlag: byte; {!o patrz stale sound_ } DistCounter: real; {! licznik kilometrow } V, Vel, AccS, AccN: real; {! predkosc w m/s i jej modul w km/h, przyspieszenie styczne i normalne w m/s^2} nrot: real; {! rotacja kol [obr/s]} EnginePower: real; {! chwilowa moc silnikow} dL, Fb, Ff : real; {przesuniecie, sila hamowania i tarcia} FTrain,FStand: real; {! sila pociagowa i oporow ruchu} Ftotal: real; {! calkowita sila dzialajaca na pojazd} UnitBrakeForce: real; {!s siła hamowania przypadająca na jeden element} SlippingWheels,SandDose: boolean; {! poslizg kol, sypanie piasku} Sand: real; {ilosc piasku} BrakeSlippingTimer:real; {pomocnicza zmienna do wylaczania przeciwposlizgu} dpBrake,dpPipe,dpMainValve,dpLocalValve: real; {! przyrosty cisnienia w kroku czasowym} BrakePress:real; {!o cisnienie w cylindrach hamulcowych} PipePress: real; {!o cisnienie w przewodzie glownym} Volume: real; {objetosc spr. powietrza w zbiorniku hamulca} CompressedVolume:real; {objetosc spr. powietrza w ukl. zasilania} Compressor: real; {! cisnienie w ukladzie zasilajacym} CompressorFlag:boolean; {!o czy wlaczona sprezarka} BrakeCtrlPos:integer; {nastawa hamulca zespolonego} LocalBrakePos:byte; {nastawa hamulca indywidualnego} BrakeStatus: byte; {0 - odham, 1 - ham., 2 - uszk., 4 - odluzniacz, 8 - antyposlizg} EmergencyBrakeFlag: boolean; {hamowanie nagle} BrakeDelayFlag: byte; {nastawa opoznienia ham. osob/towar 0/1} DynamicBrakeFlag: boolean; {czy wlaczony hamulec elektrodymiczny} DamageFlag: byte; {kombinacja bitowa stalych dtrain_* } EndSignals: byte; {0 - brak, 1,2 - przod lub tyl osygnalaizowane} CommandIn: TCommand; {komenda przekazywana przez PutCommand} {i wykonywana przez RunInternalCommand} CommandOut: string; {komenda przekazywana przez ExternalCommand} ValueOut: real; {argument komendy ktora ma byc przekazana na zewnatrz} {-zmienne dla lokomotyw} Mains: boolean; {polozenie glownego wylacznika} MainCtrlPos: byte; {polozenie glownego nastawnika} ScndCtrlPos: byte; {polozenie dodatkowego nastawnika} ActiveDir: integer;{czy lok. jest wlaczona i w ktorym kierunku} {-1 - do tylu, +1 - do przodu, 0 - wylaczona} CabNo: integer; {! numer kabiny: 1 lub -1. W przeciwnym razie brak sterowania} LastSwitchingTime: real; {czas ostatniego przelaczania czegos} RunningShape:TTrackShape;{geometria toru po ktorym jedzie pojazd} RunningTrack:TTrackParam;{parametry toru po ktorym jedzie pojazd} OffsetTrackH, OffsetTrackV: real; {przesuniecie poz. i pion. w/m toru} {-zmienne dla lokomotywy elektrycznej} RunningTraction:TTractionParam;{parametry sieci trakcyjnej nanjblizej lokomotywy} enrot, Im, Itot, Mm, Mw, Fw, Ft: real; {ilosc obrotow, prad silnika i calkowity, momenty, sily napedne} Imin,Imax: integer; {prad przelaczania automatycznego rozruchu, prad bezpiecznika} Voltage: real; {aktualne napiecie sieci zasilajacej} MainCtrlActualPos: byte; {wskaznik Rlist} ScndCtrlActualPos: byte; {wskaznik MotorParam} DelayCtrlFlag: boolean; {opoznienie w zalaczaniu} LastRelayTime: real; {czas ostatniego przelaczania stycznikow} AutoRelayFlag: boolean; {mozna zmieniac jesli AutoRelayType=2} FuseFlag: boolean; {!o bezpiecznik nadmiarowy} ResistorsFlag: boolean; {!o jazda rezystorowa} RventRot: real; {!s obroty wentylatorow rozruchowych} {-zmienne dla drezyny} PulseForce :real; {przylozona sila} PulseForceTimer: real; PulseForceCount: integer; {dla drezyny, silnika spalinowego i parowego} eAngle: real; {-dla wagonow} Load: longint; {masa w T lub ilosc w sztukach - zaladowane} LoadType: string; {co jest zaladowane} LoadStatus: integer;{-1 - trwa rozladunek, 1 - trwa naladunek, 0 - gotowe} LastLoadChangeTime: real; {--funkcje} function BrakeRatio: real; function LocalBrakeRatio: real; function PipeRatio: real; function DynamicBrakeSwitch(Switch:boolean):boolean; {! przesylanie komend sterujacych} function SendCtrlBroadcast(CtrlCommand:string; ctrlvalue:real):boolean; function SendCtrlToNext(CtrlCommand:string;ctrlvalue,dir:real):boolean; {! funkcje zwiekszajace/zmniejszajace nastawniki} {! glowny nastawnik:} function IncMainCtrl(CtrlSpeed:byte): boolean; function DecMainCtrl(CtrlSpeed:byte): boolean; {! pomocniczy nastawnik:} function IncScndCtrl(CtrlSpeed:byte): boolean; function DecScndCtrl(CtrlSpeed:byte): boolean; function AddPulseForce(Multipler:integer): boolean; {dla drezyny} {wlacza/wylacza sypanie piasku} function SandDoseOn : boolean; {! zbijanie czuwaka/SHP} function SecuritySystemReset:boolean; {test czuwaka/SHP} procedure SecuritySystemCheck(dt:real); {! stopnie hamowania - hamulec zasadniczy} function IncBrakeLevel:boolean; function DecBrakeLevel:boolean; {! stopnie hamowania - hamulec pomocniczy} function IncLocalBrakeLevel(CtrlSpeed:byte):boolean; function DecLocalBrakeLevel(CtrlSpeed:byte):boolean; {! hamulec bezpieczenstwa} function EmergencyBrakeSwitch(Switch:boolean): boolean; {hamulec przeciwposlizgowy} function AntiSlippingBrake: boolean; {odluzniacz} function BrakeReleaser: boolean; {! reczny wlacznik urzadzen antyposlizgowych} function AntiSlippingButton: boolean; {funkcje dla ukladow pneumatycznych} function IncBrakePress(PressLimit,dp:real):boolean; function DecBrakePress(PressLimit,dp:real):boolean; function BrakeDelaySwitch(BDS:byte): boolean; {! przelaczanie nastawy opoznienia} {pomocnicze funkcje dla ukladow pneumatycznych} procedure UpdateBrakePressure(dt: real); procedure UpdatePipePressure(dt:real); procedure CompressorCheck(dt:real); {wlacza, wylacza kompresor, laduje zbiornik} {! funkcje laczace/rozlaczajace sprzegi} function Attach(ConnectNo: byte; ConnectTo:PMoverParameters; CouplingType: byte):boolean; {laczenie} function Dettach(ConnectNo: byte):boolean; {rozlaczanie} {funkcje obliczajace sily} function Adhesive(staticfriction:real): real; function TractionForce(dt:real):real; function FrictionForce(R:real;TDamage:byte):real; function BrakeForce(Track:TTrackParam):real; function CouplerForce(CouplerN:byte; dt:real):real; procedure CollisionDetect(CouplerN:byte; dt:real); {obrot kol uwzgledniajacy poslizg} function ComputeRotatingWheel(WForce,dt,n:real): real; {komendy} function SetInternalCommand(NewCommand:string; NewValue1,NewValue2:real):boolean; {! do wpisywania komend przez zewnetrzne zdarzenia} function GetExternalCommand(var Command:string):real; function RunCommand(command:string; CValue1,CValue2:real):boolean; function RunInternalCommand:boolean; procedure PutCommand(NewCommand:string; NewValue1,NewValue2:real; NewLocation:TLocation); {--funkcje dla lokomotyw} {! kierunek ruchu} function DirectionForward: boolean; function DirectionBackward: boolean; {! wylacznik glowny} function MainSwitch(State:boolean): boolean; {! zmiana kabiny i resetowanie ustawien} function ChangeCab(direction:integer): boolean; {-funkcje typowe dla lokomotywy elektrycznej} {! wlaczanie bezpiecznika nadmiarowego} function FuseOn: boolean; procedure FuseOff; {wywalanie bezpiecznika nadmiarowego} {!o pokazuje bezwgl. wartosc pradu na wybranym amperomierzu} function ShowCurrent(AmpN:byte): integer; {funkcje uzalezniajace sile pociagowa od predkosci: v2n, n2r, current, momentum} function v2n:real; function current(n,U:real): real; function Momentum(I:real): real; {! odlaczanie uszkodzonych silnikow} function CutOffEngine: boolean; {! przelacznik pradu wysokiego rozruchu} function MaxCurrentSwitch(State:boolean):boolean; {! przelacznik pradu automatycznego rozruchu} function MinCurrentSwitch(State:boolean):boolean; {! przelacznik automatycznego rozruchu} function AutoRelaySwitch(State:boolean):boolean; {symulacja automatycznego rozruchu} function AutoRelayCheck: boolean; {-funkcje dla wagonow} function LoadingDone(LSpeed: real; LoadInit:string):boolean; {! WAZNA FUNKCJA - oblicza sile wypadkowa} procedure ComputeTotalForce(dt: real); {! BARDZO WAZNA FUNKCJA - oblicza przesuniecie lokomotywy lub wagonu} function ComputeMovement(dt:real; Shape:TTrackShape; var Track:TTrackParam; var ExternalVoltage:real{; var ElectricTraction:TTractionParam}; NewLoc:TLocation; var NewRot:TRotation):real; {dt powinno byc 10ms lub mniejsze} {NewRot na wejsciu daje aktualna orientacje pojazdu, na wyjsciu daje dodatkowe wychylenia od tej orientacji} {dla samochodow} function ChangeOffsetH(DeltaOffset:real): boolean; {! procedury I/O} constructor Init(LocInitial:TLocation; RotInitial:TRotation; VelInitial:real; TypeNameInit, NameInit: string; LoadInitial:longint; LoadTypeInitial: string; Cab:integer); {wywolac najpierw to} function LoadChkFile(chkpath:string):Boolean; {potem zaladowac z pliku} function CheckLocomotiveParameters(ReadyFlag:boolean): boolean; {a nastepnie sprawdzic} private function TotalMass:real; { function GetFTotal(CN:byte): real; function GetMass(CN:byte): real; procedure SendAVL(AccS,AccN,V,dL:real; CN:byte); } end; {ufff} function Distance(Loc1,Loc2: TLocation; Dim1,Dim2:TDimension) : real; {----------------------------------------------------------------} {========================McZapkie'2001===========================} {----------------------------------------------------------------}